ts-data-forge 14.6.1 → 14.6.3

package/dist/object/object.mjs

@@ -1,214 +1,367 @@
-import '../number/branded-types/finite-number.mjs';
-import '../number/branded-types/int.mjs';
-import '../number/branded-types/int16.mjs';
-import '../number/branded-types/int32.mjs';
-import '../number/branded-types/negative-finite-number.mjs';
-import '../number/branded-types/negative-int.mjs';
-import '../number/branded-types/negative-safe-int.mjs';
-import '../number/branded-types/non-negative-finite-number.mjs';
-import '../number/branded-types/non-negative-int16.mjs';
-import '../number/branded-types/non-negative-int32.mjs';
-import '../number/branded-types/non-positive-finite-number.mjs';
-import '../number/branded-types/non-positive-int.mjs';
-import '../number/branded-types/non-positive-safe-int.mjs';
-import '../number/branded-types/non-zero-finite-number.mjs';
-import '../number/branded-types/non-zero-int.mjs';
-import '../number/branded-types/non-zero-int16.mjs';
-import '../number/branded-types/non-zero-int32.mjs';
-import '../number/branded-types/non-zero-safe-int.mjs';
-import '../number/branded-types/non-zero-uint16.mjs';
-import '../number/branded-types/non-zero-uint32.mjs';
-import '../number/branded-types/positive-finite-number.mjs';
-import '../number/branded-types/positive-int.mjs';
-import '../number/branded-types/positive-int16.mjs';
-import '../number/branded-types/positive-int32.mjs';
-import '../number/branded-types/positive-safe-int.mjs';
-import '../number/branded-types/positive-uint16.mjs';
-import '../number/branded-types/positive-uint32.mjs';
-import '../number/branded-types/safe-int.mjs';
-import '../number/branded-types/safe-uint.mjs';
-import '../number/branded-types/uint.mjs';
-import '../number/branded-types/uint16.mjs';
-import '../number/branded-types/uint32.mjs';
-import '../number/enum/int8.mjs';
-import '../number/enum/uint8.mjs';
-import '../number/num.mjs';
-import '../number/refined-number-utils.mjs';
-import { isSome } from '../functional/optional/impl/optional-is-some.mjs';
-import { hasKey } from '../guard/has-key.mjs';
-import { isRecord } from '../guard/is-record.mjs';
-import '@sindresorhus/is';
-import { isNonEmpty } from '../array/impl/array-utils-length-bounded-array-guard.mjs';
-import '../collections/imap-mapped.mjs';
-import '../collections/imap.mjs';
-import '../collections/iset-mapped.mjs';
-import '../collections/iset.mjs';
-
-var Obj;
-((Obj2) => {
-  Obj2.shallowEq = (a, b, eq = Object.is) => {
-    const aEntries = Object.entries(a);
-    const bEntries = Object.entries(b);
-    if (aEntries.length !== bEntries.length) return false;
-    return aEntries.every(([k, v]) => eq(b[k], v));
-  };
-  function pick(...args) {
-    switch (args.length) {
-      case 2: {
-        const [record, keys] = args;
-        const keysSet = new Set(keys);
-        return (
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          Object.fromEntries(
-            Object.entries(record).filter(([k, _v]) => keysSet.has(k))
-          )
-        );
-      }
-      case 1: {
-        const [keys] = args;
-        return (record) => pick(record, keys);
-      }
+import { Arr } from '../array/index.mjs';
+import { Optional } from '../functional/index.mjs';
+import { hasKey, isRecord } from '../guard/index.mjs';
+
+
+
+
+
+
+
+
+export var Obj;
+(function (Obj) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Obj.shallowEq = (a, b, eq = Object.is) => {
+        const aEntries = Object.entries(a);
+        const bEntries = Object.entries(b);
+        if (aEntries.length !== bEntries.length)
+            return false;
+        return aEntries.every(([k, v]) => eq(b[k], v));
+    };
+    function pick(...args) {
+        switch (args.length) {
+            case 2: {
+                const [record, keys] = args;
+                const keysSet = new Set(keys);
+                return (
+
+                Object.fromEntries(Object.entries(record).filter(([k, _v]) => keysSet.has(k))));
+            }
+            case 1: {
+                const [keys] = args;
+                return (record) => pick(record, keys);
+            }
+        }
     }
-  }
-  Obj2.pick = pick;
-  function omit(...args) {
-    switch (args.length) {
-      case 2: {
-        const [record, keys] = args;
-        const keysSet = new Set(keys);
-        return (
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          Object.fromEntries(
-            Object.entries(record).filter(([k, _v]) => !keysSet.has(k))
-          )
-        );
-      }
-      case 1: {
-        const [keys] = args;
-        return (record) => {
-          const result = omit(
-            record,
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            keys
-          );
-          return result;
-        };
-      }
+    Obj.pick = pick;
+    function omit(...args) {
+        switch (args.length) {
+            case 2: {
+                const [record, keys] = args;
+                const keysSet = new Set(keys);
+                return (
+
+                Object.fromEntries(Object.entries(record).filter(([k, _v]) => !keysSet.has(k))));
+            }
+            case 1: {
+                const [keys] = args;
+                return (record) => {
+
+                    const result = omit(record, 
+
+                    keys);
+                    return result;
+                };
+            }
+        }
     }
-  }
-  Obj2.omit = omit;
-  Obj2.fromEntries = (entries) => (
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    Object.fromEntries(entries)
-  );
-  Obj2.map = (record, mapFn) => {
-    const mapFnWidened = mapFn;
-    return (
-      // `Object.entries` enumerates exactly the own enumerable string keys of
-      // `record`, and nothing here adds or removes an entry, so the result has
-      // the key set `MappedRecord` claims.
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      Object.fromEntries(
-        Object.entries(record).map(
-          ([k, v]) => [k, mapFnWidened(v, k)]
-        )
-      )
-    );
-  };
-  function filter(record, predicate) {
-    const predicateWidened = predicate;
-    return (
-      // `Object.entries` enumerates exactly the own enumerable string keys of
-      // `record`, and filtering only ever removes entries, so the result has a
-      // subset of those keys — which is what `FilteredRecord` claims.
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      Object.fromEntries(
-        Object.entries(record).filter(([k, v]) => predicateWidened(v, k))
-      )
-    );
-  }
-  Obj2.filter = filter;
-  Obj2.filterMap = (record, mapFn) => {
-    const mapFnWidened = mapFn;
-    return (
-      // `Object.entries` enumerates exactly the own enumerable string keys of
-      // `record`, and this only ever drops entries or replaces their values, so
-      // the result has a subset of those keys with `V2` values.
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      Object.fromEntries(
-        Object.entries(record).flatMap(([k, v]) => {
-          const mapped = mapFnWidened(v, k);
-          return isSome(mapped) ? [[k, mapped.value]] : [];
-        })
-      )
-    );
-  };
-  Obj2.merge = (...records) => (
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    Object.fromEntries(records.flatMap((r) => Object.entries(r)))
-  );
-  function deepPick(...args) {
-    switch (args.length) {
-      case 2: {
-        const [record, path] = args;
+    Obj.omit = omit;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Obj.fromEntries = (entries) => 
+
+    Object.fromEntries(entries);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Obj.map = (record, mapFn) => {
+
+
+
+        const mapFnWidened = mapFn;
         return (
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          deepPickImpl(record, path)
-        );
-      }
-      case 1: {
-        const [path] = args;
-        return (record) => deepPick(record, path);
-      }
+
+
+
+
+        Object.fromEntries(Object.entries(record).map(([k, v]) => [k, mapFnWidened(v, k)])));
+    };
+    function filter(record, predicate) {
+
+
+
+        const predicateWidened = predicate;
+        return (
+
+
+
+
+        Object.fromEntries(Object.entries(record).filter(([k, v]) => predicateWidened(v, k))));
     }
-  }
-  Obj2.deepPick = deepPick;
-  function deepOmit(...args) {
-    switch (args.length) {
-      case 2: {
-        const [record, path] = args;
+    Obj.filter = filter;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Obj.filterMap = (record, mapFn) => {
+
+
+
+        const mapFnWidened = mapFn;
         return (
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          deepOmitImpl(record, path)
-        );
-      }
-      case 1: {
-        const [path] = args;
-        return (record) => deepOmit(record, path);
-      }
+
+
+
+
+        Object.fromEntries(Object.entries(record).flatMap(([k, v]) => {
+            const mapped = mapFnWidened(v, k);
+            return Optional.isSome(mapped) ? [[k, mapped.value]] : [];
+        })));
+    };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Obj.merge = (...records) => 
+
+    Object.fromEntries(records.flatMap((r) => Object.entries(r)));
+    function deepPick(...args) {
+        switch (args.length) {
+            case 2: {
+                const [record, path] = args;
+                return (
+
+                deepPickImpl(record, path));
+            }
+            case 1: {
+                const [path] = args;
+                return (record) => deepPick(record, path);
+            }
+        }
     }
-  }
-  Obj2.deepOmit = deepOmit;
+    Obj.deepPick = deepPick;
+    function deepOmit(...args) {
+        switch (args.length) {
+            case 2: {
+                const [record, path] = args;
+                return (
+
+                deepOmitImpl(record, path));
+            }
+            case 1: {
+                const [path] = args;
+                return (record) => deepOmit(record, path);
+            }
+        }
+    }
+    Obj.deepOmit = deepOmit;
 })(Obj || (Obj = {}));
 const deepPickImpl = (record, path) => {
-  if (!isNonEmpty(path)) return record;
-  const head = path[0];
-  if (!hasKey(record, head)) return {};
-  const value = record[head];
-  const tail = path.slice(1);
-  if (!isNonEmpty(tail)) return { [head]: value };
-  if (!isRecord(value)) return { [head]: {} };
-  return {
-    [head]: deepPickImpl(value, tail)
-  };
+    if (!Arr.isNonEmpty(path))
+        return record;
+    const head = path[0];
+    if (!hasKey(record, head))
+        return {};
+    const value = record[head];
+    const tail = path.slice(1);
+    if (!Arr.isNonEmpty(tail))
+        return { [head]: value };
+    if (!isRecord(value))
+        return { [head]: {} };
+    return {
+        [head]: deepPickImpl(value, tail),
+    };
 };
 const deepOmitImpl = (record, path) => {
-  if (!isNonEmpty(path)) return record;
-  const head = path[0];
-  if (!hasKey(record, head)) return record;
-  const tail = path.slice(1);
-  if (!isNonEmpty(tail)) {
-    return Object.fromEntries(
-      Object.entries(record).filter(([k]) => k !== head)
-    );
-  }
-  const value = record[head];
-  if (!isRecord(value)) return record;
-  return {
-    ...record,
-    [head]: deepOmitImpl(value, tail)
-  };
+    if (!Arr.isNonEmpty(path))
+        return record;
+    const head = path[0];
+    if (!hasKey(record, head))
+        return record;
+    const tail = path.slice(1);
+    if (!Arr.isNonEmpty(tail)) {
+        return Object.fromEntries(Object.entries(record).filter(([k]) => k !== head));
+    }
+    const value = record[head];
+    if (!isRecord(value))
+        return record;
+    return {
+        ...record,
+        [head]: deepOmitImpl(value, tail),
+    };
 };
-
-export { Obj };
-//# sourceMappingURL=object.mjs.map
+//# sourceMappingURL=object.mjs.map