@hamak/ui-store-impl 0.3.0 → 0.4.0

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

@@ -0,0 +1,244 @@
+import { isDraft, original } from 'immer';
+import { navigate, ensurePath, areSameItineraryStep } from '@hamak/navigation-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
+                ? Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, 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/es2015/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/es2015/index.js

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

package/dist/fs/commands/fs-commands.d.ts

@@ -0,0 +1,96 @@
+import { FileNode, FileSystemNode, FileSystemState, FileContentSchema } from '@hamak/ui-store-api';
+import { StructureNodeCommand } from './structure-commands';
+import { DataUpdater } from '../utils/data-updater';
+/**
+ * Base interface for filesystem commands
+ */
+export interface FsCommandBase {
+    name: 'mkdir' | 'set-file' | 'remove' | 'update-file-content' | 'set-file-content';
+    path: string | string[];
+}
+/**
+ * Create directory command
+ */
+export interface MkdirCommand extends FsCommandBase {
+    name: 'mkdir';
+    parents?: boolean;
+}
+/**
+ * Remove file or directory command
+ */
+export interface RemoveCommand extends FsCommandBase {
+    name: 'remove';
+    recursive?: boolean;
+}
+/**
+ * Set file command (create or update)
+ */
+export interface SetFileCommand extends FsCommandBase {
+    name: 'set-file';
+    content: any;
+    schema: FileContentSchema;
+    override?: boolean;
+    contentIsPresent?: boolean;
+}
+/**
+ * Update file content with structure command
+ */
+export interface UpdateFileContentCommand extends FsCommandBase {
+    name: 'update-file-content';
+    contentCommand: StructureNodeCommand;
+}
+/**
+ * Set file content directly
+ */
+export interface SetFileContentCommand extends FsCommandBase {
+    name: 'set-file-content';
+    content: any;
+    fromRemote?: boolean;
+}
+/**
+ * Union type for all filesystem commands
+ */
+export type FileSystemCommand = MkdirCommand | RemoveCommand | SetFileCommand | UpdateFileContentCommand | SetFileContentCommand;
+/**
+ * Convert path to steps array
+ */
+export declare function pathSteps(path: string | string[]): string[];
+/**
+ * Get parent path steps
+ */
+export declare function parentPathSteps(path: string | string[]): string[];
+/**
+ * Get filesystem node at path
+ */
+export declare function getFileSystemNode(fsNode: FileSystemNode, path: string | string[]): FileSystemNode | undefined;
+/**
+ * FileSystem command handler - executes filesystem operations
+ */
+export declare class FileSystemCommandHandler {
+    readonly contentCommandHandler: FileContentCommandHandler;
+    execute(state: FileSystemState, command: FileSystemCommand): FileSystemState;
+    private executeMkdir;
+    private executeRemove;
+    private executeSetFile;
+    private executeContentCommand;
+    private contentMayChange;
+    private executeSetContentCommand;
+    protected current<T = any>(o: T): T;
+    protected original<T = any>(o: T): T | undefined;
+}
+/**
+ * File content command handler - handles structure commands on file content
+ */
+export declare class FileContentCommandHandler {
+    readonly updater: DataUpdater;
+    execute(file: FileNode, command: StructureNodeCommand): void;
+    private executeDelete;
+    private executeSet;
+    private executeAdd;
+    private executeInsert;
+    /**
+     * Executes a batch of commands, rebasing each on previous mutations.
+     */
+    executeBatch(file: FileNode, command: any): void;
+}
+//# sourceMappingURL=fs-commands.d.ts.map

package/dist/fs/commands/fs-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-commands.d.ts","sourceRoot":"","sources":["../../../src/fs/commands/fs-commands.ts"],"names":[],"mappings":"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"}

package/dist/fs/commands/fs-commands.js

