@tstdl/base 0.83.6 → 0.83.8

package/.eslintrc.cjs

@@ -66,7 +66,7 @@ module.exports = {
 
     /** import */
     'import/no-duplicates': ['warn', { 'prefer-inline': true }],
-    'import/no-cycle': ['error', { ignoreExternal: true }],
+    'import/no-cycle': ['off', { ignoreExternal: true }],
     'import/no-self-import': ['error'],
     'import/no-extraneous-dependencies': ['error', { devDependencies: false, includeTypes: true }],
     'import/no-empty-named-blocks': ['error'],
@@ -102,7 +102,7 @@ module.exports = {
     'lines-between-class-members': 'off',
     'max-classes-per-file': 'off',
     'max-len': ['off', { code: 150 }],
-    'max-lines-per-function': ['warn', { 'max': 100, 'skipBlankLines': true, 'skipComments': true }],
+    'max-lines-per-function': ['off', { 'max': 100, 'skipBlankLines': true, 'skipComments': true }],
     'max-lines': 'off',
     'max-params': 'off',
     'max-statements': 'off',

package/data-structures/array-dictionary.d.ts

@@ -0,0 +1,20 @@
+import { Dictionary } from './dictionary.js';
+export declare class ArrayDictionary<K, V> extends Dictionary<K, V, ArrayDictionary<K, V>> {
+    private keyArray;
+    private valueArray;
+    readonly [Symbol.toStringTag]: string;
+    constructor(items?: Iterable<readonly [K, V]>);
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): boolean;
+    includes([key, value]: [K, V]): boolean;
+    add(item: [K, V]): void;
+    addMany(items: Iterable<readonly [K, V]>): void;
+    clone(): ArrayDictionary<K, V>;
+    items(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    protected _clear(): void;
+    private updateSize;
+}

package/data-structures/array-dictionary.js

@@ -0,0 +1,118 @@
+"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);
+var array_dictionary_exports = {};
+__export(array_dictionary_exports, {
+  ArrayDictionary: () => ArrayDictionary
+});
+module.exports = __toCommonJS(array_dictionary_exports);
+var import_type_guards = require("../utils/type-guards.js");
+var import_dictionary = require("./dictionary.js");
+class ArrayDictionary extends import_dictionary.Dictionary {
+  keyArray;
+  valueArray;
+  [Symbol.toStringTag] = "ArrayDictionary";
+  constructor(items) {
+    super();
+    this.keyArray = [];
+    this.valueArray = [];
+    if ((0, import_type_guards.isDefined)(items)) {
+      this.addMany(items);
+      this.updateSize();
+    }
+  }
+  has(key) {
+    return this.keyArray.includes(key);
+  }
+  get(key) {
+    const index = this.keyArray.indexOf(key);
+    if (index == -1) {
+      return void 0;
+    }
+    return this.valueArray[index];
+  }
+  set(key, value) {
+    const index = this.keyArray.indexOf(key);
+    if (index == -1) {
+      this.keyArray.push(key);
+      this.valueArray.push(value);
+    } else {
+      this.valueArray[index] = value;
+    }
+    this.updateSize();
+  }
+  delete(key) {
+    const index = this.keyArray.indexOf(key);
+    if (index == -1) {
+      return false;
+    }
+    this.keyArray[index] = this.keyArray[this.keyArray.length - 1];
+    this.valueArray[index] = this.valueArray[this.valueArray.length - 1];
+    this.keyArray.length -= 1;
+    this.valueArray.length -= 1;
+    this.updateSize();
+    return true;
+  }
+  includes([key, value]) {
+    const index = this.keyArray.indexOf(key);
+    if (index == -1) {
+      return false;
+    }
+    return this.valueArray[index] == value;
+  }
+  add(item) {
+    this.set(item[0], item[1]);
+  }
+  addMany(items) {
+    for (const [key, value] of items) {
+      const index = this.keyArray.indexOf(key);
+      if (index == -1) {
+        this.keyArray.push(key);
+        this.valueArray.push(value);
+      } else {
+        this.valueArray[index] = value;
+      }
+    }
+    this.updateSize();
+  }
+  clone() {
+    const arrayDictionary = new ArrayDictionary();
+    arrayDictionary.keyArray = [...this.keyArray];
+    arrayDictionary.valueArray = [...this.valueArray];
+    arrayDictionary.updateSize();
+    return arrayDictionary;
+  }
+  *items() {
+    for (let i = 0; i < this.keyArray.length; i++) {
+      yield [this.keyArray[i], this.valueArray[i]];
+    }
+  }
+  keys() {
+    return this.keyArray[Symbol.iterator]();
+  }
+  values() {
+    return this.valueArray[Symbol.iterator]();
+  }
+  _clear() {
+    this.keyArray = [];
+    this.valueArray = [];
+  }
+  updateSize() {
+    this.setSize(this.keyArray.length / 2);
+  }
+}

package/data-structures/collection.d.ts

@@ -6,28 +6,28 @@ export declare abstract class Collection<T, TThis extends Collection<T, TThis> =
     private readonly clearSubject;
     /** emits collection on subscribe and change */
     readonly observe$: Observable<TThis>;
-    /** emits size of list */
+    /** emits size of collection */
     readonly size$: Observable<number>;
     /** emits collection on change */
     readonly change$: Observable<TThis>;
     readonly clear$: Observable<TThis>;
-    /** emits when the list is empty */
+    /** emits when the collection is empty */
     readonly onEmpty$: Observable<void>;
-    /** emits when the list has items */
+    /** emits when the collection has items */
     readonly onItems$: Observable<void>;
-    /** emits whether the list is empty */
+    /** emits whether the collection is empty */
     readonly isEmpty$: Observable<boolean>;
-    /** emits whether the list has items */
+    /** emits whether the collection has items */
     readonly hasItems$: Observable<boolean>;
-    /** resolves when the list is empty */
+    /** resolves when the collection is empty */
     get $onEmpty(): Promise<void>;
-    /** resolves when the list has items */
+    /** resolves when the collection has items */
     get $onItems(): Promise<void>;
-    /** size of list */
+    /** size of collection */
     get size(): number;
-    /** whether the list is empty */
+    /** whether the collection is empty */
     get isEmpty(): boolean;
-    /** whether the list has items */
+    /** whether the collection has items */
     get hasItems(): boolean;
     constructor();
     [Symbol.iterator](): IterableIterator<T>;

package/data-structures/collection.js

@@ -28,37 +28,37 @@ class Collection {
   clearSubject;
   /** emits collection on subscribe and change */
   observe$;
-  /** emits size of list */
+  /** emits size of collection */
   size$;
   /** emits collection on change */
   change$;
   /* emits collection on clear */
   clear$;
-  /** emits when the list is empty */
+  /** emits when the collection is empty */
   onEmpty$;
-  /** emits when the list has items */
+  /** emits when the collection has items */
   onItems$;
-  /** emits whether the list is empty */
+  /** emits whether the collection is empty */
   isEmpty$;
-  /** emits whether the list has items */
+  /** emits whether the collection has items */
   hasItems$;
-  /** resolves when the list is empty */
+  /** resolves when the collection is empty */
   get $onEmpty() {
     return (0, import_rxjs.firstValueFrom)(this.onEmpty$);
   }
-  /** resolves when the list has items */
+  /** resolves when the collection has items */
   get $onItems() {
     return (0, import_rxjs.firstValueFrom)(this.onItems$);
   }
-  /** size of list */
+  /** size of collection */
   get size() {
     return this.sizeSubject.value;
   }
-  /** whether the list is empty */
+  /** whether the collection is empty */
   get isEmpty() {
     return this.size == 0;
   }
-  /** whether the list has items */
+  /** whether the collection has items */
   get hasItems() {
     return this.size > 0;
   }

package/data-structures/dictionary.d.ts

@@ -0,0 +1,29 @@
+import { Collection } from './collection.js';
+export declare abstract class Dictionary<K, V, TThis extends Dictionary<K, V, TThis> = Dictionary<K, V, any>> extends Collection<[K, V], TThis> {
+    /** Creates a new map and copies the items */
+    toMap(): Map<K, V>;
+    /** Returns an adapter that has the same interface as {@link Map}. No copying of data involved. */
+    asMap(): Map<K, V>;
+    abstract has(key: K): boolean;
+    abstract get(key: K): V | undefined;
+    abstract set(key: K, value: V): void;
+    abstract delete(key: K): boolean;
+    abstract keys(): IterableIterator<K>;
+    abstract values(): IterableIterator<V>;
+}
+export declare class DictionaryAdapter<K, V> implements Map<K, V> {
+    private readonly dictionary;
+    readonly [Symbol.toStringTag] = "DictionaryAdapter";
+    get size(): number;
+    constructor(dictionary: Dictionary<K, V, any>);
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}

package/data-structures/dictionary.js

@@ -0,0 +1,78 @@
+"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);
+var dictionary_exports = {};
+__export(dictionary_exports, {
+  Dictionary: () => Dictionary,
+  DictionaryAdapter: () => DictionaryAdapter
+});
+module.exports = __toCommonJS(dictionary_exports);
+var import_collection = require("./collection.js");
+class Dictionary extends import_collection.Collection {
+  /** Creates a new map and copies the items */
+  toMap() {
+    return new Map(this);
+  }
+  /** Returns an adapter that has the same interface as {@link Map}. No copying of data involved. */
+  asMap() {
+    return new DictionaryAdapter(this);
+  }
+}
+class DictionaryAdapter {
+  dictionary;
+  [Symbol.toStringTag] = "DictionaryAdapter";
+  get size() {
+    return this.dictionary.size;
+  }
+  constructor(dictionary) {
+    this.dictionary = dictionary;
+  }
+  clear() {
+    this.dictionary.clear();
+  }
+  delete(key) {
+    return this.dictionary.delete(key);
+  }
+  forEach(callbackfn, thisArg) {
+    for (const [key, value] of this.dictionary) {
+      callbackfn.call(thisArg, value, key, this);
+    }
+  }
+  get(key) {
+    return this.dictionary.get(key);
+  }
+  has(key) {
+    return this.dictionary.has(key);
+  }
+  set(key, value) {
+    this.dictionary.set(key, value);
+    return this;
+  }
+  entries() {
+    return this.dictionary.items();
+  }
+  keys() {
+    return this.dictionary.keys();
+  }
+  values() {
+    return this.dictionary.values();
+  }
+  [Symbol.iterator]() {
+    return this.dictionary[Symbol.iterator]();
+  }
+}

package/data-structures/index.d.ts

@@ -1,11 +1,13 @@
+export * from './array-dictionary.js';
 export * from './array-list.js';
 export * from './circular-buffer.js';
 export * from './collection.js';
+export * from './dictionary.js';
 export * from './index-out-of-bounds.error.js';
 export * from './iterable-weak-map.js';
 export * from './linked-list.js';
 export * from './list.js';
-export * from './map.js';
+export * from './map-dictionary.js';
 export * from './multi-key-map.js';
 export * from './set.js';
 export * from './sorted-array-list.js';

package/data-structures/index.js

@@ -15,14 +15,16 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var data_structures_exports = {};
 module.exports = __toCommonJS(data_structures_exports);
+__reExport(data_structures_exports, require("./array-dictionary.js"), module.exports);
 __reExport(data_structures_exports, require("./array-list.js"), module.exports);
 __reExport(data_structures_exports, require("./circular-buffer.js"), module.exports);
 __reExport(data_structures_exports, require("./collection.js"), module.exports);
+__reExport(data_structures_exports, require("./dictionary.js"), module.exports);
 __reExport(data_structures_exports, require("./index-out-of-bounds.error.js"), module.exports);
 __reExport(data_structures_exports, require("./iterable-weak-map.js"), module.exports);
 __reExport(data_structures_exports, require("./linked-list.js"), module.exports);
 __reExport(data_structures_exports, require("./list.js"), module.exports);
-__reExport(data_structures_exports, require("./map.js"), module.exports);
+__reExport(data_structures_exports, require("./map-dictionary.js"), module.exports);
 __reExport(data_structures_exports, require("./multi-key-map.js"), module.exports);
 __reExport(data_structures_exports, require("./set.js"), module.exports);
 __reExport(data_structures_exports, require("./sorted-array-list.js"), module.exports);

package/data-structures/map-dictionary.d.ts

@@ -0,0 +1,19 @@
+import { Dictionary } from './dictionary.js';
+export declare class MapDictionary<K, V> extends Dictionary<K, V, MapDictionary<K, V>> {
+    private readonly backingMap;
+    readonly [Symbol.toStringTag]: string;
+    constructor(items?: Iterable<readonly [K, V]>);
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): boolean;
+    includes([key, value]: [K, V]): boolean;
+    add(item: [K, V]): void;
+    addMany(items: Iterable<readonly [K, V]>): void;
+    clone(): MapDictionary<K, V>;
+    items(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    protected _clear(): void;
+    private updateSize;
+}

package/data-structures/{map.js → map-dictionary.js}

@@ -16,33 +16,43 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var map_exports = {};
-__export(map_exports, {
-  Map: () => Map
+var map_dictionary_exports = {};
+__export(map_dictionary_exports, {
+  MapDictionary: () => MapDictionary
 });
-module.exports = __toCommonJS(map_exports);
-var import_collection = require("./collection.js");
-class Map extends import_collection.Collection {
+module.exports = __toCommonJS(map_dictionary_exports);
+var import_dictionary = require("./dictionary.js");
+class MapDictionary extends import_dictionary.Dictionary {
   backingMap;
-  [Symbol.toStringTag] = "Map";
+  [Symbol.toStringTag] = "MapDictionary";
   constructor(items) {
     super();
-    this.backingMap = new globalThis.Map(items);
+    this.backingMap = new Map(items);
     this.updateSize();
   }
+  has(key) {
+    return this.backingMap.has(key);
+  }
+  get(key) {
+    return this.backingMap.get(key);
+  }
+  set(key, value) {
+    this.backingMap.set(key, value);
+    this.updateSize();
+  }
+  delete(key) {
+    const result = this.backingMap.delete(key);
+    this.updateSize();
+    return result;
+  }
   includes([key, value]) {
     if (!this.has(key)) {
       return false;
     }
     return this.get(key) == value;
   }
-  set(key, value) {
-    this.backingMap.set(key, value);
-    this.updateSize();
-    return this;
-  }
   add(item) {
-    return this.set(item[0], item[1]);
+    this.set(item[0], item[1]);
   }
   addMany(items) {
     for (const item of items) {
@@ -50,29 +60,12 @@ class Map extends import_collection.Collection {
     }
     this.updateSize();
   }
-  get(key) {
-    return this.backingMap.get(key);
-  }
   clone() {
-    return new Map(this);
+    return new MapDictionary(this);
   }
   items() {
     return this.backingMap.entries();
   }
-  delete(key) {
-    const result = this.backingMap.delete(key);
-    this.updateSize();
-    return result;
-  }
-  forEach(callbackfn, thisArg) {
-    this.backingMap.forEach(callbackfn, thisArg);
-  }
-  has(key) {
-    return this.backingMap.has(key);
-  }
-  entries() {
-    return this.backingMap.entries();
-  }
   keys() {
     return this.backingMap.keys();
   }

package/data-structures/multi-key-map.d.ts

@@ -1,4 +1,4 @@
-import { Collection } from './collection.js';
+import { Dictionary } from './dictionary.js';
 type Node = {
     nodeKey: any;
     parentNode: Node | undefined;
@@ -8,24 +8,26 @@ type Node = {
     value: any;
 };
 type NewMapProvider = () => Map<any, Node>;
-export declare class MultiKeyMap<K extends any[], T> extends Collection<[K, T], MultiKeyMap<K, T>> implements Map<K, T> {
+export declare class MultiKeyMap<K extends any[], V> extends Dictionary<K, V, MultiKeyMap<K, V>> {
     private readonly newMapProvider;
     private rootNode;
     readonly [Symbol.toStringTag]: string;
     constructor(newMapProvider?: NewMapProvider);
-    includes([key, value]: [K, T]): boolean;
-    add(value: [K, T]): void;
-    addMany(values: Iterable<[K, T]>): void;
-    set(key: K, value: T): this;
+    includes([key, value]: [K, V]): boolean;
+    add(value: [K, V]): void;
+    addMany(values: Iterable<[K, V]>): void;
+    setFlat(...keyAndValue: [...key: K, value: V]): void;
+    set(key: K, value: V): void;
+    hasFlat(...key: K): boolean;
     has(key: K): boolean;
-    get(key: K): T | undefined;
+    getFlat(...key: K): V | undefined;
+    get(key: K): V | undefined;
+    deleteFlat(...key: K): boolean;
     delete(key: K): boolean;
-    clone(): MultiKeyMap<K, T>;
-    forEach(callback: (value: T, key: K, map: MultiKeyMap<K, T>) => void, thisArg?: any): void;
-    entries(): IterableIterator<[K, T]>;
+    clone(): MultiKeyMap<K, V>;
     keys(): IterableIterator<K>;
-    values(): IterableIterator<T>;
-    items(): IterableIterator<[K, T]>;
+    values(): IterableIterator<V>;
+    items(): IterableIterator<[K, V]>;
     protected _clear(): void;
     private getNode;
     private deleteNodeIfEmpty;

package/data-structures/multi-key-map.js

@@ -24,8 +24,8 @@ module.exports = __toCommonJS(multi_key_map_exports);
 var import_lazy_property = require("../utils/object/lazy-property.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_circular_buffer = require("./circular-buffer.js");
-var import_collection = require("./collection.js");
-class MultiKeyMap extends import_collection.Collection {
+var import_dictionary = require("./dictionary.js");
+class MultiKeyMap extends import_dictionary.Dictionary {
   newMapProvider;
   rootNode;
   [Symbol.toStringTag] = "MultiKeyMap";
@@ -48,6 +48,10 @@ class MultiKeyMap extends import_collection.Collection {
       this.set(value[0], value[1]);
     }
   }
+  setFlat(...keyAndValue) {
+    const key = keyAndValue.slice(0, -1);
+    this.set(key, keyAndValue[keyAndValue.length - 1]);
+  }
   set(key, value) {
     const node = this.getNode(key, true);
     const hasValue = node.hasValue;
@@ -56,12 +60,17 @@ class MultiKeyMap extends import_collection.Collection {
     if (!hasValue) {
       this.incrementSize();
     }
-    return this;
+  }
+  hasFlat(...key) {
+    return this.has(key);
   }
   has(key) {
     const node = this.getNode(key, false);
     return (0, import_type_guards.isDefined)(node) && node.hasValue;
   }
+  getFlat(...key) {
+    return this.get(key);
+  }
   get(key) {
     const node = this.getNode(key, false);
     if ((0, import_type_guards.isUndefined)(node)) {
@@ -69,6 +78,9 @@ class MultiKeyMap extends import_collection.Collection {
     }
     return node.value;
   }
+  deleteFlat(...key) {
+    return this.delete(key);
+  }
   delete(key) {
     const node = this.getNode(key, false);
     if ((0, import_type_guards.isUndefined)(node)) {
@@ -88,15 +100,6 @@ class MultiKeyMap extends import_collection.Collection {
     clone.addMany(this);
     return clone;
   }
-  forEach(callback, thisArg) {
-    const boundCallback = callback.bind(thisArg);
-    for (const item of this) {
-      boundCallback(item[1], item[0], this);
-    }
-  }
-  entries() {
-    return this.items();
-  }
   *keys() {
     for (const item of this) {
       yield item[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.83.6",
+  "version": "0.83.8",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -31,8 +31,8 @@
     "@types/mjml": "4.7",
     "@types/node": "18",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "5.55",
-    "@typescript-eslint/parser": "5.55",
+    "@typescript-eslint/eslint-plugin": "5.56",
+    "@typescript-eslint/parser": "5.56",
     "concurrently": "7.6",
     "eslint": "8.36",
     "eslint-import-resolver-typescript": "3.5",

package/utils/array/array.js

@@ -42,11 +42,9 @@ function extractValueOfArrayIfSingleElement(value) {
   return value;
 }
 function createArray(length, valueProvider) {
-  const array = [];
-  for (let i = 0; i < length; i++) {
-    array.push(valueProvider(i));
-  }
-  return array;
+  const arr = [];
+  arr.length = length;
+  return arr.fill(void 0).map((_, index) => valueProvider(index));
 }
 function shuffle(items) {
   const cloned = [...items];

package/data-structures/map.d.ts

@@ -1,21 +0,0 @@
-import { Collection } from './collection.js';
-export declare class Map<K, V> extends Collection<[K, V], Map<K, V>> implements globalThis.Map<K, V> {
-    private readonly backingMap;
-    readonly [Symbol.toStringTag]: string;
-    constructor(items?: Iterable<[K, V]>);
-    includes([key, value]: [K, V]): boolean;
-    set(key: K, value: V): this;
-    add(item: [K, V]): this;
-    addMany(items: Iterable<[K, V]>): void;
-    get(key: K): V | undefined;
-    clone(): Map<K, V>;
-    items(): IterableIterator<[K, V]>;
-    delete(key: K): boolean;
-    forEach(callbackfn: (value: V, key: K, set: globalThis.Map<K, V>) => void, thisArg?: any): void;
-    has(key: K): boolean;
-    entries(): IterableIterator<[K, V]>;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    protected _clear(): void;
-    private updateSize;
-}