@rimbu/deep 0.11.2 → 0.12.0

package/dist/module/deep.js

@@ -0,0 +1,192 @@
+import { Deep } from './internal';
+export { match } from './match';
+export { patch } from './patch';
+export { getAt, patchAt } from './path';
+export { select } from './selector';
+/**
+ * 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 function protect(source) {
+    return source;
+}
+/**
+ * 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 function getAtWith(path) {
+    return (source) => Deep.getAt(source, path);
+}
+/**
+ * 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 function patchWith(patchItem) {
+    return (source) => Deep.patch(source, patchItem);
+}
+/**
+ * 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 function patchAtWith(path, patchItem) {
+    return (source) => Deep.patchAt(source, path, patchItem);
+}
+/**
+ * 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 function matchWith(matcher) {
+    return (source) => Deep.match(source, matcher);
+}
+/**
+ * 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 function matchAt(source, path, matcher) {
+    return Deep.match(Deep.getAt(source, path), matcher);
+}
+/**
+ * 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 function matchAtWith(path, matcher) {
+    return (source) => Deep.matchAt(source, path, matcher);
+}
+/**
+ * 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 function selectWith(selector) {
+    return (source) => Deep.select(source, selector);
+}
+/**
+ * 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 function selectAt(source, path, selector) {
+    return Deep.select(Deep.getAt(source, path), selector);
+}
+/**
+ * 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 function selectAtWith(path, selector) {
+    return (source) => Deep.selectAt(source, path, selector);
+}
+/**
+ * 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 function withType() {
+    return Deep;
+}
+//# sourceMappingURL=deep.js.map

package/dist/module/deep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep.js","sourceRoot":"","sources":["../../src/deep.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,OAAO,EAAE,KAAK,EAAc,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAc,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,OAAO,EAAa,MAAM,QAAQ,CAAC;AACnD,OAAO,EAAE,MAAM,EAAiB,MAAM,YAAY,CAAC;AAGnD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,OAAO,CAAI,MAAS;IAClC,OAAO,MAAsB,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CACvB,IAAO;IAEP,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,SAAS,CACvB,SAAwB;IAExB,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,WAAW,CACzB,IAAO,EACP,SAAwD;IAExD,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,SAAgB,CAAC,CAAC;AAClE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,SAAS,CAAI,OAAiB;IAC5C,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CACrB,MAAS,EACT,IAAO,EACP,OAAiC;IAEjC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,WAAW,CACzB,IAAO,EACP,OAAsC;IAEtC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,OAAc,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,UAAU,CACxB,QAA4B;IAE5B,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,QAAQ,CAKtB,MAAS,EACT,IAAO,EACP,QAA4B;IAE5B,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,YAAY,CAK1B,IAAO,EACP,QAA4B;IAE5B,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;AAC3D,CAAC;AAgID;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,QAAQ;IACtB,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/module/index.js

@@ -5,6 +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 { Path } 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, };
 //# sourceMappingURL=index.js.map

package/dist/module/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,EACL,WAAW,EACX,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,OAAO,EAAE,IAAI,EAA6B,MAAM,YAAY,CAAC;AAE7D,cAAc,QAAQ,CAAC;AAEvB,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO;AACL;;;GAGG;AACH,IAAI,GACL,CAAC"}

package/dist/module/internal.js

@@ -1,5 +1,5 @@
-export * from './protected';
-export * from './match';
-export * from './patch';
-export * from './path';
+export { Path } from './path';
+export {} from './match';
+import * as Deep from './deep';
+export { Deep };
 //# sourceMappingURL=internal.js.map

package/dist/module/internal.js.map

@@ -1 +1 @@
-{"version":3,"file":"internal.js","sourceRoot":"","sources":["../../src/internal.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAE5B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../../src/internal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAc,MAAM,SAAS,CAAC;AAIrC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAE,IAAI,EAAE,CAAC"}

package/dist/module/match.js

@@ -1,222 +1,202 @@
-import { RimbuError, isPlainObj, isIterable, } from '@rimbu/base';
-export var Match;
-(function (Match) {
-    /**
-     * 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
-     * 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(...matchItems) {
-        return new Every(matchItems);
-    }
-    Match.every = every;
-    /**
-     * 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
-     * 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 some(...matchItems) {
-        return new Some(matchItems);
-    }
-    Match.some = some;
-    /**
-     * 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
-     * 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(...matchItems) {
-        return new None(matchItems);
-    }
-    Match.none = none;
-    /**
-     * 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
-     * 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(...matchItems) {
-        return new Single(matchItems);
-    }
-    Match.single = single;
-})(Match || (Match = {}));
-class Every {
-    constructor(matchItems) {
-        this.matchItems = matchItems;
-    }
-}
-class Some {
-    constructor(matchItems) {
-        this.matchItems = matchItems;
-    }
-}
-class None {
-    constructor(matchItems) {
-        this.matchItems = matchItems;
-    }
-}
-class Single {
-    constructor(matchItems) {
-        this.matchItems = matchItems;
-    }
-}
+import { isPlainObj, } from '@rimbu/base';
 /**
  * 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 function match(value, matcher) {
-    if (matcher instanceof Function) {
-        return matchOptions(value, value, matcher(Match));
-    }
-    return matchOptions(value, value, matcher);
+export function match(source, matcher, errorCollector = undefined) {
+    return matchEntry(source, source, source, matcher, errorCollector);
 }
-function matchOptions(value, root, matcher) {
-    if (matcher instanceof Every) {
-        let i = -1;
-        const { matchItems } = matcher;
-        const len = matchItems.length;
-        while (++i < len) {
-            if (!matchOptions(value, root, matchItems[i])) {
-                return false;
-            }
-        }
+/**
+ * Match a generic match entry against the given source.
+ */
+function matchEntry(source, parent, root, matcher, errorCollector) {
+    if (Object.is(source, matcher)) {
+        // value and target are exactly the same, always will be true
         return true;
     }
-    if (matcher instanceof Some) {
-        let i = -1;
-        const { matchItems } = matcher;
-        const len = matchItems.length;
-        while (++i < len) {
-            if (matchOptions(value, root, matchItems[i])) {
-                return true;
+    if (matcher === null || matcher === undefined) {
+        // these matchers can only be direct matches, and previously it was determined that
+        // they are not equal
+        errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`value ${JSON.stringify(source)} did not match matcher ${matcher}`);
+        return false;
+    }
+    if (typeof source === 'function') {
+        // function source values can only be directly matched
+        const result = Object.is(source, matcher);
+        if (!result) {
+            errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`both value and matcher are functions, but they do not have the same reference`);
+        }
+        return result;
+    }
+    if (typeof matcher === 'function') {
+        // resolve match function first
+        const matcherResult = matcher(source, parent, root);
+        if (typeof matcherResult === 'boolean') {
+            // function resulted in a direct match result
+            if (!matcherResult) {
+                errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`function matcher returned false for value ${JSON.stringify(source)}`);
             }
+            return matcherResult;
         }
-        return false;
+        // function resulted in a value that needs to be further matched
+        return matchEntry(source, parent, root, matcherResult, errorCollector);
     }
-    if (matcher instanceof None) {
-        let i = -1;
-        const { matchItems } = matcher;
-        const len = matchItems.length;
-        while (++i < len) {
-            if (matchOptions(value, root, matchItems[i])) {
+    if (isPlainObj(source)) {
+        // source ia a plain object, can be partially matched
+        return matchPlainObj(source, parent, root, matcher, errorCollector);
+    }
+    if (Array.isArray(source)) {
+        // source is an array
+        return matchArr(source, root, matcher, errorCollector);
+    }
+    // already determined above that the source and matcher are not equal
+    errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`value ${JSON.stringify(source)} does not match given matcher ${JSON.stringify(matcher)}`);
+    return false;
+}
+/**
+ * Match an array matcher against the given source.
+ */
+function matchArr(source, root, matcher, errorCollector) {
+    if (Array.isArray(matcher)) {
+        // directly compare array contents
+        const length = source.length;
+        if (length !== matcher.length) {
+            // if lengths not equal, arrays are not equal
+            errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`array lengths are not equal: value length ${source.length} !== matcher length ${matcher.length}`);
+            return false;
+        }
+        // loop over arrays, matching every value
+        let index = -1;
+        while (++index < length) {
+            if (!Object.is(source[index], matcher[index])) {
+                // item did not match, return false
+                errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`index ${index} does not match with value ${JSON.stringify(source[index])} and matcher ${matcher[index]}`);
                 return false;
             }
         }
+        // all items are equal
         return true;
     }
-    if (matcher instanceof Single) {
-        let i = -1;
-        const { matchItems } = matcher;
-        const len = matchItems.length;
-        let matched = false;
-        while (++i < len) {
-            if (matchOptions(value, root, matchItems[i])) {
-                if (matched) {
-                    return false;
-                }
-                matched = true;
-            }
+    // matcher is plain object with index keys
+    for (const index in matcher) {
+        const matcherAtIndex = matcher[index];
+        if (!(index in source)) {
+            // source does not have item at given index
+            errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`index ${index} does not exist in source ${JSON.stringify(source)} but should match matcher ${JSON.stringify(matcherAtIndex)}`);
+            return false;
+        }
+        // match the source item at the given index
+        const result = matchEntry(source[index], source, root, matcherAtIndex, errorCollector);
+        if (!result) {
+            // item did not match
+            errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`index ${index} does not match with value ${JSON.stringify(source[index])} and matcher ${JSON.stringify(matcherAtIndex)}`);
+            return false;
         }
-        return matched;
-    }
-    if (isPlainObj(matcher)) {
-        return matchRecord(value, root, matcher);
     }
-    return Object.is(value, matcher);
+    // all items match
+    return true;
 }
