@rimbu/deep 0.9.2 → 0.10.0

package/dist/module/path.js

@@ -9,13 +9,13 @@ export var Path;
      * @param path - the path into the object
      * @example
      * ```ts
-     * console.log(Path.getValue({ a: { b: { c: 5 } } }), 'a.b')
+     * console.log(Path.get({ a: { b: { c: 5 } } }), 'a.b')
      * // => { c: 5 }
-     * console.log(Path.getValue({ a: { b: { c: 5 } } }), 'a.b.c')
+     * console.log(Path.get({ a: { b: { c: 5 } } }), 'a.b.c')
      * // => 5
      * ```
      */
-    function getValue(source, path) {
+    function get(source, path) {
         const items = path.split('.');
         let result = source;
         for (const item of items) {
@@ -23,7 +23,7 @@ export var Path;
         }
         return result;
     }
-    Path.getValue = getValue;
+    Path.get = get;
     /**
      * Sets the value at the given path in the source to the given value.
      * @param source - the object to update
@@ -31,44 +31,22 @@ export var Path;
      * @param value - the new value to set at the given position
      * @example
      * ```ts
-     * console.log(Path.setValue({ a: { b: { c: 5  } } }))
+     * console.log(Path.update({ a: { b: { c: 5 } } }, 'a.b.c', v => v + 5)
+     * // => { a: { b: { c: 6 } } }
      * ```
      */
-    function setValue(source, path, value) {
+    function update(source, path, value) {
         const items = path.split('.');
         const last = items.pop();
-        const result = Object.assign({}, source);
-        let current = result;
+        const root = {};
+        let current = root;
         for (const item of items) {
-            current[item] = Object.assign({}, current[item]);
+            current[item] = {};
             current = current[item];
         }
-        const oldValue = current[last];
-        if (Object.is(oldValue, value))
-            return source;
         current[last] = value;
-        return result;
-    }
-    Path.setValue = setValue;
-    /**
-     * Patches the value at the given path in the source to the given value using the given
-     * `patches`.
-     * @param source - the object to update
-     * @param path - the path in the object to update
-     * @param patches - one or more patches to update the value at the given path
-     * @example
-     * ```ts
-     * console.log(Path.setValue({ a: { b: { c: 5 } } }, 'a.b.c', 8)
-     * // => { a: { b: { c: 8 } } }
-     * ```
-     */
-    function patchValue(source, path, ...patches) {
-        const value = Path.getValue(source, path);
-        const newValue = patch(value)(...patches);
-        if (Object.is(value, newValue))
-            return source;
-        return Path.setValue(source, path, newValue);
+        return patch(source, root);
     }
-    Path.patchValue = patchValue;
+    Path.update = update;
 })(Path || (Path = {}));
 //# sourceMappingURL=path.js.map

package/dist/module/path.js.map

