@oscarpalmer/atoms 0.74.1 → 0.76.0

package/dist/js/value/compare.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const math = require("../math.cjs");
+const number = require("../number.cjs");
+const string_index = require("../string/index.cjs");
+function compare(first, second) {
+  const firstParts = getParts(first);
+  const secondParts = getParts(second);
+  const length = math.max([firstParts.length, secondParts.length]);
+  const lastIndex = length - 1;
+  for (let index = 0; index < length; index += 1) {
+    const firstPart = firstParts[index];
+    const secondPart = secondParts[index];
+    if (firstPart === secondPart) {
+      if (index === lastIndex) {
+        return 0;
+      }
+      continue;
+    }
+    if (firstPart == null || typeof firstPart === "string" && firstPart.length === 0) {
+      return -1;
+    }
+    if (secondPart == null || typeof secondPart === "string" && secondPart.length === 0) {
+      return 1;
+    }
+    const firstNumber = number.getNumber(firstPart);
+    const secondNumber = number.getNumber(secondPart);
+    const firstIsNaN = Number.isNaN(firstNumber);
+    const secondIsNaN = Number.isNaN(secondNumber);
+    if (firstIsNaN || secondIsNaN) {
+      if (firstIsNaN && secondIsNaN) {
+        return string_index.getString(firstPart).localeCompare(string_index.getString(secondPart));
+      }
+      if (firstIsNaN) {
+        return 1;
+      }
+      if (secondIsNaN) {
+        return -1;
+      }
+    }
+    if (firstNumber === secondNumber) {
+      if (index === lastIndex) {
+        return 0;
+      }
+    }
+    return firstNumber - secondNumber;
+  }
+  return string_index.join(firstParts).localeCompare(string_index.join(secondParts));
+}
+function getParts(value) {
+  if (value == null) {
+    return [""];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return typeof value === "object" ? [value] : string_index.words(string_index.getString(value));
+}
+exports.compare = compare;

package/dist/js/value/{compare.mjs → compare.js}

@@ -1,13 +1,12 @@
-// src/js/value/compare.ts
-import { max } from "../math";
-import { getNumber } from "../number";
-import { words, getString, join } from "../string";
+import { max } from "../math.js";
+import { getNumber } from "../number.js";
+import { getString, join, words } from "../string/index.js";
 function compare(first, second) {
   const firstParts = getParts(first);
   const secondParts = getParts(second);
   const length = max([firstParts.length, secondParts.length]);
   const lastIndex = length - 1;
-  for (let index = 0;index < length; index += 1) {
+  for (let index = 0; index < length; index += 1) {
     const firstPart = firstParts[index];
     const secondPart = secondParts[index];
     if (firstPart === secondPart) {
@@ -41,7 +40,6 @@ function compare(first, second) {
       if (index === lastIndex) {
         return 0;
       }
-      continue;
     }
     return firstNumber - secondNumber;
   }

package/dist/js/value/diff.cjs

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const is = require("../is.cjs");
+const string_index = require("../string/index.cjs");
+const value_equal = require("./equal.cjs");
+function diff(first, second) {
+  const result = {
+    original: {
+      from: first,
+      to: second
+    },
+    type: "partial",
+    values: {}
+  };
+  const same = Object.is(first, second);
+  const firstIsArrayOrObject = is.isArrayOrPlainObject(first);
+  const secondIsArrayOrObject = is.isArrayOrPlainObject(second);
+  if (same || !firstIsArrayOrObject && !secondIsArrayOrObject) {
+    result.type = same ? "none" : "full";
+    return result;
+  }
+  if (firstIsArrayOrObject !== secondIsArrayOrObject) {
+    result.type = "full";
+  }
+  const diffs = getDiffs(
+    first,
+    second
+  );
+  const { length } = diffs;
+  if (length === 0) {
+    result.type = "none";
+  }
+  for (let index = 0; index < length; index += 1) {
+    const diff2 = diffs[index];
+    result.values[diff2.key] = { from: diff2.from, to: diff2.to };
+  }
+  return result;
+}
+function getDiffs(first, second, prefix) {
+  const changes = [];
+  const checked = /* @__PURE__ */ new Set();
+  for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
+    const value = outerIndex === 0 ? first : second;
+    if (!value) {
+      continue;
+    }
+    const keys = Object.keys(value);
+    const { length } = keys;
+    for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
+      const key = keys[innerIndex];
+      if (checked.has(key)) {
+        continue;
+      }
+      const from = first == null ? void 0 : first[key];
+      const to = second == null ? void 0 : second[key];
+      if (!value_equal.equal(from, to)) {
+        const prefixed = string_index.join([prefix, key], ".");
+        const change = {
+          from,
+          to,
+          key: prefixed
+        };
+        const nested = is.isArrayOrPlainObject(from) || is.isArrayOrPlainObject(to);
+        const diffs = nested ? getDiffs(from, to, prefixed) : [];
+        if (!nested || nested && diffs.length > 0) {
+          changes.push(change);
+        }
+        changes.push(...diffs);
+      }
+      checked.add(key);
+    }
+  }
+  return changes;
+}
+exports.diff = diff;

package/dist/js/value/{diff.mjs → diff.js}

@@ -1,7 +1,6 @@
-// src/js/value/diff.ts
-import { isArrayOrPlainObject } from "../is";
-import { join } from "../string";
-import { equal } from "./equal";
+import { isArrayOrPlainObject } from "../is.js";
+import { join } from "../string/index.js";
+import { equal } from "./equal.js";
 function diff(first, second) {
   const result = {
     original: {
@@ -21,12 +20,15 @@ function diff(first, second) {
   if (firstIsArrayOrObject !== secondIsArrayOrObject) {
     result.type = "full";
   }
-  const diffs = getDiffs(first, second);
+  const diffs = getDiffs(
+    first,
+    second
+  );
   const { length } = diffs;
   if (length === 0) {
     result.type = "none";
   }
-  for (let index = 0;index < length; index += 1) {
+  for (let index = 0; index < length; index += 1) {
     const diff2 = diffs[index];
     result.values[diff2.key] = { from: diff2.from, to: diff2.to };
   }
@@ -34,21 +36,21 @@ function diff(first, second) {
 }
 function getDiffs(first, second, prefix) {
   const changes = [];
-  const checked = new Set;
-  for (let outerIndex = 0;outerIndex < 2; outerIndex += 1) {
+  const checked = /* @__PURE__ */ new Set();
+  for (let outerIndex = 0; outerIndex < 2; outerIndex += 1) {
     const value = outerIndex === 0 ? first : second;
     if (!value) {
       continue;
     }
     const keys = Object.keys(value);
     const { length } = keys;
-    for (let innerIndex = 0;innerIndex < length; innerIndex += 1) {
+    for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
       const key = keys[innerIndex];
       if (checked.has(key)) {
         continue;
       }
-      const from = first?.[key];
-      const to = second?.[key];
+      const from = first == null ? void 0 : first[key];
+      const to = second == null ? void 0 : second[key];
       if (!equal(from, to)) {
         const prefixed = join([prefix, key], ".");
         const change = {

package/dist/js/value/equal.cjs

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const is = require("../is.cjs");
+function equal(first, second, ignoreCase) {
+  switch (true) {
+    case first === second:
+      return true;
+    case (first == null || second == null):
+      return first === second;
+    case typeof first !== typeof second:
+      return false;
+    case (first instanceof ArrayBuffer && second instanceof ArrayBuffer):
+      return equalArrayBuffer(first, second);
+    case typeof first === "boolean":
+    case (first instanceof Date && second instanceof Date):
+      return Object.is(Number(first), Number(second));
+    case (first instanceof DataView && second instanceof DataView):
+      return equalDataView(first, second);
+    case (first instanceof Error && second instanceof Error):
+      return equalProperties(first, second, ["name", "message"]);
+    case (first instanceof Map && second instanceof Map):
+      return equalMap(first, second);
+    case (first instanceof RegExp && second instanceof RegExp):
+      return equalProperties(first, second, ["source", "flags"]);
+    case (first instanceof Set && second instanceof Set):
+      return equalSet(first, second);
+    case (Array.isArray(first) && Array.isArray(second)):
+    case (is.isPlainObject(first) && is.isPlainObject(second)):
+      return equalObject(first, second);
+    case (typeof first === "string" && ignoreCase === true):
+      return Object.is(first.toLowerCase(), second.toLowerCase());
+    default:
+      return Object.is(first, second);
+  }
+}
+function equalArrayBuffer(first, second) {
+  return first.byteLength === second.byteLength ? equalObject(
+    new Uint8Array(first),
+    new Uint8Array(second)
+  ) : false;
+}
+function equalDataView(first, second) {
+  return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer) : false;
+}
+function equalMap(first, second) {
+  const { size } = first;
+  if (size !== second.size) {
+    return false;
+  }
+  const firstKeys = [...first.keys()];
+  const secondKeys = [...second.keys()];
+  if (firstKeys.some((key) => !secondKeys.includes(key))) {
+    return false;
+  }
+  for (let index = 0; index < size; index += 1) {
+    const key = firstKeys[index];
+    if (!equal(first.get(key), second.get(key))) {
+      return false;
+    }
+  }
+  return true;
+}
+function equalObject(first, second) {
+  const firstKeys = Object.keys(first);
+  const secondKeys = Object.keys(second);
+  const { length } = firstKeys;
+  if (length !== secondKeys.length || firstKeys.some((key) => !secondKeys.includes(key))) {
+    return false;
+  }
+  for (let index = 0; index < length; index += 1) {
+    const key = firstKeys[index];
+    if (!equal(first[key], second[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function equalProperties(first, second, properties) {
+  const { length } = properties;
+  for (let index = 0; index < length; index += 1) {
+    const property = properties[index];
+    if (!equal(
+      first[property],
+      second[property]
+    )) {
+      return false;
+    }
+  }
+  return true;
+}
+function equalSet(first, second) {
+  const { size } = first;
+  if (size !== second.size) {
+    return false;
+  }
+  const firstValues = [...first];
+  const secondValues = [...second];
+  for (let index = 0; index < size; index += 1) {
+    const firstValue = firstValues[index];
+    if (!secondValues.some((secondValue) => equal(firstValue, secondValue))) {
+      return false;
+    }
+  }
+  return true;
+}
+exports.equal = equal;

package/dist/js/value/{equal.mjs → equal.js}

@@ -1,5 +1,4 @@
-// src/js/value/equal.ts
-import { isPlainObject } from "../is";
+import { isPlainObject } from "../is.js";
 function equal(first, second, ignoreCase) {
   switch (true) {
     case first === second:
@@ -33,7 +32,10 @@ function equal(first, second, ignoreCase) {
   }
 }
 function equalArrayBuffer(first, second) {
-  return first.byteLength === second.byteLength ? equalObject(new Uint8Array(first), new Uint8Array(second)) : false;
+  return first.byteLength === second.byteLength ? equalObject(
+    new Uint8Array(first),
+    new Uint8Array(second)
+  ) : false;
 }
 function equalDataView(first, second) {
   return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer) : false;
@@ -48,7 +50,7 @@ function equalMap(first, second) {
   if (firstKeys.some((key) => !secondKeys.includes(key))) {
     return false;
   }
-  for (let index = 0;index < size; index += 1) {
+  for (let index = 0; index < size; index += 1) {
     const key = firstKeys[index];
     if (!equal(first.get(key), second.get(key))) {
       return false;
@@ -63,7 +65,7 @@ function equalObject(first, second) {
   if (length !== secondKeys.length || firstKeys.some((key) => !secondKeys.includes(key))) {
     return false;
   }
-  for (let index = 0;index < length; index += 1) {
+  for (let index = 0; index < length; index += 1) {
     const key = firstKeys[index];
     if (!equal(first[key], second[key])) {
       return false;
@@ -73,9 +75,12 @@ function equalObject(first, second) {
 }
 function equalProperties(first, second, properties) {
   const { length } = properties;
-  for (let index = 0;index < length; index += 1) {
+  for (let index = 0; index < length; index += 1) {
     const property = properties[index];
-    if (!equal(first[property], second[property])) {
+    if (!equal(
+      first[property],
+      second[property]
+    )) {
       return false;
     }
   }
@@ -88,7 +93,7 @@ function equalSet(first, second) {
   }
   const firstValues = [...first];
   const secondValues = [...second];
-  for (let index = 0;index < size; index += 1) {
+  for (let index = 0; index < size; index += 1) {
     const firstValue = firstValues[index];
     if (!secondValues.some((secondValue) => equal(firstValue, secondValue))) {
       return false;

package/dist/js/value/get.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const internal_value_handle = require("../internal/value/handle.cjs");
+function getValue(data, path, ignoreCase) {
+  const shouldIgnoreCase = ignoreCase === true;
+  const parts = (shouldIgnoreCase ? path.toLowerCase() : path).split(".");
+  const { length } = parts;
+  let index = 0;
+  let value = data;
+  while (index < length && value != null) {
+    value = internal_value_handle.handleValue(
+      value,
+      parts[index++],
+      null,
+      true,
+      shouldIgnoreCase
+    );
+  }
+  return value;
+}
+exports.getValue = getValue;

package/dist/js/value/{get.mjs → get.js}

@@ -1,13 +1,18 @@
-// src/js/value/get.ts
-import { handleValue } from "../internal/value-handle";
+import { handleValue } from "../internal/value/handle.js";
 function getValue(data, path, ignoreCase) {
   const shouldIgnoreCase = ignoreCase === true;
   const parts = (shouldIgnoreCase ? path.toLowerCase() : path).split(".");
   const { length } = parts;
   let index = 0;
-  let value = typeof data === "object" ? data ?? {} : {};
+  let value = data;
   while (index < length && value != null) {
-    value = handleValue(value, parts[index++], null, true, shouldIgnoreCase);
+    value = handleValue(
+      value,
+      parts[index++],
+      null,
+      true,
+      shouldIgnoreCase
+    );
   }
   return value;
 }

package/dist/js/value/index.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const value_clone = require("./clone.cjs");
+const value_compare = require("./compare.cjs");
+const value_diff = require("./diff.cjs");
+const value_equal = require("./equal.cjs");
+const value_get = require("./get.cjs");
+const value_merge = require("./merge.cjs");
+const value_set = require("./set.cjs");
+const value_smush = require("./smush.cjs");
+const value_unsmush = require("./unsmush.cjs");
+function partial(value, keys) {
+  const result = {};
+  const { length } = keys;
+  for (let index = 0; index < length; index += 1) {
+    const key = keys[index];
+    result[key] = value[key];
+  }
+  return result;
+}
+exports.clone = value_clone.clone;
+exports.compare = value_compare.compare;
+exports.diff = value_diff.diff;
+exports.equal = value_equal.equal;
+exports.getValue = value_get.getValue;
+exports.merge = value_merge.merge;
+exports.setValue = value_set.setValue;
+exports.smush = value_smush.smush;
+exports.unsmush = value_unsmush.unsmush;
+exports.partial = partial;