@rimbu/deep 2.0.0 → 2.0.2

package/dist/cjs/match.d.cts

@@ -0,0 +1,140 @@
+import { type IsAnyFunc, type IsArray, type IsPlainObj, type NotIterable } from '@rimbu/base';
+import type { Protected } from './internal.cjs';
+import type { Tuple } from './tuple.cjs';
+/**
+ * The type to determine the allowed input values for the `match` function.
+ * @typeparam T - the type of value to match
+ * @typeparam C - utility type
+ */
+export type Match<T, C extends Partial<T> = Partial<T>> = Match.Entry<T, C, T, T>;
+export declare namespace Match {
+    /**
+     * Determines the various allowed match types for given type `T`.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam P - the parent type
+     * @typeparam R - the root object type
+     */
+    type Entry<T, C, P, R> = IsAnyFunc<T> extends true ? T : IsPlainObj<T> extends true ? Match.WithResult<T, P, R, Match.Obj<T, C, P, R>> : IsArray<T> extends true ? Match.Arr<T, C, P, R> | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[] | Match.Func<T, P, R, Match.Arr<T, C, P, R> | Match.Entry<T[number & keyof T], C[number & keyof C], P, R>[]> : Match.WithResult<T, P, R, {
+        [K in keyof C]: C[K & keyof T];
+    }>;
+    /**
+     * The type that determines allowed matchers for objects.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam P - the parent type
+     * @typeparam R - the root object type
+     */
+    type Obj<T, C, P, R> = Match.ObjProps<T, C, R> | Match.CompoundForObj<T, C, P, R>;
+    /**
+     * The type to determine allowed matchers for object properties.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam R - the root object type
+     */
+    type ObjProps<T, C, R> = {
+        [K in keyof C]?: K extends keyof T ? Match.Entry<T[K], C[K], T, R> : never;
+    };
+    /**
+     * The type that determines allowed matchers for arrays/tuples.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam P - the parent type
+     * @typeparam R - the root object type
+     */
+    type Arr<T, C, P, R> = C | Match.CompoundForArr<T, C, P, R> | Match.TraversalForArr<T, C, R> | (Match.TupIndices<T, C, R> & {
+        [K in Match.CompoundType | Match.ArrayTraversalType]?: never;
+    });
+    /**
+     * A type that either directly results in result type `S` or is a function taking the value, parent, and root values, and
+     * returns a value of type `S`.
+     * @typeparam T - the input value type
+     * @typeparam P - the parent type
+     * @typeparam R - the root object type
+     * @typeparam S - the result type
+     */
+    type WithResult<T, P, R, S> = S | Match.Func<T, P, R, S>;
+    /**
+     * Type used to determine the allowed function types. Always includes booleans.
+     * @typeparam T - the input value type
+     * @typeparam P - the parent type
+     * @typeparam R - the root object type
+     * @typeparam S - the allowed return value type
+     */
+    type Func<T, P, R, S> = (current: Protected<T>, parent: Protected<P>, root: Protected<R>) => boolean | S;
+    /**
+     * Type used to indicate an object containing matches for tuple indices.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam R - the root object type
+     */
+    type TupIndices<T, C, R> = {
+        [K in Tuple.KeysOf<C>]?: Match.Entry<T[K & keyof T], C[K], T, R>;
+    } & NotIterable;
+    /**
+     * Compound keys used to indicate the type of compound.
+     */
+    type CompoundType = 'every' | 'some' | 'none' | 'single';
+    /**
+     * Keys used to indicate an array match traversal.
+     */
+    type ArrayTraversalType = `${CompoundType}Item`;
+    /**
+     * Compount matcher for objects, can only be an array staring with a compound type keyword.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam P - the parent type
+     * @typeparam R - the root object type
+     */
+    type CompoundForObj<T, C, P, R> = [
+        Match.CompoundType,
+        ...Match.Entry<T, C, P, R>[]
+    ];
+    /**
+     * Defines an object containing exactly one `CompoundType` key, having an array of matchers.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam P - the parent type
+     * @typeparam R - the root object type
+     */
+    type CompoundForArr<T, C, P, R> = {
+        [K in Match.CompoundType]: {
+            [K2 in Match.CompoundType]?: K2 extends K ? Match.Entry<T, C, P, R>[] : never;
+        };
+    }[Match.CompoundType];
+    /**
+     * Defines an object containing exactly one `TraversalType` key, having a matcher for the array element type.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam R - the root object type
+     */
+    type TraversalForArr<T, C, R> = {
+        [K in Match.ArrayTraversalType]: {
+            [K2 in Match.ArrayTraversalType]?: K2 extends K ? Match.Entry<T[number & keyof T], C[number & keyof C], T, R> : never;
+        };
+    }[Match.ArrayTraversalType];
+    /**
+     * Utility type for collecting match failure reasons
+     */
+    type FailureLog = string[];
+}
+/**
+ * Returns true if the given `value` object matches the given `matcher`, false otherwise.
+ * @typeparam T - the input value type
+ * @typeparam C - utility type
+ * @param source - the value to match (should be a plain object)
+ * @param matcher - a matcher object or a function taking the matcher API and returning a match object
+ * @param failureLog - (optional) a string array that can be passed to collect reasons why the match failed
+ * @example
+ * ```ts
+ * const input = { a: 1, b: { c: true, d: 'a' } }
+ * match(input, { a: 1 }) // => true
+ * match(input, { a: 2 }) // => false
+ * match(input, { a: (v) => v > 10 }) // => false
+ * match(input, { b: { c: true }}) // => true
+ * match(input, (['every', { a: (v) => v > 0 }, { b: { c: true } }]) // => true
+ * match(input, { b: { c: (v, parent, root) => v && parent.d.length > 0 && root.a > 0 } })
+ *  // => true
+ * ```
+ */
+export declare function match<T, C extends Partial<T> = Partial<T>>(source: T, matcher: Match<T, C>, failureLog?: Match.FailureLog): boolean;

