loudo-ds-map-interfaces 0.0.22 → 0.0.24

package/README.md

@@ -1,3 +1 @@
-# loudo-ds-map-interfaces
-
-Provides mixins for maps.
+## loudo-ds-map-interfaces

package/dist/index.d.ts

@@ -3,32 +3,33 @@ export interface Entry<K extends {}, V extends {}> {
     key: K;
     value: V;
 }
-export declare abstract class BaseMap<K extends {}, V extends {}> {
-    abstract get(key: K): V | undefined;
+export declare abstract class MapBase<K extends {}, V extends {}> {
     abstract get keyEq(): (k1: K, k2: K) => boolean;
     abstract get valueEq(): (v1: V, v2: V) => boolean;
+    abstract get(key: K): V | undefined;
     get eq(): (e1: Entry<K, V>, e2: Entry<K, V>) => boolean;
-    has(entry: Entry<K, V>): boolean;
     hasKey(key: K): boolean;
-    hasAllKeys(keys: Iterable<K>): boolean;
+    has(entry: Entry<K, V>): boolean;
     get keys(): Sized<K>;
     get values(): Sized<V>;
 }
-export interface BaseMap<K extends {}, V extends {}> extends Sized<Entry<K, V>> {
+export interface MapBase<K extends {}, V extends {}> extends Sized<Entry<K, V>> {
 }
 export declare abstract class MapChange<K extends {}, V extends {}> {
-    abstract put(key: K, value: V): V | undefined;
-    putAll(input: MapInput<K, V>): void;
+    protected abstract rawPut(key: K, value: V): V | undefined;
+    put(key: K, value: V): V | undefined;
+    putAll(entries: MapInput<K, V>): void;
+    abstract replace(entries: MapInput<K, V>): void;
 }
-export interface MapChange<K extends {}, V extends {}> extends BaseMap<K, V>, Loud<Entry<K, V>> {
+export interface MapChange<K extends {}, V extends {}> extends MapBase<K, V>, Loud<Entry<K, V>> {
 }
 export declare abstract class MapRemove<K extends {}, V extends {}> {
     abstract removeKey(key: K): V | undefined;
     abstract clear(): void;
-    drop(f: (k: K, v: V) => boolean): number;
+    abstract drop(f: (entry: Entry<K, V>) => boolean): void;
 }
-export interface MapRemove<K extends {}, V extends {}> extends BaseMap<K, V>, Loud<Entry<K, V>> {
+export interface MapRemove<K extends {}, V extends {}> extends MapBase<K, V>, Loud<Entry<K, V>> {
 }
 export type Object<K extends {}, V extends {}> = K extends string ? Record<string, V> : never;
 export type MapInput<K extends {}, V extends {}> = Iterable<Entry<K, V>> | Iterable<[K, V]> | Object<K, V>;
-export declare function forEach<K extends {}, V extends {}>(input: MapInput<K, V>, f: (k: K, v: V) => void): void;
+export declare function forEach<K extends {}, V extends {}>(input: MapInput<K, V>, f: (k: K, v: V) => void): number;

package/dist/index.js

@@ -1,65 +1,65 @@
-import { Loud, Sized } from "loudo-ds-core";
 import { mixin } from "loudo-mixin";
-export class BaseMap {
-    get eq() {
-        const me = this;
-        return (e1, e2) => {
-            if (!me.keyEq(e1.key, e2.key))
-                return false;
-            return me.valueEq(e1.value, e2.value);
-        };
-    }
+import { Loud, Sized } from "loudo-ds-core";
+import { One } from "loudo-ds-one";
+export class MapBase {
+    get eq() { return (e1, e2) => this.keyEq(e1.key, e2.key) && this.valueEq(e1.value, e2.value); }
+    hasKey(key) { return this.get(key) !== undefined; }
     has(entry) {
         const v = this.get(entry.key);
-        return v !== undefined && this.valueEq(v, entry.value);
-    }
-    hasKey(key) { return this.get(key) !== undefined; }
-    hasAllKeys(keys) {
-        for (const k of keys)
-            if (!this.hasKey(k))
-                return false;
-        return true;
+        if (v === undefined)
+            return false;
+        return this.valueEq(entry.value, v);
     }
     get keys() { return this.map(x => x.key); }
     get values() { return this.map(x => x.value); }
 }
-mixin(BaseMap, [Sized]);
+mixin(MapBase, [Sized]);
 export class MapChange {
-    putAll(input) {
-        const me = this;
-        forEach(input, (k, v) => me.put(k, v));
+    put(key, value) {
+        const r = this.rawPut(key, value);
+        if (r === undefined) {
+            this.fire({ added: { elements: One.of({ key, value }), at: -1 } });
+            return;
+        }
+        if (this.valueEq(r, value))
+            return;
+        else
+            this.fire({
+                removed: { elements: One.of({ key, value: r }), at: -1 },
+                added: { elements: One.of({ key, value }), at: -1 }
+            });
+        return r;
     }
-}
-mixin(MapChange, [BaseMap, Loud]);
-export class MapRemove {
-    drop(f) {
-        const set = new Set(this.filter(x => f(x.key, x.value)).map(x => x.key));
-        for (const x of set) {
-            this.removeKey(x);
+    putAll(entries) {
+        if (this.size === 0) {
+            const c = forEach(entries, (k, v) => this.rawPut(k, v));
+            if (c > 0)
+                this.fire({ added: { elements: this, at: -1 } });
+            return;
         }
-        return set.size;
+        forEach(entries, (k, v) => this.put(k, v));
     }
 }
-mixin(MapRemove, [BaseMap, Loud]);
+mixin(MapChange, [MapBase, Loud]);
+export class MapRemove {
+}
+mixin(MapRemove, [MapBase, Loud]);
 export function forEach(input, f) {
-    if (input instanceof Map) {
-        for (const x of input) {
-            f(x[0], x[1]);
-        }
-        return;
-    }
+    let count = 0;
     if (Symbol.iterator in input) {
         for (const x of input) {
-            if (Array.isArray(x)) {
+            count++;
+            if (Array.isArray(x))
                 f(x[0], x[1]);
-            }
-            else {
+            else
                 f(x.key, x.value);
-            }
         }
-        return;
+        return count;
     }
-    for (const [k, v] of Object.entries(input))
+    for (const [k, v] of Object.entries(input)) {
+        count++;
         f(k, v);
+    }
+    return count;
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "loudo-ds-map-interfaces",
   "type": "module",
-  "version": "0.0.22",
-  "description": "Core interfaces for loud maps (dictionaries.)",
+  "version": "0.0.24",
+  "description": "Core interfaces loud maps (dictionaries.)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -17,20 +17,23 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/p-jack/loudo-ds-core.git"
+    "url": "git+https://github.com/p-jack/loudo.git"
   },
   "author": "Paul Jack",
   "license": "BSD-3-Clause",
   "bugs": {
-    "url": "https://github.com/p-jack/loudo-ds-core/issues"
+    "url": "https://github.com/p-jack/loudo/issues"
   },
-  "homepage": "https://github.com/p-jack/loudo-ds-core#readme",
+  "homepage": "https://github.com/p-jack/loudo#readme",
   "devDependencies": {
-    "@vitest/coverage-v8": "^1.2.2",
+    "@vitest/coverage-v8": "^3.1.4",
+    "jsdom": "^26.1.0",
+    "loudo-ds-tools-capture": "^0.0.5",
     "typescript": "^5.7",
-    "vitest": "^1.2.2"
+    "vitest": "^3.1.4"
   },
   "dependencies": {
-    "loudo-ds-core": "^0.0.42"
+    "loudo-ds-core": "^0.0.44",
+    "loudo-ds-one": "^0.0.15"
   }
 }