| Get in O the type of a field of key K
|
| Get the result type of a Promise
|
| Ask TS to re-check that A1 extends A2.
And if it fails, A2 will be enforced anyway.
Can also be used to add constraints on parameters.
|
| Force TS to load a type that has not been computed (to resolve composed
types that TS haven't fully resolved, for display purposes mostly).
|
| Check whether A1 is part of A2 or not. It works like
[[Extends]] but [[Boolean]] results are narrowed to [[False]].
|
| Check whether A1 is equal to A2 or not.
|
| Check whether A1 is part of A2 or not. The difference with
extends is that it forces a [[Boolean]] return.
|
| Check whether A is similar to A1 or not. In other words, it is a compact
type that bundles [[Equals]], [[Extends]], [[Contains]], comparison types.
|
| Describes index keys for any type
|
| |
| Get the known keys of an [[Object]]
|
| Create an asynchronous operation like the original Promise type but this
one prevents promises to be wrapped within more promises (not possible).
|
| Similar to [[Cast]] but with a custom fallback Catch. If it fails,
it will enforce Catch instead of A2.
|
| Create your own opaque sub-type from a type A
|
| A placeholder that is used in various ways
|
| Get in O the type of a field of key K
|
| Get the result type of a Promise
|
| Ask TS to re-check that A1 extends A2.
And if it fails, A2 will be enforced anyway.
Can also be used to add constraints on parameters.
|
| Force TS to load a type that has not been computed (to resolve composed
types that TS haven't fully resolved, for display purposes mostly).
|
| Check whether A1 is part of A2 or not. It works like
[[Extends]] but [[Boolean]] results are narrowed to [[False]].
|
| Check whether A1 is equal to A2 or not.
|
| Check whether A1 is part of A2 or not. The difference with
extends is that it forces a [[Boolean]] return.
|
| Check whether A is similar to A1 or not. In other words, it is a compact
type that bundles [[Equals]], [[Extends]], [[Contains]], comparison types.
|
| Describes index keys for any type
|
| |
| Get the known keys of an [[Object]]
|
| Create an asynchronous operation like the original Promise type but this
one prevents promises to be wrapped within more promises (not possible).
|
| Similar to [[Cast]] but with a custom fallback Catch. If it fails,
it will enforce Catch instead of A2.
|
| Create your own opaque sub-type from a type A
|
| A placeholder that is used in various ways
|
| Logical && operator (behaves like the JS one)
|
| Logical ! operator (behaves like the JS one)
|
| Logical || operator (behaves like the JS one)
|
| Logical ^ operator (behaves like the JS one)
|
| Logical && operator (behaves like the JS one)
|
| Logical ! operator (behaves like the JS one)
|
| Logical || operator (behaves like the JS one)
|
| Logical ^ operator (behaves like the JS one)
|
| Alias to create/describe a class
|
| Get the instance type of a class from a class object
|
| Get the parameters of a class constructor
|
| Alias to create/describe a class
|
| Get the instance type of a class from a class object
|
| Get the parameters of a class constructor
|
| Check whether O, or its sub-objects have fields that match M
where the maximum allowed depth is set with limit.
|
| Determine whether A is literal or not
|
| Auto-complete, validate, and query the string path of an object O
|
| Compose [[Function]]s together
|
| |
| Force A to comply with W. A must be a shape of W. In other words, A
must extend W and have the same properties - no more, no less.
|
| Alias to create a [[Function]]
|
| Extract arguments' length from a [[Function]]
|
| Prevent type widening on generic function parameters
|
| Explain to TS which function parameter has priority for generic inference
|
| Extract parameters from a [[Function]]
|
| Pipe [[Function]]s together
|
| Creates a promisified version of a Function F
|
| Extract the return type of a [[Function]]
|
| Undoes the work that was done by [[Curry]]
|
| Replaces invalid parts of a path with never
|
| Auto-complete, validate, and query the string path of an object O
|
| Compose [[Function]]s together
|
| |
| Force A to comply with W. A must be a shape of W. In other words, A
must extend W and have the same properties - no more, no less.
|
| Alias to create a [[Function]]
|
| Extract arguments' length from a [[Function]]
|
| Prevent type widening on generic function parameters
|
| Explain to TS which function parameter has priority for generic inference
|
| Extract parameters from a [[Function]]
|
| Pipe [[Function]]s together
|
| Creates a promisified version of a Function F
|
| Extract the return type of a [[Function]]
|
| Undoes the work that was done by [[Curry]]
|
| Replaces invalid parts of a path with never
|
| |
| Transform a number into an [[Iteration]]
(to use [[Prev]], [[Next]], & [[Pos]])
|
| Get the position of I (string)
|
| Move I's position forward
|
| Get the position of I (number)
|
| Move I's position backwards
|
| |
| Transform a number into an [[Iteration]]
(to use [[Prev]], [[Next]], & [[Pos]])
|
| Get the position of I (string)
|
| Move I's position forward
|
| Get the position of I (number)
|
| Move I's position backwards
|
| Add an element A at the end of L.
|
| Assign a list of [[List]] into L with [[Merge]]. Merges from left to
right, first items get overridden by the next ones (last-in overrides).
|
| Make that at least one of the keys K are required in L at a time.
|
| Make that L's fields cannot be [[Nullable]] or [[Optional]] (it's like
[[Required]] & [[NonNullable]] at once).
|
| Get the keys of L that are [[Compulsory]]
|
| Attach L1 at the end of L
|
| Get a [[List]] that is the difference between L & L1
(L's differences have priority over L1's if entries overlap)
(If match = 'default', no type checks are done)
|
| Remove N entries out of L
|
| Split L into a [[Union]] with K keys in such a way that none of
the keys are ever present with one another within the different unions.
|
| Exclude the entries of L1 out of L
(If match = 'default', no type checks are done)
|
| Exclude the keys of L1 out of the keys of L
(If match = 'default', no type checks are done)
|
| Pick a range of entries (portion) from L
|
| Filter out of L the entries that match M
|
| Filter out the keys of L which entries match M
|
| Remove all dimensions of L (10 max)
|
| Split L into sub-[[List]]s every N
|
| Check whether L has a entry of key K that matches M
|
| Check whether L has nested entries that match M
|
| |
| Check whether L has entries that match M
|
| Get the intersecting entries of L & L1
(If match = 'default', no type checks are done)
|
| Get the intersecting entries of L & L1
(If match = 'default', no type checks are done)
|
| |
| |
| |
| |
| |
| Get the longest [[List]] of L & L1
(L has priority if both lengths are equal)
|
| Accurately merge the fields of L with the ones of L1. It is
equivalent to the spread operator in JavaScript. [[Union]]s and [[Optional]]
fields will be handled gracefully.
|
| [[Merge]] a list of [[List]]s into L. Merges from left to right, first
items get completed by the next ones (last-in completes).
|
| Modify L with LMod & the [[x]] placeholder
|
| Make some entries of L not nullable (deeply or not)
|
| Get the keys of L that are non-nullable
|
| Make some entries of L nullable (deeply or not)
|
| Get the keys of L that are nullable
|
| Transform a [[List]] into an [[Object]] equivalent
|
| Remove out of L the entries of key K
|
| Make L optional (deeply or not)
|
| Get the keys of L that are optional
|
| Update the entries of L with the ones of L1
|
| Make all fields of O optional (deeply or not)
|
| Complete the fields of L with the ones of L1. This is a version of
[[Merge]] that does NOT handle optional fields, it only completes fields of O
with the ones of O1 if they don't exist.
|
| [[Patch]] a list of [[List]]s into L. Patches from left to right, first
items get completed by the next ones (last-in completes).
|
| Get in L the type of nested properties
|
| Get all the possible paths of L
(⚠️ this won't work with circular-refs)
|
| Extract out of L the entries of key K
|
| Remove the last element out of L
|
| Add an element A at the beginning of L
|
| Make L readonly (deeply or not)
|
| Get the keys of L that are readonly
|
| Remove out of L a range of entries
|
| Fill a [[List]] with N times A
|
| Update with A the entries of L that match M
|
| Make L required (deeply or not)
|
| Get the keys of L that are readonly
|
| Turn a [[List]] the other way around
|
| Extract the entries of L that match M
|
| Get the keys of L which entries match M
|
| Get the shortest [[List]] of L & L1
(L has priority if both lengths are equal)
|
| Remove the first item out of a [[List]]
|
| Extract N entries out of L
|
| Make some entries of L not undefined (deeply or not)
|
| Get the keys of L that are undefined
|
| Make the fields of L union the ones of L1
|
| Transform a [[List]] into an [[Union]]
|
| |
| Update in L the entries of key K with A.
Use the [[x]] placeholder to get the current field type.
|
| Make L writable (deeply or not)
|
| Get the keys of L that are writable
|
| Pair up the entries of L with L1
|
| Create an [[Object]] from [[List]]s of keys & fields
|
| Add an element A at the end of L.
|
| Assign a list of [[List]] into L with [[Merge]]. Merges from left to
right, first items get overridden by the next ones (last-in overrides).
|
| Make that at least one of the keys K are required in L at a time.
|
| Make that L's fields cannot be [[Nullable]] or [[Optional]] (it's like
[[Required]] & [[NonNullable]] at once).
|
| Get the keys of L that are [[Compulsory]]
|
| Attach L1 at the end of L
|
| Get a [[List]] that is the difference between L & L1
(L's differences have priority over L1's if entries overlap)
(If match = 'default', no type checks are done)
|
| Remove N entries out of L
|
| Split L into a [[Union]] with K keys in such a way that none of
the keys are ever present with one another within the different unions.
|
| Exclude the entries of L1 out of L
(If match = 'default', no type checks are done)
|
| Exclude the keys of L1 out of the keys of L
(If match = 'default', no type checks are done)
|
| Pick a range of entries (portion) from L
|
| Filter out of L the entries that match M
|
| Filter out the keys of L which entries match M
|
| Remove all dimensions of L (10 max)
|
| Split L into sub-[[List]]s every N
|
| Check whether L has a entry of key K that matches M
|
| Check whether L has nested entries that match M
|
| |
| Check whether L has entries that match M
|
| Get the intersecting entries of L & L1
(If match = 'default', no type checks are done)
|
| Get the intersecting entries of L & L1
(If match = 'default', no type checks are done)
|
| |
| |
| |
| |
| |
| Get the longest [[List]] of L & L1
(L has priority if both lengths are equal)
|
| Accurately merge the fields of L with the ones of L1. It is
equivalent to the spread operator in JavaScript. [[Union]]s and [[Optional]]
fields will be handled gracefully.
|
| [[Merge]] a list of [[List]]s into L. Merges from left to right, first
items get completed by the next ones (last-in completes).
|
| Modify L with LMod & the [[x]] placeholder
|
| Make some entries of L not nullable (deeply or not)
|
| Get the keys of L that are non-nullable
|
| Make some entries of L nullable (deeply or not)
|
| Get the keys of L that are nullable
|
| Transform a [[List]] into an [[Object]] equivalent
|
| Remove out of L the entries of key K
|
| Make L optional (deeply or not)
|
| Get the keys of L that are optional
|
| Update the entries of L with the ones of L1
|
| Make all fields of O optional (deeply or not)
|
| Complete the fields of L with the ones of L1. This is a version of
[[Merge]] that does NOT handle optional fields, it only completes fields of O
with the ones of O1 if they don't exist.
|
| [[Patch]] a list of [[List]]s into L. Patches from left to right, first
items get completed by the next ones (last-in completes).
|
| Get in L the type of nested properties
|
| Get all the possible paths of L
(⚠️ this won't work with circular-refs)
|
| Extract out of L the entries of key K
|
| Remove the last element out of L
|
| Add an element A at the beginning of L
|
| Make L readonly (deeply or not)
|
| Get the keys of L that are readonly
|
| Remove out of L a range of entries
|
| Fill a [[List]] with N times A
|
| Update with A the entries of L that match M
|
| Make L required (deeply or not)
|
| Get the keys of L that are readonly
|
| Turn a [[List]] the other way around
|
| Extract the entries of L that match M
|
| Get the keys of L which entries match M
|
| Get the shortest [[List]] of L & L1
(L has priority if both lengths are equal)
|
| Remove the first item out of a [[List]]
|
| Extract N entries out of L
|
| Make some entries of L not undefined (deeply or not)
|
| Get the keys of L that are undefined
|
| Make the fields of L union the ones of L1
|
| Transform a [[List]] into an [[Union]]
|
| |
| Update in L the entries of key K with A.
Use the [[x]] placeholder to get the current field type.
|
| Make L writable (deeply or not)
|
| Get the keys of L that are writable
|
| Pair up the entries of L with L1
|
| Create an [[Object]] from [[List]]s of keys & fields
|
| |
| |
| |
| |
| |
| |
| |
| |
| Get the absolute value of a [[Number]]
|
| Add a [[Number]] to another one
|
| Check if a [[Number]] is bigger than another one
|
| Check if a [[Number]] is greater or equal to another one
|
| Check whether a [[Number]] is negative or not
|
| Check whether a [[Number]] is positive or not
|
| Check whether a [[Number]] is null or not
|
| Check if a [[Number]] is lower than another one
|
| Check if a [[Number]] is lower or equal to another one
|
| |
| Create a range of * *number**s
|
| Subtract a [[Number]] from another one
|
| Get the absolute value of a [[Number]]
|
| Add a [[Number]] to another one
|
| Check if a [[Number]] is bigger than another one
|
| Check if a [[Number]] is greater or equal to another one
|
| Check whether a [[Number]] is negative or not
|
| Check whether a [[Number]] is positive or not
|
| Check whether a [[Number]] is null or not
|
| Check if a [[Number]] is lower than another one
|
| Check if a [[Number]] is lower or equal to another one
|
| |
| Create a range of * *number**s
|
| Subtract a [[Number]] from another one
|
| Assign a list of [[Object]] into O with [[Merge]]. Merges from right to
left, first items get overridden by the next ones (last-in overrides).
|
| Make that at least one of the keys K are required in O at a time.
|
| Make that O's fields cannot be [[Nullable]] or [[Optional]] (it's like
[[Required]] & [[NonNullable]] at once).
|
| Get the keys of O that are [[Compulsory]]
|
| Get an [[Object]] that is the difference between O & O1
(O's differences have priority over O1's if fields overlap)
(If match = 'default', no type checks are done)
|
| Split O into a [[Union]] with K keys in such a way that none of
the keys are ever present with one another within the different unions.
|
| Exclude the fields of O1 out of O
(If match = 'default', no type checks are done)
|
| Exclude the keys of O1 out of the keys of O
(If match = 'default', no type checks are done)
|
| Filter out of O the fields that match M
|
| Filter out the keys of O which fields match M
|
| Check whether O has a field of key K that matches M
|
| Check whether O has nested properties that match M
|
| Check whether O has fields that match M
|
| Get the intersecting fields of O & O1
(If match = 'default', no type checks are done)
|
| Get the intersecting keys of O & O1
(If match = 'default', no type checks are done)
|
| Swaps the keys and values of an [[Object]] (if applicable)
|
| Transform an [[Object]] into a [[List]]
(It will only pick numeric literal indexes)
|
| Accurately merge the fields of O with the ones of O1. It is
equivalent to the spread operator in JavaScript. [[Union]]s and [[Optional]]
fields will be handled gracefully.
|
| [[Merge]] a list of [[Object]]s into O. Merges from left to right, first
items get completed by the next ones (last-in completes).
|
| Modify O with OMod & the [[x]] placeholder
|
| Make some fields of O not nullable (deeply or not)
(Optional fields will be left untouched & undefined)
|
| Get the keys of O that are non-nullable
|
| Make some fields of O nullable (deeply or not)
|
| Get the keys of O that are nullable
|
| |
| Remove out of O the fields of key K
|
| Make some fields of O optional (deeply or not)
|
| Get the keys of O that are optional
|
| Update the fields of O with the ones of O1
(only the existing fields will be updated)
|
| Complete the fields of O at Path with the ones of O1
|
| Remove out of O the fields at Path
|
| Extract out of O the fields at Path
|
| Make some fields of O readonly at Path (deeply or not)
|
| Create an object filled with A for the fields at the end of Path
|
| Update in O the fields at Path with A
|
| Make all fields of O optional (deeply or not)
|
| Complete the fields of O with the ones of O1. This is a version of
[[Merge]] that does NOT handle optional fields, it only completes fields of
O with the ones of O1.
|
| [[Patch]] a list of [[Object]]s into O. Patches from left to right, first
items get completed by the next ones (last-in completes).
|
| Get in O the type of nested properties
|
| Get all the possible paths of O
(⚠️ this won't work with circular-refs)
|
| Extract out of O the fields of key K
|
| Make some fields of O readonly (deeply or not)
|
| Get the keys of O that are readonly
|
| Create an object filled with A for the fields K
|
| Update with A the fields of O that match M
|
| Make some fields of O required (deeply or not)
|
| Get the keys of O that are required
|
| Extract the fields of O that match M
|
| Get the keys of O which fields match M
|
| Make some fields of O undefined (deeply or not)
|
| Get the keys of O that are undefined
(⚠️ needs --strictNullChecks enabled)
|
| Make the fields of O union the ones of O1
|
| Transform an [[Object]] into an [[Union]]
|
| Update in O the fields of key K with A.
Use the [[x]] placeholder to get the current field type.
|
| Make some fields of O writable (deeply or not)
|
| Get the keys of O that are writable
|
| Assign a list of [[Object]] into O with [[Merge]]. Merges from right to
left, first items get overridden by the next ones (last-in overrides).
|
| Make that at least one of the keys K are required in O at a time.
|
| Make that O's fields cannot be [[Nullable]] or [[Optional]] (it's like
[[Required]] & [[NonNullable]] at once).
|
| Get the keys of O that are [[Compulsory]]
|
| Get an [[Object]] that is the difference between O & O1
(O's differences have priority over O1's if fields overlap)
(If match = 'default', no type checks are done)
|
| Split O into a [[Union]] with K keys in such a way that none of
the keys are ever present with one another within the different unions.
|
| Exclude the fields of O1 out of O
(If match = 'default', no type checks are done)
|
| Exclude the keys of O1 out of the keys of O
(If match = 'default', no type checks are done)
|
| Filter out of O the fields that match M
|
| Filter out the keys of O which fields match M
|
| Check whether O has a field of key K that matches M
|
| Check whether O has nested properties that match M
|
| Check whether O has fields that match M
|
| Get the intersecting fields of O & O1
(If match = 'default', no type checks are done)
|
| Get the intersecting keys of O & O1
(If match = 'default', no type checks are done)
|
| Swaps the keys and values of an [[Object]] (if applicable)
|
| Transform an [[Object]] into a [[List]]
(It will only pick numeric literal indexes)
|
| Accurately merge the fields of O with the ones of O1. It is
equivalent to the spread operator in JavaScript. [[Union]]s and [[Optional]]
fields will be handled gracefully.
|
| [[Merge]] a list of [[Object]]s into O. Merges from left to right, first
items get completed by the next ones (last-in completes).
|
| Modify O with OMod & the [[x]] placeholder
|
| Make some fields of O not nullable (deeply or not)
(Optional fields will be left untouched & undefined)
|
| Get the keys of O that are non-nullable
|
| Make some fields of O nullable (deeply or not)
|
| Get the keys of O that are nullable
|
| |
| Remove out of O the fields of key K
|
| Make some fields of O optional (deeply or not)
|
| Get the keys of O that are optional
|
| Update the fields of O with the ones of O1
(only the existing fields will be updated)
|
| Complete the fields of O at Path with the ones of O1
|
| Remove out of O the fields at Path
|
| Extract out of O the fields at Path
|
| Make some fields of O readonly at Path (deeply or not)
|
| Create an object filled with A for the fields at the end of Path
|
| Update in O the fields at Path with A
|
| Make all fields of O optional (deeply or not)
|
| Complete the fields of O with the ones of O1. This is a version of
[[Merge]] that does NOT handle optional fields, it only completes fields of
O with the ones of O1.
|
| [[Patch]] a list of [[Object]]s into O. Patches from left to right, first
items get completed by the next ones (last-in completes).
|
| Get in O the type of nested properties
|
| Get all the possible paths of O
(⚠️ this won't work with circular-refs)
|
| Extract out of O the fields of key K
|
| Make some fields of O readonly (deeply or not)
|
| Get the keys of O that are readonly
|
| Create an object filled with A for the fields K
|
| Update with A the fields of O that match M
|
| Make some fields of O required (deeply or not)
|
| Get the keys of O that are required
|
| Extract the fields of O that match M
|
| Get the keys of O which fields match M
|
| Make some fields of O undefined (deeply or not)
|
| Get the keys of O that are undefined
(⚠️ needs --strictNullChecks enabled)
|
| Make the fields of O union the ones of O1
|
| Transform an [[Object]] into an [[Union]]
|
| Update in O the fields of key K with A.
Use the [[x]] placeholder to get the current field type.
|
| Make some fields of O writable (deeply or not)
|
| Get the keys of O that are writable
|
| Get the character at position K
|
| Concat many literals together
|
| Get the length of a string
|
| |
| Split S by D into a [[List]]
|
| Get the character at position K
|
| Concat many literals together
|
| Get the length of a string
|
| |
| Split S by D into a [[List]]
|
| Add an element A at the end of L.
|
| Assign a list of [[List]] into L with [[Merge]]. Merges from left to
right, first items get overridden by the next ones (last-in overrides).
|
| Make that at least one of the keys K are required in L at a time.
|
| Make that L's fields cannot be [[Nullable]] or [[Optional]] (it's like
[[Required]] & [[NonNullable]] at once).
|
| Get the keys of L that are [[Compulsory]]
|
| Attach L1 at the end of L
|
| Get a [[List]] that is the difference between L & L1
(L's differences have priority over L1's if entries overlap)
(If match = 'default', no type checks are done)
|
| Remove N entries out of L
|
| Split L into a [[Union]] with K keys in such a way that none of
the keys are ever present with one another within the different unions.
|
| Exclude the entries of L1 out of L
(If match = 'default', no type checks are done)
|
| Exclude the keys of L1 out of the keys of L
(If match = 'default', no type checks are done)
|
| Pick a range of entries (portion) from L
|
| Filter out of L the entries that match M
|
| Filter out the keys of L which entries match M
|
| Remove all dimensions of L (10 max)
|
| Split L into sub-[[List]]s every N
|
| Check whether L has a entry of key K that matches M
|
| Check whether L has nested entries that match M
|
| |
| Check whether L has entries that match M
|
| Get the intersecting entries of L & L1
(If match = 'default', no type checks are done)
|
| Get the intersecting entries of L & L1
(If match = 'default', no type checks are done)
|
| |
| |
| |
| |
| |
| Get the longest [[List]] of L & L1
(L has priority if both lengths are equal)
|
| Accurately merge the fields of L with the ones of L1. It is
equivalent to the spread operator in JavaScript. [[Union]]s and [[Optional]]
fields will be handled gracefully.
|
| [[Merge]] a list of [[List]]s into L. Merges from left to right, first
items get completed by the next ones (last-in completes).
|
| Modify L with LMod & the [[x]] placeholder
|
| Make some entries of L not nullable (deeply or not)
|
| Get the keys of L that are non-nullable
|
| Make some entries of L nullable (deeply or not)
|
| Get the keys of L that are nullable
|
| Transform a [[List]] into an [[Object]] equivalent
|
| Remove out of L the entries of key K
|
| Make L optional (deeply or not)
|
| Get the keys of L that are optional
|
| Update the entries of L with the ones of L1
|
| Make all fields of O optional (deeply or not)
|
| Complete the fields of L with the ones of L1. This is a version of
[[Merge]] that does NOT handle optional fields, it only completes fields of O
with the ones of O1 if they don't exist.
|
| [[Patch]] a list of [[List]]s into L. Patches from left to right, first
items get completed by the next ones (last-in completes).
|
| Get in L the type of nested properties
|
| Get all the possible paths of L
(⚠️ this won't work with circular-refs)
|
| Extract out of L the entries of key K
|
| Remove the last element out of L
|
| Add an element A at the beginning of L
|
| Make L readonly (deeply or not)
|
| Get the keys of L that are readonly
|
| Remove out of L a range of entries
|
| Fill a [[List]] with N times A
|
| Update with A the entries of L that match M
|
| Make L required (deeply or not)
|
| Get the keys of L that are readonly
|
| Turn a [[List]] the other way around
|
| Extract the entries of L that match M
|
| Get the keys of L which entries match M
|
| Get the shortest [[List]] of L & L1
(L has priority if both lengths are equal)
|
| Remove the first item out of a [[List]]
|
| Extract N entries out of L
|
| Make some entries of L not undefined (deeply or not)
|
| Get the keys of L that are undefined
|
| Make the fields of L union the ones of L1
|
| Transform a [[List]] into an [[Union]]
|
| |
| Update in L the entries of key K with A.
Use the [[x]] placeholder to get the current field type.
|
| Make L writable (deeply or not)
|
| Get the keys of L that are writable
|
| Pair up the entries of L with L1
|
| Create an [[Object]] from [[List]]s of keys & fields
|
| |
| |
| Add an element A at the end of L.
|
| Assign a list of [[List]] into L with [[Merge]]. Merges from left to
right, first items get overridden by the next ones (last-in overrides).
|
| Make that at least one of the keys K are required in L at a time.
|
| Make that L's fields cannot be [[Nullable]] or [[Optional]] (it's like
[[Required]] & [[NonNullable]] at once).
|
| Get the keys of L that are [[Compulsory]]
|
| Attach L1 at the end of L
|
| Get a [[List]] that is the difference between L & L1
(L's differences have priority over L1's if entries overlap)
(If match = 'default', no type checks are done)
|
| Remove N entries out of L
|
| Split L into a [[Union]] with K keys in such a way that none of
the keys are ever present with one another within the different unions.
|
| Exclude the entries of L1 out of L
(If match = 'default', no type checks are done)
|
| Exclude the keys of L1 out of the keys of L
(If match = 'default', no type checks are done)
|
| Pick a range of entries (portion) from L
|
| Filter out of L the entries that match M
|
| Filter out the keys of L which entries match M
|
| Remove all dimensions of L (10 max)
|
| Split L into sub-[[List]]s every N
|
| Check whether L has a entry of key K that matches M
|
| Check whether L has nested entries that match M
|
| |
| Check whether L has entries that match M
|
| Get the intersecting entries of L & L1
(If match = 'default', no type checks are done)
|
| Get the intersecting entries of L & L1
(If match = 'default', no type checks are done)
|
| |
| |
| |
| |
| |
| Get the longest [[List]] of L & L1
(L has priority if both lengths are equal)
|
| Accurately merge the fields of L with the ones of L1. It is
equivalent to the spread operator in JavaScript. [[Union]]s and [[Optional]]
fields will be handled gracefully.
|
| [[Merge]] a list of [[List]]s into L. Merges from left to right, first
items get completed by the next ones (last-in completes).
|
| Modify L with LMod & the [[x]] placeholder
|
| Make some entries of L not nullable (deeply or not)
|
| Get the keys of L that are non-nullable
|
| Make some entries of L nullable (deeply or not)
|
| Get the keys of L that are nullable
|
| Transform a [[List]] into an [[Object]] equivalent
|
| Remove out of L the entries of key K
|
| Make L optional (deeply or not)
|
| Get the keys of L that are optional
|
| Update the entries of L with the ones of L1
|
| Make all fields of O optional (deeply or not)
|
| Complete the fields of L with the ones of L1. This is a version of
[[Merge]] that does NOT handle optional fields, it only completes fields of O
with the ones of O1 if they don't exist.
|
| [[Patch]] a list of [[List]]s into L. Patches from left to right, first
items get completed by the next ones (last-in completes).
|
| Get in L the type of nested properties
|
| Get all the possible paths of L
(⚠️ this won't work with circular-refs)
|
| Extract out of L the entries of key K
|
| Remove the last element out of L
|
| Add an element A at the beginning of L
|
| Make L readonly (deeply or not)
|
| Get the keys of L that are readonly
|
| Remove out of L a range of entries
|
| Fill a [[List]] with N times A
|
| Update with A the entries of L that match M
|
| Make L required (deeply or not)
|
| Get the keys of L that are readonly
|
| Turn a [[List]] the other way around
|
| Extract the entries of L that match M
|
| Get the keys of L which entries match M
|
| Get the shortest [[List]] of L & L1
(L has priority if both lengths are equal)
|
| Remove the first item out of a [[List]]
|
| Extract N entries out of L
|
| Make some entries of L not undefined (deeply or not)
|
| Get the keys of L that are undefined
|
| Make the fields of L union the ones of L1
|
| Transform a [[List]] into an [[Union]]
|
| |
| Update in L the entries of key K with A.
Use the [[x]] placeholder to get the current field type.
|
| Make L writable (deeply or not)
|
| Get the keys of L that are writable
|
| Pair up the entries of L with L1
|
| Create an [[Object]] from [[List]]s of keys & fields
|
| Get an [[Union]] that is the difference between U1 & U2
|
| |
| |
| Check whether U contains U1
|
| Get the overlapping members of U1 and U2
|
| Transform a [[Union]] to an * intersection*
|
| Get the last item within an [[Union]]
(⚠️ it might not preserve order)
|
| Transform a [[Union]] into a [[List]]
(⚠️ it might not preserve order)
|
| Merge a [[Union]] of [[Object]]s into a single one
|
| Remove undefined & null out of U
|
| Add undefined | null to U
|
| Remove an item out of U
(⚠️ it might not preserve order)
|
| |
| Extract the part of U that matches M
|
| |
| Get an [[Union]] that is the difference between U1 & U2
|
| |
| |
| Check whether U contains U1
|
| Get the overlapping members of U1 and U2
|
| Transform a [[Union]] to an * intersection*
|
| Get the last item within an [[Union]]
(⚠️ it might not preserve order)
|
| Transform a [[Union]] into a [[List]]
(⚠️ it might not preserve order)
|
| Merge a [[Union]] of [[Object]]s into a single one
|
| Remove undefined & null out of U
|
| Add undefined | null to U
|
| Remove an item out of U
(⚠️ it might not preserve order)
|
| |
| Extract the part of U that matches M
|
| |