@ix-xs/node-comfort 1.2.0 → 2.0.0

package/types/src/Num.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Num.d.ts","sourceRoot":"","sources":["../../src/Num.js"],"names":[],"mappings":"AAOE;;;;;;;;;;;GAWG;AACH,6BALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;GAOG;AACH,+BALW,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;;;;GASG;AACH,6BAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;GAMG;AACH,6BAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;GAMG;AACH,4BAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;;;;;GAUG;AACH,4BALW,MAAM,OACN,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;GAYG;AACH,gCAPW,MAAM,SACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;;;GAQG;AACH,6BAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;GASG;AACH,+BAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;GAKG;AACH,4BAHW,MAAM,EAAE,GACN,MAAM,CAIlB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,EAAE,GACN,MAAM,CAIlB;AAED;;;;;GAKG;AACH,+BAHW,MAAM,EAAE,GACN,MAAM,CAOlB;AAED;;;;;GAKG;AACH,4BAHW,MAAM,EAAE,GACN,MAAM,GAAC,SAAS,CAI5B;AAED;;;;;GAKG;AACH,4BAHW,MAAM,EAAE,GACN,MAAM,GAAC,SAAS,CAI5B;AAED;;;;;;;;;;GAUG;AACH,+BALW,MAAM,SACN,MAAM,aACN,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,mCAJW,MAAM,YACN;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,GACpD,MAAM,CAalB;AAED;;;;;;;;;;GAUG;AACH,kCAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAelB;AAED;;;;;;;;;;GAUG;AACH,iCAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;;;;GASG;AACH,+BAHW,MAAM,GACJ,MAAM,CASlB;AAED;;;;;;;;;;GAUG;AACH,6BAJW,GAAC,aACD,MAAM,GACJ,MAAM,CAMlB;AAED;;;;GAIG;AACH,8BAHW,MAAM,GACJ,OAAO,CAInB;AAED;;;;GAIG;AACH,6BAHW,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6BALW,MAAM,QACN,MAAM,SACN,MAAM,GACJ,MAAM,EAAE,CAkBpB"}
+{"version":3,"file":"Num.d.ts","sourceRoot":"","sources":["../../src/Num.js"],"names":[],"mappings":"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"}

package/types/src/Obj.d.ts

