@vorplex/core 0.0.11 → 0.0.20

package/dist/functions/ok.function.d.ts

@@ -0,0 +1,7 @@
+export type Result<TValue, TFailure extends {
+    reason: string;
+}> = [null, TValue] | [TFailure, TValue];
+export declare function ok<T>(value: T): Result<T, null>;
+export declare function fail<TReason extends string, T extends {
+    reason: TReason;
+}>(error: T): Result<null, T>;

package/dist/functions/ok.function.js

@@ -0,0 +1,6 @@
+export function ok(value) {
+    return [null, value];
+}
+export function fail(error) {
+    return [error, null];
+}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './consts/mime-type.const';
 export * from './consts/unit.const';
 export * from './functions/debounce.function';
 export * from './functions/is-node-environment.function';
+export * from './functions/ok.function';
 export * from './functions/parse-path-selector.function';
 export * from './functions/parse-url.function';
 export * from './interfaces/group.interface';

package/dist/index.js

@@ -3,6 +3,7 @@ export * from './consts/mime-type.const';
 export * from './consts/unit.const';
 export * from './functions/debounce.function';
 export * from './functions/is-node-environment.function';
+export * from './functions/ok.function';
 export * from './functions/parse-path-selector.function';
 export * from './functions/parse-url.function';
 export * from './interfaces/group.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vorplex/core",
-  "version": "0.0.11",
+  "version": "0.0.20",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -15,16 +15,14 @@
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
   "dependencies": {
-    "tslib": "^2.8.1"
+    "tslib": "2.8.1"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.2",
-    "jest": "^29.5.0",
-    "ts-jest": "^29.1.0"
+    "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/"
   }
 }