loudo-ds-lmap 0.0.1

package/LICENSE.txt

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, p-jack
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1 @@
+# loudo-ds-lmap

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+import { Entry, MapChange, MapRemove } from "loudo-ds-map-interfaces";
+interface Bucket<K, V> {
+    key: K;
+    value: V;
+    hashCode: number;
+    next: B<K, V>;
+    prev: B<K, V>;
+    chain: B<K, V>;
+}
+type B<K, V> = Bucket<K, V> | null;
+export interface HashConfig<K extends {}, V extends {}> {
+    readonly load?: number;
+    hashCode(key: K): number;
+    keyEq?(key1: K, key2: K): boolean;
+    valueEq?(value1: V, value2: V): boolean;
+}
+export declare class LMap<K extends {}, V extends {}> {
+    #private;
+    readonly config: HashConfig<K, V>;
+    private buckets;
+    firstB: B<K, V>;
+    lastB: B<K, V>;
+    constructor(config: HashConfig<K, V>);
+    get size(): number;
+    get first(): Entry<K, V> | undefined;
+    get last(): Entry<K, V> | undefined;
+    get only(): Entry<K, V>;
+    get keyEq(): (k1: K, k2: K) => boolean;
+    get valueEq(): (v1: V, v2: V) => boolean;
+    get load(): number;
+    hasKey(key: K): boolean;
+    get(key: K): V | undefined;
+    [Symbol.iterator](): IterableIterator<Entry<K, V>>;
+    private grow;
+    private bucket;
+    put(key: K, value: V): V | undefined;
+    remove(key: K): V | undefined;
+    clear(): void;
+}
+export interface LMap<K extends {}, V extends {}> extends MapChange<K, V>, MapRemove<K, V> {
+}
+export {};

package/dist/index.js

