loudo-ds-lmap 0.0.4 → 0.0.8

package/dist/index.d.ts

@@ -8,31 +8,38 @@ interface Bucket<K, V> {
     chain: B<K, V>;
 }
 type B<K, V> = Bucket<K, V> | null;
-export interface LMapConfig<K extends {}, V extends {}> {
+export interface Config<K extends {}, V extends {}> {
     readonly load?: number;
-    hashCode(key: K): number;
-    keyEq?(key1: K, key2: K): boolean;
-    valueEq?(value1: V, value2: V): boolean;
+    readonly initial?: number;
+    readonly hashCode: (key: K) => number;
+    readonly keyEq?: (key1: K, key2: K) => boolean;
+    readonly valueEq?: (value1: V, value2: V) => boolean;
 }
+type Conf<K extends {}, V extends {}> = Required<Config<K, V>>;
+export declare const conf: unique symbol;
+export declare const firstB: unique symbol;
+export declare const lastB: unique symbol;
+export declare const buckets: unique symbol;
+export declare const size: unique symbol;
 export declare class LMap<K extends {}, V extends {}> {
-    protected _config: LMapConfig<K, V>;
-    protected buckets: B<K, V>[];
-    protected firstB: B<K, V>;
-    protected lastB: B<K, V>;
-    protected _size: number;
-    constructor(input: MapInput<K, V>, config: LMapConfig<K, V>);
+    protected [conf]: Conf<K, V>;
+    protected [buckets]: B<K, V>[];
+    protected [firstB]: B<K, V>;
+    protected [lastB]: B<K, V>;
+    protected [size]: number;
+    constructor(input: MapInput<K, V>, _config: Config<K, V>);
+    static from<K extends {}, V extends {}>(input: MapInput<K, V>, config: Config<K, V>): LMap<K, V>;
     get size(): number;
-    get config(): LMapConfig<K, V>;
+    get capacity(): 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;
-    protected afterGet(bucket: B<K, V>): void;
-    [Symbol.iterator](): IterableIterator<Entry<K, V>>;
+    protected afterGet(_bucket: B<K, V>): void;
+    [Symbol.iterator](): Iterator<Entry<K, V>>;
     private grow;
     private bucket;
     put(key: K, value: V): V | undefined;

package/dist/index.js

@@ -1,29 +1,53 @@
-import { mixin, toTin, OnlyError } from "loudo-ds-core";
+var _a, _b, _c, _d;
+import { OnlyError } from "loudo-ds-core";
 import { MapChange, MapRemove } from "loudo-ds-map-interfaces";
+import { One } from "loudo-ds-one";
+import { mixin } from "loudo-mixin";
+function confize(config) {
+    var _e, _f, _g, _h;
+    return {
+        load: (_e = config.load) !== null && _e !== void 0 ? _e : 0.75,
+        initial: (_f = config.initial) !== null && _f !== void 0 ? _f : 4,
+        keyEq: (_g = config.keyEq) !== null && _g !== void 0 ? _g : Object.is,
+        valueEq: (_h = config.valueEq) !== null && _h !== void 0 ? _h : Object.is,
+        hashCode: config.hashCode
+    };
+}
+export const conf = Symbol("conf");
+export const firstB = Symbol("firstB");
+export const lastB = Symbol("lastB");
+export const buckets = Symbol("buckets");
+export const size = Symbol("size");
 export class LMap {
-    constructor(input, config) {
-        this.buckets = [];
-        this.firstB = null;
-        this.lastB = null;
-        this._size = 0;
-        this._config = config;
-        for (let i = 0; i < 4; i++) {
-            this.buckets.push(null);
-        }
+    constructor(input, _config) {
+        this[_a] = [];
+        this[_b] = null;
+        this[_c] = null;
+        this[_d] = 0;
+        const c = confize(_config);
+        if (c.load <= 0 || c.load >= 1)
+            throw new TypeError("illegal load factor " + c.load);
+        if (!Number.isSafeInteger(c.initial) || c.initial <= 0)
+            throw new TypeError("illegal capacity " + c.initial);
+        this[conf] = c;
+        this[buckets] = new Array(c.initial);
+        this[buckets].fill(null);
         this.putAll(input);
     }
-    get size() { return this._size; }
-    get config() { return this._config; }
-    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; }
+    static from(input, config) {
+        return new LMap(input, config);
+    }
+    get size() { return this[size]; }
+    get capacity() { return this[buckets].length; }
+    get first() { var _e; return (_e = this[firstB]) !== null && _e !== void 0 ? _e : undefined; }
+    get last() { var _e; return (_e = this[lastB]) !== null && _e !== void 0 ? _e : undefined; }
     get only() {
-        if (this._size !== 1)
+        if (this[size] !== 1)
             throw new OnlyError();
-        return this.firstB;
+        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; }
+    get keyEq() { return this[conf].keyEq; }
+    get valueEq() { return this[conf].valueEq; }
     hasKey(key) {
         return this.bucket(key) !== null;
     }
@@ -32,27 +56,27 @@ export class LMap {
         this.afterGet(bucket);
         return bucket === null || bucket === void 0 ? void 0 : bucket.value;
     }
-    afterGet(bucket) { }
-    *[Symbol.iterator]() {
-        for (let bucket = this.firstB; bucket !== null; bucket = bucket.next) {
+    afterGet(_bucket) { }
+    *[(_a = buckets, _b = firstB, _c = lastB, _d = size, 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;
+        const old = this[buckets];
+        const n = new Array(old.length * 2);
+        n.fill(null);
+        this[buckets] = n;
+        for (let bucket = this[firstB]; bucket != null; bucket = bucket.next) {
+            const i = Math.abs(bucket.hashCode) % n.length;
+            const chain = n[i];
+            n[i] = bucket;
+            bucket.chain = chain !== null && chain !== void 0 ? chain : null;
         }
     }
     bucket(key) {
-        const hash = this.config.hashCode(key);
-        let bucket = this.buckets[Math.abs(hash) % this.buckets.length];
+        const hash = this[conf].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;
@@ -61,49 +85,48 @@ export class LMap {
         return null;
     }
     put(key, value) {
-        if (this._size / this.buckets.length >= this.load)
+        if (this[size] / this[buckets].length >= this[conf].load)
             this.grow();
-        const hashCode = this.config.hashCode(key);
+        const hashCode = this[conf].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];
+        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;
                 this.afterGet(b);
-                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 }
+                    added: { elements: One.of(bucket), at: undefined },
+                    removed: { elements: One.of({ key: key, value: r }), at: undefined }
                 });
                 return r;
             }
             b = b.chain;
         }
-        bucket.chain = this.buckets[i];
-        this.buckets[i] = bucket;
-        if (this.firstB === null) {
-            this.firstB = bucket;
-            this.lastB = bucket;
+        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;
+            this[lastB].next = bucket;
+            bucket.prev = this[lastB];
+            this[lastB] = bucket;
         }
-        this._size++;
-        this.fire({ cleared: false, added: { elements: toTin([bucket]), at: undefined, count: 1 } });
+        this[size]++;
+        this.fire({ cleared: false, added: { elements: One.of(bucket), at: undefined } });
         return undefined;
     }
     removeKey(key) {
-        const hash = this.config.hashCode(key);
+        const hash = this[conf].hashCode(key);
         let prev = null;
-        const i = Math.abs(hash) % this.buckets.length;
-        let bucket = this.buckets[i];
+        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;
@@ -112,31 +135,33 @@ export class LMap {
         }
         if (bucket === null)
             return undefined;
-        this._size--;
+        this[size]--;
         if (prev === null)
-            this.buckets[i] = bucket.chain;
+            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 (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 } });
+        const elements = One.of(bucket);
+        this.fire({ cleared: false, removed: { elements, at: undefined } });
         return bucket.value;
     }
     clear() {
         if (this.size === 0)
             return;
-        this.firstB = null;
-        this.lastB = null;
-        this._size = 0;
+        this[firstB] = null;
+        this[lastB] = null;
+        this[size] = 0;
+        this[buckets] = new Array(this[conf].initial);
+        this[buckets].fill(null);
         this.fire({ cleared: true });
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loudo-ds-lmap",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.8",
   "description": "Flexible loud map.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,6 +33,7 @@
     "vitest": "^2.1.4"
   },
   "dependencies": {
-    "loudo-ds-map-interfaces": "^0.0.12"
+    "loudo-ds-map-interfaces": "^0.0.18",
+    "loudo-ds-one": "^0.0.8"
   }
 }