@hamak/ui-store-impl 0.3.0 → 0.4.1

package/dist/fs/utils/data-updater.js

@@ -0,0 +1,248 @@
+import { isDraft, original } from 'immer';
+import { navigate, ensurePath, areSameItineraryStep } from '@hamak/shared-utils';
+/**
+ * Type guard for checking if a value is an object
+ */
+function isObject(o) {
+    if (o === undefined || o === null) {
+        return false;
+    }
+    return (isDraft(o) && typeof original(o) === 'object')
+        || typeof o === 'object';
+}
+/**
+ * Type guard for checking if a value is an array
+ */
+function isArray(o) {
+    if (o === undefined || o === null) {
+        return false;
+    }
+    return (isDraft(o) && Array.isArray(original(o)))
+        || Array.isArray(o);
+}
+/**
+ * DataUpdater class handles operations on data structures using itineraries
+ */
+export class DataUpdater {
+    /**
+     * Delete a value at the specified itinerary
+     */
+    executeDelete(data, itinerary) {
+        if (itinerary === undefined) {
+            return;
+        }
+        const { parent, value: step } = itinerary;
+        const parentNode = navigate(data, parent);
+        if (!(parentNode === undefined)) {
+            if (isArray(parentNode)) {
+                if (step.type === 'position') {
+                    parentNode.splice(step.position, 1);
+                }
+                else {
+                    // TODO log expected PositionStep
+                }
+            }
+            else if (isObject(parentNode)) {
+                if (step.type === 'property') {
+                    if (parentNode !== null) {
+                        delete parentNode[step.propertyName];
+                    }
+                }
+                else {
+                    // TODO log expected PropertyStep
+                }
+            }
+            else {
+                // TODO log expected object
+            }
+        }
+        else {
+            // TODO log Parent Node not found
+        }
+    }
+    /**
+     * Set a value at the specified itinerary
+     */
+    executeSet(data, itinerary, value, prototypeToParent) {
+        if (itinerary === undefined) {
+            return;
+        }
+        const { parent, value: step } = itinerary;
+        const parentNode = ensurePath(data, parent, prototypeToParent);
+        if (!(parentNode === undefined)) {
+            if (isArray(parentNode)) {
+                if (step.type === 'position') {
+                    parentNode[step.position] = value;
+                }
+                else {
+                    // TODO log expected PositionStep
+                }
+            }
+            else if (isObject(parentNode)) {
+                if (step.type === 'property') {
+                    if (parentNode !== null) {
+                        parentNode[step.propertyName] = value;
+                    }
+                }
+                else {
+                    // TODO log expected PropertyStep
+                }
+            }
+            else {
+                // TODO log expected object
+            }
+        }
+        else {
+            // TODO log Parent Node not found
+        }
+    }
+    /**
+     * Add a value at the specified itinerary
+     */
+    executeAdd(data, itinerary, value, prototypeToParent) {
+        const targetNode = ensurePath(data, itinerary, prototypeToParent);
+        if (!(targetNode === undefined)) {
+            if (isArray(targetNode)) {
+                targetNode.push(value);
+            }
+            else {
+                // TODO log expected object
+            }
+        }
+        else {
+            // TODO log Parent Node not found
+        }
+    }
+    /**
+     * Insert a value at the specified position
+     */
+    executeInsert(data, itinerary, value, prototypeToParent) {
+        const { value: step, parent } = itinerary;
+        if (step.type === 'position') {
+            const parentNode = ensurePath(data, parent, prototypeToParent);
+            if (parentNode !== undefined) {
+                if (isArray(parentNode)) {
+                    parentNode.splice(step.position, 0, value);
+                }
+                else {
+                    // TODO log expected object
+                }
+            }
+            else {
+                // TODO log Parent Node not found
+            }
+        }
+        else {
+            // TODO log expecting position step
+        }
+    }
+    /**
+     * Rebase a pending command's itinerary on top of an altering command.
+     * Returns null if the pending command should be dropped (e.g., targets a deleted element).
+     * Enhanced: Handles rebasing for nested itineraries, not just at the first divergence.
+     */
+    rebasePendingCommandOn(alteringCmd, pendingCmd) {
+        // Convert itinerary stack to array (root to leaf)
+        function itineraryToArray(it) {
+            const arr = [];
+            let current = it;
+            while (current) {
+                arr.push(current.value);
+                current = current.parent;
+            }
+            return arr.reverse();
+        }
+        // Convert array back to itinerary stack (leaf to root)
+        function arrayToItinerary(arr) {
+            // Assumes arr.length > 0
+            let it = { parent: undefined, value: arr[0] };
+            for (let i = 1; i < arr.length; i++) {
+                it = { parent: it, value: arr[i] };
+            }
+            return it;
+        }
+        // Rebase a single position step if needed
+        function rebasePositionStep(alteringStep, alteringCmd, pendingStep) {
+            if (pendingStep.type !== 'position' || alteringStep.type !== 'position')
+                return pendingStep;
+            let { position: pendingIdx } = pendingStep;
+            const { position: alteringIdx } = alteringStep;
+            if (alteringCmd.name === 'insert-at' && pendingIdx >= alteringIdx) {
+                pendingIdx += 1;
+            }
+            else if (alteringCmd.name === 'delete-at') {
+                if (pendingIdx > alteringIdx) {
+                    pendingIdx -= 1;
+                }
+                // If pendingIdx === alteringIdx, leave unchanged (may be dropped by batch context)
+            }
+            return pendingIdx !== pendingStep.position
+                ? { ...pendingStep, position: pendingIdx }
+                : pendingStep;
+        }
+        const alteringArr = itineraryToArray(alteringCmd.itinerary);
+        const pendingArr = itineraryToArray(pendingCmd.itinerary);
+        // Find first index where steps differ
+        let commonLength = 0;
+        while (commonLength < alteringArr.length &&
+            commonLength < pendingArr.length &&
+            areSameItineraryStep(alteringArr[commonLength], pendingArr[commonLength])) {
+            commonLength++;
+        }
+        // Rebase all position steps after the divergence point
+        const rebasedArr = pendingArr.slice();
+        for (let i = 0; i < alteringArr.length; i++) {
+            if (alteringArr[i].type === 'position' &&
+                pendingArr.length > i &&
+                pendingArr[i].type === 'position') {
+                // Only rebase if the pending itinerary matches the altering up to this step
+                const isDescendant = alteringArr
+                    .slice(0, i)
+                    .every((step, j) => areSameItineraryStep(step, pendingArr[j]));
+                if (isDescendant) {
+                    rebasedArr[i] = rebasePositionStep(alteringArr[i], alteringCmd, pendingArr[i]);
+                }
+            }
+        }
+        // If no itinerary, return as is
+        if (rebasedArr.length === 0)
+            return pendingCmd;
+        return {
+            ...pendingCmd,
+            itinerary: arrayToItinerary(rebasedArr),
+        };
+    }
+    /**
+     * Executes a batch of commands, rebasing each on previous mutations.
+     * @param data The data object to mutate
+     * @param command The batch update command
+     */
+    executeBatch(data, command) {
+        const { commands } = command;
+        const applied = [];
+        for (let i = 0; i < commands.length; i++) {
+            let rebased = commands[i];
+            for (let j = 0; j < applied.length && rebased != null; j++) {
+                rebased = this.rebasePendingCommandOn(applied[j], rebased);
+            }
+            if (rebased != null) {
+                switch (rebased.name) {
+                    case 'add-at':
+                        this.executeAdd(data, rebased.itinerary, rebased.value, rebased.prototypes);
+                        break;
+                    case 'insert-at':
+                        this.executeInsert(data, rebased.itinerary, rebased.value, rebased.prototypes);
+                        break;
+                    case 'set-at':
+                        this.executeSet(data, rebased.itinerary, rebased.value, rebased.prototypes);
+                        break;
+                    case 'delete-at':
+                        this.executeDelete(data, rebased.itinerary);
+                        break;
+                }
+                applied.push(rebased);
+            }
+            // If rebased is null, skip this command (it targets a deleted element)
+        }
+    }
+}