@@ -1 +1 @@
-{"version":3,"file":"path.js","sourceRoot":"","sources":["../../src/path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,EAAS,MAAM,YAAY,CAAC;AAcnD,MAAM,KAAW,IAAI,CAiHpB;AAjHD,WAAiB,IAAI;IAwBnB;;;;;;;;;;;;;OAaG;IACH,SAAgB,QAAQ,CACtB,MAAS,EACT,IAAO;QAEP,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAE9B,IAAI,MAAM,GAAQ,MAAM,CAAC;QAEzB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;SACvB;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAbe,aAAQ,WAavB,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,QAAQ,CACtB,MAAS,EACT,IAAO,EACP,KAAwB;QAExB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;QAE1B,MAAM,MAAM,qBAAQ,MAAM,CAAE,CAAC;QAE7B,IAAI,OAAO,GAAQ,MAAM,CAAC;QAE1B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,OAAO,CAAC,IAAI,CAAC,qBAAQ,OAAO,CAAC,IAAI,CAAC,CAAE,CAAC;YACrC,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;SACzB;QAED,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAE/B,IAAI,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC;YAAE,OAAO,MAAM,CAAC;QAE9C,OAAO,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QAEtB,OAAO,MAAM,CAAC;IAChB,CAAC;IAxBe,aAAQ,WAwBvB,CAAA;IAED;;;;;;;;;;;OAWG;IACH,SAAgB,UAAU,CACxB,MAAS,EACT,IAAO,EACP,GAAG,OAAuC;QAE1C,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC1C,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;QAE1C,IAAI,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC;YAAE,OAAO,MAAM,CAAC;QAE9C,OAAO,IAAI,CAAC,QAAQ,CAAW,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;IACzD,CAAC;IAXe,eAAU,aAWzB,CAAA;AACH,CAAC,EAjHgB,IAAI,KAAJ,IAAI,QAiHpB"}
+{"version":3,"file":"path.js","sourceRoot":"","sources":["../../src/path.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAcnC,MAAM,KAAW,IAAI,CAqFpB;AArFD,WAAiB,IAAI;IAwBnB;;;;;;;;;;;;;OAaG;IACH,SAAgB,GAAG,CACjB,MAAuB,EACvB,IAAO;QAEP,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAE9B,IAAI,MAAM,GAAQ,MAAM,CAAC;QAEzB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;SACvB;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAbe,QAAG,MAalB,CAAA;IAED;;;;;;;;;;OAUG;IACH,SAAgB,MAAM,CACpB,MAAuB,EACvB,IAAO,EACP,KAAgC;QAEhC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;QAE1B,MAAM,IAAI,GAAwB,EAAE,CAAC;QAErC,IAAI,OAAO,GAAG,IAAI,CAAC;QAEnB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACnB,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;SACzB;QAED,OAAO,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QAEtB,OAAO,KAAK,CAAI,MAAM,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;IApBe,WAAM,SAoBrB,CAAA;AACH,CAAC,EArFgB,IAAI,KAAJ,IAAI,QAqFpB"}

package/dist/module/protected.js

@@ -0,0 +1,8 @@
+/**
+ * Returns the same value wrapped in the Protected type
+ * @param value - the value to wrap
+ */
+export function Protected(value) {
+    return value;
+}
+//# sourceMappingURL=protected.js.map

package/dist/module/protected.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protected.js","sourceRoot":"","sources":["../../src/protected.ts"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAI,KAAQ;IACnC,OAAO,KAAY,CAAC;AACtB,CAAC"}

package/dist/types/index.d.ts

@@ -1,8 +1,9 @@
 /**
  * @packageDocumentation
  *
- * The `@rimbu/deep` package provides utilities to patch and match plain JavaScript objects..<br/>
+ * The `@rimbu/deep` package provides utilities to patch and match plain JavaScript objects.<br/>
  * <br/>
  * See the [Rimbu docs Deep overview page](/docs/deep/overview) for more information.
  */
-export * from './internal';
+export { patch, patchNested, Patch, match, Match, Path, Protected, } from './internal';
+export { Tuple } from './tuple';

package/dist/types/internal.d.ts

@@ -1,6 +1,4 @@
-export * from './tuple';
-export * from './literal';
-export * from './immutable';
+export * from './protected';
 export * from './match';
-export * from './path';
 export * from './patch';
+export * from './path';

package/dist/types/match.d.ts

@@ -1,111 +1,124 @@
-import type { ArrayNonEmpty } from '@rimbu/common';
-import { Immutable, Literal } from './internal';
+import { type IsPlainObj, type PlainObj } from '@rimbu/base';
+import type { Protected } from './internal';
 /**
- * Type to determine the allowed input type for the `match` functions.
- * @typeparam T - the input type
- * @typeparam P - the parant type
- * @typeparam R - the root type
+ * The type to determine the allowed input values for the `match` functions.
+ * @typeparam T - the type of value to match
  */
-export declare type Match<T> = MatchHelper<T, T, T>;
-declare type MatchHelper<T, P, R> = T extends Literal.Obj ? Match.MatchObj<T, P, R> : T extends readonly any[] ? Match.MatchArray<T, P, R> : Match.Compare<T, P, R>;
+export declare type Match<T> = Match.Options<T, T>;
 export declare namespace Match {
     /**
-     * Type to determine the allowed input type for `match` functions given an object type T.
-     * @typeparam T - the input type, being an object
-     * @typeparam P - the parant type
-     * @typeparam R - the root type
+     * The types of supported match input.
+     * @typeparam T - the type of value to match
+     * @typeparam R - the root object type
      */
-    type MatchObj<T, P, R> = (Match.Compare<T, P, R> | {
-        [K in keyof T]?: MatchHelper<T[K], T, R>;
-    }) & Literal.NoIterable;
+    type Options<T, R> = Every<T, R> | Some<T, R> | None<T, R> | Single<T, R> | Match.Obj<T, R>;
     /**
-     * Type representing at least one Match object for type T
-     * @typeparam T - the target type
+     * The type to determine allowed matchers for objects.
+     * @typeparam T - the type of value to match
+     * @typeparam R - the root object type
      */
-    type Multi<T> = ArrayNonEmpty<Match<T>>;
+    type Obj<T, R> = {
+        [K in keyof T]?: Match.ObjItem<T[K], R> | ((current: Protected<T[K]>, parent: Protected<T>, root: Protected<R>) => boolean | Match.ObjItem<T[K], R>);
+    };
     /**
-     * Type representing matchers for values that are not objects or arrays
-     * @typeparam T - the input type
-     * @typeparam P - the parant type
-     * @typeparam R - the root type
+     * The type to determine allowed matchers for object properties.
+     * @typeparam T - the type of value to match
+     * @typeparam R - the root object type
      */
-    type Compare<T, P, R> = Literal.Value<T> | ((value: Immutable<T>, parent: Immutable<P>, root: Immutable<R>) => boolean);
+    type ObjItem<T, R> = IsPlainObj<T> extends true ? Match.Options<T, R> : T extends Iterable<infer U> ? T | Iterable<U> : T;
     /**
-     * Type representing allowed matchers for arrays
-     * @typeparam T - the array type
-     * @typeparam P - the parent type
-     * @typeparam R - the root type
-     */
-    type MatchArray<T extends readonly any[], P, R> = (Match.Compare<T, P, R> | {
-        [K in {
-            [K2 in keyof T]: K2;
-        }[keyof T]]?: MatchHelper<T[K], T, R>;
-    }) & Literal.NoIterable;
-    /**
-     * Returns true if the given `value` matches all of the given objects in the `matchers` array.
-     * @typeparam T - the type of the object to match
-     * @param value - the value to match
-     * @param matchers - one or more `Match` objects
+     * Returns a matcher that returns true if every given `matchItem` matches the given value.
+     * @typeparam T - the type of value to match
+     * @typeparam R - the root object type
+     * @typeparam Q - a utility type for the matcher
+     * @param matchItems - the match specifications to test
      * @example
      * ```ts
-     * matchAll({ g: { h: 'abc' }})({ g: { h: 'a' }}) => false
-     * matchAll({ g: { h: 'abc' }})({ g: { h: v => v.length > 1 }}) => true
+     * const input = { a: 1, b: { c: true, d: 'a' } }
+     * match(input, Match.every({ a: 1, { c: true } } )) // => true
+     * match(input, Match.every({ a: 1, { c: false } } )) // => false
      * ```
      */
-    function all<T>(value: T): (...matchers: Match.Multi<T>) => boolean;
+    function every<T, R, Q extends T = T>(...matchItems: Match.Options<Q, R>[]): Every<T, R, Q>;
     /**
-     * Returns true if the given `value` matches any of the given objects in the `matchers` array.
-     * @typeparam T - the type of the object to match
-     * @param value - the value to match
-     * @param matchers - one or more `Match` objects
+     * Returns a matcher that returns true if at least one of given `matchItem` matches the given value.
+     * @typeparam T - the type of value to match
+     * @typeparam R - the root object type
+     * @typeparam Q - a utility type for the matcher
+     * @param matchItems - the match specifications to test
      * @example
      * ```ts
-     * matchAny({ g: { h: 'abc' }})({ g: { h: 'a' }}, { g: { h: v => v.length < 2 }}) => false
-     * matchAny({ g: { h: 'abc' }})({ g: { h: 'a' }}, { g: { h: v => v.length > 1 }}) => true
+     * const input = { a: 1, b: { c: true, d: 'a' } }
+     * match(input, Match.some({ a: 5, { c: true } } )) // => true
+     * match(input, Match.some({ a: 5, { c: false } } )) // => false
      * ```
      */
-    function any<T>(value: T): (...matchers: Match.Multi<T>) => boolean;
+    function some<T, R, Q extends T = T>(...matchItems: Match.Options<Q, R>[]): Some<T, R, Q>;
     /**
-     * Returns a function that takes a value of type T, and returns true if the value matches all the
-     * given `matches` array of Match instances.
-     * @typeparam T - the type of the object to match
-     * @typeparam T2 - the type to use for the Match, should be equal to T
-     * @param matches - at least one Match instance to perform on a given `value`
+     * Returns a matcher that returns true if none of given `matchItem` matches the given value.
+     * @typeparam T - the type of value to match
+     * @typeparam R - the root object type
+     * @typeparam Q - a utility type for the matcher
+     * @param matchItems - the match specifications to test
      * @example
      * ```ts
-     * type Person = { name: string, age: number }
-     * const m = Match.createAll<Person>({ age: v => v > 20 }, { name: v => v.length > 2 })
-     *
-     * console.log(m({ name: 'abc', age: 10 }))
-     * // => false
-     * console.log(m({ name: 'abc', age: 20 }))
-     * // => true
-     * console.log(m({ name: 'a', age: 20 }))
-     * // => false
+     * const input = { a: 1, b: { c: true, d: 'a' } }
+     * match(input, Match.none({ a: 5, { c: true } } )) // => false
+     * match(input, Match.none({ a: 5, { c: false } } )) // => true
      * ```
      */
-    function createAll<T, T2 extends T = T>(...matches: Match.Multi<T2>): (value: T) => boolean;
+    function none<T, R, Q extends T = T>(...matchItems: Match.Options<Q, R>[]): None<T, R, Q>;
     /**
-     * Returns a function that takes a value of type T, and returns true if the value matches any of the
-     * given `matches` array of Match instances.
-     * @typeparam T - the type of the object to match
-     * @typeparam T2 - the type to use for the Match, should be equal to T
-     * @param matches - at least one Match instance to perform on a given `value`
+     * Returns a matcher that returns true if exactly one of given `matchItem` matches the given value.
+     * @typeparam T - the type of value to match
+     * @typeparam R - the root object type
+     * @typeparam Q - a utility type for the matcher
+     * @param matchItems - the match specifications to test
      * @example
      * ```ts
-     * type Person = { name: string, age: number }
-     * const m = Match.createAny<Person>({ age: v => v > 20 }, { name: v => v.length > 2 })
-     *
-     * console.log(m({ name: 'abc', age: 10 }))
-     * // => true
-     * console.log(m({ name: 'abc', age: 20 }))
-     * // => true
-     * console.log(m({ name: 'a', age: 20 }))
-     * // => true
-     * console.log(m({ name: 'a', age: 10 }))
-     * // => false
+     * const input = { a: 1, b: { c: true, d: 'a' } }
+     * match(input, Match.single({ a: 1, { c: true } } )) // => false
+     * match(input, Match.single({ a: 1, { c: false } } )) // => true
      * ```
      */
-    function createAny<T, T2 extends T = T>(...matches: Match.Multi<T2>): (value: T) => boolean;
+    function single<T, R, Q extends T = T>(...matchItems: Match.Options<Q, R>[]): Single<T, R, Q>;
+    /**
+     * The functions that are optionally provided to a match function.
+     */
+    type Api = typeof Match;
+}
+declare class Every<T, R, Q extends T = T> {
+    readonly matchItems: Match.Options<Q, R>[];
+    constructor(matchItems: Match.Options<Q, R>[]);
 }
+declare class Some<T, R, Q extends T = T> {
+    readonly matchItems: Match.Options<Q, R>[];
+    constructor(matchItems: Match.Options<Q, R>[]);
+}
+declare class None<T, R, Q extends T = T> {
+    readonly matchItems: Match.Options<Q, R>[];
+    constructor(matchItems: Match.Options<Q, R>[]);
+}
+declare class Single<T, R, Q extends T = T> {
+    readonly matchItems: Match.Options<Q, R>[];
+    constructor(matchItems: Match.Options<Q, R>[]);
+}
+/**
+ * Returns true if the given `value` object matches the given `matcher`, false otherwise.
+ * @typeparam T - the input value type
+ * @param value - 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
+ * @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 }) => 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>(value: T & PlainObj<T>, matcher: Match<T> | ((matchApi: Match.Api) => Match<T>)): boolean;
 export {};

package/dist/types/patch.d.ts

@@ -1,79 +1,82 @@
-import type { ArrayNonEmpty } from '@rimbu/common';
-import { Literal } from './internal';
+import { type AnyFunc, type PlainObj } from '@rimbu/base';
+import type { Protected } from './internal';
 /**
- * Type to determine the allowed input type for the `patch` function.
- * @typeparam T - the input type
- * @typeparam P - the parant type
- * @typeparam R - the root type
+ * A type to determine the allowed input type for the `patch` function.
+ * @typeparam T - the input type to be patched
  */
-export declare type Patch<T> = PatchHelper<T, T, T>;
-declare type PatchHelper<T, P, R> = T extends Literal.Obj ? Patch.PatchObj<T, P, R> : T extends readonly unknown[] ? Patch.PatchArray<T, P, R> : Patch.Update<T, P, R>;
-/**
- * Returns an updated version of given `value`, without modifying the value, where the contents
- * are updated according to the given `patches` Patch array.
- * @typeparam T - the type of the value to patch
- * @param value - the value to update
- * @param patches - one or more `Patch` objects indicating modifications to the value
- * @example
- * ```ts
- * patch({ g: { h: 5 }})({ g: { h: 6 }})          // => { g: { h: 6 }}
- * patch({ g: { h: 5 }})({ g: { h: v => v + 1 }}) // => { g: { h: 6 }}
- * patch({ g: { h: 5 }})({ g: { h: 1 }}, { g: { h: v => v + 1 }})
- * // => { g: { h: 2 }}
- * patch({ a: 1, b: 3 })({ a: (v, p) => v * p.b, (v, p) => v + p.a })
- * // => { a: 3, b: 4 }
- * ```
- */
-export declare function patch<T>(value: T): (...patches: Patch.Multi<T>) => T;
+export declare type Patch<T> = Patch.Entry<T, T>;
 export declare namespace Patch {
-    const MAP: unique symbol;
     /**
-     * Type to determine the allowed input type for the `patch` function given an object type T.
-     * @typeparam T - the input type, being an object
-     * @typeparam P - the parant type
-     * @typeparam R - the root type
+     * 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 R - the root object type
      */
-    type PatchObj<T extends Literal.Obj, P = T, R = T> = Patch.Update<T, P, R> | {
-        [K in keyof T]?: PatchHelper<T[K], T, R>;
-    };
+    type Entry<T, R> = Patch.Obj<T, R> | ((patchNested: Patch.Nested) => Patch.Obj<T, R>);
     /**
-     * Type representing at least one Patch object for type T
-     * @typeparam T - the target type
+     * The object patch type, allows the user to specify keys in T that should be patched, and each given key contains either a new value or a nested patch, or a function receiving
+     * the current value, the parent object, and the root object, and returning a new value or a nested patch.
+     * @typeparam T - the input value type
+     * @typeparam R - the root object type
      */
-    type Multi<T> = ArrayNonEmpty<Patch<T>>;
+    type Obj<T, R> = {
+        [K in keyof T]?: (T[K] extends AnyFunc ? never : ObjItem<T[K], R>) | ((cur: Protected<T[K]>, parent: Protected<T>, root: Protected<R>) => ObjItem<T[K], R>);
+    };
     /**
-     * Type representing patches for values that are not objects or arrays
-     * @typeparam T - the input type
-     * @typeparam P - the parant type
-     * @typeparam R - the root type
+     * A patch object can have as update either a new value or a nested patch object
+     * @typeparam T - the input value type
+     * @typeparam R - the root object type
      */
-    type Update<T, P, R> = Literal.Value<T> | ((value: T, parent: P, root: R) => T extends boolean ? boolean : T);
+    type ObjItem<T, R> = T | NestedObj<T, R>;
     /**
-     * Type representing allowed patches for arrays
-     * @typeparam T - the array type
-     * @typeparam P - the parent type
-     * @typeparam R - the root type
+     * The function type to create a nested Patch object.
      */
-    type PatchArray<T extends readonly unknown[], P, R> = (Patch.Update<T, P, R> | (T extends readonly (infer E)[] ? {
-        [Patch.MAP]: PatchHelper<E, T, R>;
-    } : never) | {
-        [K in {
-            [K2 in keyof T]: K2;
-        }[keyof T]]?: PatchHelper<T[K], T, R>;
-    }) & Literal.NoIterable;
+    type Nested = typeof patchNested;
     /**
-     * Returns a function that patches a given object of type `T` with the given `patches`
-     * Patch array.
-     * @typeparam T - the value type to operate on
-     * @typeparam T2 - the type the Patch is done for, should be equal to T
-     * @param patches - the patches to apply to a given object
+     * Returns a function that patches a given `value` with the given `patchItems`.
+     * @typeparam T - the patch value type
+     * @typeparam Q - the input value type
+     * @param patchItems - a number of `Patch` objects that patch a given value of type T.
      * @example
      * ```ts
-     * const r = Patch.create<{ a: number, b: number }>({ b: v => v + 1 })({ a: 1, b: 2})
-     * console.log(r)
-     * // => { a: 1, b: 3 }
+     * const items = [{ a: 1, b: 'a' }, { a: 2, b: 'b' }]
+     * items.map(Patch.create({ a: v => v + 1 }))
+     * // => [{ a: 2, b: 'a' }, { a: 3, b: 'b' }]
      * ```
      */
-    function create<T, T2 extends T = T>(...patches: Patch.Multi<T2>): (value: T) => T;
+    function create<T, Q extends T = T>(...patchItems: Patch<T & Q>[]): (value: Q & PlainObj<Q>) => Q;
 }
+declare class NestedObj<T, R, Q extends T = T> {
+    readonly patchDataItems: Patch.Obj<Q, R>[];
+    constructor(patchDataItems: Patch.Obj<Q, R>[]);
+}
+/**
+ * Returns a nested patch object based on the given `patchDataItems` that work on a subpart
+ * of a larger object to be patched.
+ * @typeparam T - the input value type
+ * @typeparam R - the root object type
+ * @typeparam Q - the patch type
+ * @param patchDataItems - a number of `Patch` objects to be applied to the subpart of the object
+ * @example
+ * ```ts
+ * patch({ a: 1, b: { c: true, d: 'a' } }, { b: patchNested({ d: 'b' }) })
+ * // => { a: 1, b: { c: true, d: 'b' } }
+ * ```
+ */
+export declare function patchNested<T, R, Q extends T = T>(...patchDataItems: Patch.Obj<Q, R>[]): NestedObj<T, R, Q>;
+/**
+ * Returns an immutably updated version of the given `value` where the given `patchItems` have been
+ * applied to the result.
+ * @param value - the input value to patch
+ * @param patchItems - the `Patch` objects 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>(value: T & PlainObj<T>, ...patchItems: Patch<T>[]): T;
 export {};

package/dist/types/path.d.ts

@@ -1,4 +1,5 @@
-import { Literal, Patch } from './internal';
+import type { Update } from '@rimbu/common';
+import type { IsPlainObj, PlainObj } from '@rimbu/base';
 /**
  * A string representing a path into an (nested) object of type T.
  * @typeparam T - the object type to select in
@@ -7,7 +8,7 @@ import { Literal, Patch } from './internal';
  * const p: Path<{ a: { b: { c : 5 }}}> = 'a.b'
  * ```
  */
-export declare type Path<T> = T extends Literal.Obj ? {
+export declare type Path<T> = IsPlainObj<T> extends true ? {
     [K in string & keyof T]: `${K}` | `${K}.${Path<T[K]>}`;
 }[string & keyof T] : never;
 export declare namespace Path {
@@ -30,13 +31,13 @@ export declare namespace Path {
      * @param path - the path into the object
      * @example
      * ```ts
-     * console.log(Path.getValue({ a: { b: { c: 5 } } }), 'a.b')
+     * console.log(Path.get({ a: { b: { c: 5 } } }), 'a.b')
      * // => { c: 5 }
-     * console.log(Path.getValue({ a: { b: { c: 5 } } }), 'a.b.c')
+     * console.log(Path.get({ a: { b: { c: 5 } } }), 'a.b.c')
      * // => 5
      * ```
      */
-    function getValue<T, P extends Path<T> = Path<T>>(source: T, path: P): Path.Result<T, P>;
+    function get<T, P extends Path<T> = Path<T>>(source: T & PlainObj<T>, path: P): Path.Result<T, P>;
     /**
      * Sets the value at the given path in the source to the given value.
      * @param source - the object to update
@@ -44,21 +45,9 @@ export declare namespace Path {
      * @param value - the new value to set at the given position
      * @example
      * ```ts
-     * console.log(Path.setValue({ a: { b: { c: 5  } } }))
+     * console.log(Path.update({ a: { b: { c: 5 } } }, 'a.b.c', v => v + 5)
+     * // => { a: { b: { c: 6 } } }
      * ```
      */
-    function setValue<T, P extends Path<T> = Path<T>>(source: T, path: P, value: Path.Result<T, P>): T;
-    /**
-     * Patches the value at the given path in the source to the given value using the given
-     * `patches`.
-     * @param source - the object to update
-     * @param path - the path in the object to update
-     * @param patches - one or more patches to update the value at the given path
-     * @example
-     * ```ts
-     * console.log(Path.setValue({ a: { b: { c: 5 } } }, 'a.b.c', 8)
-     * // => { a: { b: { c: 8 } } }
-     * ```
-     */
-    function patchValue<T, P extends Path<T> = Path<T>>(source: T, path: P, ...patches: Patch.Multi<Path.Result<T, P>>): T;
+    function update<T, P extends Path<T> = Path<T>>(source: T & PlainObj<T>, path: P, value: Update<Path.Result<T, P>>): T;
 }

package/dist/types/protected.d.ts

@@ -0,0 +1,13 @@
+import type { IsPlainObj } from '@rimbu/base';
+/**
+ * A deep readonly typed version of given type T. Makes all properties or elements read only.
+ * @typeparam T - the input type
+ */
+export declare type Protected<T> = T extends readonly (infer E)[] ? readonly Protected<E>[] : T extends Map<infer K, infer V> ? Map<Protected<K>, Protected<V>> : T extends Set<infer E> ? Set<Protected<E>> : T extends Promise<infer E> ? Promise<Protected<E>> : IsPlainObj<T> extends true ? {
+    readonly [K in keyof T]: Protected<T[K]>;
+} : T;
+/**
+ * Returns the same value wrapped in the Protected type
+ * @param value - the value to wrap
+ */
+export declare function Protected<T>(value: T): Protected<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimbu/deep",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Tools to use handle plain JS objects as immutable objects",
   "keywords": [
     "immutable",
@@ -57,8 +57,8 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@rimbu/base": "^0.8.2",
-    "@rimbu/common": "^0.9.2",
+    "@rimbu/base": "^0.9.0",
+    "@rimbu/common": "^0.9.3",
     "tslib": "^2.4.0"
   },
   "publishConfig": {
@@ -68,5 +68,5 @@
     "index": "src/index.ts",
     "replacer": "../../config/denoify-rimbu-replacer.js"
   },
-  "gitHead": "33dd7ca935f19f513586834a2ce1b1f886352ae7"
+  "gitHead": "4efaf8c469d606381517984436383fd6b1b61ec0"
 }

package/src/index.ts

@@ -1,9 +1,19 @@
 /**
  * @packageDocumentation
  *
- * The `@rimbu/deep` package provides utilities to patch and match plain JavaScript objects..<br/>
+ * The `@rimbu/deep` package provides utilities to patch and match plain JavaScript objects.<br/>
  * <br/>
  * See the [Rimbu docs Deep overview page](/docs/deep/overview) for more information.
  */
 
-export * from './internal';
+export {
+  patch,
+  patchNested,
+  Patch,
+  match,
+  Match,
+  Path,
+  Protected,
+} from './internal';
+
+export { Tuple } from './tuple';

package/src/internal.ts

@@ -1,6 +1,5 @@
-export * from './tuple';
-export * from './literal';
-export * from './immutable';
+export * from './protected';
+
 export * from './match';
-export * from './path';
 export * from './patch';
+export * from './path';