@rimbu/common 0.12.3 → 1.0.0-alpha.2

package/dist/cjs/eq.cjs

@@ -0,0 +1,210 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/eq.mts
+var eq_exports = {};
+__export(eq_exports, {
+  Eq: () => Eq
+});
+module.exports = __toCommonJS(eq_exports);
+var Eq;
+((Eq2) => {
+  function convertAnyToString(value) {
+    if (typeof value !== "object" || null === value || !("toString" in value) || typeof value.toString !== "function" || value.toString !== Object.prototype.toString) {
+      return String(value);
+    }
+    return JSON.stringify(value);
+  }
+  Eq2.convertAnyToString = convertAnyToString;
+  const _anyFlatEq = createAnyEq("FLAT");
+  const _anyShallowEq = createAnyEq("SHALLOW");
+  const _anyDeepEq = createAnyEq("DEEP");
+  function defaultEq() {
+    return _anyDeepEq;
+  }
+  Eq2.defaultEq = defaultEq;
+  Eq2.objectIs = Object.is;
+  const _valueOfEq = (v1, v2) => Object.is(v1.valueOf(), v2.valueOf());
+  function valueOfEq() {
+    return _valueOfEq;
+  }
+  Eq2.valueOfEq = valueOfEq;
+  function dateEq() {
+    return _valueOfEq;
+  }
+  Eq2.dateEq = dateEq;
+  function createIterableEq(itemEq) {
+    return (v1, v2) => {
+      if (Object.is(v1, v2))
+        return true;
+      const iter1 = v1[Symbol.iterator]();
+      const iter2 = v2[Symbol.iterator]();
+      while (true) {
+        const value1 = iter1.next();
+        const value2 = iter2.next();
+        if (value1.done || value2.done)
+          return value1.done === value2.done;
+        if (!itemEq(value1.value, value2.value))
+          return false;
+      }
+    };
+  }
+  const _iterableAnyEq = createIterableEq(defaultEq());
+  function iterableEq(itemEq) {
+    if (void 0 === itemEq)
+      return _iterableAnyEq;
+    return createIterableEq(itemEq);
+  }
+  Eq2.iterableEq = iterableEq;
+  function createObjectEq(valueEq) {
+    return (v1, v2) => {
+      if (Object.is(v1, v2))
+        return true;
+      if (v1.constructor !== v2.constructor)
+        return false;
+      for (const key in v1) {
+        if (!(key in v2))
+          return false;
+      }
+      for (const key in v2) {
+        if (!(key in v1))
+          return false;
+      }
+      for (const key in v1) {
+        const value1 = v1[key];
+        const value2 = v2[key];
+        if (!valueEq(value1, value2))
+          return false;
+      }
+      return true;
+    };
+  }
+  const _objectEq = createObjectEq(defaultEq());
+  function objectEq(valueEq) {
+    if (void 0 === valueEq)
+      return _objectEq;
+    return createObjectEq(valueEq);
+  }
+  Eq2.objectEq = objectEq;
+  function createAnyEq(mode) {
+    const result = (v1, v2) => {
+      if (Object.is(v1, v2))
+        return true;
+      const type1 = typeof v1;
+      const type2 = typeof v2;
+      if (type1 !== type2)
+        return false;
+      switch (type1) {
+        case "undefined":
+        case "bigint":
+        case "boolean":
+        case "number":
+        case "string":
+        case "symbol":
+        case "function":
+          return Object.is(v1, v2);
+        case "object": {
+          if (v1 === null || v2 === null)
+            return false;
+          if (v1.constructor !== v2.constructor) {
+            return false;
+          }
+          if (v1 instanceof Boolean || v1 instanceof Date || v1 instanceof Number || v1 instanceof String) {
+            return _valueOfEq(v1, v2);
+          }
+          if (mode !== "FLAT") {
+            if (Symbol.iterator in v1 && Symbol.iterator in v2) {
+              if (mode === "SHALLOW") {
+                return createIterableEq(_anyFlatEq)(v1, v2);
+              }
+              return createIterableEq(result)(v1, v2);
+            }
+            if (mode === "SHALLOW") {
+              return createObjectEq(_anyFlatEq)(v1, v2);
+            }
+            return _objectEq(v1, v2);
+          }
+          return false;
+        }
+      }
+    };
+    return result;
+  }
+  function anyFlatEq() {
+    return _anyFlatEq;
+  }
+  Eq2.anyFlatEq = anyFlatEq;
+  function anyShallowEq() {
+    return _anyShallowEq;
+  }
+  Eq2.anyShallowEq = anyShallowEq;
+  function anyDeepEq() {
+    return _anyDeepEq;
+  }
+  Eq2.anyDeepEq = anyDeepEq;
+  const _defaultCollator = Intl.Collator("und");
+  const _defaultStringCollatorEq = (v1, v2) => _defaultCollator.compare(v1, v2) === 0;
+  function createStringCollatorEq(...args) {
+    if (args.length === 0)
+      return _defaultStringCollatorEq;
+    const collator = Intl.Collator(...args);
+    return (v1, v2) => collator.compare(v1, v2) === 0;
+  }
+  Eq2.createStringCollatorEq = createStringCollatorEq;
+  const _stringCaseInsensitiveEq = createStringCollatorEq("und", {
+    sensitivity: "accent"
+  });
+  function stringCaseInsentitiveEq() {
+    return _stringCaseInsensitiveEq;
+  }
+  Eq2.stringCaseInsentitiveEq = stringCaseInsentitiveEq;
+  const _stringCharCodeEq = (v1, v2) => {
+    const len = v1.length;
+    if (len !== v2.length)
+      return false;
+    let i = -1;
+    while (++i < len) {
+      if (v1.charCodeAt(i) !== v2.charCodeAt(i))
+        return false;
+    }
+    return true;
+  };
+  function stringCharCodeEq() {
+    return _stringCharCodeEq;
+  }
+  Eq2.stringCharCodeEq = stringCharCodeEq;
+  const _anyToStringEq = (v1, v2) => convertAnyToString(v1) === convertAnyToString(v2);
+  function anyToStringEq() {
+    return _anyToStringEq;
+  }
+  Eq2.anyToStringEq = anyToStringEq;
+  const _anyJsonEq = (v1, v2) => JSON.stringify(v1) === JSON.stringify(v2);
+  function anyJsonEq() {
+    return _anyJsonEq;
+  }
+  Eq2.anyJsonEq = anyJsonEq;
+  function tupleSymmetric(eq = defaultEq()) {
+    return (tup1, tup2) => eq(tup1[0], tup2[0]) && eq(tup1[1], tup2[1]) || eq(tup1[0], tup2[1]) && eq(tup1[1], tup2[0]);
+  }
+  Eq2.tupleSymmetric = tupleSymmetric;
+})(Eq || (Eq = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Eq
+});

