@rimbu/deep 0.11.3 → 0.12.1

package/dist/types/deep.d.ts

@@ -0,0 +1,284 @@
+import type { Match, Patch, Path, Protected, Selector } from './internal';
+export { match, type Match } from './match';
+export { patch, type Patch } from './patch';
+export { getAt, patchAt, type Path } from './path';
+export { select, type Selector } from './selector';
+export type { Protected } from './protected';
+/**
+ * Returns the same value wrapped in the `Protected` type.
+ * @typeparam T - the source value type
+ * @param source - the value to wrap
+ * @note does not perform any runtime protection, it is only a utility to easily add the `Protected`
+ * type to a value
+ * @example
+ * ```ts
+ * const obj = Deep.protect({ a: 1, b: { c: true, d: [1] } })
+ * obj.a = 2        // compiler error: a is readonly
+ * obj.b.c = false  // compiler error: c is readonly
+ * obj.b.d.push(2)  // compiler error: d is a readonly array
+ * (obj as any).b.d.push(2)  // will actually mutate the object
+ * ```
+ */
+export declare function protect<T>(source: T): Protected<T>;
+/**
+ * Returns a function that gets the value at the given string `path` inside an object.
+ * @typeparam T - the input value type
+ * @typeparam P - the string literal path type in the object
+ * @param path - the string path in the object
+ * @param source - the value from which to extract the path value
+ * @example
+ * ```ts
+ * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
+ * items.map(Deep.getAtWith('a.c'));
+ * // => ['a', 'b']
+ * ```
+ */
+export declare function getAtWith<T, P extends Path.Get<T>>(path: P): (source: T) => Path.Result<T, P>;
+/**
+ * Returns a function that patches a given `source` with the given `patchItems`.
+ * @typeparam T - the patch value type
+ * @typeparam TE - utility type
+ * @typeparam TT - utility type
+ * @param patchItem - the `Patch` definition to update the given value of type `T` with.
+ * @param source - the value to use the given `patchItem` on.
+ * @example
+ * ```ts
+ * const items = [{ a: 1, b: 'a' }, { a: 2, b: 'b' }];
+ * items.map(Deep.patchWith([{ a: v => v + 1 }]));
+ * // => [{ a: 2, b: 'a' }, { a: 3, b: 'b' }]
+ * ```
+ */
+export declare function patchWith<T, TE extends T = T, TT = T>(patchItem: Patch<TT, TE>): (source: TE) => T;
+/**
+ * Returns a function that patches a given `value` with the given `patchItems` at the given `path`.
+ * @typeparam T - the patch value type
+ * @typeparam P - the string literal path type in the object
+ * @typeparam TE - utility type
+ * @typeparam TT - utility type
+ * @param path - the string path in the object
+ * @param patchItem - the `Patch` definition to update the value at the given `path` in `T` with.
+ * @param source - the value to use the given `patchItem` on at the given `path`.
+ * @example
+ * ```ts
+ * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
+ * items.map(Deep.patchAtWith('a', [{ b: (v) => v + 1 }]));
+ * // => [{ a: { b: 2, c: 'a' } }, { a: { b: 3, c: 'b' } }]
+ * ```
+ */
+export declare function patchAtWith<T, P extends Path.Set<T>, TE extends T = T, TT = T>(path: P, patchItem: Patch<Path.Result<TE, P>, Path.Result<TT, P>>): (source: T) => T;
+/**
+ * Returns a function that matches a given `value` with the given `matcher`.
+ * @typeparam T - the patch value type
+ * @param matcher - a matcher object that matches input values.
+ * @param source - the value to use the given `patchItem` on at the given `path`.
+ * @example
+ * ```ts
+ * const items = [{ a: 1, b: 'a' }, { a: 2, b: 'b' }];
+ * items.filter(Deep.matchWith({ a: 2 }));
+ * // => [{ a: 2, b: 'b' }]
+ * ```
+ */
+export declare function matchWith<T>(matcher: Match<T>): (source: T) => boolean;
+/**
+ * Returns true if the given `value` object matches the given `matcher` at the given `path`, false otherwise.
+ * @typeparam T - the input value type
+ * @typeparam P - the string literal path type in the object
+ * @param source - the input value
+ * @param path - the string path in the 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' } }
+ * Deep.matchAt(input, 'b', { c: true })
+ * // => true
+ * ```
+ */
+export declare function matchAt<T, P extends Path.Get<T>>(source: T, path: P, matcher: Match<Path.Result<T, P>>): boolean;
+/**
+ * Returns a function that matches a given `value` with the given `matcher` at the given string `path`.
+ * @typeparam T - the patch value type
+ * @typeparam P - the string literal path type in the object
+ * @typeparam TE - utility type
+ * @param path - the string path in the object
+ * @param matcher - a matcher object that matches input values.
+ * @param source - the value to use the given `matcher` on at the given `path`.
+ * @example
+ * ```ts
+ * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
+ * items.filter(Deep.matchAtWith('a.b', 2));
+ * // => [{ a: 2, b: 'b' }]
+ * ```
+ */
+export declare function matchAtWith<T, P extends Path.Get<T>, TE extends T = T>(path: P, matcher: Match<Path.Result<T & TE, P>>): (source: T) => boolean;
+/**
+ * Returns a function that selects a certain shape from a given `value` with the given `selector`.
+ * @typeparam T - the patch value type
+ * @typeparam SL - the selector shape type
+ * @param selector - a shape indicating the selection from the source values
+ * @param source - the value to use the given `selector` on.
+ * @example
+ * ```ts
+ * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
+ * items.map(Deep.selectWith({ q: 'a.c', z: ['a.b', v => v.a.b + 1] as const }));
+ * // => [{ q: 'a', z: [1, 2] }, { q: 'b', z: [2, 3] }]
+ * ```
+ */
+export declare function selectWith<T, SL extends Selector<T>>(selector: Selector.Shape<SL>): (source: T) => Selector.Result<T, SL>;
+/**
+ * Returns the result of applying the given `selector` shape to the given `source` value.
+ * @typeparam T - the patch value type
+ * @typeparam P - the string literal path type in the object
+ * @typeparam SL - the selector shape type
+ * @param source - the source value to select from
+ * @param path - the string path in the object
+ * @param selector - a shape indicating the selection from the source value at the given path
+ * @example
+ * ```ts
+ * const item = { a: { b:  1, c: 'a' } };
+ * Deep.selectAt(item, 'a', { q: 'c', z: ['b', v => v.b + 1] as const });
+ * // => { q: 'a', z: [1, 2] }
+ * ```
+ */
+export declare function selectAt<T, P extends Path.Get<T>, SL extends Selector<Path.Result<T, P>>>(source: T, path: P, selector: Selector.Shape<SL>): Selector.Result<Path.Result<T, P>, SL>;
+/**
+ * Returns a function that selects a certain shape from a given `value` with the given `selector` at the given string `path`.
+ * @typeparam T - the patch value type
+ * @typeparam P - the string literal path type in the object
+ * @typeparam SL - the selector shape type
+ * @param path - the string path in the object
+ * @param selector - a shape indicating the selection from the source values
+ * @example
+ * ```ts
+ * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
+ * items.map(Deep.selectAtWith('a', { q: 'c', z: ['b', v => v.b + 1] as const }));
+ * // => [{ q: 'a', z: [1, 2] }, { q: 'b', z: [2, 3] }]
+ * ```
+ */
+export declare function selectAtWith<T, P extends Path.Get<T>, SL extends Selector<Path.Result<T, P>>>(path: P, selector: Selector.Shape<SL>): (source: T) => Selector.Result<Path.Result<T, P>, SL>;
+/**
+ * Typed and curried Deep API, used in situations where the target type
+ * is known but the value will be applied later.
+ * @typeparam T - the target type
+ * @example
+ * ```ts
+ * const s = { a: 1, b: { c: 'a', d: true }};
+ * const upd = Deep.withType<typeof s>().patchWith([{ a: (v) => v + 1 }]);
+ * upd(s);
+ * // => { a: 2, b: { c: 'a', d: true }}
+ * ```
+ */
+export interface WithType<T> {
+    /**
+     * Returns a function that given an object returns the value at the given `path`.
+     * @typeparam P - a Path in object type T
+     * @param path - the path into the object
+     * @example
+     * ```ts
+     * const value = { a: { b: { c: 5 } } }
+     * const getValue = Deep.withType<typeof value>().getAtWith('a.b.c');
+     * getValue(value);
+     * // => 5
+     * ```
+     */
+    getAtWith<P extends Path.Get<T>>(path: P): (source: T) => Path.Result<T, P>;
+    /**
+     * Returns a function that patches a given `value` with the given `patchItems`.
+     * @typeparam TT - utility type
+     * @param patchItem - the `Patch` definition to update the given value with
+     * @param source - the value to use the given `patchItem` on.
+     * @example
+     * ```ts
+     * const value = { a: 1, b: 'a' };
+     * const upd = Deep.withType<typeof value>().patch([{ a: v => v + 1 }]);
+     * upd(value);
+     * // => { a: 2, b: 'a' }
+     * ```
+     */
+    patchWith<TE extends T = T, TT = T>(patchItem: Patch<TT, TE>): (source: TE) => T;
+    /**
+     * Returns a function that patches a given `value` with the given `patchItems` at the given `path`.
+     * @typeparam P - the string literal path type in the object
+     * @typeparam TT - utility type
+     * @param path - the string path in the object
+     * @param patchItem - the `Patch` definition to update the given value with
+     * @param source - the value to use the given `patchItem` on at the given `path`.
+     * @example
+     * ```ts
+     * const value = { a: { b: 1, c: 'a' } };
+     * const upd = Deep.withType<typeof value>().patchAtWith('a', [{ b: (v) => v + 1 }])
+     * upd(value);
+     * // => { a: { b: 2, c: 'a' } }
+     * ```
+     */
+    patchAtWith<P extends Path.Set<T>, TT = T>(path: P, patchItem: Patch<Path.Result<T, P>, Path.Result<TT, P>>): (source: T) => T;
+    /**
+     * Returns a function that matches a given `value` with the given `matcher`.
+     * @param matcher - a matcher object that matches input values.
+     * @param source - the value to use the given `matcher` on.
+     * @example
+     * ```ts
+     * const value = { a: 1, b: 'a' };
+     * const m = Deep.withType<typeof value>().matchWith({ a: 1 });
+     * m(value);
+     * // => true
+     * ```
+     */
+    matchWith(matcher: Match<T>): (source: T) => boolean;
+    /**
+     * Returns a function that matches a given `value` with the given `matcher` at the given string `path`.
+     * @typeparam P - the string literal path type in the object
+     * @param path - the string path in the object
+     * @param matcher - a matcher object that matches input values.
+     * @param source - the value to use the given `matcher` on at the given `path`.
+     * @example
+     * ```ts
+     * const items = [{ a: { b:  1, c: 'a' } }, { a: { b: 2, c: 'b' } }];
+     * items.filter(Deep.matchAtWith('a.b', 2));
+     * // => [{ a: 2, b: 'b' }]
+     * ```
+     */
+    matchAtWith<P extends Path.Get<T>>(path: P, matcher: Match<Path.Result<T, P>>): (source: T) => boolean;
+    /**
+     * Returns a function that selects a certain shape from a given `value` with the given `selector`.
+     * @typeparam SL - the selector shape type
+     * @param selector - a shape indicating the selection from the source values
+     * @param source - the value to use the given `selector` on.
+     * @example
+     * ```ts
+     * const value = { a: { b: 1, c: 'a' } };
+     * const sel = Deep.withType<typeof value>().selectWith({ q: 'a.b' });
+     * sel(value);
+     * // => { q: 1 }
+     * ```
+     */
+    selectWith<SL extends Selector<T>>(selector: Selector.Shape<SL>): (source: T) => Selector.Result<T, SL>;
+    /**
+     * Returns a function that selects a certain shape from a given `value` with the given `selector` at the given string `path`.
+     * @typeparam P - the string literal path type in the object
+     * @typeparam SL - the selector shape type
+     * @param path - the string path in the object
+     * @param selector - a shape indicating the selection from the source values
+     * @param source - the value to use the given `selector` on at the given `path`.
+     * @example
+     * ```ts
+     * const value = { a: { b: 1, c: 'a' } };
+     * const sel = Deep.withType<typeof value>().selectAtWith('a', { q: 'b' });
+     * sel(value);
+     * // => { q: 1 }
+     * ```
+     */
+    selectAtWith<P extends Path.Get<T>, SL extends Selector<Path.Result<T, P>>>(path: P, selector: Selector.Shape<SL>): (source: T) => Selector.Result<Path.Result<T, P>, SL>;
+}
+/**
+ * Returns a curried API with a known target type. This can be useful for using the methods in
+ * contexts where the target type can be inferred from the usage.
+ * @typeparam T - the target type
+ * @example
+ * ```ts
+ * const s = { a: 1, b: { c: 'a', d: true }}
+ * const upd = Deep.withType<typeof s>().patchWith([{ d: (v) => !v }])
+ * upd(s)
+ * // => { a: 1, b: { c: 'a', d: false }}
+ * ```
+ */
+export declare function withType<T>(): WithType<T>;

