@tstdl/base 0.83.7 → 0.83.9

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'],

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

@@ -1,31 +1,32 @@
-import { Collection } from './collection.js';
+import { Dictionary } from './dictionary.js';
 type Node = {
     nodeKey: any;
     parentNode: Node | undefined;
-    hasInnerMap: boolean;
-    children: Map<any, Node>;
+    children: Map<any, Node> | undefined;
     hasValue: boolean;
     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

@@ -21,18 +21,17 @@ __export(multi_key_map_exports, {
   MultiKeyMap: () => MultiKeyMap
 });
 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";
   constructor(newMapProvider = () => /* @__PURE__ */ new Map()) {
     super();
     this.newMapProvider = newMapProvider;
-    this.rootNode = createNode(void 0, void 0, this.newMapProvider);
+    this.rootNode = createNode(void 0, void 0);
   }
   includes([key, value]) {
     if (!this.has(key)) {
@@ -48,29 +47,40 @@ 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;
-    node.hasValue = true;
     node.value = value;
-    if (!hasValue) {
+    if (!node.hasValue) {
+      node.hasValue = true;
       this.incrementSize();
     }
-    return this;
+  }
+  hasFlat(...key) {
+    return this.has(key);
   }
   has(key) {
-    const node = this.getNode(key, false);
+    const node = this.getNode(key);
     return (0, import_type_guards.isDefined)(node) && node.hasValue;
   }
+  getFlat(...key) {
+    return this.get(key);
+  }
   get(key) {
-    const node = this.getNode(key, false);
+    const node = this.getNode(key);
     if ((0, import_type_guards.isUndefined)(node)) {
       return void 0;
     }
     return node.value;
   }
+  deleteFlat(...key) {
+    return this.delete(key);
+  }
   delete(key) {
-    const node = this.getNode(key, false);
+    const node = this.getNode(key);
     if ((0, import_type_guards.isUndefined)(node)) {
       return false;
     }
@@ -88,15 +98,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];
@@ -115,7 +116,7 @@ class MultiKeyMap extends import_collection.Collection {
       if (node.hasValue) {
         yield [key, node.value];
       }
-      if (node.hasInnerMap) {
+      if ((0, import_type_guards.isDefined)(node.children)) {
         for (const innerNode of node.children.values()) {
           queue.add([[...key, innerNode.nodeKey], innerNode]);
         }
@@ -123,48 +124,44 @@ class MultiKeyMap extends import_collection.Collection {
     }
   }
   _clear() {
-    this.rootNode = createNode(void 0, void 0, this.newMapProvider);
-  }
-  getNode(key, create) {
-    let node = getOrCreateChildNode(this.rootNode, key[0], this.newMapProvider);
-    for (let i = 1; i < key.length; i++) {
-      if (!node.hasInnerMap && !create) {
-        return void 0;
+    this.rootNode = createNode(void 0, void 0);
+    this.setSize(0);
+  }
+  getNode(key, create = false) {
+    let node = this.rootNode;
+    for (const nodeKey of key) {
+      if ((0, import_type_guards.isUndefined)(node.children)) {
+        if (!create) {
+          return void 0;
+        }
+        node.children = this.newMapProvider();
       }
-      node = getOrCreateChildNode(this.rootNode, key[i], this.newMapProvider);
+      let childNode = node.children.get(nodeKey);
+      if ((0, import_type_guards.isUndefined)(childNode)) {
+        if (!create) {
+          return void 0;
+        }
+        childNode = createNode(nodeKey, node);
+        node.children.set(nodeKey, childNode);
+      }
+      node = childNode;
     }
     return node;
   }
   deleteNodeIfEmpty(node) {
-    if (node.hasValue || node.hasInnerMap && node.children.size > 0 || (0, import_type_guards.isUndefined)(node.parentNode)) {
+    if (node.hasValue || (0, import_type_guards.isDefined)(node.children) && node.children.size > 0 || (0, import_type_guards.isUndefined)(node.parentNode)) {
       return;
     }
     node.parentNode.children.delete(node.nodeKey);
     this.deleteNodeIfEmpty(node.parentNode);
   }
 }
-function getOrCreateChildNode(node, key, newMapProvider) {
-  const childNode = node.children.get(key);
-  if ((0, import_type_guards.isDefined)(childNode)) {
-    return childNode;
-  }
-  const newNode = createNode(key, node, newMapProvider);
-  node.children.set(key, newNode);
-  return newNode;
-}
-function createNode(nodeKey, parentNode, newMapProvider) {
-  return (0, import_lazy_property.lazyObject)({
-    nodeKey: { value: nodeKey },
-    parentNode: { value: parentNode },
-    hasInnerMap: false,
-    children() {
-      return getChildren(this, newMapProvider);
-    },
+function createNode(nodeKey, parentNode) {
+  return {
+    nodeKey,
+    parentNode,
+    children: void 0,
     hasValue: false,
-    value: { value: void 0 }
-  });
-}
-function getChildren(node, newMapProvider) {
-  node.hasInnerMap = true;
-  return newMapProvider();
+    value: void 0
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.83.7",
+  "version": "0.83.9",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"