dynamic-multikey-map 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Liam Martens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# dynamic-multikey-map
+
+[![badge](https://img.shields.io/npm/v/dynamic-multikey-map)](https://www.npmjs.com/package/dynamic-multikey-map) [![badge](https://img.shields.io/bundlephobia/min/dynamic-multikey-map)](https://bundlephobia.com/package/dynamic-multikey-map) ![badge](https://img.shields.io/github/license/LiamMartens/dynamic-multikey-map)
+
+This is a dynamic multiple key map to map a single object to multiple dynamic values.
+
+## Usage
+
+```js
+import { MultiKeyMap } from "dynamic-multikey-map";
+
+type ValueType = {
+  username: string;
+  ssn: string;
+};
+
+const map = new MultiKeyMap<ValueType, string>([
+  (value: ValueType) => value.ssn,
+  (value: ValueType) => value.username,
+]);
+
+map.add({
+  username: "john.doe",
+  ssn: "123-45-6789",
+});
+
+expect(map.get("john.doe")).toEqual(map.get("123-45-6789"));
+```

package/lib/MultiKeyMap.d.ts

@@ -0,0 +1,66 @@
+type ExtractorFunction<T, K> = (value: T) => K;
+export declare class MultiKeyMap<ObjectType, KeyValueTypes extends unknown> {
+    extractors: ExtractorFunction<ObjectType, KeyValueTypes>[];
+    protected valueKeys: Map<ObjectType, KeyValueTypes[]>;
+    protected map: Map<KeyValueTypes, ObjectType>;
+    constructor(extractors: ExtractorFunction<ObjectType, KeyValueTypes>[]);
+    get size(): number;
+    /**
+     * Clears the map keys and values
+     */
+    clear: () => void;
+    /**
+     * Adds a value to the map
+     * @param value
+     */
+    add: (value: ObjectType) => void;
+    /**
+     * Removes a value from the map by value
+     * @param value
+     * @returns false if the value was not found in the map, true if successfull
+     */
+    deleteByValue: (value: ObjectType) => boolean;
+    /**
+     * Removes a value from the map by key
+     * @param key
+     * @returns false if the key was not found in the map, true if successfull
+     */
+    deleteByKey: (key: KeyValueTypes) => boolean;
+    /**
+     * @param key
+     * @returns if a key exists in the map
+     */
+    has: (key: KeyValueTypes) => boolean;
+    /**
+     * Finds he value for a specified key
+     * @param key
+     * @returns associated value
+     */
+    get: (key: KeyValueTypes) => ObjectType | undefined;
+    /**
+     * Replaces the value of a specific key. It will update all previously associated keys to match
+     * @param key
+     * @param value
+     * @returns true if successfull, false if not found
+     */
+    replace: (key: KeyValueTypes, value: ObjectType) => boolean;
+    /**
+     * @returns an iterator for the map keys
+     */
+    keys: () => IterableIterator<KeyValueTypes[]>;
+    /**
+     * @returns an iterator for the map entries
+     */
+    entries: () => IterableIterator<[KeyValueTypes[], ObjectType]>;
+    /**
+     * @returns an iterator for the map values
+     */
+    values: () => IterableIterator<ObjectType>;
+    /**
+     * Loops over the map with a callback
+     * @param callbackfn
+     * @param thisArg
+     */
+    forEach: (callbackfn: (value: ObjectType, key: KeyValueTypes[], map: this) => void, thisArg?: any) => void;
+}
+export {};

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { MultiKeyMap } from "./MultiKeyMap.js";

package/lib/index.js

@@ -0,0 +1,182 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/MultiKeyMap.ts
+var MultiKeyMap = class {
+  constructor(extractors) {
+    this.extractors = extractors;
+    __publicField(this, "valueKeys", /* @__PURE__ */ new Map());
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+    /**
+     * Clears the map keys and values
+     */
+    __publicField(this, "clear", () => {
+      this.valueKeys.clear();
+      this.map.clear();
+    });
+    /**
+     * Adds a value to the map
+     * @param value
+     */
+    __publicField(this, "add", (value) => {
+      const valueKeys = [];
+      for (const fn of this.extractors) {
+        const key = fn(value);
+        valueKeys.push(key);
+        if (this.map.has(key)) {
+          console.warn("[duplicate_key] ".concat(key), value);
+        }
+        this.map.set(key, value);
+      }
+      this.valueKeys.set(value, valueKeys);
+    });
+    /**
+     * Removes a value from the map by value
+     * @param value
+     * @returns false if the value was not found in the map, true if successfull
+     */
+    __publicField(this, "deleteByValue", (value) => {
+      if (this.valueKeys.has(value)) {
+        const keys = this.valueKeys.get(value);
+        this.valueKeys.delete(value);
+        for (const key of keys) {
+          this.map.delete(key);
+        }
+        return true;
+      }
+      return false;
+    });
+    /**
+     * Removes a value from the map by key
+     * @param key
+     * @returns false if the key was not found in the map, true if successfull
+     */
+    __publicField(this, "deleteByKey", (key) => {
+      if (this.map.has(key)) {
+        const value = this.map.get(key);
+        const keys = this.valueKeys.get(value);
+        if (keys) {
+          this.valueKeys.delete(value);
+          for (const key2 of keys) {
+            this.map.delete(key2);
+          }
+        }
+        return true;
+      }
+      return false;
+    });
+    /**
+     * @param key
+     * @returns if a key exists in the map
+     */
+    __publicField(this, "has", (key) => {
+      return this.map.has(key);
+    });
+    /**
+     * Finds he value for a specified key
+     * @param key
+     * @returns associated value
+     */
+    __publicField(this, "get", (key) => {
+      return this.map.get(key);
+    });
+    /**
+     * Replaces the value of a specific key. It will update all previously associated keys to match
+     * @param key
+     * @param value
+     * @returns true if successfull, false if not found
+     */
+    __publicField(this, "replace", (key, value) => {
+      if (this.has(key)) {
+        this.deleteByValue(value);
+        this.add(value);
+        return true;
+      }
+      return false;
+    });
+    /**
+     * @returns an iterator for the map keys
+     */
+    __publicField(this, "keys", () => {
+      const valueKeys = this.valueKeys.values();
+      const iterator = {
+        [Symbol.iterator]: () => iterator,
+        next: () => {
+          const entry = valueKeys.next();
+          if (entry.done) {
+            return { done: true, value: void 0 };
+          }
+          return {
+            done: entry.done,
+            value: entry.value
+          };
+        }
+      };
+      return iterator;
+    });
+    /**
+     * @returns an iterator for the map entries
+     */
+    __publicField(this, "entries", () => {
+      const valueKeys = this.valueKeys.entries();
+      const iterator = {
+        [Symbol.iterator]: () => iterator,
+        next: () => {
+          const entry = valueKeys.next();
+          if (entry.done) {
+            return { done: true, value: void 0 };
+          }
+          return {
+            done: entry.done,
+            value: [entry.value[1], entry.value[0]]
+          };
+        }
+      };
+      return iterator;
+    });
+    /**
+     * @returns an iterator for the map values
+     */
+    __publicField(this, "values", () => {
+      const values = this.valueKeys.keys();
+      const iterator = {
+        [Symbol.iterator]: () => iterator,
+        next: () => {
+          const entry = values.next();
+          if (entry.done) {
+            return { done: true, value: void 0 };
+          }
+          return {
+            done: entry.done,
+            value: entry.value
+          };
+        }
+      };
+      return iterator;
+    });
+    /**
+     * Loops over the map with a callback
+     * @param callbackfn
+     * @param thisArg
+     */
+    __publicField(this, "forEach", (callbackfn, thisArg) => {
+      for (const [value, keys] of this.valueKeys) {
+        if (typeof thisArg === "undefined" || thisArg === null) {
+          callbackfn(value, keys, this);
+        } else {
+          callbackfn.call(thisArg, value, keys, this);
+        }
+      }
+    });
+  }
+  get size() {
+    return this.valueKeys.size;
+  }
+};
+export {
+  MultiKeyMap
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "dynamic-multikey-map",
+  "type": "module",
+  "packageManager": "bun@1.0.23",
+  "version": "1.0.0",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    }
+  },
+  "files": ["lib", "LICENSE"],
+  "devDependencies": {
+    "esbuild": "^0.20.0",
+    "vitest": "^1.2.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "test": "vitest",
+    "compile:js": "esbuild --bundle --target=safari11 --outfile=./lib/index.js --format=esm ./src/index.ts",
+    "compile:ts": "tsc -p tsconfig.build.json",
+    "compile": "bun run compile:js && bun run compile:ts"
+  }
+}