@rimbu/deep 0.11.3 → 0.12.1

package/dist/main/deep.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withType = exports.selectAtWith = exports.selectAt = exports.selectWith = exports.matchAtWith = exports.matchAt = exports.matchWith = exports.patchAtWith = exports.patchWith = exports.getAtWith = exports.protect = exports.select = exports.patchAt = exports.getAt = exports.patch = exports.match = void 0;
+var internal_1 = require("./internal");
+var match_1 = require("./match");
+Object.defineProperty(exports, "match", { enumerable: true, get: function () { return match_1.match; } });
+var patch_1 = require("./patch");
+Object.defineProperty(exports, "patch", { enumerable: true, get: function () { return patch_1.patch; } });
+var path_1 = require("./path");
+Object.defineProperty(exports, "getAt", { enumerable: true, get: function () { return path_1.getAt; } });
+Object.defineProperty(exports, "patchAt", { enumerable: true, get: function () { return path_1.patchAt; } });
+var selector_1 = require("./selector");
+Object.defineProperty(exports, "select", { enumerable: true, get: function () { return selector_1.select; } });
+/**
+ * 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
+ * ```
+ */
+function protect(source) {
+    return source;
+}
+exports.protect = protect;
+/**
+ * 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']
+ * ```
+ */
+function getAtWith(path) {
+    return function (source) { return internal_1.Deep.getAt(source, path); };
+}
+exports.getAtWith = getAtWith;
+/**
+ * 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' }]
+ * ```
+ */
+function patchWith(patchItem) {
+    return function (source) { return internal_1.Deep.patch(source, patchItem); };
+}
+exports.patchWith = patchWith;
+/**
+ * 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' } }]
+ * ```
+ */
+function patchAtWith(path, patchItem) {
+    return function (source) { return internal_1.Deep.patchAt(source, path, patchItem); };
+}
+exports.patchAtWith = patchAtWith;
+/**
+ * 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' }]
+ * ```
+ */
+function matchWith(matcher) {
+    return function (source) { return internal_1.Deep.match(source, matcher); };
+}
+exports.matchWith = matchWith;
+/**
+ * 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
+ * ```
+ */
+function matchAt(source, path, matcher) {
+    return internal_1.Deep.match(internal_1.Deep.getAt(source, path), matcher);
+}
+exports.matchAt = matchAt;
+/**
+ * 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' }]
+ * ```
+ */
+function matchAtWith(path, matcher) {
+    return function (source) { return internal_1.Deep.matchAt(source, path, matcher); };
+}
+exports.matchAtWith = matchAtWith;
+/**
+ * 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] }]
+ * ```
+ */
+function selectWith(selector) {
+    return function (source) { return internal_1.Deep.select(source, selector); };
+}
+exports.selectWith = selectWith;
+/**
+ * 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] }
+ * ```
+ */
+function selectAt(source, path, selector) {
+    return internal_1.Deep.select(internal_1.Deep.getAt(source, path), selector);
+}
+exports.selectAt = selectAt;
+/**
+ * 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] }]
+ * ```
+ */
+function selectAtWith(path, selector) {
+    return function (source) { return internal_1.Deep.selectAt(source, path, selector); };
+}
+exports.selectAtWith = selectAtWith;
+/**
+ * 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 }}
+ * ```
+ */
+function withType() {
+    return internal_1.Deep;
+}
+exports.withType = withType;
+//# sourceMappingURL=deep.js.map

package/dist/main/deep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep.js","sourceRoot":"","sources":["../../src/deep.ts"],"names":[],"mappings":";;;AACA,uCAAkC;AAElC,iCAA4C;AAAnC,8FAAA,KAAK,OAAA;AACd,iCAA4C;AAAnC,8FAAA,KAAK,OAAA;AACd,+BAAmD;AAA1C,6FAAA,KAAK,OAAA;AAAE,+FAAA,OAAO,OAAA;AACvB,uCAAmD;AAA1C,kGAAA,MAAM,OAAA;AAGf;;;;;;;;;;;;;;GAcG;AACH,SAAgB,OAAO,CAAI,MAAS;IAClC,OAAO,MAAsB,CAAC;AAChC,CAAC;AAFD,0BAEC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,SAAS,CACvB,IAAO;IAEP,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAxB,CAAwB,CAAC;AAC9C,CAAC;AAJD,8BAIC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,SAAS,CACvB,SAAwB;IAExB,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,SAAgB,CAAC,EAApC,CAAoC,CAAC;AAC1D,CAAC;AAJD,8BAIC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,WAAW,CACzB,IAAO,EACP,SAAwD;IAExD,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,SAAgB,CAAC,EAA5C,CAA4C,CAAC;AAClE,CAAC;AALD,kCAKC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,SAAS,CAAI,OAAiB;IAC5C,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,EAA3B,CAA2B,CAAC;AACjD,CAAC;AAFD,8BAEC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,OAAO,CACrB,MAAS,EACT,IAAO,EACP,OAAiC;IAEjC,OAAO,eAAI,CAAC,KAAK,CAAC,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC;AACvD,CAAC;AAND,0BAMC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,WAAW,CACzB,IAAO,EACP,OAAsC;IAEtC,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,OAAc,CAAC,EAA1C,CAA0C,CAAC;AAChE,CAAC;AALD,kCAKC;AAED;;;;;;;;;;;;GAYG;AACH,SAAgB,UAAU,CACxB,QAA4B;IAE5B,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAA7B,CAA6B,CAAC;AACnD,CAAC;AAJD,gCAIC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,QAAQ,CAKtB,MAAS,EACT,IAAO,EACP,QAA4B;IAE5B,OAAO,eAAI,CAAC,MAAM,CAAC,eAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;AACzD,CAAC;AAVD,4BAUC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,YAAY,CAK1B,IAAO,EACP,QAA4B;IAE5B,OAAO,UAAC,MAAM,IAAK,OAAA,eAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,EAArC,CAAqC,CAAC;AAC3D,CAAC;AATD,oCASC;AAkID;;;;;;;;;;;GAWG;AACH,SAAgB,QAAQ;IACtB,OAAO,eAAI,CAAC;AACd,CAAC;AAFD,4BAEC"}