@@ -1,189 +1,475 @@
+declare namespace _exports {
+    export { PathLeaf, Paths, NullishToUndefined, PathValue, PathStep, PathInput, DeepReadonly, Change, MergeOptions, CompactOptions };
+}
+declare namespace _exports {
+    export { clone };
+    export { merge };
+    export { mergeWith };
+    export { defaults };
+    export { equal };
+    export { diff };
+    export { get };
+    export { set };
+    export { unset };
+    export { has };
+    export { pick };
+    export { omit };
+    export { filter };
+    export { mapValues };
+    export { mapKeys };
+    export { renameKeys };
+    export { invert };
+    export { compact };
+    export { flatten };
+    export { unflatten };
+    export { keys };
+    export { entries };
+    export { fromEntries };
+    export { size };
+    export { isEmpty };
+    export { deepFreeze };
+}
+export = _exports;
 /**
- * Deeply clones a value.
+ * Values that end a path: dates, regexes, maps, sets, functions and arrays.
+ */
+type PathLeaf = Date | RegExp | Map<any, any> | Set<any> | ((...args: any[]) => any) | readonly any[];
+/**
+ * Every dotted path of an object type, up to 6 levels. This is what powers
+ * path completion in `obj.get()` and friends.
+ */
+type Paths<T, Depth extends unknown[] = []> = Depth["length"] extends 6 ? never : T extends PathLeaf ? never : T extends object ? { [K in keyof T & (string | number)]: NonNullable<T[K]> extends PathLeaf ? `${K}` : NonNullable<T[K]> extends object ? `${K}` | `${K}.${Paths<NonNullable<T[K]>, [...Depth, 0]>}` : `${K}`; }[keyof T & (string | number)] : never;
+type NullishToUndefined<T> = [Extract<T, null | undefined>] extends [never] ? never : undefined;
+/**
+ * The type found at a dotted path of `T`, or `any` for an unknown path.
+ */
+type PathValue<T, P extends string> = P extends `${infer Head}.${infer Rest}` ? PathStep<T, Head> extends infer Next ? ([Next] extends [typeof _NOT_FOUND] ? any : PathValue<Next, Rest> | NullishToUndefined<T>) : any : PathStep<T, P> extends infer Next ? ([Next] extends [typeof _NOT_FOUND] ? any : Next | NullishToUndefined<T>) : any;
+type PathStep<T, K extends string> = K extends keyof NonNullable<T> ? NonNullable<T>[K] : NonNullable<T> extends readonly (infer E)[] ? (K extends `${number}` ? E | undefined : typeof _NOT_FOUND) : typeof _NOT_FOUND;
+/**
+ * A path: a known dotted path (completed by your editor), any other string
+ * like `"items[0].name"`, or an array of keys.
+ */
+type PathInput<T> = Paths<T> | (string & {}) | ReadonlyArray<string | number>;
+/**
+ * `T`, read-only all the way down.
+ */
+type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]>; } : T;
+/**
+ * One difference reported by `diff()`.
+ */
+type Change = {
+    /**
+     * Where it changed, like `["address", "city"]`.
+     */
+    path: Array<string | number>;
+    type: "added" | "removed" | "changed";
+    /**
+     * The old value.
+     */
+    from?: unknown;
+    /**
+     * The new value.
+     */
+    to?: unknown;
+};
+/**
+ * Options for `mergeWith()`.
+ */
+type MergeOptions = {
+    /**
+     * When both sides have an array: keep the last, join them, or join without duplicates. Defaults to `"replace"`.
+     */
+    arrays?: "concat" | "replace" | "unique" | undefined;
+    /**
+     * Don't let `undefined` overwrite an existing value.
+     */
+    skipUndefined?: boolean | undefined;
+};
+/**
+ * Options for `compact()`.
+ */
+type CompactOptions = {
+    /**
+     * Clean nested objects and arrays too.
+     */
+    deep?: boolean | undefined;
+    /**
+     * Also remove `""`, `[]` and `{}`.
+     */
+    removeEmpty?: boolean | undefined;
+};
+/**
+ * Deep copy. Uses `structuredClone` when it can, and falls back to a copy
+ * that keeps functions and class prototypes.
+ *
+ * @example
+ * const copy = obj.clone({ a: { b: [1, 2] }, when: new Date() });
+ * copy.a.b.push(3); // the original is untouched
+ *
+ * @template T
+ * @param {T} value
+ * @returns {T}
+ */
+declare function clone<T>(value: T): T;
+/**
+ * Deep-merges objects into a new one. Later objects win, nested objects are
+ * merged, arrays are replaced. See `mergeWith()` to join arrays instead.
+ *
+ * @example
+ * obj.merge({ db: { host: "localhost", port: 5432 } }, { db: { port: 6543 } });
+ * // { db: { host: "localhost", port: 6543 } }
+ *
+ * @template {object} A
+ * @overload
+ * @param {A} a
+ * @returns {A}
+ */
+declare function merge<A extends object>(a: A): A;
+/**
+ * Deep-merges `b` into a copy of `a`.
+ *
+ * @template {object} A
+ * @template {object} B
+ * @overload
+ * @param {A} a
+ * @param {B} b
+ * @returns {A & B}
+ */
+declare function merge<A extends object, B extends object>(a: A, b: B): A & B;
+/**
+ * Deep-merges three objects; the last one wins.
+ *
+ * @template {object} A
+ * @template {object} B
+ * @template {object} C
+ * @overload
+ * @param {A} a
+ * @param {B} b
+ * @param {C} c
+ * @returns {A & B & C}
+ */
+declare function merge<A extends object, B extends object, C extends object>(a: A, b: B, c: C): A & B & C;
+/**
+ * Deep-merges any number of objects; the last one wins.
+ *
+ * @overload
+ * @param {...object} sources
+ * @returns {Record<string, any>}
+ */
+declare function merge(...sources: object[]): Record<string, any>;
+/**
+ * Like `merge()`, with a choice of what happens to arrays and `undefined`.
+ *
+ * @example
+ * obj.mergeWith({ arrays: "unique" }, { tags: ["a", "b"] }, { tags: ["b", "c"] });
+ * // { tags: ["a", "b", "c"] }
+ * obj.mergeWith({ skipUndefined: true }, { port: 80 }, { port: undefined });
+ * // { port: 80 }
+ *
+ * @param {MergeOptions} options
+ * @param {...object} sources
+ * @returns {Record<string, any>}
+ */
+declare function mergeWith(options: MergeOptions, ...sources: object[]): Record<string, any>;
+/**
+ * Fills in missing properties from defaults, deeply. Values that are set,
+ * even `null` or `0`, are kept.
+ *
+ * @example
+ * obj.defaults({ port: 8080, db: { user: "me" } }, { port: 80, db: { user: "root", pass: "" } });
+ * // { port: 8080, db: { user: "me", pass: "" } }
+ *
+ * @template {object} T
+ * @template {object} D
+ * @param {T} target
+ * @param {...D} sources The first one has the highest priority.
+ * @returns {T & D}
+ */
+declare function defaults<T extends object, D extends object>(target: T, ...sources: D[]): T & D;
+/**
+ * Deep equality. Knows about arrays, dates, regexes, maps, sets, typed
+ * arrays, `NaN` and circular references.
+ *
+ * @example
+ * obj.equal({ a: [1, { b: 2 }] }, { a: [1, { b: 2 }] }); // true
+ * obj.equal(new Set([1, 2]), new Set([2, 1]));          // true
+ * obj.equal({ a: 1 }, { a: 1, b: undefined });          // false
+ *
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+declare function equal(a: unknown, b: unknown): boolean;
+/**
+ * Lists what changed between two values, deeply. Handy for audit logs and
+ * partial updates.
  *
- * Uses the native `structuredClone` when the value supports it (plain data,
- * Dates, Maps, Sets, typed arrays, ...), and falls back to a manual deep copy
- * otherwise. Functions are copied by reference.
+ * @example
+ * obj.diff({ name: "Ada", tags: ["a"] }, { name: "Ada L.", tags: ["a", "b"] });
+ * // [
+ * //   { path: ["name"], type: "changed", from: "Ada", to: "Ada L." },
+ * //   { path: ["tags", 1], type: "added", to: "b" },
+ * // ]
+ *
+ * @param {unknown} before
+ * @param {unknown} after
+ * @returns {Change[]} Empty when nothing changed.
+ */
+declare function diff(before: unknown, after: unknown): Change[];
+/**
+ * Reads a nested value from a dotted path. Your editor completes the paths
+ * and knows the type of the result.
  *
  * @example
- * const copy = nodeComfort.obj.clone({ a: { b: 1 } });
+ * obj.get(config, "db.pool.max");      // number | undefined
+ * obj.get(config, "db.pool.max", 10);  // number
+ * obj.get(data, "users[0].name");
+ * obj.get(data, ["users", 0, "name"]);
  *
  * @template T
- * @param {T} value - Value to clone.
- * @returns {T} A deep copy.
+ * @template {string} P
+ * @overload
+ * @param {T} object
+ * @param {P | Paths<T> | ReadonlyArray<string | number>} path Like `"a.b.c"`, `"a[0].b"` or `["a", 0, "b"]`.
+ * @returns {PathValue<T, P>}
  */