-function matchRecord(value, root, matcher) {
-    if (!isPlainObj(matcher)) {
-        RimbuError.throwInvalidUsageError('match: to prevent accidental errors, match only supports plain objects as input.');
+/**
+ * Match an object matcher against the given source.
+ */
+function matchPlainObj(source, parent, root, matcher, errorCollector) {
+    if (Array.isArray(matcher)) {
+        // the matcher is of compound type
+        return matchCompound(source, parent, root, matcher, errorCollector);
     }
+    // partial object props matcher
     for (const key in matcher) {
-        if (!(key in value))
+        if (!(key in source)) {
+            // the source does not have the given key
+            errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`key ${key} is specified in matcher but not present in value ${JSON.stringify(source)}`);
             return false;
-        const matchValue = matcher[key];
-        const target = value[key];
-        if (matchValue instanceof Function) {
-            if (target instanceof Function && Object.is(target, matchValue)) {
-                return true;
+        }
+        // match the source value at the given key with the matcher at given key
+        const result = matchEntry(source[key], source, root, matcher[key], errorCollector);
+        if (!result) {
+            errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`key ${key} does not match in value ${JSON.stringify(source[key])} with matcher ${JSON.stringify(matcher[key])}`);
+            return false;
+        }
+    }
+    // all properties match
+    return true;
+}
+/**
+ * Match a compound matcher against the given source.
+ */
+function matchCompound(source, parent, root, compound, errorCollector) {
+    // first item indicates compound match type
+    const matchType = compound[0];
+    const length = compound.length;
+    // start at index 1
+    let index = 0;
+    switch (matchType) {
+        case 'every': {
+            while (++index < length) {
+                // if any item does not match, return false
+                const result = matchEntry(source, parent, root, compound[index], errorCollector);
+                if (!result) {
+                    errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`in compound "every": match at index ${index} failed`);
+                    return false;
+                }
             }
-            const result = matchValue(target, value, root);
-            if (typeof result === 'boolean') {
+            return true;
+        }
+        case 'none': {
+            // if any item matches, return false
+            while (++index < length) {
+                const result = matchEntry(source, parent, root, compound[index], errorCollector);
                 if (result) {
-                    continue;
+                    errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`in compound "none": match at index ${index} succeeded`);
+                    return false;
                 }
-                return false;
-            }
-            if (!matchRecordItem(target, root, result)) {
-                return false;
             }
+            return true;
         }
-        else {
-            if (!matchRecordItem(target, root, matchValue)) {
-                return false;
+        case 'single': {
+            // if not exactly one item matches, return false
+            let onePassed = false;
+            while (++index < length) {
+                const result = matchEntry(source, parent, root, compound[index], errorCollector);
+                if (result) {
+                    if (onePassed) {
+                        errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`in compound "single": multiple matches succeeded`);
+                        return false;
+                    }
+                    onePassed = true;
+                }
             }
-        }
-    }
-    return true;
-}
-function matchRecordItem(value, root, matcher) {
-    if (isIterable(matcher) && isIterable(value)) {
-        const it1 = value[Symbol.iterator]();
-        const it2 = matcher[Symbol.iterator]();
-        while (true) {
-            const v1 = it1.next();
-            const v2 = it2.next();
-            if (v1.done !== v2.done || v1.value !== v2.value) {
-                return false;
+            if (!onePassed) {
+                errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`in compound "single": no matches succeeded`);
             }
-            if (v1.done) {
-                return true;
+            return onePassed;
+        }
+        case 'some': {
+            // if any item matches, return true
+            while (++index < length) {
+                const result = matchEntry(source, parent, root, compound[index], errorCollector);
+                if (result) {
+                    return true;
+                }
             }
+            errorCollector === null || errorCollector === void 0 ? void 0 : errorCollector.push(`in compound "some": no matches succeeded`);
+            return false;
         }
     }
-    if (isPlainObj(value)) {
-        return matchOptions(value, root, matcher);
-    }
-    return Object.is(value, matcher);
 }
 //# sourceMappingURL=match.js.map