package/dist/types/index.d.ts

@@ -5,5 +5,14 @@
  * <br/>
  * See the [Rimbu docs Deep overview page](/docs/deep/overview) for more information.
  */
-export { patch, patchNested, Patch, match, Match, Path, Protected, } from './internal';
 export { Tuple } from './tuple';
+export type { Protected, Patch } from './internal';
+export { Path, type Selector, type Match } from './internal';
+export * from './deep';
+import * as Deep from './deep';
+export { 
+/**
+ * Convenience namespace offering access to most common functions used in the `@rimbu/deep` package.
+ * These are mainly utilities to patch and match plain JavaScript objects.
+ */
+Deep, };

package/dist/types/internal.d.ts

@@ -1,4 +1,7 @@
-export * from './protected';
-export * from './match';
-export * from './patch';
-export * from './path';
+export type { Protected } from './protected';
+export { Path } from './path';
+export { type Match } from './match';
+export type { Patch } from './patch';
+export type { Selector } from './selector';
+import * as Deep from './deep';
+export { Deep };

package/dist/types/match.d.ts

@@ -1,124 +1,118 @@
-import { type IsPlainObj, type PlainObj } from '@rimbu/base';
+import { IsAnyFunc, IsArray, IsPlainObj, NotIterable } from '@rimbu/base';
 import type { Protected } from './internal';
