@hamak/ui-store 0.5.1

package/dist/impl/fs/core/fs-adapter.js

@@ -0,0 +1,204 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { FileSystemCommandHandler, pathSteps } from '../commands/fs-commands';
+import { fileSystemNodeInitialState } from '../../../api';
+/**
+ * Factory function to create a FileSystemAdapter
+ */
+export function createFileSystemAdapter(sliceName) {
+    return new FileSystemAdapter(sliceName);
+}
+/**
+ * FileSystemAdapter - Manages Redux state for virtual filesystem
+ */
+export class FileSystemAdapter {
+    constructor(sliceName) {
+        Object.defineProperty(this, "sliceName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: sliceName
+        });
+        Object.defineProperty(this, "actions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "commandHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reducer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.actions = new FileSystemNodeActions(sliceName);
+        this.commandHandler = new FileSystemCommandHandler();
+        this.reducer = (state = this.getInitialState(), action) => {
+            if (this.actions.isFileSystemNodeAction(action)) {
+                return this.commandHandler.execute(state, action.command);
+            }
+            return state;
+        };
+    }
+    getInitialState() {
+        return { root: { type: 'directory', name: '', children: {}, state: fileSystemNodeInitialState() } };
+    }
+    getActions() {
+        return this.actions;
+    }
+    getReducer(extraReducers) {
+        if (extraReducers === undefined) {
+            return this.reducer;
+        }
+        return (state, action) => this.reducer(extraReducers(state, action), action);
+    }
+    createSelector(fileSystemSelector, path) {
+        const rootSelector = createSelector(fileSystemSelector, fs => fs?.root);
+        const steps = pathSteps(path);
+        if (steps === undefined || steps.length === 0) {
+            return rootSelector;
+        }
+        return steps.reduce((acc, step) => {
+            return createSelector(acc, o => {
+                if (o === undefined || o.type === 'file') {
+                    return o;
+                }
+                else {
+                    return o.children[step];
+                }
+            });
+        }, rootSelector);
+    }
+}
+/**
+ * FileSystemNodeActions - Action creators for filesystem operations
+ */
+export class FileSystemNodeActions {
+    constructor(sliceName) {
+        Object.defineProperty(this, "sliceName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: sliceName
+        });
+        Object.defineProperty(this, "_mkdirType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_setFileType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_removeType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_updateFileContentType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_setFileContentType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_setExtensionStateType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "actionTypeSet", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._mkdirType = `${this.sliceName}/createDirectoryNode`;
+        this._setFileType = `${this.sliceName}/createFileNode`;
+        this._removeType = `${this.sliceName}/removeNode`;
+        this._updateFileContentType = `${this.sliceName}/updateFileContent`;
+        this._setFileContentType = `${this.sliceName}/setFileContent`;
+        this._setExtensionStateType = `${this.sliceName}/setExtensionState`;
+        this.actionTypeSet = new Set([
+            this._mkdirType,
+            this._setFileType,
+            this._removeType,
+            this._updateFileContentType,
+            this._setFileContentType,
+            this._setExtensionStateType
+        ]);
+    }
+    get mkdirType() {
+        return this._mkdirType;
+    }
+    get setFileType() {
+        return this._setFileType;
+    }
+    get removeType() {
+        return this._removeType;
+    }
+    get updateFileContentType() {
+        return this._updateFileContentType;
+    }
+    get setFileContentType() {
+        return this._setFileContentType;
+    }
+    get setExtensionStateType() {
+        return this._setExtensionStateType;
+    }
+    isFileSystemNodeAction(action) {
+        return this.actionTypeSet.has(action.type);
+    }
+    mkdir(path, parents, extensionStates) {
+        return {
+            type: this.mkdirType,
+            command: { name: 'mkdir', path, parents, extensionStates }
+        };
+    }
+    setFile(path, content, schema, params = { override: true, contentIsPresent: true }) {
+        const { override, contentIsPresent, extensionStates } = params;
+        return {
+            type: this.setFileType,
+            command: { name: 'set-file', path, content, schema, override, contentIsPresent, extensionStates }
+        };
+    }
+    updateFileContent(path, contentCommand) {
+        return {
+            type: this.updateFileContentType,
+            command: { name: 'update-file-content', path, contentCommand }
+        };
+    }
+    setFileContent(path, content, fromRemote = false) {
+        return {
+            type: this.setFileContentType,
+            command: { name: 'set-file-content', path, content, fromRemote }
+        };
+    }
+    removeNode(path, recursive) {
+        return {
+            type: this.removeType,
+            command: { name: 'remove', path, recursive }
+        };
+    }
+    setExtensionState(path, key, state) {
+        return {
+            type: this.setExtensionStateType,
+            command: { name: 'set-extension-state', path, key, state }
+        };
+    }
+}

package/dist/impl/fs/core/fs-facade.d.ts

