Preparing search index...
The search index is not available

@neozen/zen - v

Settings

Member Visibility

Protected
Inherited
External

Theme

@neozen/zen
FunctionTypes

Type Alias FunctionTypes

FunctionTypes:
    | Function
    | GeneratorFunction
    | AsyncFunction
    | AsyncGeneratorFunction
    | ((...args: any) => any)

Defined in src/code/typezen/functionType.ts:5

setProp
Sets a *value* to an *object*, to a given *path* that's either:
SetPropOptions
Options interface for [ `z.setProp` ](../functions/setProp.html )
setProp_DefaultOptions
Default options for [ `z.setProp` ](../functions/setProp.html )
getProp
Gets a value from an Object, with a given path. If no valid path exists, `undefined` is returned.
GetPropOptions
Options interface for [ `z.getProp` ](../functions/getProp.html )
getProp_DefaultOptions
Default options for [ `z.getProp` ](../functions/getProp.html )
isDisjoint
Returns true if there are no common values between the elements of the two Arrays or Sets (i.e their intersection is empty)
IsDisjointOptions
Options interface for [ `z.isDisjoint` ](../functions/isDisjoint.html )
isDisjoint_DefaultOptions
Default options for [ `z.isDisjoint` ](../functions/isDisjoint.html )
isRefDisjoint
Given two Property Bags (i.e any z.isRef, incl Objects, Arrays, Set, Maps, Symbols, Boxed primitives etc), it returns `true` if there are **NO common/shared References** in their entries/elements/properties.
IsRefDisjointOptions
Options interface for [ `z.isRefDisjoint` ](../functions/isRefDisjoint.html )
isRefDisjoint_DefaultOptions
Default options for [ `z.isRefDisjoint` ](../functions/isRefDisjoint.html )
getRefs
Gets a flat list of all references of an isMany value (Array, Object, Set, Map etc) & returns them as an array.
GetRefsOptions
Options type for [ `z.getRefs` ](../functions/getRefs.html )
getRefs_DefaultOptions
Default options for [ `z.getRefs` ](../functions/getRefs.html )
isEqual
Deeply compares 2 input values, returning `true` if they are considered equal, with loads of awesome options!
IsEqualOptions
Options interface for [ `z.isEqual` ](../functions/isEqual.html )
IsEqualCustomizerCallback
Customizer callback type for [ `z.isEqual` ](../functions/isEqual.html ).
isEqual_DefaultOptions
Default options for [ `z.isEqual` ](../functions/isEqual.html ) *
arrayize
Places value in a new array, if it's not already an array.
keys
`keys()` returns an array of: **a)** Nestedly occurring `keys` or `indexes` (eg `Set` keys, array indexes etc) or **b)** `props` of the input value (props on all objects), including symbols, own & inherited, enumerable & nonEnumerable! The returned props can be filtered by prop type (string or symbol), enumerability, own/inherited, top-level props etc.
keysS
A Simplified typings version of `keys()` that returns only `string` or `symbol` props types of the input value, based on the options.
Keys
Returns either or both a) the NestedKeys along with b) the Props of the Tinput, based on the `KeysOptions` passed.
KeysS
IKeysOptions
Options interface for z.keys
IKeys_DefaultOptions
keys_DefaultOptions
InspectableNested
Only these types have **Inspectable Nested Keys** (separate from their props), that can be inspected at runtime (without affecting the input value).
isInspectableNested
values
Returns an array of either OR both of:
Values
Returns either or both A) the `InsideValues` (i.e Nested Values) along with B) PropsValues of the Tinput, based on the `KeysOptions` passed.
each
Iterate over the (many) items of a value, calling the callback for each item. Think of `_.each()` or `Array.forEach()`, but more powerful via [ `z.loop()` ](../functions/loop.html ). Hence, it works with ANY value, not just arrays and objects, but also `Map`, `Set`, `Iterator`, `Generator` & even `AsyncIterators` (where it returns a promise resolving when iteration ends!
EachIteratee
EachAsyncIteratee
take
Takes `n` elements from the beginning of the value ( `Array`, `Object`, `Set`, `Map` etc). If `n` is a function, it stops as soon as it returns `false` or `z.STOP`.
map
Map over the (many) items of **any possible input value**, returning a new instance of the same input value type (if possible), with the results of calling the projector/mapping function on every "nested" element of the input value (for collections like Objects, Arrays, Maps, Sets but also for Iterators, Generators, AsyncIterators etc).
IMapOptions
filter
Filter over the (many) items of a value and returning of **a new instance of the value**, containing the elements that pass the filter with [ `isPass` ](../functions/isPass.html ) (an elaborate kind of truthy). Value can be `Object`, `Array`, `Map`, `Iterators` and many more.
clone
Creates a perfect shallow clone of whatever value is given (and can be perfectly cloned :)
functionType
Determine the type of function: class definition OR function (and what kind)
FunctionTypeNames
FunctionTypes
FUNCTION_TYPE_NAMES
isAgree
Checks if `value` is in agreement with an `agreement` - see below.
isAnyNumber
Checks and returns true, if value is any kind of a "real number", a good candidate for `Number()` :
isArrayBuffer
Checks if value ia an ArrayBuffer
isSetEqual
Returns true if the two passed Sets or Arrays representing sets of items, are set-equal (i.e. they contain the same items, irrespective of items order).
isAsyncFunction
Checks if value is declared as an [ `AsyncFunction` ](../types/AsyncFunction.html ). This includes only `async () => Promise<any>` declarations, but NOT normal functions that returns a Promise (i.e `() => Promise<any>` ).
AsyncFunction
isAsyncGenerator
Checks if value is an `AsyncGenerator`, i.e `Object [Generator] {}`, what a `GeneratorFunction` returns:
isAsyncGeneratorFunction
Checks if value is a `AsyncGeneratorFunction`, eg `async function* () {}` When you call an `AsyncGeneratorFunction`, it returns an `AsyncGenerator`, that you can loop with `for await (const x of asyncGenerator()) {}`, or better yet `for await (const [item] of z.loop(asyncGenerator())) {}`
isBigInt
Checks if value is *BigInt*
isBoxedPrimitive
Checks if value is a boxed primitive. Boxed primitives are:
isBoxedBoolean
isBoxedNumber
isBoxedString
isClass
Check if a value is a class (instead of a "normal" function), with a type guard, so you can `new value()` without TS errors.
classType
ClassTypeNames
CLASS_TYPE_NAMES
isUserClass
Returns true if the value is a **user class** only, as opposed to a "normal" functions OR non user-defined class, i.e the internal ones like Promise, Object, Array, Set, Map etc
SYSTEM_CLASSES
constructor
Returns the `constructor` of an Object value, if it exists.
isSystemClass
Returns true if the value is a **user class** only, as opposed to a "normal" functions OR non user-defined class, i.e the internal ones like Promise, Object, Array, Set, Map etc
SystemClasses
Just a stub - not working to matching exclusively System classes, it matches everything!
isEnumerable
isExact
Shortcut of [ `z.isEqual` ](../functions/isEqual.html ) with forced options
isTrue
Returns true if the value is strict `true` OR `new Boolean(true)`
isOk
Returns true if value is a **Zen truthy**, defined as `!_.isBad(value)`, which includes:
isTruthy
Returns if value is strict *JS truthy*, i.e `!!value`, along with `value !== z.NOTHING` && not `new Boolean(false)` @todo: type guard
isStrictTrue
Returns true if value is strict `true`
isFalse
Returns true if the value is strict `false`, including `new Boolean(false)`
isBad
Returns true if value is **zen falsey**, a.k.a bad, which includes
isFalsy
Returns true if value is `JS falsy`, i.e `!value`, but also if `value === z.NOTHING` or `new Boolean(false)`
isStrictFalse
Returns true if value is strict `false`
isFunction
Check if the value is a function, using the `typeof` operator.
isGenerator
Checks if value is a `Generator` i.e `Object [Generator] {}`, what a `GeneratorFunction` returns
isGeneratorFunction
Checks and returns `true`, if value is either a:
isInstance
Checks if value passed is a **user class instance**, created with `new MyClass()`, as opposed to Plain/POJSO Objects, i.e an object created as literal `{}` or by `Object.create()` or `new Object()`.
isIqual
Shortcut of [ `z.isEqual` ](../functions/isEqual.html ) with forced options =
isPlainIterator
Checks if value is a **plain** Iterator.
isIxact
Shortcut of [ `z.isEqual` ](../functions/isEqual.html ) with forced options =
isLike
Shortcut of [ `z.isEqual` ](../functions/isEqual.html ) with forced options
isMapIterator
Checks if value is a Map Iterator - includes `map.entries()`, `map.values()`, `map.keys()`, `map[Symbol.iterator]()` etc.
MapIteratorKeys
MapIteratorValues
MapIteratorEntries
isNativeError
Checks if the value is an instance of Native (i.e built-in) Error
isMany
Returns `true` if the data type is a natural holder of other items, also known as a "collection" (eg Array, Object, Set, Map) but Many is also Iterator, Generator, arguments etc, hence the name `isMany` instead of `isCollection`.
isManyType
Many
Supposedly matches any type that can hold many items, including system types like Array, Set, Map, Iterator, Generator, arguments etc.
ManyNames
ManySystem
All system types that are Many, everything but your own pojsos / plain objects & instances.
ManySystemNames
MANY_NAMES
MANY_SYSTEM_NAMES
isNumber
Checks if value is either a [strict number](../functions/isStrictNumber.html ) OR `BigInt` OR `Infinity`, excluding only `NaN` s & boxed `new Number('123')`.
isNumberString
Check if value is a **string number**, like `'123'` or `'123.456'`
NumberString
A Number value, but as a string
isPOJSObject
Checks and returns true if value is a POJSO Object (Plain Old JS Object), such as object literal {} or object created by `Object.create()` etc, but NOT instances (eg `new MyClass()` ).
isPrimitive
Returns `true` if the data type is a Primitive, according to the [definition of "primitive" in JavaScript](https://developer.mozilla.org/en-US/docs/Glossary/Primitive)
isPrimitiveType
Returns `true` if `theType` is a name of a Primitive
Primitive
Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive), also including the pseudo type `void`.
PrimitiveNames
The names of the primitive types: 'string', 'number', 'boolean', 'undefined', 'null', 'symbol', 'bigint' ( `void` is not included, it's a pseudo type)
PRIMITIVE_NAMES
isPromise
Checks if a value is a Promise. Its 2024 and we still need this ;-(
IfPromise
IsPromise
UnwrapPromise
Unwraps the "awaited type" of the Promise, but only once (unlike Awaited which is recursive). Non-promise "thenables" should resolve to `never`. This DOESNT emulate the behavior of `await`, it just unwraps the type of top-level Promise.
isRealFunction
Checks if value passed is any kind of Function, but excluding Classes. Uses z.isFunction that works for async generator functions (unlike lodash).
isRef
Returns `true` if the data type is a Reference type.
isRealObject
Returns `true` if input value passed is any kind of **real object** (a.k.a. a hash) in any form, such as object literal {}, class instance (instantiated with new MyClass), object created by `Object.create()` with or without a specified prototype etc).
IfRealObject
IsRealObject
Returns `true` if the value is a **realObject** as defined in [ `isRealObject()` ](../functions/isRealObject.html )
isSetIterator
SetIteratorEntries
SetIteratorKeys
SetIteratorValues
isStrictNumber
Check if value is a **strict number**, excluding NaNs & boxed `new Number('123'), BigInt & Infinity.
isTypedArray
Checks if the value is a [ `TypedArray` ](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) adding the **correct type guard**, that lodash lacks.
typedArrayType
TypedArrayNames
TypedArrayNumber
TypedArrayBigInt
TypedArrayNumberNames
TypedArrayBigIntNames
TYPED_ARRAY_NAMES
TYPED_ARRAY_NUMBER_NAMES
TYPED_ARRAY_BIGINT_NAMES
isTypedArrayBigInt
isBigInt64Array
isBigUint64Array
isTypedArrayNumber
isInt8Array
isUint8Array
isUint8ClampedArray
isInt16Array
isUint16Array
isInt32Array
isUint32Array
isFloat32Array
isFloat64Array
isTypedArrayName
isAnyArray
Returns true if the value is an array of any type, including TypedArrays.
loop
@todo: Write docs for `loop()` - accepts any input value (usually a "collection" or a container of other nested items) and returns a Generator (actually a LoopGenerator) blah blah
IloopMeta
IloopCallbacks
The sole purpose of callbacks to exist here in `IloopCallbacks`, separately from [ `ILoopOptions` ](../interfaces/ILoopOptions.html ), is due to a Zen/TypeScript limitation, that doesn't properly infer the type of a callback's arguments (it ignores the options, probably cause they belong to same type interface before it has been initialized).
FilterCallback
MapCallback
MapKeysCallback
TakeCallback
ItemsCallback
IFilterOnlyOptions
FilterReturn
ILoopOptions
Options interface for z.keys
LoopValues
Get the loop items (a.k.a values), depending on the input value type and options
LoopKeys
Get the loop keys, depending on the input value type and options.
ILoop_DefaultOptions
LOOP_SYMBOL
AsyncLoopGenerator
LoopGenerator
TloopCallbackNames
loopCallbackNames
loop_DefaultOptions
isLoopGenerator
isAsyncLoopGenerator
numberEnumToNumberVal
Returns the validated & existing `number value` part of a "numeric" enum (the right hand-side), given either side (the string or number part) of a "numeric" enum.
numberEnumToStringKey
Returns the validated & existing enum "string key" part of a "numeric" enum (the string at left hand side), given either side (the string or number part) of a "numeric" enum.
isDataView
Check if value is a DataView
realObjectType
Determine the type of an [ `z.isRealObject` ](../functions/isRealObject.html ): an `'instance'` of a class or a plain `'pojso'` object.
RealObjectTypeNames
REAL_OBJECT_TYPE_NAMES
instanceType
Given an instance, it returns the class type: 'systemClass' | 'userClass'
InstanceTypeNames
INSTANCE_TYPE_NAMES
type
Returns the **type name** of the value passed, similar to the flawed [ `typeof` ](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof), but in a much richer, fine-grained & *non-Bad Parts* manner, recognising & many more distinct "real" types.
isType
Returns `true` if the type name passed is a valid type name
TypeNames
TYPE_NAMES
realType
The most fine-grained and granular version of `z.type()`, returning the **Real-World Type Name** of the value passed, not just a general type:
isRealType
Returns `true` if the type name passed is a valid type name
RealTypeNames
REAL_TYPE_NAMES
isAnyJustIterator
Checks if value is any kind of `Iterator` or `AsyncIterator`, including `Generator` and `AsyncGenerator`, but **excluding** standard Iterables (that are legally also Iterators) like `Array`, `Set` & `Map`, that have their own [ `z.type` ](../functions/type ) and are more than Any Just Iterator.
STOP
Use `return STOP` or `return STOP(returnValue)` to stop iteration in callback functions, like `map`, `filter`, `take` etc.
isStop
Returns if value is a `STOP` or `STOP()` (i.e a `Stop` instance with a returnValue, the last of the iteration).
StopClass
An instance that represents a stopping of iteration, carrying an optional "return" value.
Stop
NOTHING
A Symbol that represents the absense of at value at runtime - similar idea to `never` type in TypeScript.
isNothing
Returns if value is a `z.NOTHING`, i.e the absence of any value, in the ZenType/ZenDas world.
isPass
Returns if value is passing, used in various filters and projections.
DataViewType
ArrayBufferCursor
Create an `ArrayBufferCursor` to get an iterator-like reader for an ArrayBuffer. It implements the `DataView` methods under the hood.
mapKeys
Map over the (many) keys/indexes of **any possible input value**, returning a new instance of the same input value type (if possible), with the results of calling the projector/mapping function on every "nested" key/prop/index of the input value.
reduce
ReduceCallback
find
Find and return an item, as soon as `findCb` returns `true` (not truthy).
findKey
Find and return an item, as soon as `findCb` returns `true` (not truthy).
typeIsTrue
Check a type is `true` Useful with `IsEqual`, for a strict type check
typeIsFalse
Check a type is `false` Useful with `IsEqual`, for a strict type check
Any
Any kind of value falls into one of these types, either a single value or a many values holder.
AsyncIteratorOrGenerator
IteratorOrGenerator
GeneratorType
TypedArrayExact
TypedArrayValueType
Returns the value used in the TypedArray, i.e number or bigint
ValueOfStrict
Like type-fest's `ValueOf` but:
IsNestingObject
Returns `true` if the input value is a `NestingObject` :
IfNestingObject
isNestingObject
Checks if input is a Nesting Object - it follows IsNestingObject type
InsideValues
InsideValues
InsideKeys
Like `InsideValue`, but for the keys of the nested values.
GeneratorReturnType
Gets the value type of a Generator or AsyncGenerator
ObjectPropTypes
Props of an object: string and symbol only, unlike number in Arrays indexes, or primitive/objects in Map & Set keys
SymbolObject
Needed because of TS2538: Type symbol cannot be used as an index type
PropertyBag
PropBag helper type - all Pojsos, instances, functions & IArguments that dont have plain props, instead "special" keys/indexes (like array have indexes, maps have keys, sets have values as keys, etc.)
If
If Condition is true, then return Then, else return Else
IfAnd
If both Conditions are true, then return Then, else return Else
IfOr
If either Condition is true, then return Then, else return Else
IfExtends
If T1 extends T2, then return Then (default true), else return Else (default false)
Not
Negates the passed boolean
IsAnyOrUnknown
Returns true if T is any or unknown, otherwise returns false
IfAnyOrUnknown
If T is any or unknown, then return Then, else return Else
IsUndefined
IfUndefined
IsAnyOrUnknownOrUndefined
Returns true if T is any, unknown, undefined
IfAnyOrUnknownOrUndefined
If T is any, unknown, undefined, then return Then, else return Else
IsAbsent
Returns true if T is any, unknown, undefined, null, never, void
IfAbsent
If T is any, unknown, undefined, null, never, void, then return Then, else return Else
IsPropTrue
Returns `true` if TpropName on the Tobject is `true`, `false` if it is `false`, otherwise (if its undefined etc), it returns `Tdefault` (that it self defaults to `false` )
IsPropFalse
PropsOfKnownPrototype
Get the prototype chain's props of `Tinput`, according to the `TkeysOptions` passed, so we can exclude them from the instance props.
PropsValuesOfKnownPrototype
Get the props values based on KeysOptions
NO_TYPE_CHANGE
BaseType
Returns the BaseType of the Tinput, i.e the base type without extra props, but maintaining the same type, including the Type of any Nested values.
PropsOfBaseType
Get all the props of a default known system's object (i.e effectively, its prototype).
PropsOfStringOrSymbol
BasicProps
Returns `string` or `symbol` types, based on the options
PropsStrict
Like Props, excluding props of the BaseType (only own)
Props
Get ALL the props of Tinput object, based on the KeysOptions passed
PropsValues
PropsOfPropType
A type helper to extract the prop names, of props with a matching `TpropType`, i.e the type of the props (i.e `string` or `symbol` ) from any value type.
PropsString
PropsSymbol
InstanceTypeAll
Like InstanceType<T>, but also works for private constructors:
MethodNames
Extract the method key names from a class
PropNames
Extract the non-method key names from a class
JustMethods
Extract the methods from a class, return a new structure with methods only.
JustProps
Create a new type from an object type extracting just properties, not methods.
Unliteral
Convert all literal types to their base type, eg 'foobar' => string, 123 => number, true => boolean, etc.
SingleSystemNames
SingleSystem
SINGLE_SYSTEM_NAMES
SingleNames
SINGLE_NAMES
Single
Matches all Single values, as defined in ZenType. This includes all Primitive types and all TSystemSingles.
IsSingle
IfSingle
SingleOrWeak
Matches a Single or a WeakSet or WeakMap (BUT unfortunately also Set & Map). So, it is BROKEN! Use `IsSingleOrWeak` instead that works fine!
IsSingleOrWeak
Returns true if T is a Single or a WeakSet or WeakMap.
IfSingleOrWeak
IsBoxedPrimitive
IfBoxedPrimitive
isSingleOrWeak
isSingle
Returns `true` if the data type is a "single" or "plain" value, in terms of NOT naturally/normally having compound or "Many" items (eg props, array items etc) inside it that we can iterate over.
isSingleType

Generated using TypeDoc