package/dist/main/index.js

@@ -7,15 +7,13 @@
  * See the [Rimbu docs Deep overview page](/docs/deep/overview) for more information.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tuple = exports.Protected = exports.Path = exports.Match = exports.match = exports.Patch = exports.patchNested = exports.patch = void 0;
-var internal_1 = require("./internal");
-Object.defineProperty(exports, "patch", { enumerable: true, get: function () { return internal_1.patch; } });
-Object.defineProperty(exports, "patchNested", { enumerable: true, get: function () { return internal_1.patchNested; } });
-Object.defineProperty(exports, "Patch", { enumerable: true, get: function () { return internal_1.Patch; } });
-Object.defineProperty(exports, "match", { enumerable: true, get: function () { return internal_1.match; } });
-Object.defineProperty(exports, "Match", { enumerable: true, get: function () { return internal_1.Match; } });
-Object.defineProperty(exports, "Path", { enumerable: true, get: function () { return internal_1.Path; } });
-Object.defineProperty(exports, "Protected", { enumerable: true, get: function () { return internal_1.Protected; } });
+exports.Deep = exports.Path = exports.Tuple = void 0;
+var tslib_1 = require("tslib");
 var tuple_1 = require("./tuple");
 Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return tuple_1.Tuple; } });
+var internal_1 = require("./internal");
+Object.defineProperty(exports, "Path", { enumerable: true, get: function () { return internal_1.Path; } });
+tslib_1.__exportStar(require("./deep"), exports);
+var Deep = tslib_1.__importStar(require("./deep"));
+exports.Deep = Deep;
 //# sourceMappingURL=index.js.map

package/dist/main/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,uCAQoB;AAPlB,iGAAA,KAAK,OAAA;AACL,uGAAA,WAAW,OAAA;AACX,iGAAA,KAAK,OAAA;AACL,iGAAA,KAAK,OAAA;AACL,iGAAA,KAAK,OAAA;AACL,gGAAA,IAAI,OAAA;AACJ,qGAAA,SAAS,OAAA;AAGX,iCAAgC;AAAvB,8FAAA,KAAK,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;;AAEH,iCAAgC;AAAvB,8FAAA,KAAK,OAAA;AAGd,uCAA6D;AAApD,gGAAA,IAAI,OAAA;AAEb,iDAAuB;AAEvB,mDAA+B;AAM7B,oBAAI"}

package/dist/main/internal.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deep = exports.Path = void 0;
 var tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./protected"), exports);
-tslib_1.__exportStar(require("./match"), exports);
-tslib_1.__exportStar(require("./patch"), exports);
-tslib_1.__exportStar(require("./path"), exports);
+var path_1 = require("./path");
+Object.defineProperty(exports, "Path", { enumerable: true, get: function () { return path_1.Path; } });
+var match_1 = require("./match");
+var Deep = tslib_1.__importStar(require("./deep"));
+exports.Deep = Deep;
 //# sourceMappingURL=internal.js.map

package/dist/main/internal.js.map

@@ -1 +1 @@
-{"version":3,"file":"internal.js","sourceRoot":"","sources":["../../src/internal.ts"],"names":[],"mappings":";;;AAAA,sDAA4B;AAE5B,kDAAwB;AACxB,kDAAwB;AACxB,iDAAuB"}
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../../src/internal.ts"],"names":[],"mappings":";;;;AACA,+BAA8B;AAArB,4FAAA,IAAI,OAAA;AACb,iCAAqC;AAIrC,mDAA+B;AACtB,oBAAI"}