package/dist/cjs/patch.cjs

@@ -1,105 +1,132 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/patch.mts
-var patch_exports = {};
-__export(patch_exports, {
-  patch: () => patch
-});
-module.exports = __toCommonJS(patch_exports);
-var import_base = require("@rimbu/base");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patch = patch;
+var tslib_1 = require("tslib");
+var base_1 = require("@rimbu/base");
+/**
+ * Returns an immutably updated version of the given `value` where the given `patchItems` have been
+ * applied to the result.
+ * The Rimbu patch notation is as follows:
+ * - if the target is a simple value or array, the patch can be the same type or a function returning the same type
+ * - if the target is a tuple (array of fixed length), the patch be the same type or an object containing numeric keys with patches indicating the tuple index to patch
+ * - if the target is an object, the patch can be the same type, or an array containing partial keys with their patches for the object
+ * @typeparam T - the type of the value to patch
+ * @typeparam TE - a utility type
+ * @typeparam TT - a utility type
+ * @param value - the input value to patch
+ * @param patchItem - the `Patch` value to apply to the input value
+ * @example
+ * ```ts
+ * const input = { a: 1, b: { c: true, d: 'a' } }
+ * patch(input, [{ a: 2 }])  // => { a: 2, b: { c: true, d: 'a' } }
+ * patch(input, [{ b: [{ c: (v) => !v }] }] )
+ * // => { a: 1, b: { c: false, d: 'a' } }
+ * patch(input: [{ a: (v) => v + 1, b: [{ d: 'q' }] }] )
+ * // => { a: 2, b: { c: true, d: 'q' } }
+ * ```
+ */
 function patch(value, patchItem) {
-  return patchEntry(value, value, value, patchItem);
+    return patchEntry(value, value, value, patchItem);
 }
 function patchEntry(value, parent, root, patchItem) {
-  if (Object.is(value, patchItem)) {
-    return value;
-  }
-  if (typeof value === "function") {
+    if (Object.is(value, patchItem)) {
+        // patching a value with itself never changes the value
+        return value;
+    }
+    if (typeof value === 'function') {
+        // function input, directly return patch
+        return patchItem;
+    }
+    if (typeof patchItem === 'function') {
+        // function patch always needs to be resolved first
+        var item = patchItem(value, parent, root);
+        return patchEntry(value, parent, root, item);
+    }
+    if ((0, base_1.isPlainObj)(value)) {
+        // value is plain object
+        return patchPlainObj(value, root, patchItem);
+    }
+    if (Array.isArray(value)) {
+        // value is tuple or array
+        return patchArr(value, root, patchItem);
+    }
+    // value is primitive type or complex object
     return patchItem;
-  }
-  if (typeof patchItem === "function") {
-    const item = patchItem(value, parent, root);
-    return patchEntry(value, parent, root, item);
-  }
-  if ((0, import_base.isPlainObj)(value)) {
-    return patchPlainObj(value, root, patchItem);
-  }
-  if (Array.isArray(value)) {
-    return patchArr(value, root, patchItem);
-  }
-  return patchItem;
 }
 function patchPlainObj(value, root, patchItem) {
-  if (!Array.isArray(patchItem)) {
-    return patchItem;
-  }
-  const result = { ...value };
-  let anyChange = false;
-  for (const entry of patchItem) {
-    const currentRoot = value === root ? { ...result } : root;
-    const parent = { ...result };
-    for (const key in entry) {
-      const currentValue = result[key];
-      const newValue = patchEntry(
-        currentValue,
-        parent,
-        currentRoot,
-        entry[key]
-      );
-      if (!Object.is(currentValue, newValue)) {
-        anyChange = true;
-        result[key] = newValue;
-      }
+    var e_1, _a;
+    if (!Array.isArray(patchItem)) {
+        // the patch is a complete replacement of the current value
+        return patchItem;
+    }
+    // patch is an array of partial updates
+    // copy the input value
+    var result = tslib_1.__assign({}, value);
+    var anyChange = false;
+    try {
+        // loop over patches in array
+        for (var patchItem_1 = tslib_1.__values(patchItem), patchItem_1_1 = patchItem_1.next(); !patchItem_1_1.done; patchItem_1_1 = patchItem_1.next()) {
+            var entry = patchItem_1_1.value;
+            // update root if needed
+            var currentRoot = value === root ? tslib_1.__assign({}, result) : root;
+            // keep current updated result as parent
+            var parent = tslib_1.__assign({}, result);
+            // loop over all the patch keys
+            for (var key in entry) {
+                // patch the value at the given key with the patch at that key
+                var currentValue = result[key];
+                var newValue = patchEntry(currentValue, parent, currentRoot, entry[key]);
+                if (!Object.is(currentValue, newValue)) {
+                    // if value changed, set it in result and mark change
+                    anyChange = true;
+                    result[key] = newValue;
+                }
+            }
+        }
     }
-  }
-  if (anyChange) {
-    return result;
-  }
-  return value;
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (patchItem_1_1 && !patchItem_1_1.done && (_a = patchItem_1.return)) _a.call(patchItem_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (anyChange) {
+        // something changed, return new value
+        return result;
+    }
+    // nothing changed, return old value
+    return value;
 }
 function patchArr(value, root, patchItem) {
-  if (Array.isArray(patchItem)) {
-    return patchItem;
-  }
-  const result = [...value];
-  let anyChange = false;
-  for (const index in patchItem) {
-    const numIndex = index;
-    const currentValue = result[numIndex];
-    const newValue = patchEntry(
-      currentValue,
-      value,
-      root,
-      patchItem[index]
-    );
-    if (!Object.is(newValue, currentValue)) {
-      anyChange = true;
-      result[numIndex] = newValue;
+    if (Array.isArray(patchItem)) {
+        // value is a normal array
+        // patch is a complete replacement of current array
+        return patchItem;
     }
-  }
-  if (anyChange) {
-    return result;
-  }
-  return value;
+    // value is a tuple
+    // patch is an object containing numeric keys with function values
+    // that update the tuple at the given indices
+    // copy the tuple
+    var result = tslib_1.__spreadArray([], tslib_1.__read(value), false);
+    var anyChange = false;
+    // loop over all index keys in object
+    for (var index in patchItem) {
+        var numIndex = index;
+        // patch the tuple at the given index
+        var currentValue = result[numIndex];
+        var newValue = patchEntry(currentValue, value, root, patchItem[index]);
+        if (!Object.is(newValue, currentValue)) {
+            // if value changed, set it in result and mark change
+            anyChange = true;
+            result[numIndex] = newValue;
+        }
+    }
+    if (anyChange) {
+        // something changed, return new value
+        return result;
+    }
+    // nothing changed, return old value
+    return value;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  patch
-});
+//# sourceMappingURL=patch.cjs.map

package/dist/cjs/patch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.cjs","sourceRoot":"","sources":["../../_cjs_prepare/patch.cts"],"names":[],"mappings":"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"}

package/dist/cjs/patch.d.cts

@@ -0,0 +1,89 @@
+import { type IsAnyFunc, type IsArray, type IsPlainObj } from '@rimbu/base';
+import type { Protected } from './internal.cjs';
+import type { Tuple } from './tuple.cjs';
+/**
+ * A type to determine the allowed input type for the `patch` function.
+ * @typeparam T - the input type to be patched
+ */
+export type Patch<T, C = T> = Patch.Entry<T, C, T, T>;
+export declare namespace Patch {
+    /**
+     * The entry type for a (nested) patch. Can be either a patch object or a function accepting the nested patch function and returning a patch object.
+     * @typeparam T - the input value type
+     * @typeparam C - a utility type
+     * @typeparam P - the parent type
+     * @typeparam R - the root object type
+     */
+    type Entry<T, C, P, R> = IsAnyFunc<T> extends true ? T : IsPlainObj<T> extends true ? Patch.WithResult<T, P, R, Patch.Obj<T, C, R>> : Tuple.IsTuple<T> extends true ? Patch.WithResult<T, P, R, T | Patch.Tup<T, C, R>> : IsArray<T> extends true ? Patch.WithResult<T, P, R, T> : Patch.WithResult<T, P, R, T>;
+    /**
+     * Either result type S, or a patch function with the value type, the parent type, and the root type.
+     * @typeparam T - the value type
+     * @typeparam P - the parent type
+     * @typeparam R - the root type
+     * @typeparam S - the result type
+     */
+    type WithResult<T, P, R, S> = S | Patch.Func<T, P, R, S>;
+    /**
+     * A function patch type that is a function taking the current value, the parent and root values,
+     * and returns a return value.
+     * @typeparam T - the value type
+     * @typeparam P - the parent type
+     * @typeparam R - the root type
+     * @typeparam S - the result type
+     */
+    type Func<T, P, R, S> = (current: Protected<T>, parent: Protected<P>, root: Protected<R>) => Protected<S>;
+    /**
+     * A type defining the allowed patch values for tuples.
+     * @typeparam T - the input tuple type
+     * @typeparam C - a utility type
+     * @typeparam R - the root type
+     */
+    type Tup<T, C, R> = {
+        [K in Tuple.KeysOf<T>]?: Patch.Entry<T[K & keyof T], C[K & keyof C], T, R>;
+    } & NotIterable;
+    /**
+     * Utility type to exclude Iterable types.
+     */
+    type NotIterable = {
+        [Symbol.iterator]?: never;
+    };
+    /**
+     * A type defining the allowed patch values for objects.
+     * @typeparam T - the input value type
+     * @typeparam C - a utility type
+     * @typeparam R - the root object type
+     */
+    type Obj<T, C, R> = T | Patch.ObjProps<T, C, R>[];
+    /**
+     * A type defining the allowed patch values for object properties.
+     * @typeparam T - the input value type
+     * @typeparam C - a utility type
+     * @typeparam R - the root object type
+     */
+    type ObjProps<T, C, R> = {
+        [K in keyof C]?: K extends keyof T ? Patch.Entry<T[K], C[K], T, R> : never;
+    };
+}
+/**
+ * Returns an immutably updated version of the given `value` where the given `patchItems` have been
+ * applied to the result.
+ * The Rimbu patch notation is as follows:
+ * - if the target is a simple value or array, the patch can be the same type or a function returning the same type
+ * - if the target is a tuple (array of fixed length), the patch be the same type or an object containing numeric keys with patches indicating the tuple index to patch
+ * - if the target is an object, the patch can be the same type, or an array containing partial keys with their patches for the object
+ * @typeparam T - the type of the value to patch
+ * @typeparam TE - a utility type
+ * @typeparam TT - a utility type
+ * @param value - the input value to patch
+ * @param patchItem - the `Patch` value to apply to the input value
+ * @example
+ * ```ts
+ * const input = { a: 1, b: { c: true, d: 'a' } }
+ * patch(input, [{ a: 2 }])  // => { a: 2, b: { c: true, d: 'a' } }
+ * patch(input, [{ b: [{ c: (v) => !v }] }] )
+ * // => { a: 1, b: { c: false, d: 'a' } }
+ * patch(input: [{ a: (v) => v + 1, b: [{ d: 'q' }] }] )
+ * // => { a: 2, b: { c: true, d: 'q' } }
+ * ```
+ */
+export declare function patch<T, TE extends T = T, TT = T>(value: T, patchItem: Patch<TE, T & TT>): T;