@@ -0,0 +1,311 @@
+import { fileSystemNodeInitialState } from '@hamak/ui-store-api';
+import { DataUpdater } from '../utils/data-updater';
+import { produce, current, isDraft, original } from 'immer';
+import { deepEqual } from '../utils/deep-equal';
+/**
+ * Convert path to steps array
+ */
+export function pathSteps(path) {
+    if (Array.isArray(path)) {
+        return path;
+    }
+    return path.split('/').filter(s => s.trim().length > 0);
+}
+/**
+ * Get parent path steps
+ */
+export function parentPathSteps(path) {
+    const steps = pathSteps(path);
+    return steps.length > 0 ? steps.slice(0, steps.length - 1) : steps;
+}
+/**
+ * Get filesystem node at path
+ */
+export function getFileSystemNode(fsNode, path) {
+    const steps = pathSteps(path);
+    let result = fsNode;
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        if (result === undefined) {
+            return undefined;
+        }
+        else if (result.type === 'directory') {
+            result = result.children[step];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return result;
+}
+/**
+ * Create a directory node
+ */
+function createDirectoryNode(step) {
+    return {
+        type: 'directory',
+        state: fileSystemNodeInitialState(),
+        name: step,
+        children: {}
+    };
+}
+/**
+ * Create a file node
+ */
+function createFileNode(name, content, schema, state) {
+    return { type: 'file', name, content, schema, state };
+}
+/**
+ * FileSystem command handler - executes filesystem operations
+ */
+export class FileSystemCommandHandler {
+    constructor() {
+        this.contentCommandHandler = new FileContentCommandHandler();
+    }
+    execute(state, command) {
+        switch (command.name) {
+            case 'mkdir': return this.executeMkdir(state, command);
+            case 'set-file': return this.executeSetFile(state, command);
+            case 'update-file-content': return this.executeContentCommand(state, command);
+            case 'set-file-content': return this.executeSetContentCommand(state, command);
+            case 'remove': return this.executeRemove(state, command);
+        }
+    }
+    executeMkdir(state, command) {
+        const { path, parents } = command;
+        const steps = pathSteps(path);
+        return produce(state, draft => {
+            const { root } = draft;
+            let dir = root;
+            for (let i = 0; i < steps.length; i++) {
+                const step = steps[i];
+                if (i + 1 === steps.length) {
+                    // Last step is the element to create
+                    if (dir.children[step] === undefined) {
+                        dir.children[step] = createDirectoryNode(step);
+                    }
+                }
+                else {
+                    let child = dir.children[step];
+                    if (child === undefined) {
+                        if (parents === true) {
+                            child = createDirectoryNode(step);
+                            dir.children[step] = child;
+                        }
+                        else {
+                            return;
+                        }
+                    }
+                    else if (child.type === 'directory') {
+                        dir = child;
+                    }
+                    else {
+                        return;
+                    }
+                    dir = child;
+                }
+            }
+        });
+    }
+    executeRemove(state, command) {
+        const { path, recursive } = command;
+        const steps = pathSteps(path);
+        return produce(state, draft => {
+            const { root } = draft;
+            const parentDir = getFileSystemNode(root, steps.slice(0, steps.length - 1));
+            if (parentDir === undefined) {
+                return;
+            }
+            if (parentDir.type === 'directory') {
+                const last = steps[steps.length - 1];
+                const child = parentDir.children[last];
+                if (child?.type === 'directory'
+                    && Object.keys(child.children).length > 0
+                    && !(recursive === true)) {
+                    return;
+                }
+                delete parentDir.children[last];
+            }
+        });
+    }
+    executeSetFile(state, command) {
+        const { path, content, schema, override, contentIsPresent } = command;
+        const steps = pathSteps(path);
+        return produce(state, draft => {
+            const { root } = draft;
+            const parentPath = steps.slice(0, steps.length - 1);
+            const parentDir = getFileSystemNode(root, parentPath);
+            if (parentDir === undefined) {
+                return;
+            }
+            if (parentDir.type === 'directory') {
+                const last = steps[steps.length - 1];
+                const child = parentDir.children[last];
+                if (child === undefined || override === true) {
+                    parentDir.children[last] = createFileNode(last, content, schema, fileSystemNodeInitialState(contentIsPresent));
+                }
+                else {
+                    console.warn(`File already exists at location`, path);
+                }
+            }
+            else {
+                console.warn(`Parent file is not directory`, parentPath);
+            }
+        });
+    }
+    executeContentCommand(state, command) {
+        const { path, contentCommand } = command;
+        return produce(state, draft => {
+            const { root } = draft;
+            const fileNode = getFileSystemNode(root, path);
+            if (fileNode !== undefined) {
+                if (fileNode.type === 'file') {
+                    this.contentCommandHandler.execute(fileNode, contentCommand);
+                    const previousFile = getFileSystemNode(state.root, path);
+                    const previousContent = previousFile?.type === "file" ? previousFile.content : undefined;
+                    this.contentMayChange(fileNode);
+                }
+                else {
+                    console.warn(`Not a file at location`, path);
+                }
+            }
+            else {
+                console.warn(`No file found at location`, path);
+            }
+        });
+    }
+    contentMayChange(fileNode) {
+        const changed = !deepEqual(this.original(fileNode.content), this.current(fileNode.content));
+        if (changed) {
+            if (fileNode.state === undefined) {
+                fileNode.state = fileSystemNodeInitialState();
+            }
+            fileNode.state.contentHistory.push(this.original(fileNode.content));
+            // check compared to memo modification status
+            if (fileNode.state.memo !== undefined) {
+                const memo = fileNode.state.memo;
+                memo.modified = !deepEqual(this.current(memo.originalContent), this.current(fileNode.content));
+            }
+        }
+    }
+    executeSetContentCommand(state, command) {
+        const { path, content, fromRemote } = command;
+        return produce(state, draft => {
+            const { root } = draft;
+            const fileNode = getFileSystemNode(root, path);
+            if (fileNode !== undefined) {
+                if (fileNode.type === 'file') {
+                    fileNode.content = content;
+                    if (fileNode.state === undefined) {
+                        fileNode.state = fileSystemNodeInitialState(true);
+                    }
+                    if (fromRemote) {
+                        fileNode.state.contentLoaded = true;
+                        if (fileNode.state.memo === undefined) {
+                            fileNode.state.memo = { originalContent: { value: content }, modified: false };
+                        }
+                        else {
+                            const memo = fileNode.state.memo;
+                            memo.originalContent = { value: content };
+                            memo.modified = false;
+                        }
+                    }
+                    else {
+                        this.contentMayChange(fileNode);
+                    }
+                }
+                else {
+                    console.warn(`Not a file at location`, path);
+                }
+            }
+            else {
+                console.warn(`No file found at location`, path);
+            }
+        });
+    }
+    current(o) {
+        if (o === null || o === undefined) {
+            return o;
+        }
+        return isDraft(o) ? current(o) : o;
+    }
+    original(o) {
+        if (o === null || o === undefined) {
+            return o;
+        }
+        return isDraft(o) ? original(o) : o;
+    }
+}
+/**
+ * File content command handler - handles structure commands on file content
+ */
+export class FileContentCommandHandler {
+    constructor() {
+        this.updater = new DataUpdater();
+    }
+    execute(file, command) {
+        switch (command.name) {
+            case 'add-at':
+                {
+                    this.executeAdd(file, command);
+                }
+                break;
+            case 'insert-at':
+                {
+                    this.executeInsert(file, command);
+                }
+                break;
+            case 'set-at':
+                {
+                    this.executeSet(file, command);
+                }
+                break;
+            case 'delete-at':
+                {
+                    this.executeDelete(file, command);
+                }
+                break;
+            case 'batch-update':
+                {
+                    this.executeBatch(file, command);
+                }
+                break;
+        }
+    }
+    executeDelete(file, command) {
+        const { itinerary } = command;
+        if (itinerary === undefined) {
+            file.content = undefined;
+        }
+        const { content } = file;
+        this.updater.executeDelete(content, itinerary);
+    }
+    executeSet(file, command) {
+        const { itinerary, value } = command;
+        if (itinerary === undefined) {
+            file.content = value;
+        }
+        const { content } = file;
+        this.updater.executeSet(content, itinerary, value);
+    }
+    executeAdd(file, command) {
+        const { itinerary, value } = command;
+        const { content } = file;
+        this.updater.executeAdd(content, itinerary, value);
+    }
+    executeInsert(file, command) {
+        const { itinerary, value } = command;
+        if (itinerary === undefined) {
+            return;
+        }
+        const { content } = file;
+        this.updater.executeInsert(content, itinerary, value);
+    }
+    /**
+     * Executes a batch of commands, rebasing each on previous mutations.
+     */
+    executeBatch(file, command) {
+        const { content } = file;
+        this.updater.executeBatch(content, command);
+    }
+}