Sign In with GitHub
Sign In with GitLab@std/collections@0.215.0
latest
Works with
•JSR Score70%•It is unknown whether this package works with Browsers, Deno, Node.js, Cloudflare Workers, Bun
Downloads1/wk
•Published2 years ago (0.215.0)
- @std/collections
deep_merge
- all symbols
- default
- aggregate_groups
- associate_by
- associate_with
- chunk
- deep_merge
- distinct
- distinct_by
- drop_last_while
- drop_while
- filter_entries
- filter_keys
- filter_values
- find_single
- first_not_nullish_of
- includes_value
- intersect
- join_to_string
- map_entries
- map_keys
- map_not_nullish
- map_values
- max_by
- max_of
- max_with
- min_by
- min_of
- min_with
- partition
- partition_entries
- permutations
- reduce_groups
- running_reduce
- sample
- sliding_windows
- sort_by
- sum_of
- take_last_while
- take_while
- union
- unzip
- without_all
- zip
Functions
f
deepMerge<>(): DeepMerge<T, U, Options>
T extends Record<PropertyKey, unknown>,
U extends Record<PropertyKey, unknown>,
Options extends DeepMergeOptions = { arrays: "merge"; sets: "merge"; maps: "merge"; }
record: Readonly<T>,
other: Readonly<U>,
options?: Readonly<Options>
2 overloads
Merges the two given Records, recursively merging any nested Records with the second collection overriding the first in case of conflict
Type Aliases
T
ArrayValueType<T> = T extends Array<infer V> ? V : never
Get array values type
T
DeepMerge<T, U, Options = Record<string, MergingStrategy>> = [T, U] extends [Record<PropertyKey, unknown>, Record<PropertyKey, unknown>] ? Merge<T, U, Options> : T | U
Merge deeply two objects
T
DeepMergeOptions = { arrays?: MergingStrategy; maps?: MergingStrategy; sets?: MergingStrategy; }
Deep merge options
T
ExpandRecursively<T> = T extends Record<PropertyKey, unknown> ? T extends infer O ? [K in keyof O]: ExpandRecursively<O[K]> : never : T
Force intellisense to expand the typing to hide merging typings
T
MapKeyType<T> = T extends Map<infer K, unknown> ? K : never
Get map values types
T
MapValueType<T> = T extends Map<unknown, infer V> ? V : never
Get map values types
T
Merge<> = ExpandRecursively<X>
T,
U,
Options,
X =
MergeRightOmitComplexes<T, U>
& MergeAllRecords<T, U, Options>
& (Options extends { sets: "replace"; } ? PartialByType<U, Set<unknown>> : MergeAllSets<T, U>)
& (Options extends { arrays: "replace"; } ? PartialByType<U, Array<unknown>> : MergeAllArrays<T, U>)
& (Options extends { maps: "replace"; } ? PartialByType<U, Map<unknown, unknown>> : MergeAllMaps<T, U>)
& MergeAllRecords<T, U, Options>
& (Options extends { sets: "replace"; } ? PartialByType<U, Set<unknown>> : MergeAllSets<T, U>)
& (Options extends { arrays: "replace"; } ? PartialByType<U, Array<unknown>> : MergeAllArrays<T, U>)
& (Options extends { maps: "replace"; } ? PartialByType<U, Map<unknown, unknown>> : MergeAllMaps<T, U>)
Merge two objects
T
MergeAllArrays<> = Z
T,
U,
X = PartialByType<T, Array<unknown>>,
Y = PartialByType<U, Array<unknown>>,
Z = [K in keyof X & keyof Y]: Array<ArrayValueType<X[K]> | ArrayValueType<Y[K]>>
Merge all sets types definitions from keys present in both objects
T
MergeAllMaps<> = Z
T,
U,
X = PartialByType<T, Map<unknown, unknown>>,
Y = PartialByType<U, Map<unknown, unknown>>,
Z = [K in keyof X & keyof Y]: Map<>
MapKeyType<X[K]> | MapKeyType<Y[K]>,
MapValueType<X[K]> | MapValueType<Y[K]>
Merge all sets types definitions from keys present in both objects
T
MergeAllRecords<> = Z
T,
U,
Options,
X = PartialByType<T, Record<PropertyKey, unknown>>,
Y = PartialByType<U, Record<PropertyKey, unknown>>,
Z = [K in keyof X & keyof Y]: DeepMerge<X[K], Y[K], Options>
Merge all records types definitions from keys present in both objects
T
MergeAllSets<> = Z
T,
U,
X = PartialByType<T, Set<unknown>>,
Y = PartialByType<U, Set<unknown>>,
Z = [K in keyof X & keyof Y]: Set<SetValueType<X[K]> | SetValueType<Y[K]>>
Merge all sets types definitions from keys present in both objects
T
MergeRightOmitComplexes<T, U, X = ObjectXorKeys<T, U> & OmitComplexes<[K in keyof U]: U[K]>> = X
Merge two objects, with left precedence
T
MergingStrategy = "replace" | "merge"
Merging strategy
T
ObjectXorKeys<> = Y
T,
U,
X = Omit<T, keyof U> & Omit<U, keyof T>,
Y = [K in keyof X]: X[K]
Object with keys in either T or U but not in both
T
OmitComplexes<T> = Omit<>
T,
keyof PartialByType<>
T,
Map<unknown, unknown>
| Set<unknown>
| Array<unknown>
| Record<PropertyKey, unknown>
| Set<unknown>
| Array<unknown>
| Record<PropertyKey, unknown>
Exclude map, sets and array from type
T
PartialByType<T, U> = [K in keyof T in keyof T[K] extends U ? K : never]: T[K]
Filter of keys matching a given type
T
SetValueType<T> = T extends Set<infer V> ? V : never
Get set values type