@@ -0,0 +1,153 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _LMap_size;
+import { mixin, toTin, OnlyError } from "loudo-ds-core";
+import { MapChange, MapRemove } from "loudo-ds-map-interfaces";
+export class LMap {
+    constructor(config) {
+        this.buckets = [];
+        this.firstB = null;
+        this.lastB = null;
+        _LMap_size.set(this, 0);
+        this.config = config;
+        for (let i = 0; i < 4; i++) {
+            this.buckets.push(null);
+        }
+    }
+    get size() { return __classPrivateFieldGet(this, _LMap_size, "f"); }
+    get first() { var _a; return (_a = this.firstB) !== null && _a !== void 0 ? _a : undefined; }
+    get last() { var _a; return (_a = this.lastB) !== null && _a !== void 0 ? _a : undefined; }
+    get only() {
+        if (__classPrivateFieldGet(this, _LMap_size, "f") !== 1)
+            throw new OnlyError();
+        return this.firstB;
+    }
+    get keyEq() { var _a; return (_a = this.config.keyEq) !== null && _a !== void 0 ? _a : Object.is; }
+    get valueEq() { var _a; return (_a = this.config.valueEq) !== null && _a !== void 0 ? _a : Object.is; }
+    get load() { var _a; return (_a = this.config.load) !== null && _a !== void 0 ? _a : 0.75; }
+    hasKey(key) {
+        return this.bucket(key) !== null;
+    }
+    get(key) {
+        var _a;
+        return (_a = this.bucket(key)) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    *[(_LMap_size = new WeakMap(), Symbol.iterator)]() {
+        for (let bucket = this.firstB; bucket !== null; bucket = bucket.next) {
+            yield bucket;
+        }
+    }
+    grow() {
+        const buckets = [];
+        for (let i = 0; i < this.buckets.length; i++)
+            buckets.push(null);
+        this.buckets = buckets;
+        for (let bucket = this.firstB; bucket != null; bucket = bucket.next) {
+            const i = Math.abs(bucket.hashCode) % buckets.length;
+            const chain = buckets[i];
+            buckets[i] = bucket;
+            bucket.chain = chain;
+        }
+    }
+    bucket(key) {
+        const hash = this.config.hashCode(key);
+        let bucket = this.buckets[Math.abs(hash) % this.buckets.length];
+        while (bucket !== null) {
+            if (bucket.hashCode === hash && this.keyEq(key, bucket.key))
+                return bucket;
+            bucket = bucket.chain;
+        }
+        return null;
+    }
+    put(key, value) {
+        var _a;
+        if (__classPrivateFieldGet(this, _LMap_size, "f") / this.buckets.length >= this.load)
+            this.grow();
+        const hashCode = this.config.hashCode(key);
+        const bucket = {
+            key, value, hashCode, prev: null, next: null, chain: null,
+        };
+        const i = Math.abs(hashCode) % this.buckets.length;
+        let b = this.buckets[i];
+        while (b !== null) {
+            if (b.hashCode === hashCode && this.keyEq(key, b.key)) {
+                const r = b.value;
+                b.value = value;
+                const elements = toTin([bucket]);
+                this.fire({
+                    cleared: false,
+                    added: { elements: toTin([bucket]), at: undefined, count: 1 },
+                    removed: { elements: toTin([{ key: key, value: r }]), at: undefined, count: 1 }
+                });
+                return r;
+            }
+            b = b.chain;
+        }
+        bucket.chain = this.buckets[i];
+        this.buckets[i] = bucket;
+        if (this.firstB === null) {
+            this.firstB = bucket;
+            this.lastB = bucket;
+        }
+        else {
+            this.lastB.next = bucket;
+            bucket.prev = this.lastB;
+            this.lastB = bucket;
+        }
+        __classPrivateFieldSet(this, _LMap_size, (_a = __classPrivateFieldGet(this, _LMap_size, "f"), _a++, _a), "f");
+        this.fire({ cleared: false, added: { elements: toTin([bucket]), at: undefined, count: 1 } });
+        return undefined;
+    }
+    remove(key) {
+        var _a;
+        const hash = this.config.hashCode(key);
+        let prev = null;
+        const i = Math.abs(hash) % this.buckets.length;
+        let bucket = this.buckets[i];
+        while (bucket !== null) {
+            if (bucket.hashCode === hash && this.keyEq(key, bucket.key))
+                break;
+            prev = bucket;
+            bucket = bucket.chain;
+        }
+        if (bucket === null)
+            return undefined;
+        __classPrivateFieldSet(this, _LMap_size, (_a = __classPrivateFieldGet(this, _LMap_size, "f"), _a--, _a), "f");
+        if (prev === null)
+            this.buckets[i] = bucket.chain;
+        else
+            prev.chain = bucket.chain;
+        if (this.firstB === bucket)
+            this.firstB = bucket.next;
+        if (this.lastB === bucket)
+            this.lastB = bucket.prev;
+        if (bucket.next !== null) {
+            bucket.next.prev = bucket.prev;
+        }
+        if (bucket.prev !== null) {
+            bucket.prev.next = bucket.next;
+        }
+        const elements = toTin([bucket]);
+        this.fire({ cleared: false, removed: { elements, at: undefined, count: 1 } });
+        return bucket.value;
+    }
+    clear() {
+        if (this.size === 0)
+            return;
+        this.firstB = null;
+        this.lastB = null;
+        __classPrivateFieldSet(this, _LMap_size, 0, "f");
+        this.fire({ cleared: true });
+    }
+}
+mixin(LMap, [MapChange, MapRemove]);
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "loudo-ds-lmap",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Flexible loud map.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "README.md",
+    "dist/index.js",
+    "dist/index.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "test": "vitest --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/p-jack/loudo-ds.git"
+  },
+  "author": "Paul Jack",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/p-jack/loudo-ds/issues"
+  },
+  "homepage": "https://github.com/p-jack/loudo-ds#readme",
+  "devDependencies": {
+    "@types/web": "^0.0.138",
+    "@vitest/coverage-v8": "^2.1.4",
+    "jsdom": "^25.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  },
+  "dependencies": {
+    "loudo-ds-map-interfaces": "^0.0.4"
+  }
+}