-export function clone<T>(value: T): T;
+declare function get<T, P extends string>(object: T, path: P | Paths<T> | ReadonlyArray<string | number>): PathValue<T, P>;
 /**
- * Deeply merges two or more plain objects into a new object.
+ * Reads a nested value from a dotted path, or returns `fallback` if there's
+ * nothing there.
  *
- * Later sources win. Plain-object values are merged recursively; arrays and
- * other values are replaced (not concatenated). Inputs are never mutated.
+ * @template T
+ * @template {string} P
+ * @template F
+ * @overload
+ * @param {T} object
+ * @param {P | Paths<T> | ReadonlyArray<string | number>} path Like `"a.b.c"`, `"a[0].b"` or `["a", 0, "b"]`.
+ * @param {F} fallback
+ * @returns {Exclude<PathValue<T, P>, undefined> | F}
+ */
+declare function get<T, P extends string, F>(object: T, path: P | Paths<T> | ReadonlyArray<string | number>, fallback: F): Exclude<PathValue<T, P>, undefined> | F;
+/**
+ * Returns a copy with a nested value set. Missing levels are created
+ * (arrays when the next key is a number).
  *
  * @example
- * nodeComfort.obj.merge({ a: { x: 1 } }, { a: { y: 2 } });
- * // { a: { x: 1, y: 2 } }
+ * obj.set({}, "a.b.c", 1);            // { a: { b: { c: 1 } } }
+ * obj.set(state, "user.name", "Ada"); // state is untouched
  *
- * @param {...Record<string, any>} sources - Objects to merge.
- * @returns {Record<string, any>} The merged object.
+ * @template T
+ * @param {T} object
+ * @param {PathInput<T>} path
+ * @param {unknown} value
+ * @returns {T}
  */
