@vorplex/core 0.0.15 → 0.0.21

package/dist/index.d.ts

@@ -62,6 +62,9 @@ export * from './modules/state/adaptors/array/array-adaptor.util';
 export * from './modules/state/adaptors/entity/entity-adaptor.util';
 export * from './modules/state/adaptors/entity/entity-map.type';
 export * from './modules/state/adaptors/entity/entity.interface';
+export * from './modules/storage/in-memory.model';
+export * from './modules/storage/local-storage.model';
+export * from './modules/storage/storage-provider.interface';
 export * from './modules/string/string.util';
 export * from './modules/subscribable/subscribable.model';
 export * from './modules/subscribable/subscription.interface';

package/dist/index.js

@@ -63,6 +63,9 @@ export * from './modules/state/adaptors/array/array-adaptor.util';
 export * from './modules/state/adaptors/entity/entity-adaptor.util';
 export * from './modules/state/adaptors/entity/entity-map.type';
 export * from './modules/state/adaptors/entity/entity.interface';
+export * from './modules/storage/in-memory.model';
+export * from './modules/storage/local-storage.model';
+export * from './modules/storage/storage-provider.interface';
 export * from './modules/string/string.util';
 export * from './modules/subscribable/subscribable.model';
 export * from './modules/subscribable/subscription.interface';

package/dist/modules/changes/changes.util.d.ts

@@ -1,19 +1,39 @@
 export type ArrayChange = Record<`$${number}` | `$${number}+`, any | typeof $Changes.deleted>;