package/dist/cjs/err.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/err.mts
+var err_exports = {};
+__export(err_exports, {
+  Err: () => Err,
+  ErrBase: () => ErrBase
+});
+module.exports = __toCommonJS(err_exports);
+function Err() {
+  return ErrBase.msg("Err: Forced to throw error")();
+}
+var ErrBase;
+((ErrBase2) => {
+  class CustomError {
+    constructor(message) {
+      this.message = message;
+    }
+    get name() {
+      return this.constructor.name;
+    }
+  }
+  ErrBase2.CustomError = CustomError;
+  class ForcedError extends CustomError {
+  }
+  ErrBase2.ForcedError = ForcedError;
+  function msg(message) {
+    return function() {
+      throw new ErrBase2.ForcedError(message);
+    };
+  }
+  ErrBase2.msg = msg;
+})(ErrBase || (ErrBase = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Err,
+  ErrBase
+});

package/dist/cjs/index-range.cjs

@@ -0,0 +1,114 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index-range.mts
+var index_range_exports = {};
+__export(index_range_exports, {
+  IndexRange: () => IndexRange
+});
+module.exports = __toCommonJS(index_range_exports);
+var IndexRange;
+((IndexRange2) => {
+  function getIndexRangeIndices(range) {
+    if (void 0 !== range.amount) {
+      if (void 0 === range.start)
+        return [0, range.amount - 1];
+      if (Array.isArray(range.start)) {
+        const [start2, includeStart] = range.start;
+        if (includeStart)
+          return [start2, start2 + range.amount - 1];
+        return [start2 + 1, start2 + 1 + range.amount - 1];
+      }
+      return [range.start, range.start + range.amount - 1];
+    }
+    let start = 0;
+    let end = void 0;
+    if (`start` in range) {
+      if (Array.isArray(range.start)) {
+        if (range.start[1])
+          start = range.start[0];
+        else
+          start = range.start[0] + 1;
+      } else
+        start = range.start ?? 0;
+    }
+    if (`end` in range) {
+      if (Array.isArray(range.end)) {
+        if (range.end[1])
+          end = range.end[0];
+        else
+          end = range.end[0] - 1;
+      } else
+        end = range.end;
+    }
+    return [start, end];
+  }
+  IndexRange2.getIndexRangeIndices = getIndexRangeIndices;
+  function getIndicesFor(range, length) {
+    if (length <= 0)
+      return "empty";
+    let start = 0;
+    let end = length - 1;
+    if (void 0 !== range.start) {
+      if (Array.isArray(range.start)) {
+        start = range.start[0];
+        if (!range.start[1])
+          start++;
+      } else
+        start = range.start;
+      if (start >= length || -start > length)
+        return "empty";
+      if (start < 0)
+        start = length + start;
+    }
+    if (void 0 !== range.amount) {
+      if (range.amount <= 0)
+        return "empty";
+      if (void 0 === range.start) {
+        if (range.amount >= length)
+          return "all";
+        return [0, Math.min(end, range.amount - 1)];
+      }
+      end = start + range.amount - 1;
+    } else if (void 0 !== range.end) {
+      if (Array.isArray(range.end)) {
+        end = range.end[0];
+        if (!range.end[1]) {
+          if (end === 0)
+            return "empty";
+          end--;
+        }
+      } else
+        end = range.end;
+      if (end < 0)
+        end = length + end;
+    }
+    if (end < start)
+      return "empty";
+    end = Math.min(length - 1, end);
+    if (start === 0 && end === length - 1)
+      return "all";
+    return [start, end];
+  }
+  IndexRange2.getIndicesFor = getIndicesFor;
+})(IndexRange || (IndexRange = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IndexRange
+});