-export function merge(...sources: Record<string, any>[]): Record<string, any>;
+declare function set<T>(object: T, path: PathInput<T>, value: unknown): T;
 /**
- * Deeply compares two values for structural equality.
+ * Returns a copy without the property at `path`.
  *
- * Handles plain objects, arrays, Dates, RegExps, Maps and Sets.
+ * @example
+ * obj.unset({ a: { b: 1, c: 2 } }, "a.b"); // { a: { c: 2 } }
+ *
+ * @template T
+ * @param {T} object
+ * @param {PathInput<T>} path
+ * @returns {T}
+ */
+declare function unset<T>(object: T, path: PathInput<T>): T;
+/**
+ * Does the path exist? A property set to `undefined` still counts.
  *
  * @example
- * nodeComfort.obj.equal({ a: [1, 2] }, { a: [1, 2] }); // true
+ * obj.has({ a: { b: undefined } }, "a.b"); // true
+ * obj.has({ a: {} }, "a.b");               // false
  *
- * @param {*} a - First value.
- * @param {*} b - Second value.
- * @returns {boolean} True if the values are deeply equal.
+ * @template T
+ * @param {T} object
+ * @param {PathInput<T>} path
+ * @returns {boolean}
  */
-export function equal(a: any, b: any): boolean;
+declare function has<T>(object: T, path: PathInput<T>): boolean;
 /**
- * Gets a nested value from an object using a dot/bracket path.
+ * A copy with only the listed keys.
  *
  * @example
- * nodeComfort.obj.get({ a: { b: [{ c: 42 }] } }, "a.b[0].c");    // 42
- * nodeComfort.obj.get({}, "a.b.c", "default");                   // "default"
+ * obj.pick(user, ["id", "email"]);
  *
- * @param {Record<string, any>} object - Source object.
- * @param {string|Array<string|number>} path - Dot path or key array.
- * @param {*} [fallback] - Returned when the path does not resolve.
- * @returns {*} The value at the path, or the fallback.
+ * @template {object} T
+ * @template {keyof T} K
+ * @param {T} object
+ * @param {readonly K[]} keys
+ * @returns {Pick<T, K>}
  */
-export function get(object: Record<string, any>, path: string | Array<string | number>, fallback?: any): any;
+declare function pick<T extends object, K extends keyof T>(object: T, keys: readonly K[]): Pick<T, K>;
 /**
- * Sets a nested value in an object using a dot/bracket path (returns a clone).
+ * A copy without the listed keys.
+ *
+ * @example
+ * obj.omit(user, ["password", "token"]);
  *
- * Intermediate objects/arrays are created as needed. The original object is
- * not mutated.
+ * @template {object} T
+ * @template {keyof T} K
+ * @param {T} object
+ * @param {readonly K[]} keys
+ * @returns {Omit<T, K>}
+ */
+declare function omit<T extends object, K extends keyof T>(object: T, keys: readonly K[]): Omit<T, K>;
+/**
+ * Keeps the entries that pass a test.
  *
  * @example
- * nodeComfort.obj.set({}, "a.b.c", 1); // { a: { b: { c: 1 } } }
+ * obj.filter({ a: 1, b: 2, c: 3 }, (value) => value > 1); // { b: 2, c: 3 }
  *
- * @param {Record<string, any>} object - Source object.
- * @param {string|Array<string|number>} path - Dot path or key array.
- * @param {*} value - Value to set.
- * @returns {Record<string, any>} A new object with the value set.
+ * @template {object} T
+ * @param {T} object
+ * @param {(value: T[keyof T], key: keyof T & string) => unknown} predicate
+ * @returns {Partial<T>}
  */