+import type { Tuple } from './tuple';
 /**
- * The type to determine the allowed input values for the `match` functions.
+ * 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 declare type Match<T> = Match.Options<T, T>;
+export declare type Match<T, C extends Partial<T> = Partial<T>> = Match.Entry<T, C, T, T>;
 export declare namespace Match {
     /**
-     * The types of supported match input.
-     * @typeparam T - the type of value to match
+     * Determines the various allowed match types for given type `T`.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam P - the parant type
      * @typeparam R - the root object type
      */
-    type Options<T, R> = Every<T, R> | Some<T, R> | None<T, R> | Single<T, R> | Match.Obj<T, R>;
+    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 ? // determine allowed match values for array or tuple
+    Match.Arr<T, C, P, R> | Match.Func<T, P, R, Match.Arr<T, C, P, R>> : Match.WithResult<T, P, R, {
+        [K in keyof C]: C[K & keyof T];
+    }>;
     /**
-     * The type to determine allowed matchers for objects.
-     * @typeparam T - the type of value to match
+     * The type that determines allowed matchers for objects.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam P - the parant type
      * @typeparam R - the root object type
      */
-    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 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 type of value to match
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
      * @typeparam R - the root object type
      */
-    type ObjItem<T, R> = IsPlainObj<T> extends true ? Match.Options<T, R> : T extends Iterable<infer U> ? T | Iterable<U> : T;
+    type ObjProps<T, C, R> = {
+        [K in keyof C]?: K extends keyof T ? Match.Entry<T[K], C[K], T, R> : never;
+    };
     /**
-     * Returns a matcher that returns true if every given `matchItem` matches the given value.
-     * @typeparam T - the type of value to match
+     * The type that determines allowed matchers for arrays/tuples.
+     * @typeparam T - the input value type
+     * @typeparam C - utility type
+     * @typeparam P - the parant type
      * @typeparam R - the root object type
-     * @typeparam Q - a utility type for the matcher
-     * @param matchItems - the match specifications to test
-     * @example
-     * ```ts
-     * 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 every<T, R, Q extends T = T>(...matchItems: Match.Options<Q, R>[]): Every<T, R, Q>;
+    type Arr<T, C, P, R> = C | Match.CompoundForArr<T, C, P, R> | (Match.TupIndices<T, C, R> & {
+        [K in Match.CompoundType]?: never;
+    });
+    type WithResult<T, P, R, S> = S | Match.Func<T, P, R, S>;
     /**
-     * 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
+     * Type used to determine the allowed function types. Always includes booleans.
+     * @typeparam T - the input value type
+     * @typeparam P - the parant type
      * @typeparam R - the root object type
-     * @typeparam Q - a utility type for the matcher
-     * @param matchItems - the match specifications to test
-     * @example
-     * ```ts
-     * 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
-     * ```
+     * @typeparam S - the allowed return value type
      */