package/dist/fs/utils/deep-equal.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Deep equality check for objects and arrays
+ */
+export declare function deepEqual(obj1: any, obj2: any): boolean;
+//# sourceMappingURL=deep-equal.d.ts.map

package/dist/fs/utils/deep-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-equal.d.ts","sourceRoot":"","sources":["../../../src/fs/utils/deep-equal.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CA+BvD"}

package/dist/fs/utils/deep-equal.js

@@ -0,0 +1,28 @@
+/**
+ * Deep equality check for objects and arrays
+ */
+export function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 === null || obj2 === null || typeof obj1 !== 'object' || typeof obj2 !== 'object') {
+        return false;
+    }
+    if (Array.isArray(obj1) !== Array.isArray(obj2)) {
+        return false;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!keys2.includes(key)) {
+            return false;
+        }
+        if (!deepEqual(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/index.d.ts

@@ -5,4 +5,5 @@
 export * from './core';
 export * from './middleware';
 export * from './plugin';
+export * from './fs';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,MAAM,CAAC"}

package/dist/index.js

@@ -5,3 +5,4 @@
 export * from './core';
 export * from './middleware';
 export * from './plugin';
+export * from './fs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamak/ui-store-impl",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "private": false,
   "type": "module",
   "description": "UI Store Implementation - Redux store implementation with middleware",
@@ -34,10 +34,13 @@
     }
   },
   "dependencies": {
-    "@hamak/ui-store-api": "0.3.0",
-    "@hamak/ui-store-spi": "0.3.0",
-    "@hamak/microkernel-api": "0.3.0",
-    "@hamak/microkernel-spi": "0.3.0",
+    "@hamak/shared-utils": "0.4.1",
+    "@hamak/ui-store-api": "0.4.1",
+    "@hamak/ui-store-spi": "0.4.1",
+    "@hamak/microkernel-api": "0.4.1",
+    "@hamak/microkernel-spi": "0.4.1",
+    "@reduxjs/toolkit": "^2.0.0",
+    "immer": "^10.0.0",
     "redux": "^5.0.1",
     "redux-thunk": "^3.1.0"
   },