-export function set(object: Record<string, any>, path: string | Array<string | number>, value: any): Record<string, any>;
+declare function filter<T extends object>(object: T, predicate: (value: T[keyof T], key: keyof T & string) => unknown): Partial<T>;
 /**
- * Checks whether a nested path exists in an object.
+ * Transforms every value, keeping the keys.
+ *
+ * @example
+ * obj.mapValues({ a: 1, b: 2 }, (v) => v * 10); // { a: 10, b: 20 }
  *
- * @param {Record<string, any>} object - Source object.
- * @param {string|Array<string|number>} path - Dot path or key array.
- * @returns {boolean} True if the path resolves.
+ * @template {object} T
+ * @template R
+ * @param {T} object
+ * @param {(value: T[keyof T], key: keyof T & string) => R} fn
+ * @returns {{ [K in keyof T]: R }}
  */
-export function has(object: Record<string, any>, path: string | Array<string | number>): boolean;
+declare function mapValues<T extends object, R>(object: T, fn: (value: T[keyof T], key: keyof T & string) => R): { [K in keyof T]: R; };
 /**
- * Returns a new object containing only the given keys.
+ * Transforms every key, keeping the values.
  *
  * @example
- * nodeComfort.obj.pick({ a: 1, b: 2, c: 3 }, ["a", "c"]); // { a: 1, c: 3 }
+ * obj.mapKeys({ first_name: "Ada" }, (key) => nc.str.camelCase(key)); // { firstName: "Ada" }
  *
- * @param {Record<string, any>} object - Source object.
- * @param {string[]} keys - Keys to keep.
- * @returns {Record<string, any>} The picked object.
+ * @template {object} T
+ * @param {T} object
+ * @param {(key: keyof T & string, value: T[keyof T]) => PropertyKey} fn Returns the new key.
+ * @returns {Record<string, T[keyof T]>}
  */
-export function pick(object: Record<string, any>, keys: string[]): Record<string, any>;
+declare function mapKeys<T extends object>(object: T, fn: (key: keyof T & string, value: T[keyof T]) => PropertyKey): Record<string, T[keyof T]>;
 /**
- * Returns a new object without the given keys.
+ * Renames some keys and leaves the others alone.
  *
  * @example
- * nodeComfort.obj.omit({ a: 1, b: 2, c: 3 }, ["b"]); // { a: 1, c: 3 }
+ * obj.renameKeys({ _id: 1, name: "Ada" }, { _id: "id" }); // { id: 1, name: "Ada" }
  *
- * @param {Record<string, any>} object - Source object.
- * @param {string[]} keys - Keys to remove.
- * @returns {Record<string, any>} The remaining object.
+ * @template {object} T
+ * @param {T} object
+ * @param {Partial<Record<keyof T, string>>} mapping Old name to new name.
+ * @returns {Record<string, T[keyof T]>}
  */
-export function omit(object: Record<string, any>, keys: string[]): Record<string, any>;
+declare function renameKeys<T extends object>(object: T, mapping: Partial<Record<keyof T, string>>): Record<string, T[keyof T]>;
 /**
- * Returns a new object keeping only the entries that pass a predicate.
+ * Swaps keys and values.
  *
  * @example
- * nodeComfort.obj.filter({ a: 1, b: 2, c: 3 }, (v) => v > 1); // { b: 2, c: 3 }
+ * obj.invert({ a: "x", b: "y" }); // { x: "a", y: "b" }
  *
- * @param {Record<string, any>} object - Source object.
- * @param {(value: any, key: string) => boolean} predicate - Test function.
- * @returns {Record<string, any>} The filtered object.
+ * @param {Record<string, PropertyKey>} object
+ * @returns {Record<string, string>}
  */
