@niche-works/utils
@niche-works/utils is a niche library of general-purpose utility functions covering a wide range of categories including arrays, objects, strings, numbers, dates, timers, and more.
Installation
npm install @niche-works/utils
# or
pnpm add @niche-works/utilsUsage
import { ensureArray, normalizeString, rangeClamp } from '@niche-works/utils';You can also import by category.
import { ensureArray } from '@niche-works/utils/array';
import { normalizeString } from '@niche-works/utils/string';Data Last Pattern
Many functions have a .dataLast property that returns a curried function receiving data as the last argument. This is useful for pipeline processing.
import { ensureArray } from '@niche-works/utils/array';
// data-first (normal call)
const arr = ensureArray('hello'); // ['hello']
// data-last (curried)
const toArray = ensureArray.dataLast();
const arr2 = toArray('hello'); // ['hello']API Reference
array — Array Operations
asArray(data, options?) *
Converts any value to an array. Iterables are spread; strings and primitives become single-element arrays.
asArray([1, 2, 3]); // [1, 2, 3]
asArray('hello'); // ['hello']
asArray(null); // []
asArray(new Set([1, 2])); // [1, 2]| Option | Type | Description |
|---|---|---|
raw |
boolean |
When true, wraps iterables as a single element without spreading |
ensureArray(data, options?) *
Wraps a non-array value in an array. Returns an empty array for null/undefined.
ensureArray([1, 2]); // [1, 2]
ensureArray(42); // [42]
ensureArray(null); // []| Option | Type | Description |
|---|---|---|
raw |
boolean |
When true, wraps the value as a single element without checking if it's an array |
cycle(data, size) *
Generates a new array of the specified size by cycling (looping) through the input array. A negative size reverses the direction.
cycle([1, 2, 3], 7); // [1, 2, 3, 1, 2, 3, 1]
cycle([1, 2, 3], -5); // [3, 2, 1, 3, 2]insertAt(data, index, items, options?) *
Inserts elements at the specified index. The index is clamped to the valid range.
insertAt([1, 2, 3], 1, [10, 20]); // [1, 10, 20, 2, 3]| Option | Type | Description |
|---|---|---|
inplace |
boolean |
When true, directly modifies the original array |
pushAll(data, source, options?) *
Returns a new array with all elements of source appended to data. Returns null if data is null.
pushAll([1, 2], [3, 4]); // [1, 2, 3, 4]pushAllMutable(data, source) *
Mutably appends all elements of another array to the array.
const arr = [1, 2];
pushAllMutable(arr, [3, 4]); // arr => [1, 2, 3, 4]pushUnique(data, items, options?) *
Returns a new array with only non-duplicate elements from items appended.
pushUnique([1, 2], [2, 3, 4]); // [1, 2, 3, 4]pushUniqueMutable(data, items, options?) *
Mutably appends only non-duplicate elements from items to the array.
rotateArray(data, options?) *
Rotates the array by taking elements from the front and adding them to the end.
rotateArray([1, 2, 3, 4, 5], { count: 2 }); // [3, 4, 5, 1, 2]| Option | Type | Description |
|---|---|---|
count |
number |
Number of elements to rotate (default: 1) |
inplace |
boolean |
When true, directly modifies the original array |
nestedKeyBy(data, properties, options?) *
Converts an array into a nested object keyed by property values. Each leaf holds a single item.
const users = [
{ id: 'a', role: 'admin', name: 'Alice' },
{ id: 'b', role: 'user', name: 'Bob' },
];
nestedKeyBy(users, ['role', 'id']);
// { admin: { a: {...} }, user: { b: {...} } }| Option | Type | Description |
|---|---|---|
overwrite |
boolean |
When true, later values take precedence for duplicate keys (default: earlier values take precedence) |
flat |
boolean |
When true, produces a flat object with concatenated keys |
keySeparator |
string |
Key separator for flat mode (default: '.') |
nestedGroupBy(data, properties, options?) *
Converts an array into a nested object keyed by property values. Each leaf holds an array of items.
nestedGroupBy(users, 'role');
// { admin: [...], user: [...] }sortDependencies(data, options?) *
Topologically sorts an array based on dependencies. Throws if circular dependencies are detected.
const nodes = [
{ id: 'A', deps: ['B'] },
{ id: 'B', deps: [] },
];
sortDependencies(nodes, {
idProp: 'id',
depsProp: 'deps',
depsIdProp: (dep) => dep,
ignoreNoSubstance: true,
});
// [{ id: 'B' }, { id: 'A' }]| Option | Type | Description |
|---|---|---|
idProp |
keyof I | Function |
Property name or function to get the ID |
depsProp |
keyof I | Function |
Property name or function to get the dependency list |
depsIdProp |
keyof I | Function |
Property name or function to get the dependency item's ID |
isTree |
boolean |
Process tree-structured dependencies |
ignoreNoSubstance |
boolean |
Ignore non-existent dependency targets |
desc |
boolean |
When true, reverses the order |
swapPairs(data) *
Swaps elements in adjacent pairs within the array.
swapPairs([1, 2, 3, 4]); // [2, 1, 4, 3]maybeFind(data, predicate) *
Returns the first element matching the predicate, or undefined if none is found.
maybeMap(data, mapper, options?) *
Maps each element and returns a new array with null/undefined values removed.
firstDefined(data) *
Returns the first non-undefined value in the array.
firstPresent(data) *
Returns the first non-null/non-undefined value in the array.
clearArray(data)
Removes all elements from the array (mutating).
boolean — Boolean
ensureBoolean(value, options?) *
Converts a value to a boolean. Strings like 'true', '1', and 'yes' can also be converted to true.
ensureBoolean('true'); // true
ensureBoolean(0); // false
ensureBoolean('yes', { trueValues: ['yes'] }); // truecompare — Comparison
compare(left, operator, right) *
Compares two values using an operator and returns a boolean.
compare(5, '>', 3); // true
compare(5, 'between', [1, 10]); // true
compare('a', 'in', ['a', 'b']); // trueSupported operators: '=' '!=' '<' '<=' '>' '>=' 'between' 'in' 'notIn'
isEqualBy(a, b, options?) *
Checks equality of two values using the specified comparison mode.
isEqualBy({ a: 1 }, { a: 1 }, { mode: 'deep' }); // true| Option | Type | Description |
|---|---|---|
mode |
'strict' | 'loose' | 'deep' |
Comparison mode (default: 'strict') |
customizer |
Function |
Custom comparison function |
isEqualWith(a, b, customizer) *
Recursively checks equality of two values using a custom comparator function.
date — Date
asUtcDate(date)
Returns a new Date that interprets the local date's year/month/day/hour/minute/second components as UTC values.
// JST 2024-01-15 12:00:00 → treated as UTC 2024-01-15 12:00:00
asUtcDate(new Date(2024, 0, 15, 12, 0, 0));createUtcDate(year, month, day, ...)
Creates a date in the UTC timezone.
interpolateDate(value, ratio, options?) *
Returns a date interpolated between two dates at the given ratio.
interpolateDate(targetDate, 0.5, { baseValue: startDate });
// date halfway between startDate and targetDateformat — Format
analyzeNumberFormat(format)
Parses a number format string (e.g. Excel format) and returns information about integer/decimal digit counts, separators, prefix/suffix, etc.
analyzeNumberFormat('#,##0.00');
// { intNumLength: 1, dp: true, dpLength: 2, ... }function — Function Utilities
withCache(fn, options?)
Caches the result of an async function to prevent duplicate requests with the same arguments.
const cachedFetch = withCache(fetchUser, { ttl: 60000 });
await cachedFetch('user-1'); // API call
await cachedFetch('user-1'); // returned from cache| Option | Type | Description |
|---|---|---|
ttl |
number |
Cache time-to-live (ms) |
cacheKey |
Function |
Cache key generator function |
withRetry(fn, maxRetries, options?)
An async function wrapper that automatically retries on failure.
const reliableFetch = withRetry(fetchData, 3, {
delay: 1000,
exponentialBackoff: true,
});| Option | Type | Description |
|---|---|---|
delay |
number |
Wait time before retry (ms) |
exponentialBackoff |
boolean |
Use exponential backoff |
shouldRetry |
Function |
Function to determine whether to retry |
onRetry |
Function |
Callback called on retry |
withTimeout(fn, timeout, options?)
An async function wrapper that throws TimeoutError if it doesn't complete within the specified time.
const timedFetch = withTimeout(fetchData, 5000);withFallback(fn, fallback, options?)
An async function wrapper that returns a fallback value when an error occurs.
const safeFetch = withFallback(fetchData, null);alwaysTrue() / alwaysFalse() / alwaysInput(v) / alwaysVoid()
Functions that always return a fixed value.
alwaysTrue(); // true
alwaysFalse(); // false
alwaysInput('hi'); // 'hi'
alwaysVoid(); // undefinedmaybeApply(fn, value)
Applies the function only if value is not null/undefined.
maybeCall(fn, ...args)
Calls fn only if it is a function.
ensureAsync(fn)
Converts a synchronous function into an asynchronous one (returns a Promise).
geometry — Geometry
fitToRatio(value, ratio, options?) *
Scales a value to fit an aspect ratio.
fitToRatio(100, 16 / 9, { mode: 'expand' }); // 178
fitToRatio(100, 16 / 9, { mode: 'shrink' }); // 56| Option | Type | Description |
|---|---|---|
mode |
'expand' | 'shrink' |
Expand or shrink mode |
decimals |
number |
Decimal places |
Dedicated functions for specific ratios are also provided.
| Function | Ratio | Data Last |
|---|---|---|
fitToGolden |
Golden ratio (1.618…) | ✓ |
fitToSilver |
Silver ratio (2.414…) | |
fitToBronze |
Bronze ratio (3.303…) | |
fitToDouble |
2:1 | |
fitToYamato |
Yamato ratio (√2) | |
fitToSqrt2 |
√2 | |
fitToSqrt3 |
√3 | |
fitToSqrt5 |
√5 | |
fitToHarmonic |
Harmonic ratio | |
fitToPlatinum |
Platinum ratio |
input — Input Control
limitDecimal(value, options?)
Validates and formats numeric input. Supports decimal place limits, min/max constraints, and both interactive (typing in progress) and batch processing modes.
limitDecimal('3.14159', { dp: 2 }); // '3.14'
limitDecimal('999', { max: 100 }); // '100'
limitDecimal('-', { interactive: true, min: -100 }); // '-' (allow while typing)| Option | Type | Description |
|---|---|---|
dp |
number |
Maximum decimal places |
min |
number | string |
Minimum value |
max |
number | string |
Maximum value |
interactive |
boolean |
Allow in-progress states (-, trailing ., etc.) |
limitNaturalNumber(value, options?)
Converts and limits values to natural numbers (positive integers).
limitNaturalNumber(3.7); // 3
limitNaturalNumber(0); // null (zero not allowed)
limitNaturalNumber(0, { allowZero: true }); // 0limitPositiveNumber(value, options?) *
Converts and limits values to positive numbers (greater than zero).
map — Map Operations
ensureMap(data, options?) *
Converts various types of values to a Map.
ensureMap({ a: 1, b: 2 }); // Map { 'a' => 1, 'b' => 2 }
ensureMap([['a', 1]]); // Map { 'a' => 1 }
ensureMap(null); // Map {}measure — Performance Measurement
measure(fn, options?)
Measures the execution time of a function.
const result = measure(() => heavyCalc(), { iteration: 100 });
console.log(result.time); // execution time (ms)| Option | Type | Description |
|---|---|---|
iteration |
number |
Number of executions (default: 10) |
measureAsync(fn, options?)
Measures the execution time of an async function.
comparePerformance(fns, options?)
Compares the execution time of multiple functions.
comparePerformanceAsync(fns, options?)
Compares the execution time of multiple async functions.
number — Number
rangeClamp(value, min, max) *
Clamps a value to the min-max range.
rangeClamp(150, 0, 100); // 100
rangeClamp(-10, 0, 100); // 0rangeLoop(value, min, max) *
When out of range, returns the value looped (modulo) back into range.
rangeLoop(12, 0, 10); // 2
rangeLoop(-1, 0, 10); // 9rangeDefault(value, min, max, defaultValue) *
When out of range, returns the default value.
rangeMax(value, max) *
Returns the maximum value when the value exceeds it.
rangeMin(value, min) *
Returns the minimum value when the value falls below it.
rangePingpong(value, min, max) *
When out of range, returns the value ping-ponged (bounced) back into range.
interpolateNumber(value, ratio, options?) *
Returns a value interpolated between a base value and a target at the given ratio.
interpolateNumber(100, 0.5, { baseValue: 0 }); // 50
interpolateNumber(200, 0.25, { baseValue: 100 }); // 125roundToStep(value, step) *
Rounds a value to the nearest step.
roundToStep(7, 5); // 5
roundToStep(8, 5); // 10ensureNumber(value, options?) *
Converts a value to a number.
ensureRange(value, options?) *
Clamps a value to the specified range.
getValidMinMax(min, max)
Gets a valid min/max pair (with automatic ordering correction, etc.).
getValidNumber(value, options?) *
Validates and returns a valid number.
isWithinRange(value, min, max) *
Returns whether the value is ≥ min and ≤ max.
isStrictlyWithinRange(value, min, max) *
Returns whether the value is > min and < max.
object — Object Operations
get(data, path) *
Gets a nested property using dot or bracket notation.
get({ a: { b: { c: 42 } } }, 'a.b.c'); // 42
get({ arr: [1, 2, 3] }, 'arr[1]'); // 2set(data, path, value) *
Returns a new object with the nested property set at the given path (immutable).
set({ a: { b: 1 } }, 'a.b', 99); // { a: { b: 99 } }setMutable(data, path, value) *
Mutably sets the nested property at the given path.
unset(data, path) *
Returns a new object with the property at the given path removed (immutable).
unset({ a: 1, b: 2 }, 'a'); // { b: 2 }unsetMutable(data, path) *
Mutably removes the property at the given path. Uses splice for arrays to compact the array.
update(data, values) *
Returns a new object with existing properties updated to new values (immutable).
updateMutable(data, values) *
Mutably updates existing own properties of an object. Returns the previous values.
omit(data, paths) *
Returns an object with the specified path properties omitted.
omit({ a: 1, b: 2, c: 3 }, ['b']); // { a: 1, c: 3 }filterByKeys(target, condition, options?) *
Filters an object (recursively) to keep only entries whose keys contain the specified string.
filterByKeys({ name: 'Alice', age: 30 }, 'na');
// { name: 'Alice' }| Option | Type | Description |
|---|---|---|
normalize |
boolean |
Apply string normalization before comparison |
filterByValues(target, condition, options?) *
Filters an object (recursively) to keep only entries whose values contain the specified value.
filterByValues({ a: 'Alice', b: 'Bob', c: 1 }, 'Ali');
// { a: 'Alice' }
filterByValues({ a: 1, b: 2, c: 1 }, 1);
// { a: 1, c: 1 }| Option | Type | Description |
|---|---|---|
normalize |
boolean |
Apply normalization before string comparison |
transformObject(source, rules, options?) *
Transforms and extracts object structure according to mapping rules.
transformObject({ firstName: 'Alice', age: 30 }, [
{ from: 'firstName', to: 'user.name' },
{ from: (s) => s.age * 2, to: 'doubleAge' },
]);
// { user: { name: 'Alice' }, doubleAge: 60 }| Rule Property | Type | Description |
|---|---|---|
from |
string | Function |
Path or function to compute the source value |
to |
string | Function |
Path or function to transform the result |
shouldRemoveFromSource |
boolean |
When true, removes the source property |
| Option | Type | Description |
|---|---|---|
deleteSourceKeys |
boolean |
When true, removes source keys for all rules |
flattenObject(data, options?) *
Converts a nested object to a flat key-value pair structure.
flattenObject({ a: { b: { c: 1 } } });
// { 'a.b.c': 1 }| Option | Type | Description |
|---|---|---|
keySeparator |
string |
Key separator character (default: '.') |
ignoreArray |
boolean |
When true, does not expand arrays |
distribute(data, rules, options?) *
Distributes object properties into multiple groups according to rules.
cloneDeep(data)
Deep-clones an object.
cloneShallow(data)
Shallow-clones an object. Supports Array, Map, Set, ArrayBuffer, TypedArray, DataView, Date, and RegExp.
createCaseInsensitiveObject(options?)
Creates a case-insensitive object (Proxy) where key lookups are case-insensitive.
const obj = createCaseInsensitiveObject({ target: { Name: 'Alice' } });
obj['name']; // 'Alice'
obj['NAME']; // 'Alice'
'name' in obj; // true
// caseSensitive: true makes keys case-sensitive
const sensitive = createCaseInsensitiveObject({
target: { Name: 'Alice' },
caseSensitive: true,
});
sensitive['name']; // undefined
sensitive['Name']; // 'Alice'| Option | Type | Description |
|---|---|---|
target |
object |
Initial value object |
caseSensitive |
boolean |
When true, keys are case-sensitive (default: false) |
storedKeyType |
'transformed' | 'original' |
Key storage format |
isMutable |
boolean |
When true, directly modifies the original object |
includeInherited |
boolean |
When true, includes inherited properties |
createKeyTransformObject(transformKey, options?)
Creates an object (Proxy) that manages keys using a transform function. It is the foundation of createCaseInsensitiveObject.
// Object that stores all keys in uppercase
const obj = createKeyTransformObject((_, key) =>
typeof key === 'string' ? key.toUpperCase() : key,
);
obj['name'] = 'Alice';
obj['NAME']; // 'Alice'countKeys(data)
Returns the number of own properties of an object.
forEachValues(data, callback, options?) *
Executes a callback for each property value of an object. Stops if the callback returns false.
forEachValues({ a: 1, b: 2 }, (value) => {
if (value === 2) return false; // stop
});getByNormalizedKey(data, key, options?)
Gets an object value by a normalized key (e.g. ignoring case).
setByNormalizedKey(data, key, value, options?)
Sets a value in an object using a normalized key.
maybeAssign(target, source) *
Returns a new object with each property of source set in target (immutable).
maybeAssignMutable(target, source)
Mutably sets each property of source in target.
maybeDefault(target, defaults) *
Returns a new object with default values set for null/undefined properties in target.
maybeDefaultMutable(target, defaults, options?)
Mutably sets default values for null/undefined properties in target.
| Option | Type | Description |
|---|---|---|
overwriteNull |
boolean |
When true, also overwrites properties that are null |
maybeHasOwn(data, key)
Returns whether an object has the specified property as its own. Returns false when data is null.
stableStringify(data)
Returns a JSON string with the object's keys recursively sorted alphabetically.
stableStringify({ b: 2, a: 1 }); // '{"a":1,"b":2}'needsDefineProperty(target, key, descriptor)
Determines whether a property definition needs to be applied.
setProperty(target, key, descriptor)
Defines a property using Object.defineProperty.
overrideInstance(target, overrides)
Overrides methods or properties of an instance.
string — String
normalizeString(value, options?) *
Normalizes a string to a unified representation. Useful for absorbing variation in search and comparison.
normalizeString('ＡＢＣ', { ignoreWidth: true }); // 'abc'
normalizeString('アイウ', { ignoreKana: true }); // 'あいう'
normalizeString('Café', { ignoreDakuon: true }); // 'Cafe'
normalizeString('Hello World', { ignoreCase: true }); // 'hello world'| Option | Type | Description |
|---|---|---|
ignoreCase |
boolean |
Ignore case (unify to lowercase) |
ignoreWidth |
boolean |
Ignore full-width/half-width (unify to half-width) |
ignoreKana |
boolean |
Ignore katakana/hiragana (unify to hiragana) |
ignoreDakuon |
boolean |
Ignore voiced/semi-voiced consonant marks |
ignoreSokuon |
boolean |
Ignore geminate consonants (っ/ッ → つ/ツ) |
ignoreYouon |
boolean |
Ignore contracted sounds (ゃゅょ, etc.) |
ignoreChouon |
boolean |
Ignore long vowel marks (ー) |
ignoreLineFeed |
boolean |
Ignore line feeds |
ignoreSpace |
boolean |
Ignore spaces |
ignoreCompatibility |
boolean |
Normalize Unicode compatibility characters |
ignoreComposition |
boolean |
Normalize Unicode composed characters |
replacePlaceholders(template, values, options?) *
Replaces placeholders in a template string with values.
replacePlaceholders('Hello {{name}}, {{greeting}}!', {
name: 'Alice',
greeting: 'how are you',
});
// 'Hello Alice, how are you!'
replacePlaceholders('{{0}} and {{1}}', ['Alice', 'Bob']);
// 'Alice and Bob'| Option | Type | Description |
|---|---|---|
bracket |
[string, string] |
Placeholder bracket characters (default: ['{{', '}}']) |
removePlaceholders |
boolean |
When true, removes placeholders with no matching value |
flatKeys |
boolean |
When true, resolves with flat (non-nested) keys |
interpolateString(value, ratio, options?)
Interpolates a string animation-style (e.g. typing effect).
interpolateString('Hello', 0.6); // 'Hel'
interpolateString('World', 0.5, { initialValue: 'Hello' }); // intermediate value like 'HellWorld'transformString(str, types, options?) *
Applies multiple transformation types to a string sequentially. You can combine case conversions and character type conversions.
replaceByMap(str, map, options?) *
Replaces all occurrences in a string according to a map (object or array).
replaceByMap('hello world', { hello: 'hi', world: 'earth' });
// 'hi earth'createExtractor(bracket)
Creates a function that extracts parts surrounded by the specified bracket characters.
const extract = createExtractor(['{{', '}}']);
extract('{{name}} here'); // ['name']Character Type Conversion
| Function | Description | Data Last |
|---|---|---|
retypeToFullWidth(str) |
Half-width to full-width | ✓ |
retypeToHalfWidth(str) |
Full-width to half-width | |
retypeToHiragana(str) |
Katakana to hiragana | ✓ |
retypeToKatakana(str) |
Hiragana to katakana | |
retypeToHiraganaSeion(str) |
Katakana to hiragana (clear sounds only) | |
retypeToKatakanaSeion(str) |
Hiragana to katakana (clear sounds only) | |
retypeToNoChouon(str) |
Remove long vowel marks | |
retypeToNoLineFeed(str) |
Remove line feeds | |
retypeToNoSpace(str) |
Remove spaces | |
retypeToNfc(str) |
NFC normalization | ✓ |
retypeToNfd(str) |
NFD normalization | ✓ |
retypeToNfkc(str) |
NFKC normalization | ✓ |
retypeToNfkd(str) |
NFKD normalization | ✓ |
retype(str, types, options?) |
Apply multiple character type conversions |
Case Conversion
| Function | Description | Example | Data Last |
|---|---|---|---|
recaseCamel(str) |
camelCase | helloWorld |
✓ |
recasePascal(str) |
PascalCase | HelloWorld |
✓ |
recaseSnake(str) |
snake_case | hello_world |
✓ |
recaseScreamingSnake(str) |
SCREAMING_SNAKE_CASE | HELLO_WORLD |
✓ |
recaseKebab(str) |
kebab-case | hello-world |
✓ |
recaseTitle(str) |
Title Case | Hello World |
✓ |
recaseLower(str) |
lowercase | hello world |
✓ |
recaseUpper(str) |
UPPERCASE | HELLO WORLD |
✓ |
lowerFirst(str) |
Lowercase first char | helloWorld |
✓ |
upperFirst(str) |
Uppercase first char | HelloWorld |
✓ |
Other String Utilities
| Function | Description | Data Last |
|---|---|---|
ensureString(value) |
Convert to string | ✓ |
escapeRegExp(str) |
Escape special regex characters | |
isFullWidth(str) |
Check if all characters are full-width | |
isHalfWidth(str) |
Check if all characters are half-width | |
isLooseEqual(a, b, options?) |
Check equality after normalizing strings | ✓ |
isSurroundedBy(str, prefix, suffix) |
Check if surrounded by specified prefix/suffix | ✓ |
maybeReplace(str, pattern, replacement) |
Replace only if the pattern matches | ✓ |
safeMatchAll(str, pattern) |
Safely execute matchAll and return results |
timer — Timer
debounce(fn, delay, options?)
Returns a debounce function that executes once after the specified time following the last call.
const onInput = debounce((value) => search(value), 300);
// .cancel() cancels the pending execution
// .flush() executes immediately
// .isIdle() checks whether idlethrottle(fn, delay, options?)
Returns a throttle function that executes at most once per specified interval.
const onScroll = throttle((e) => update(e), 100);sleep(duration)
Returns a Promise that waits for the specified number of milliseconds.
await sleep(1000); // wait 1 secondtype — Type Checking
| Function | Description | Data Last |
|---|---|---|
isBlank(value) |
Is null/undefined/empty string/whitespace-only string |
|
isNullish(value) |
Is null or undefined |
|
isPresent(value) |
Is not null/undefined |
|
isUndefined(value) |
Is undefined |
|
isEmptyCollection(value) |
Is empty Array/Map/Set |
|
isEmptyValue(value) |
Is null/undefined/empty string/empty array/empty object, etc. |
|
isValidDate(value) |
Is a valid Date object |
|
isInvalidDate(value) |
Is an invalid Date object (Invalid Date) |
|
isValidNumber(value, options?) |
Is a valid number (excluding NaN/Infinity) | |
isNumberLike(value) |
Is a number or numeric string | |
isNonNegativeInteger(value) |
Is a non-negative integer | |
isPrimitive(value) |
Is a primitive type | |
isRegExp(value) |
Is a RegExp |
|
isIterable(value) |
Is iterable | |
isAsyncIterable(value) |
Is async iterable | |
getRawType(value) |
Gets the internal type string from Object.prototype.toString |
|
kind(value) |
Gets the kind of value as a string | ✓ |
priority(value) |
Gets the priority of the value as a number | ✓ |
ensureValidValue(value, options?) |
Returns a fallback if the value is not valid | ✓ |
unsafeCast(value) |
Type cast ignoring type checking |
* Data Last support
License
MIT