@tspro/ts-utils-lib 1.18.0 → 1.19.1

package/dist/index.js

@@ -1,4 +1,4 @@
-/* TsUtilsLib v1.18.0 | (c) 2023 PahkaSoft | Licensed under the MIT License */
+/* TsUtilsLib v1.19.1 | (c) 2023 PahkaSoft | Licensed under the MIT License */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -25,6 +25,8 @@ var index_exports = {};
 __export(index_exports, {
   Assert: () => assert_exports,
   Cookies: () => cookies_exports,
+  DeepSet: () => DeepSet,
+  DefaultArray: () => DefaultArray,
   Device: () => device_exports,
   DivRect: () => DivRect,
   Guard: () => guard_exports,
@@ -34,6 +36,8 @@ __export(index_exports, {
   Map2: () => Map2,
   Map3: () => Map3,
   MultiContainer: () => MultiContainer,
+  Set1: () => Set1,
+  SetBase: () => SetBase,
   SignedIndexArray: () => SignedIndexArray,
   SmallIntCache: () => SmallIntCache,
   Stack: () => Stack,
@@ -516,21 +520,6 @@ var _consent;
 var _expires;
 var str = _read(ConsentCookieName);
 _consent = str === "accept" /* Accept */ || str === "decline" /* Decline */ ? str : void 0;
-function setExpireDays(days) {
-  _expires = /* @__PURE__ */ new Date();
-  _expires.setDate(_expires.getDate() + days);
-}
-function isConsentPending() {
-  return _consent === void 0;
-}
-function accept() {
-  _consent = "accept" /* Accept */;
-  _save(ConsentCookieName, _consent);
-}
-function decline() {
-  _consent = "decline" /* Decline */;
-  _save(ConsentCookieName, _consent);
-}
 function _getList() {
   let s = document.cookie;
   return s.split(";").map((c) => c.trim());
@@ -550,18 +539,31 @@ function _read(name, defaultValue) {
 function _erase(name) {
   document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 UTC;";
 }
+function setExpireDays(days) {
+  _expires = /* @__PURE__ */ new Date();
+  _expires.setDate(_expires.getDate() + days);
+}
+function isConsentPending() {
+  return _consent === void 0;
+}
+function accept() {
+  _consent = "accept" /* Accept */;
+  _save(ConsentCookieName, _consent);
+}
+function decline() {
+  _consent = "decline" /* Decline */;
+  _save(ConsentCookieName, _consent);
+}
 function save(name, value) {
-  if (_consent === "accept" /* Accept */) {
+  if (_consent === "accept" /* Accept */)
     _save(name, value);
-  }
   return value;
 }
 function read(name, defaultValue) {
-  if (_consent === "accept" /* Accept */) {
-    return _read(name, defaultValue) || defaultValue;
-  } else {
+  if (_consent === "accept" /* Accept */)
+    return _read(name, defaultValue) ?? defaultValue;
+  else
     return defaultValue;
-  }
 }
 function readInt(name, defaultValue) {
   if (_consent === "accept" /* Accept */) {
@@ -580,9 +582,8 @@ function readBool(name, defaultValue) {
   }
 }
 function erase(name) {
-  if (_consent === "accept" /* Accept */ || name === ConsentCookieName) {
+  if (_consent === "accept" /* Accept */ || name === ConsentCookieName)
     _erase(name);
-  }
 }
 function eraseAll() {
   document.cookie.split(";").forEach((c) => erase(c.trim().split("=")[0]));
@@ -690,7 +691,7 @@ function toPx(input) {
   } else {
     value = parseFloat(input);
   }
-  assert_exports.finite(value, "value in function toPx");
+  assert_exports.isFinite(value, "value in function toPx");
   switch (unit) {
     case "mm":
       return mmToPx(value);
@@ -1038,11 +1039,11 @@ function toArray(a) {
 function duplicate(a) {
   return a === void 0 ? a : a.slice();
 }
-function removeDuplicates(a) {
-  return a.filter((item, pos, arr) => arr.indexOf(item) === pos);
+function removeDuplicates(arr, compareFn) {
+  return compareFn !== void 0 ? arr.filter((a, id, self) => id === self.findIndex((b) => compareFn(a, b))) : arr.filter((a, id, self) => id === self.indexOf(a));
 }
-function removeDuplicatesCmp(arr, cmp2) {
-  return arr.filter((t1, index, self) => index === self.findIndex((t2) => cmp2(t1, t2)));
+function removeDuplicatesCmp(arr, compareFn) {
+  return arr.filter((a, id, self) => id === self.findIndex((b) => compareFn(a, b)));
 }
 function fillArray(fillValue, fillCount) {
   if (!isInteger2(fillCount) || fillCount < 0) {
@@ -1505,30 +1506,83 @@ function makeSentenceFromPascal(PascalString) {
 // src/utils/index.ts
 var Is = guard_exports;
 
+// src/core/format-value.ts
+function formatValue(value) {
+  if (isString2(value)) {
+    return `"${value}"`;
+  } else if (isArray2(value)) {
+    return `[ ${value.map((e) => formatValue(e)).join(", ")} ]`.replaceAll("  ", " ");
+  } else if (isFunction2(value.toString)) {
+    return value.toString();
+  } else {
+    return JSON.stringify(value);
+  }
+}
+
 // src/core/stack.ts
 var Stack = class {
   constructor() {
-    __publicField(this, "list", []);
+    __publicField(this, "data", []);
+  }
+  assertId(id) {
+    assert_exports.isIntegerBetween(id, 0, this.length - 1, `Stack index ${id} out of range.`);
+    return id;
   }
-  push(e) {
-    this.list.push(e);
-    return e;
+  get length() {
+    return this.data.length;
+  }
+  push(el) {
+    this.data.push(el);
+    return el;
   }
   pop() {
-    assert_exports.int_gt(this.list.length, 0);
-    return this.list.pop();
+    this.assertId(this.length - 1);
+    return this.data.pop();
+  }
+  popOrUndef() {
+    return this.data.pop();
+  }
+  popOr(defaultValueOrCreator) {
+    return this.isEmpty() ? isFunction2(defaultValueOrCreator) ? defaultValueOrCreator() : defaultValueOrCreator : this.data.pop();
   }
   top() {
-    return assert_exports.array_elem(this.list, this.list.length - 1, "Stack is empty!");
+    return this.data[this.assertId(this.length - 1)];
+  }
+  topOrUndef() {
+    return this.data[this.length - 1];
+  }
+  topOr(defaultValueOrCreator) {
+    return this.isEmpty() ? isFunction2(defaultValueOrCreator) ? defaultValueOrCreator() : defaultValueOrCreator : this.data[this.length - 1];
+  }
+  peek(depth = 0) {
+    return this.data[this.assertId(this.data.length - 1 - depth)];
+  }
+  peekOrUndef(depth = 0) {
+    return this.data[this.data.length - 1 - depth];
+  }
+  peekOr(depth = 0, defaultValueOrCreator) {
+    const id = this.data.length - 1 - depth;
+    const value = id < 0 ? void 0 : this.data[id];
+    return value === void 0 ? isFunction2(defaultValueOrCreator) ? defaultValueOrCreator() : defaultValueOrCreator : value;
+  }
+  *values() {
+    for (let id = this.data.length - 1; id >= 0; id--)
+      yield this.data[id];
+  }
+  *[Symbol.iterator]() {
+    yield* this.values();
   }
   toArray() {
-    return this.list;
+    return [...this.data];
   }
-  get length() {
-    return this.list.length;
+  isEmpty() {
+    return this.length === 0;
   }
   clear() {
-    this.list.length = 0;
+    this.data.length = 0;
+  }
+  toString() {
+    return `Stack(${this.length})${formatValue(this.data)}`;
   }
 };
 
@@ -2112,6 +2166,14 @@ var IndexArray = class _IndexArray {
   get size() {
     return this.valCount;
   }
+  get length() {
+    return this.hasPos.length;
+  }
+  trimRight() {
+    let newLength = this.length;
+    while (newLength > 0 && this.hasPos[newLength - 1] !== true) newLength--;
+    if (newLength < this.length) this.posVal.length = this.hasPos.length = newLength;
+  }
   isEmpty() {
     return this.size === 0;
   }
@@ -2146,6 +2208,7 @@ var IndexArray = class _IndexArray {
     this.posVal[id] = void 0;
     this.hasPos[id] = false;
     this.valCount--;
+    this.trimRight();
     return true;
   }
   clear() {
@@ -2282,10 +2345,12 @@ var IndexArray = class _IndexArray {
     }
     return true;
   }
+  toArray() {
+    return this.valuesArray();
+  }
   toString() {
-    if (this.size === 0) return `IndexArray[ ]`;
-    const entries = this.entriesArray().map(([id, value]) => `${id}: ${value}`).join(", ");
-    return `IndexArray[ ${entries} ]`;
+    const entries = this.entriesArray().map(([id, v]) => `${formatValue(id)}: ${formatValue(v)}`).join(", ");
+    return `IndexArray[ ${entries} ]`.replaceAll("  ", " ");
   }
 };
 
@@ -2543,10 +2608,215 @@ var SignedIndexArray = class _SignedIndexArray {
     }
     return true;
   }
+  toArray() {
+    return this.valuesArray();
+  }
   toString() {
-    if (this.size === 0) return `SignedIndexArray[ ]`;
-    const entries = this.entriesArray().map(([id, value]) => `${id}: ${value}`).join(", ");
-    return `SignedIndexArray[ ${entries} ]`;
+    const entries = this.entriesArray().map(([id, v]) => `${formatValue(id)}: ${formatValue(v)}`).join(", ");
+    return `SignedIndexArray[ ${entries} ]`.replaceAll("  ", " ");
+  }
+};
+
+// src/core/default-array.ts
+var DefaultArray = class _DefaultArray {
+  constructor(lengthOrValues, defaultValue) {
+    this.defaultValue = defaultValue;
+    __publicField(this, "data");
+    if (typeof lengthOrValues === "number") {
+      this.data = Array(lengthOrValues).fill(defaultValue);
+    } else {
+      this.data = Array.from(lengthOrValues).map(
+        (v) => v === void 0 ? defaultValue : v
+      );
+    }
+  }
+  get size() {
+    return this.data.length;
+  }
+  get length() {
+    return this.data.length;
+  }
+  assertId(id) {
+    if (id < 0 || id >= this.data.length)
+      throw new RangeError(`DefaultArray: Index ${id} out of range`);
+    return id;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  isDefault(id) {
+    return this.data[this.assertId(id)] === this.defaultValue;
+  }
+  isSet(id) {
+    return this.data[this.assertId(id)] !== this.defaultValue;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  has(id) {
+    return this.isSet(id);
+  }
+  set(id, value) {
+    return this.data[this.assertId(id)] = value;
+  }
+  get(id) {
+    return this.data[this.assertId(id)];
+  }
+  getOrDefault(id, defaultValue) {
+    let value = this.get(id);
+    return value === this.defaultValue ? defaultValue : value;
+  }
+  getOrCreate(id, creatorOrValue) {
+    if (!this.has(id)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(id, value);
+      return value;
+    }
+    return this.get(id);
+  }
+  delete(id) {
+    this.assertId(id);
+    if (this.data[id] === this.defaultValue) return false;
+    this.data[id] = this.defaultValue;
+    return true;
+  }
+  clear(empty = false) {
+    if (empty)
+      this.data = [];
+    else
+      this.data.fill(this.defaultValue);
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [id, value] of this.entries()) {
+      callbackfn.call(thisArg, value, id, this);
+    }
+  }
+  *indices() {
+    yield* this.data.keys();
+  }
+  *values() {
+    yield* this.data.values();
+  }
+  *entries() {
+    yield* this.data.entries();
+  }
+  indicesArray() {
+    return [...this.indices()];
+  }
+  valuesArray() {
+    return [...this.values()];
+  }
+  entriesArray() {
+    return [...this.entries()];
+  }
+  *kvKeys() {
+    for (const id of this.indices()) {
+      yield [id];
+    }
+  }
+  *kvValues() {
+    for (const value of this.values()) {
+      yield value;
+    }
+  }
+  *kvEntries() {
+    for (const [id, value] of this.entries()) {
+      yield [[id], value];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.entries();
+  }
+  clone() {
+    const ctor = this.constructor;
+    const clone = new ctor(this.length, this.defaultValue);
+    clone.data = this.data.slice();
+    return clone;
+  }
+  merge(other, conflictResolver) {
+    if (this.constructor !== other.constructor)
+      throw new Error(`Cannot merge DefaultArray: different classes (${this.constructor.name} vs ${other.constructor.name})`);
+    if (this.defaultValue !== other.defaultValue)
+      throw new Error(`Cannot merge DefaultArray: different defaultValue (${this.defaultValue} vs ${other.defaultValue})`);
+    for (const [id, value] of other.entries()) {
+      if (this.isDefault(id))
+        this.set(id, value);
+      else if (conflictResolver)
+        this.set(id, conflictResolver(this.get(id), value, id));
+      else
+        this.set(id, value);
+    }
+    return this;
+  }
+  some(fn) {
+    for (const [id, value] of this.entries()) {
+      if (fn(value, id)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const [id, value] of this.entries()) {
+      if (!fn(value, id)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = new this.constructor(this.length, this.defaultValue);
+    for (const [id, value] of this.entries()) {
+      if (predicate(value, id, this)) result.set(id, value);
+    }
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.entries();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty DefaultArray with no initial value!");
+      }
+      return init;
+    }
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value[1];
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const [id, value] = current.value;
+      acc = fn(acc, value, id);
+    }
+    return acc;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const [id, value] of this.entries()) {
+      result.push(fn(value, id));
+    }
+    return result;
+  }
+  map(fn, defaultValue) {
+    let result = new _DefaultArray(this.data.length, defaultValue);
+    for (let id = 0; id < this.data.length; id++) {
+      result.data[id] = fn(this.data[id], id);
+    }
+    return result;
+  }
+  equals(other, eq2) {
+    if (this.size !== other.size) return false;
+    eq2 ?? (eq2 = (a, b) => a === b);
+    for (let id = 0; id < this.data.length; ++id) {
+      if (!eq2(this.data[id], other.data[id])) return false;
+    }
+    return true;
+  }
+  toArray() {
+    return this.valuesArray();
+  }
+  toString() {
+    const entries = this.entriesArray().map(([id, v]) => `${formatValue(id)}: ${formatValue(v)}`).join(", ");
+    return `DefaultArray[ ${entries} ]`.replaceAll("  ", " ");
   }
 };
 
@@ -2703,8 +2973,8 @@ var Map1 = class _Map1 {
     return new Map(this.map1);
   }
   toString() {
-    const entries = [...this.map1].map(([k, v]) => `${k} => ${v}`).join(", ");
-    return entries.length === 0 ? `Map1(0){ }` : `Map1(${this.size}){ ${entries} }`;
+    const entries = [...this.map1].map(([k, v]) => `${formatValue(k)} => ${formatValue(v)}`).join(", ");
+    return `Map1(${this.size}){ ${entries} }`.replaceAll("  ", " ");
   }
 };
 
@@ -2897,10 +3167,10 @@ var Map2 = class _Map2 {
   toString() {
     const entries = [];
     for (const [key1, map2] of this.map1) {
-      const inner = [...map2].map(([key2, v]) => `${key2} => ${v}`).join(", ");
-      entries.push(`${key1} => { ${inner} }`);
+      const inner = [...map2].map(([key2, v]) => `${formatValue(key2)} => ${formatValue(v)}`).join(", ");
+      entries.push(`${formatValue(key1)} => { ${inner} }`);
     }
-    return entries.length === 0 ? `Map2(0){ }` : `Map2(${this.size}){ ${entries} }`;
+    return `Map2(${this.size}){ ${entries} }`.replaceAll("  ", " ");
   }
 };
 
@@ -3125,11 +3395,209 @@ var Map3 = class _Map3 {
     const entries = [];
     for (const [key1, map2] of this.map1) {
       for (const [key2, map3] of map2) {
-        const inner = [...map3].map(([key3, v]) => `${key3} => ${v}`).join(", ");
-        entries.push(`${key1} => ${key2} => { ${inner} }`);
+        const inner = [...map3].map(([key3, v]) => `${formatValue(key3)} => ${formatValue(v)}`).join(", ");
+        entries.push(`${formatValue(key1)} => ${formatValue(key2)} => { ${inner} }`);
+      }
+    }
+    return `Map3(${this.size}){ ${entries.join(", ")} }`.replaceAll("  ", " ");
+  }
+};
+
+// src/core/set.ts
+var SetBase = class {
+  constructor(entries) {
+    __publicField(this, "data");
+    this.data = new Set(entries ?? []);
+  }
+  has(value) {
+    return this.some((v) => this.valueEquals(v, value));
+  }
+  add(value) {
+    if (!this.has(value))
+      this.data.add(value);
+    return value;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  set(key, value) {
+    if (!this.valueEquals(key, value))
+      throw new TypeError("SetBase.set() requires key === value.");
+    this.add(value);
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  get(key) {
+    return this.has(key) ? key : void 0;
+  }
+  /** @internal - This method exists only for interface `KVComponent` compatibility.*/
+  getOrDefault(key, defaultValue) {
+    return this.get(key) ?? defaultValue;
+  }
+  getOrCreate(key, creatorOrValue) {
+    if (!this.has(key)) {
+      const value = isFunction2(creatorOrValue) ? creatorOrValue() : creatorOrValue;
+      this.set(key, value);
+      return value;
+    }
+    return this.get(key);
+  }
+  delete(value) {
+    if (!this.has(value)) return false;
+    for (const v of this.values()) {
+      if (this.valueEquals(v, value)) {
+        this.data.delete(v);
+        return true;
+      }
+    }
+    return false;
+  }
+  clear() {
+    this.data.clear();
+  }
+  get size() {
+    return this.data.size;
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  forEach(callbackfn, thisArg) {
+    this.data.forEach((value) => callbackfn.call(thisArg, value, this));
+  }
+  *keys() {
+    yield* this.data.keys();
+  }
+  *values() {
+    yield* this.data.values();
+  }
+  *entries() {
+    yield* this.data.entries();
+  }
+  *kvKeys() {
+    for (const key of this.keys()) {
+      yield [key];
+    }
+  }
+  *kvValues() {
+    for (const el of this.values()) {
+      yield el;
+    }
+  }
+  *kvEntries() {
+    for (const [key, el] of this.entries()) {
+      yield [[key], el];
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.values();
+  }
+  clone() {
+    const result = this.createEmpty();
+    for (const v of this.values()) result.add(v);
+    return result;
+  }
+  merge(other) {
+    for (const value of other.values()) {
+      this.add(value);
+    }
+    return this;
+  }
+  some(fn) {
+    for (const value of this.data) {
+      if (fn(value)) return true;
+    }
+    return false;
+  }
+  every(fn) {
+    for (const value of this.data) {
+      if (!fn(value)) return false;
+    }
+    return true;
+  }
+  filter(predicate) {
+    const result = this.createEmpty();
+    for (const value of this.data)
+      if (predicate(value, this)) result.add(value);
+    return result;
+  }
+  reduce(fn, init) {
+    let iterator = this.values();
+    let first = iterator.next();
+    if (first.done) {
+      if (arguments.length < 2) {
+        throw new TypeError("Reduce of empty SetBase with no initial value!");
       }
+      return init;
     }
-    return entries.length === 0 ? `Map3(0){ }` : `Map3(${this.size}){ ${entries.join(", ")} }`;
+    let acc;
+    let start;
+    if (arguments.length < 2) {
+      acc = first.value;
+      start = iterator.next();
+    } else {
+      acc = init;
+      start = first;
+    }
+    for (let current = start; !current.done; current = iterator.next()) {
+      const value = current.value;
+      acc = fn(acc, value);
+    }
+    return acc;
+  }
+  mapValues(fn) {
+    let result = this.createEmpty();
+    for (const value of this.data) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  mapToArray(fn) {
+    let result = [];
+    for (const value of this.values()) {
+      result.push(fn(value));
+    }
+    return result;
+  }
+  map(fn) {
+    let result = this.createEmpty();
+    for (const value of this.values()) {
+      result.add(fn(value));
+    }
+    return result;
+  }
+  toSet() {
+    return new Set(this.data);
+  }
+  toArray() {
+    return [...this.values()];
+  }
+  toString() {
+    return `${this.getName()}(${this.size})${formatValue([...this.data])}`.replaceAll("  ", " ");
+  }
+};
+var Set1 = class _Set1 extends SetBase {
+  constructor(entries) {
+    super(entries);
+  }
+  createEmpty() {
+    return new _Set1();
+  }
+  valueEquals(a, b) {
+    return a === b;
+  }
+  getName() {
+    return "Set1";
+  }
+};
+var DeepSet = class _DeepSet extends SetBase {
+  constructor(entries) {
+    super(entries);
+  }
+  createEmpty() {
+    return new _DeepSet();
+  }
+  valueEquals(a, b) {
+    return isDeepEqual2(a, b);
+  }
+  getName() {
+    return "DeepSet";
   }
 };
 
@@ -3191,11 +3659,11 @@ var MultiContainer = class {
     const entries = [];
     for (const keys of this.keys()) {
       const arr = this.getAll(...keys);
-      const keyStr = Array.isArray(keys) ? `[${keys.map((k) => JSON.stringify(k)).join(", ")}]` : `[${JSON.stringify(keys)}]`;
-      const valuesStr = Array.isArray(arr) ? `[${arr.map((v) => JSON.stringify(v)).join(", ")}]` : "[]";
+      const keyStr = Array.isArray(keys) ? formatValue(keys) : "[ ]";
+      const valuesStr = Array.isArray(arr) ? formatValue(arr) : "[ ]";
       entries.push(`${keyStr} => ${valuesStr}`);
     }
-    return `MultiContainer{ ${entries.join(", ")} }`;
+    return `MultiContainer{ ${entries.join(", ")} }`.replaceAll("  ", " ");
   }
 };
 function asMulti(base) {
@@ -3282,6 +3750,8 @@ var SmallIntCache = class {
 0 && (module.exports = {
   Assert,
   Cookies,
+  DeepSet,
+  DefaultArray,
   Device,
   DivRect,
   Guard,
@@ -3291,6 +3761,8 @@ var SmallIntCache = class {
   Map2,
   Map3,
   MultiContainer,
+  Set1,
+  SetBase,
   SignedIndexArray,
   SmallIntCache,
   Stack,