-    function some<T, R, Q extends T = T>(...matchItems: Match.Options<Q, R>[]): Some<T, R, Q>;
+    type Func<T, P, R, S> = (current: Protected<T>, parent: Protected<P>, root: Protected<R>) => boolean | S;
     /**
-     * Returns a matcher that returns true if none of given `matchItem` matches the given value.
-     * @typeparam T - the type of value to match
+     * 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
-     * @typeparam Q - a utility type for the matcher
-     * @param matchItems - the match specifications to test
-     * @example
-     * ```ts
-     * 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 none<T, R, Q extends T = T>(...matchItems: Match.Options<Q, R>[]): None<T, R, Q>;
+    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';
     /**
-     * Returns a matcher that returns true if exactly one of given `matchItem` matches the given value.
-     * @typeparam T - the type of value to match
+     * 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
-     * @typeparam Q - a utility type for the matcher
-     * @param matchItems - the match specifications to test
-     * @example
-     * ```ts
-     * 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 single<T, R, Q extends T = T>(...matchItems: Match.Options<Q, R>[]): Single<T, R, Q>;
+    type CompoundForObj<T, C, P, R> = [
+        Match.CompoundType,
+        ...Match.Entry<T, C, P, R>[]
+    ];
     /**
-     * The functions that are optionally provided to a match function.
+     * 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 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>[]);
+    type CompoundForArr<T, C, P, R> = {
+        [K in CompoundType]: {
+            [K2 in CompoundType]?: K2 extends K ? Match.Entry<T, C, P, R>[] : never;
+        };
+    }[CompoundType];
+    /**
+     * Utility type for collecting errors
+     */
+    type ErrorCollector = string[] | undefined;
 }
 /**
  * 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)
+ * @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 errorCollector - (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, { 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, (['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 {};
+export declare function match<T, C extends Partial<T> = Partial<T>>(source: T, matcher: Match<T, C>, errorCollector?: Match.ErrorCollector): boolean;

package/dist/types/patch.d.ts

@@ -1,82 +1,89 @@
-import { type AnyFunc, type PlainObj } from '@rimbu/base';
+import { IsAnyFunc, IsArray, IsPlainObj } from '@rimbu/base';
 import type { Protected } from './internal';
+import type { Tuple } from './tuple';
 /**
  * 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> = Patch.Entry<T, T>;
+export declare 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, R> = Patch.Obj<T, R> | ((patchNested: Patch.Nested) => Patch.Obj<T, R>);
+    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>;
     /**
-     * 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
+     * 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 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 NotIterable = {
+        [Symbol.iterator]?: never;
     };
     /**
-     * A patch object can have as update either a new value or a nested patch object
+     * 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 ObjItem<T, R> = T | NestedObj<T, R>;
-    /**
-     * The function type to create a nested Patch object.
-     */
-    type Nested = typeof patchNested;
+    type Obj<T, C, R> = T | Patch.ObjProps<T, C, R>[];
     /**
-     * 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 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' }]
-     * ```
+     * 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
      */
-    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>[]);
+    type ObjProps<T, C, R> = {
+        [K in keyof C]?: K extends keyof T ? Patch.Entry<T[K], C[K], T, R> : never;
+    };
 }
-/**
- * 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.
+ * 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 patchItems - the `Patch` objects to apply to the input value
+ * @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 }) }) )
+ * 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' }) }) )
+ * 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 {};
+export declare function patch<T, TE extends T = T, TT = T>(value: T, patchItem: Patch<TE, T & TT>): T;