-export function filter(object: Record<string, any>, predicate: (value: any, key: string) => boolean): Record<string, any>;
+declare function invert(object: Record<string, PropertyKey>): Record<string, string>;
 /**
- * Maps over an object's values, returning a new object with the same keys.
+ * Removes `null` and `undefined` values, and optionally empty ones.
  *
  * @example
- * nodeComfort.obj.mapValues({ a: 1, b: 2 }, (v) => v * 10); // { a: 10, b: 20 }
+ * obj.compact({ a: 1, b: null, c: undefined });                          // { a: 1 }
+ * obj.compact({ a: { b: null, c: "" } }, { deep: true, removeEmpty: true }); // {}
  *
- * @param {Record<string, any>} object - Source object.
- * @param {(value: any, key: string) => any} fn - Mapping function.
- * @returns {Record<string, any>} The mapped object.
+ * @template {object} T
+ * @param {T} object
+ * @param {CompactOptions} [options]
+ * @returns {Partial<T>}
  */
-export function mapValues(object: Record<string, any>, fn: (value: any, key: string) => any): Record<string, any>;
+declare function compact<T extends object>(object: T, options?: CompactOptions): Partial<T>;
 /**
- * Maps over an object's keys, returning a new object with remapped keys.
+ * Flattens nested objects into dotted keys. Arrays stay as values.
  *
  * @example
- * nodeComfort.obj.mapKeys({ a: 1 }, (k) => k.toUpperCase()); // { A: 1 }
+ * obj.flatten({ db: { host: "x", port: 5432 } }); // { "db.host": "x", "db.port": 5432 }
  *
- * @param {Record<string, any>} object - Source object.
- * @param {(key: string, value: any) => string} fn - Key-mapping function.
- * @returns {Record<string, any>} The remapped object.
+ * @param {object} object
+ * @param {string} [prefix=""] Added in front of every key.
+ * @returns {Record<string, unknown>}
  */
-export function mapKeys(object: Record<string, any>, fn: (key: string, value: any) => string): Record<string, any>;
+declare function flatten(object: object, prefix?: string): Record<string, unknown>;
 /**
- * Swaps keys and values of an object.
+ * Rebuilds nested objects from dotted keys. The opposite of `flatten()`.
  *
  * @example
- * nodeComfort.obj.invert({ a: "x", b: "y" }); // { x: "a", y: "b" }
+ * obj.unflatten({ "db.host": "x", "db.port": 5432 }); // { db: { host: "x", port: 5432 } }
  *
- * @param {Record<string, any>} object - Source object.
- * @returns {Record<string, string>} The inverted object.
+ * @param {Record<string, unknown>} object
+ * @returns {Record<string, any>}
  */
-export function invert(object: Record<string, any>): Record<string, string>;
+declare function unflatten(object: Record<string, unknown>): Record<string, any>;
 /**
- * Removes entries whose value is `null` or `undefined` (shallow).
+ * `Object.keys`, but typed with the object's actual keys.
  *
  * @example
- * nodeComfort.obj.compact({ a: 1, b: null, c: undefined }); // { a: 1 }
+ * for (const key of obj.keys(config)) config[key]; // no type error
  *
- * @param {Record<string, any>} object - Source object.
- * @returns {Record<string, any>} The compacted object.
+ * @template {object} T
+ * @param {T} object
+ * @returns {Array<keyof T & string>}
  */
-export function compact(object: Record<string, any>): Record<string, any>;
+declare function keys<T extends object>(object: T): Array<keyof T & string>;
 /**
- * Flattens a nested object into a single-level object with dot-path keys.
+ * `Object.entries`, with typed keys and values.
+ *
+ * @template {object} T
+ * @param {T} object
+ * @returns {Array<[keyof T & string, T[keyof T]]>}
+ */
+declare function entries<T extends object>(object: T): Array<[keyof T & string, T[keyof T]]>;
+/**
+ * `Object.fromEntries` that accepts any iterable (a `Map` too) and skips
+ * unsafe keys.
  *
  * @example
- * nodeComfort.obj.flatten({ a: { b: { c: 1 } } }); // { "a.b.c": 1 }
+ * obj.fromEntries(new Map([["x", true]])); // { x: true }
  *
- * @param {Record<string, any>} object - Source object.
- * @param {string} [prefix=""] - Prefix for keys (used internally).
- * @returns {Record<string, any>} The flattened object.
+ * @template {PropertyKey} K
+ * @template V
+ * @param {Iterable<readonly [K, V]>} pairs
+ * @returns {Record<K, V>}
  */