@@ -0,0 +1,37 @@
+import { FileNode, FileSystemNode, FileSystemState, Selector } from '../../../api';
+import { FileSystemAdapter, FileSystemNodeActions } from './fs-adapter';
+import { Path, Pathway, PathwayResolver, RelativePathwayResolver } from '@hamak/shared-utils';
+/**
+ * Selector that returns a FileSystemNode generally the root of the Filesystem Overlay
+ */
+export interface StoreFileSystemOverlaySelector<S> {
+    /**
+     * The key of the overlay
+     */
+    key: string;
+    selector: Selector<S, FileSystemNode | undefined>;
+}
+/**
+ * StoreFileSystemFacade - High-level API for filesystem operations
+ */
+export declare class StoreFileSystemFacade<S = any> {
+    private fileSystemSelector;
+    private adapter;
+    constructor(fileSystemSelector: Selector<S, FileSystemState | undefined>, adapter: FileSystemAdapter);
+    getActions(): FileSystemNodeActions;
+    createSelector(path: string | string[]): Selector<S, FileSystemNode | undefined>;
+    createFileSelector(path: string | string[]): Selector<S, FileNode | undefined>;
+    selectFromRoot(state: S, path?: string[]): FileSystemNode | undefined;
+    selectFileFromRoot(state: S, path?: string[]): FileNode | undefined;
+}
+/**
+ * StoreFileSystemPathwayResolver - Pathway resolver for filesystem state
+ */
+export declare class StoreFileSystemPathwayResolver<S = any> implements PathwayResolver<FileSystemNode> {
+    private state;
+    private fs;
+    constructor(state: S, fs: StoreFileSystemFacade<S>);
+    resolve(path: string | string[] | Pathway): FileSystemNode | undefined;
+    relativeTo(path: Path): RelativePathwayResolver<FileSystemNode>;
+}
+//# sourceMappingURL=fs-facade.d.ts.map

package/dist/impl/fs/core/fs-facade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-facade.d.ts","sourceRoot":"","sources":["../../../../src/impl/fs/core/fs-facade.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EACR,cAAc,EACd,eAAe,EACf,QAAQ,EACT,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9F;;GAEG;AACH,MAAM,WAAW,8BAA8B,CAAC,CAAC;IAC/C;;OAEG;IACH,GAAG,EAAG,MAAM,CAAC;IACb,QAAQ,EAAG,QAAQ,CAAC,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC,CAAA;CACnD;AAED;;GAEG;AACH,qBAAa,qBAAqB,CAAC,CAAC,GAAG,GAAG;IAEtC,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,OAAO;gBADP,kBAAkB,EAAE,QAAQ,CAAC,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC,EAC5D,OAAO,EAAG,iBAAiB;IAGrC,UAAU,IAAK,qBAAqB;IAIpC,cAAc,CAAC,IAAI,EAAG,MAAM,GAAG,MAAM,EAAE,GAAI,QAAQ,CAAC,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAIlF,kBAAkB,CAAC,IAAI,EAAG,MAAM,GAAG,MAAM,EAAE,GAAI,QAAQ,CAAC,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAWhF,cAAc,CAAC,KAAK,EAAG,CAAC,EAAE,IAAI,GAAG,MAAM,EAAO,GAAI,cAAc,GAAG,SAAS;IAmB5E,kBAAkB,CAAC,KAAK,EAAG,CAAC,EAAE,IAAI,GAAG,MAAM,EAAO,GAAI,QAAQ,GAAG,SAAS;CAY3E;AAGD;;GAEG;AACH,qBAAa,8BAA8B,CAAC,CAAC,GAAG,GAAG,CAAE,YAAW,eAAe,CAAC,cAAc,CAAC;IACjF,OAAO,CAAC,KAAK;IAAM,OAAO,CAAC,EAAE;gBAArB,KAAK,EAAG,CAAC,EAAU,EAAE,EAAG,qBAAqB,CAAC,CAAC,CAAC;IAGpE,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,GAAG,cAAc,GAAG,SAAS;IAKtE,UAAU,CAAC,IAAI,EAAG,IAAI,GAAI,uBAAuB,CAAC,cAAc,CAAC;CAGlE"}

package/dist/impl/fs/core/fs-facade.js