-export interface ChangeConflicts {
+export interface ChangeCompareResult {
+    similarities: any;
     conflicts: any;
     differences: any;
 }
 export interface ChangeRebase<T = any> {
+    /**
+     * The remote with local changes
+     */
     result: T;
-    conflicts?: {
-        local: ChangeConflicts;
-        remote: ChangeConflicts;
-    };
-    merge?: {
-        source: T;
-        remote: T;
-        local: T;
-        result: T;
+    /**
+     * Only defined when the rebase contains conflicts.
+     * Contains rebase conflicts and merge
+     */
+    conflict?: {
+        local: ChangeCompareResult;
+        remote: ChangeCompareResult;
+        merge?: {
+            /**
+             * The source with remote and local none conflicting changes
+             */
+            source: T;
+            /**
+             * The `.source` with remote conflict changes
+             */
+            remote: T;
+            /**
+             * The `.source` with local conflict changes
+             */
+            local: T;
+            /**
+             * The remote with local none conflicting changes
+             */
+            result: T;
+        };
     };
 }
 export declare class $Changes {
@@ -22,15 +42,11 @@ export declare class $Changes {
     static getArrayChanges(a: any[], b: any[]): ArrayChange | undefined;
     static getObjectChanges(a: Record<string, any>, b: Record<string, any>): Record<string, any | typeof $Changes.deleted>;
     static get(a: any, b: any): undefined | any | Record<string, any | typeof $Changes.deleted> | ArrayChange;
-    static classifyPathsByOverlap(changesA: any, changesB: any): {
-        conflicts: string[];
-        differences: string[];
-    };
-    static resolveConflicts(changesA: any, changesB: any): ChangeConflicts;
+    static compareChanges(changesA: any, changesB: any): ChangeCompareResult;
     private static pathsOverlap;
     static hasConflict(changesA: any, changesB: any): boolean;
     static asValue(changes: any): any;
-    static apply(value: any, changes: any): any;
+    static apply(value: any, ...changes: any[]): any;
     static rebase(source: any, local: any, remote: any): ChangeRebase;
     /**
      * Excludes specific paths from a changes object and cleans up empty containers.

package/dist/modules/changes/changes.util.js

@@ -107,33 +107,31 @@ export class $Changes {
             return $Changes.getArrayChanges(a, b);
         return $Changes.getObjectChanges(a, b);
     }
-    static classifyPathsByOverlap(changesA, changesB) {
+    static compareChanges(changesA, changesB) {
         const aPaths = $Object.getPaths(changesA);
         const bPaths = $Object.getPaths(changesB);
+        const similarities = new Set();
         const conflicts = new Set();
         const differences = new Set();
-        for (const aPath of aPaths) {
-            if (bPaths.some(bPath => this.pathsOverlap(aPath, bPath)))
-                conflicts.add(aPath);
-            else
-                differences.add(aPath);
-        }
         for (const bPath of bPaths) {
-            if (aPaths.some(aPath => this.pathsOverlap(aPath, bPath)))
-                conflicts.add(bPath);
-            else
+            let overlapped;
+            for (const aPath of aPaths) {
+                if (this.pathsOverlap(aPath, bPath)) {
+                    overlapped = true;
+                    const longestPath = aPath.length > bPath.length ? aPath : bPath;
+                    if ($Value.equals($Value.get(changesA, longestPath), $Value.get(changesB, longestPath)))
+                        similarities.add(bPath);
+                    else
+                        conflicts.add(bPath);
+                }
+            }
+            if (!overlapped)
                 differences.add(bPath);
         }
         return {
-            conflicts: Array.from(conflicts),
-            differences: Array.from(differences)
-        };
-    }
-    static resolveConflicts(changesA, changesB) {
-        const { conflicts, differences } = this.classifyPathsByOverlap(changesA, changesB);
-        return {
-            differences: $Changes.excludeChanges(changesB, conflicts),
-            conflicts: $Changes.excludeChanges(changesB, differences)
+            similarities: $Changes.excludeChanges(changesB, [...conflicts, ...differences]),
+            differences: $Changes.excludeChanges(changesB, [...similarities, ...conflicts]),
+            conflicts: $Changes.excludeChanges(changesB, [...similarities, ...differences])
         };
     }
     static pathsOverlap(a, b) {
@@ -151,8 +149,11 @@ export class $Changes {
         const bPaths = $Object.getPaths(changesB);
         for (const bPath of bPaths) {
             for (const aPath of aPaths) {
-                if (this.pathsOverlap(aPath, bPath))
-                    return true;
+                if (this.pathsOverlap(aPath, bPath)) {
+                    const longestPath = aPath.length > bPath.length ? aPath : bPath;
+                    if (!$Value.equals($Value.get(changesA, longestPath), $Value.get(changesB, longestPath)))
+                        return true;
+                }
             }
         }
         return false;
@@ -164,7 +165,6 @@ export class $Changes {
             return changes.map(item => $Changes.asValue(item));
         }
         if (typeof changes === 'object' && changes !== null) {
-            // cannot materialize array index changes without a base; strip them
             if ($Changes.isArrayIndexChange(changes))
                 return undefined;
             const result = {};
@@ -177,80 +177,86 @@ export class $Changes {
         }
         return changes;
     }
-    static apply(value, changes) {
-        function applyArrayChange(originalArray, change) {
-            if (!$Changes.isArrayIndexChange(change))
-                return $Value.clone(change);
-            const result = $Value.clone(originalArray);
-            const entries = Object.entries(change)
-                .map(([k, v]) => {
-                const isInsert = k.endsWith('+');
-                const nStr = isInsert ? k.slice(1, -1) : k.slice(1);
-                return [Number.parseInt(nStr, 10), isInsert, v];
-            })
-                .filter(([i]) => !Number.isNaN(i))
-                .sort(([iA, insA, vA], [iB, insB, vB]) => {
-                const aDel = vA === $Changes.deleted;
-                const bDel = vB === $Changes.deleted;
-                // deletes first, highest -> lowest
-                if (aDel !== bDel)
-                    return aDel ? -1 : 1;
-                if (aDel && bDel)
-                    return iB - iA;
-                // inserts next, lowest -> highest
-                if (insA !== insB)
-                    return insA ? -1 : 1;
-                if (insA && insB)
+    static apply(value, ...changes) {
+        function apply(value, changes) {
+            function applyArrayChange(originalArray, change) {
+                if (!$Changes.isArrayIndexChange(change))
+                    return $Value.clone(change);
+                const result = $Value.clone(originalArray);
+                const entries = Object.entries(change)
+                    .map(([k, v]) => {
+                    const isInsert = k.endsWith('+');
+                    const nStr = isInsert ? k.slice(1, -1) : k.slice(1);
+                    return [Number.parseInt(nStr, 10), isInsert, v];
+                })
+                    .filter(([i]) => !Number.isNaN(i))
+                    .sort(([iA, insA, vA], [iB, insB, vB]) => {
+                    const aDel = vA === $Changes.deleted;
+                    const bDel = vB === $Changes.deleted;
+                    // deletes first, highest -> lowest
+                    if (aDel !== bDel)
+                        return aDel ? -1 : 1;
+                    if (aDel && bDel)
+                        return iB - iA;
+                    // inserts next, lowest -> highest
+                    if (insA !== insB)
+                        return insA ? -1 : 1;
+                    if (insA && insB)
+                        return iA - iB;
+                    // sets last, lowest -> highest
                     return iA - iB;
-                // sets last, lowest -> highest
-                return iA - iB;
-            });
-            for (const [index, isInsert, op] of entries) {
-                if (op === $Changes.deleted) {
-                    if (index >= 0 && index < result.length)
-                        result.splice(index, 1);
-                }
-                else if (isInsert) {
-                    const v = $Value.clone(op);
-                    const idx = Math.min(Math.max(index, 0), result.length);
-                    result.splice(idx, 0, v);
-                }
-                else {
-                    if (index >= result.length)
-                        result.length = index + 1;
-                    result[index] = $Changes.apply(result[index], op);
+                });
+                for (const [index, isInsert, op] of entries) {
+                    if (op === $Changes.deleted) {
+                        if (index >= 0 && index < result.length)
+                            result.splice(index, 1);
+                    }
+                    else if (isInsert) {
+                        const v = $Value.clone(op);
+                        const idx = Math.min(Math.max(index, 0), result.length);
+                        result.splice(idx, 0, v);
+                    }
+                    else {
+                        if (index >= result.length)
+                            result.length = index + 1;
+                        result[index] = $Changes.apply(result[index], op);
+                    }
                 }
+                return result;
             }
-            return result;
-        }
-        if (changes === undefined)
-            return value;
-        if (value == null || typeof changes !== 'object')
-            return $Changes.asValue(changes);
-        if (Array.isArray(value)) {
-            return applyArrayChange(value, changes);
-        }
-        else if (typeof value === 'object') {
-            if (Array.isArray(changes))
+            if (changes === undefined)
+                return value;
+            if (value == null || typeof changes !== 'object')
                 return $Changes.asValue(changes);
-            const result = { ...value };
-            for (const [key, change] of Object.entries(changes)) {
-                if (change === $Changes.deleted) {
-                    delete result[key];
-                }
-                else if (Array.isArray(result[key])) {
-                    result[key] = applyArrayChange(result[key] || [], change);
-                }
-                else if (typeof change === 'object' && change !== null) {
-                    result[key] = $Changes.apply(result[key], change);
-                }
-                else {
-                    result[key] = change;
+            if (Array.isArray(value)) {
+                return applyArrayChange(value, changes);
+            }
+            else if (typeof value === 'object') {
+                if (Array.isArray(changes))
+                    return $Changes.asValue(changes);
+                const result = { ...value };
+                for (const [key, change] of Object.entries(changes)) {
+                    if (change === $Changes.deleted) {
+                        delete result[key];
+                    }
+                    else if (Array.isArray(result[key])) {
+                        result[key] = applyArrayChange(result[key] || [], change);
+                    }
+                    else if (typeof change === 'object' && change !== null) {
+                        result[key] = $Changes.apply(result[key], change);
+                    }
+                    else {
+                        result[key] = change;
+                    }
                 }
+                return result;
             }
-            return result;
+            return $Changes.asValue(changes);
+        }
+        for (const change of changes) {
+            value = apply(value, change);
         }
-        return $Changes.asValue(changes);
+        return value;
     }
     static rebase(source, local, remote) {
         const localChanges = $Changes.get(source, local);
@@ -267,20 +273,20 @@ export class $Changes {
             return { result };
         }
         else {
-            const localConflict = $Changes.resolveConflicts(remoteChanges, localChanges);
-            const remoteConflict = $Changes.resolveConflicts(localChanges, remoteChanges);
-            const sourceWithDifferences = $Changes.apply($Changes.apply(source, remoteConflict.differences), localConflict.differences);
+            const localConflict = $Changes.compareChanges(remoteChanges, localChanges);
+            const remoteConflict = $Changes.compareChanges(localChanges, remoteChanges);
+            const sourceWithDifferences = $Changes.apply(source, remoteConflict.differences, localConflict.differences, remoteConflict.similarities, localConflict.similarities);
             const mergedWithLocalDifferences = $Changes.apply(remote, localConflict.differences);
             return {
-                conflicts: {
+                conflict: {
                     local: localConflict,
                     remote: remoteConflict,
-                },
-                merge: {
-                    source: sourceWithDifferences,
-                    remote: $Changes.apply(sourceWithDifferences, remoteConflict.conflicts),
-                    local: $Changes.apply(sourceWithDifferences, localConflict.conflicts),
-                    result: mergedWithLocalDifferences
+                    merge: {
+                        source: sourceWithDifferences,
+                        remote: $Changes.apply(sourceWithDifferences, remoteConflict.conflicts),
+                        local: $Changes.apply(sourceWithDifferences, localConflict.conflicts),
+                        result: mergedWithLocalDifferences
+                    },
                 },
                 result: $Changes.apply(mergedWithLocalDifferences, localConflict.conflicts)
             };

package/dist/modules/storage/in-memory.model.d.ts

@@ -0,0 +1,17 @@
+import { StorageProvider } from './storage-provider.interface';
+export declare class InMemoryStorage implements StorageProvider {
+    private static storage;
+    private static getStore;
+    static get<T = any>(database: string, store: string, key: string): Promise<T | null>;
+    static set(database: string, store: string, key: string, value: any): Promise<void>;
+    static delete(database: string, store: string, key: string): Promise<void>;
+    static clear(database: string, store: string): Promise<void>;
+    static keys(database: string, store: string): Promise<string[]>;
+    static getAll<T = any>(database: string, store: string): Promise<T[]>;
+    get<T = any>(database: string, store: string, key: string): Promise<T | null>;
+    set(database: string, store: string, key: string, value: any): Promise<void>;
+    delete(database: string, store: string, key: string): Promise<void>;
+    clear(database: string, store: string): Promise<void>;
+    keys(database: string, store: string): Promise<string[]>;
+    getAll<T = any>(database: string, store: string): Promise<T[]>;
+}

package/dist/modules/storage/in-memory.model.js

@@ -0,0 +1,35 @@
+export class InMemoryStorage {
+    static storage = new Map();
+    static getStore(database, store) {
+        if (!this.storage.has(database))
+            this.storage.set(database, new Map());
+        const db = this.storage.get(database);
+        if (!db.has(store))
+            db.set(store, new Map());
+        return db.get(store);
+    }
+    static async get(database, store, key) {
+        return this.getStore(database, store).get(key) ?? null;
+    }
+    static async set(database, store, key, value) {
+        this.getStore(database, store).set(key, value);
+    }
+    static async delete(database, store, key) {
+        this.getStore(database, store).delete(key);
+    }
+    static async clear(database, store) {
+        this.getStore(database, store).clear();
+    }
+    static async keys(database, store) {
+        return [...this.getStore(database, store).keys()];
+    }
+    static async getAll(database, store) {
+        return [...this.getStore(database, store).values()];
+    }
+    async get(database, store, key) { return InMemoryStorage.get(database, store, key); }
+    async set(database, store, key, value) { return InMemoryStorage.set(database, store, key, value); }
+    async delete(database, store, key) { return InMemoryStorage.delete(database, store, key); }
+    async clear(database, store) { return InMemoryStorage.clear(database, store); }
+    async keys(database, store) { return InMemoryStorage.keys(database, store); }
+    async getAll(database, store) { return InMemoryStorage.getAll(database, store); }
+}

package/dist/modules/storage/local-storage.model.d.ts

@@ -0,0 +1,16 @@
+import { StorageProvider } from './storage-provider.interface';
+export declare class LocalStorage implements StorageProvider {
+    private static key;
+    static get<T = any>(database: string, store: string, key: string): Promise<T | null>;
+    static set(database: string, store: string, key: string, value: any): Promise<void>;
+    static delete(database: string, store: string, key: string): Promise<void>;
+    static clear(database: string, store: string): Promise<void>;
+    static keys(database: string, store: string): Promise<string[]>;
+    static getAll<T = any>(database: string, store: string): Promise<T[]>;
+    get<T = any>(database: string, store: string, key: string): Promise<T | null>;
+    set(database: string, store: string, key: string, value: any): Promise<void>;
+    delete(database: string, store: string, key: string): Promise<void>;
+    clear(database: string, store: string): Promise<void>;
+    keys(database: string, store: string): Promise<string[]>;
+    getAll<T = any>(database: string, store: string): Promise<T[]>;
+}

package/dist/modules/storage/local-storage.model.js

@@ -0,0 +1,49 @@
+export class LocalStorage {
+    static key(database, store, key) {
+        return `${database}:${store}:${key ?? ''}`;
+    }
+    static async get(database, store, key) {
+        const raw = localStorage.getItem(this.key(database, store, key));
+        return raw != null ? JSON.parse(raw) : null;
+    }
+    static async set(database, store, key, value) {
+        localStorage.setItem(this.key(database, store, key), JSON.stringify(value));
+    }
+    static async delete(database, store, key) {
+        localStorage.removeItem(this.key(database, store, key));
+    }
+    static async clear(database, store) {
+        const prefix = this.key(database, store);
+        for (let i = localStorage.length - 1; i >= 0; i--) {
+            const key = localStorage.key(i);
+            if (key?.startsWith(prefix))
+                localStorage.removeItem(key);
+        }
+    }
+    static async keys(database, store) {
+        const prefix = this.key(database, store);
+        const result = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key?.startsWith(prefix))
+                result.push(key.slice(prefix.length));
+        }
+        return result;
+    }
+    static async getAll(database, store) {
+        const prefix = this.key(database, store);
+        const result = [];
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key?.startsWith(prefix))
+                result.push(JSON.parse(localStorage.getItem(key)));
+        }
+        return result;
+    }
+    async get(database, store, key) { return LocalStorage.get(database, store, key); }
+    async set(database, store, key, value) { return LocalStorage.set(database, store, key, value); }
+    async delete(database, store, key) { return LocalStorage.delete(database, store, key); }
+    async clear(database, store) { return LocalStorage.clear(database, store); }
+    async keys(database, store) { return LocalStorage.keys(database, store); }
+    async getAll(database, store) { return LocalStorage.getAll(database, store); }
+}

package/dist/modules/storage/storage-provider.interface.d.ts

@@ -0,0 +1,8 @@
+export interface StorageProvider<TDatabase extends string = string, TStore extends string = string> {
+    get<T = any>(database: TDatabase, store: TStore, key: string): Promise<T | null>;
+    set(database: TDatabase, store: TStore, key: string, value: any): Promise<void>;
+    delete(database: TDatabase, store: TStore, key: string): Promise<void>;
+    clear(database: TDatabase, store: TStore): Promise<void>;
+    keys(database: TDatabase, store: TStore): Promise<string[]>;
+    getAll<T = any>(database: TDatabase, store: TStore): Promise<T[]>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vorplex/core",
-  "version": "0.0.15",
+  "version": "0.0.21",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -18,13 +18,11 @@
     "tslib": "2.8.1"
   },
   "devDependencies": {
-    "@types/jest": "29.5.14",
-    "jest": "29.7.0",
-    "ts-jest": "29.4.5"
+    "vitest": "3.2.4"
   },
   "scripts": {
     "build": "tsc -b --force tsconfig.build.json",
-    "test": "jest",
+    "test": "vitest run",
     "npm:publish": "pnpm publish --registry=https://registry.npmjs.org/"
   }
 }