-export function flatten(object: Record<string, any>, prefix?: string): Record<string, any>;
+declare function fromEntries<K extends PropertyKey, V>(pairs: Iterable<readonly [K, V]>): Record<K, V>;
 /**
- * Rebuilds a nested object from a flat, dot-path keyed object.
+ * How many entries: own keys of an object, size of a map or set, length of
+ * an array or string.
  *
  * @example
- * nodeComfort.obj.unflatten({ "a.b.c": 1 }); // { a: { b: { c: 1 } } }
+ * obj.size({ a: 1, b: 2 }); // 2
  *
- * @param {Record<string, any>} object - Flat object.
- * @returns {Record<string, any>} The nested object.
+ * @param {unknown} value
+ * @returns {number}
  */
-export function unflatten(object: Record<string, any>): Record<string, any>;
+declare function size(value: unknown): number;
 /**
- * Checks whether an object has no own enumerable keys.
+ * Does the object have no own keys? `null` and `undefined` count as empty.
  *
- * @param {Record<string, any>} object - Source object.
- * @returns {boolean} True if the object is empty.
+ * @param {unknown} object
+ * @returns {boolean}
  */
-export function isEmpty(object: Record<string, any>): boolean;
+declare function isEmpty(object: unknown): boolean;
 /**
- * Freezes an object deeply, making it (and all nested objects) immutable.
+ * Freezes an object and everything inside it. Good for configuration and
+ * constants.
+ *
+ * @example
+ * const CONFIG = obj.deepFreeze({ db: { host: "localhost" } });
+ * CONFIG.db.host = "x"; // TypeScript error, and ignored at runtime
  *
- * @param {Record<string, any>} object - Object to freeze.
- * @returns {Record<string, any>} The same, now deeply-frozen, object.
+ * @template T
+ * @param {T} object
+ * @returns {DeepReadonly<T>} The same object.
  */
-export function deepFreeze(object: Record<string, any>): Record<string, any>;
+declare function deepFreeze<T>(object: T): DeepReadonly<T>;
+/** Marks an unknown path segment in `PathStep`. */
+declare const _NOT_FOUND: unique symbol;
 //# sourceMappingURL=Obj.d.ts.map

package/types/src/Obj.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Obj.d.ts","sourceRoot":"","sources":["../../src/Obj.js"],"names":[],"mappings":"AAmEE;;;;;;;;;;;;;GAaG;AACH,sBAJa,CAAC,SACH,CAAC,GACC,CAAC,CASb;AAED;;;;;;;;;;;;GAYG;AACH,kCAHc,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAA,GACpB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAkB/B;AAED;;;;;;;;;;;GAWG;AACH,yBAJW,GAAC,KACD,GAAC,GACC,OAAO,CA+BnB;AAED;;;;;;;;;;;GAWG;AACH,4BALW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QACnB,MAAM,GAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,aAC3B,GAAC,GACC,GAAC,CAUb;AAED;;;;;;;;;;;;;GAaG;AACH,4BALW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QACnB,MAAM,GAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,SAC3B,GAAC,GACC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAgB/B;AAED;;;;;;GAMG;AACH,4BAJW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QACnB,MAAM,GAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,GACzB,OAAO,CAUnB;AAED;;;;;;;;;GASG;AACH,6BAJW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QACnB,MAAM,EAAE,GACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQ/B;AAED;;;;;;;;;GASG;AACH,6BAJW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QACnB,MAAM,EAAE,GACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAS/B;AAED;;;;;;;;;GASG;AACH,+BAJW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,aACnB,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,GAClC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQ/B;AAED;;;;;;;;;GASG;AACH,kCAJW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MACnB,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,KAAK,GAAG,GAC9B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQ/B;AAED;;;;;;;;;GASG;AACH,gCAJW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MACnB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,MAAM,GACjC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQ/B;AAED;;;;;;;;GAQG;AACH,+BAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQlC;AAED;;;;;;;;GAQG;AACH,gCAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAI/B;AAED;;;;;;;;;GASG;AACH,gCAJW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,WACnB,MAAM,GACJ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAa/B;AAED;;;;;;;;GAQG;AACH,kCAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQ/B;AAED;;;;;GAKG;AACH,gCAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,OAAO,CAInB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAW/B"}
+{"version":3,"file":"Obj.d.ts","sourceRoot":"","sources":["../../src/Obj.js"],"names":[],"mappings":"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"}