@@ -0,0 +1,98 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { Pathway, RelativePathwayResolver } from '@hamak/shared-utils';
+/**
+ * StoreFileSystemFacade - High-level API for filesystem operations
+ */
+export class StoreFileSystemFacade {
+    constructor(fileSystemSelector, adapter) {
+        Object.defineProperty(this, "fileSystemSelector", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fileSystemSelector
+        });
+        Object.defineProperty(this, "adapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: adapter
+        });
+    }
+    getActions() {
+        return this.adapter.getActions();
+    }
+    createSelector(path) {
+        return this.adapter.createSelector(this.fileSystemSelector, path);
+    }
+    createFileSelector(path) {
+        const nodeSelector = this.adapter.createSelector(this.fileSystemSelector, path);
+        return createSelector([nodeSelector], (f) => {
+            if (f?.type === 'file') {
+                return f;
+            }
+            else {
+                return undefined;
+            }
+        });
+    }
+    selectFromRoot(state, path = []) {
+        const fileSystemState = this.fileSystemSelector(state);
+        if (fileSystemState === undefined || fileSystemState === null) {
+            return undefined;
+        }
+        else {
+            const root = fileSystemState.root;
+            return (path ?? []).reduce((acc, step) => {
+                if (acc === undefined || acc === null) {
+                    return undefined;
+                }
+                else {
+                    switch (acc.type) {
+                        case "directory": return acc.children[step];
+                        case "file": return undefined;
+                    }
+                }
+            }, root);
+        }
+    }
+    selectFileFromRoot(state, path = []) {
+        const fsNode = this.selectFromRoot(state, path);
+        if (fsNode === undefined) {
+            return undefined;
+        }
+        else {
+            if (fsNode.type === "file") {
+                return fsNode;
+            }
+            else {
+                throw new Error(`Expecting file at path '${Pathway.of(path).toString()}' but got '${fsNode.type}'`);
+            }
+        }
+    }
+}
+/**
+ * StoreFileSystemPathwayResolver - Pathway resolver for filesystem state
+ */
+export class StoreFileSystemPathwayResolver {
+    constructor(state, fs) {
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+        Object.defineProperty(this, "fs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fs
+        });
+    }
+    resolve(path) {
+        const segments = Pathway.of(path).getSegments();
+        return this.fs.selectFromRoot(this.state, segments);
+    }
+    relativeTo(path) {
+        return new RelativePathwayResolver(this, path);
+    }
+}

package/dist/impl/fs/index.d.ts

@@ -0,0 +1,8 @@
+export * from './core/fs-adapter';
+export * from './core/fs-facade';
+export * from './commands/fs-commands';
+export * from './commands/structure-commands';
+export { pathSteps, parentPathSteps } from '@hamak/shared-utils';
+export * from './utils/data-updater';
+export * from './utils/deep-equal';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/fs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/fs/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAG9C,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGjE,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}

package/dist/impl/fs/index.js

@@ -0,0 +1,11 @@
+// Core filesystem functionality
+export * from './core/fs-adapter';
+export * from './core/fs-facade';
+// Commands
+export * from './commands/fs-commands';
+export * from './commands/structure-commands';
+// Re-export path utilities from shared-utils for backward compatibility
+export { pathSteps, parentPathSteps } from '@hamak/shared-utils';
+// Utilities
+export * from './utils/data-updater';
+export * from './utils/deep-equal';

package/dist/impl/fs/utils/data-updater.d.ts

@@ -0,0 +1,36 @@
+import { Itinerary, StackElement } from '@hamak/shared-utils';
+import { UnitaryStructureNodeCommand, BatchUpdateStructureNodeCommand } from '../commands/structure-commands';
+/**
+ * DataUpdater class handles operations on data structures using itineraries
+ */
+export declare class DataUpdater {
+    /**
+     * Delete a value at the specified itinerary
+     */
+    executeDelete(data: any, itinerary: Itinerary | undefined): void;
+    /**
+     * Set a value at the specified itinerary
+     */
+    executeSet(data: any, itinerary: Itinerary | undefined, value: any, prototypeToParent?: StackElement<any>): void;
+    /**
+     * Add a value at the specified itinerary
+     */
+    executeAdd(data: any, itinerary: Itinerary | undefined, value: any, prototypeToParent?: StackElement<any>): void;
+    /**
+     * Insert a value at the specified position
+     */
+    executeInsert(data: any, itinerary: Itinerary, value: any, prototypeToParent?: StackElement<any>): void;
+    /**
+     * 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: UnitaryStructureNodeCommand, pendingCmd: UnitaryStructureNodeCommand): UnitaryStructureNodeCommand | null;
+    /**
+     * 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: any, command: BatchUpdateStructureNodeCommand): void;
+}
+//# sourceMappingURL=data-updater.d.ts.map

package/dist/impl/fs/utils/data-updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-updater.d.ts","sourceRoot":"","sources":["../../../../src/impl/fs/utils/data-updater.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,YAAY,EAKb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,2BAA2B,EAC3B,+BAA+B,EAChC,MAAM,gCAAgC,CAAC;AAyBxC;;GAEG;AACH,qBAAa,WAAW;IAEtB;;OAEG;IACI,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS;IA8BhE;;OAEG;IACI,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,iBAAiB,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC;IA+BhH;;OAEG;IACI,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,iBAAiB,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC;IAahH;;OAEG;IACI,aAAa,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,iBAAiB,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC;IAkBvG;;;;OAIG;IACI,sBAAsB,CAC3B,WAAW,EAAE,2BAA2B,EACxC,UAAU,EAAE,2BAA2B,GACtC,2BAA2B,GAAG,IAAI;IAqFrC;;;;OAIG;IACI,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,+BAA+B,GAAG,IAAI;CA4B/E"}

package/dist/impl/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/impl/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/impl/fs/utils/deep-equal.d.ts.map

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