@hamak/ui-store-impl 0.3.0 → 0.4.1

package/src/fs/core/fs-facade.ts

@@ -0,0 +1,100 @@
+import { createSelector } from '@reduxjs/toolkit';
+import {
+  DirectoryNode,
+  FileNode,
+  FileSystemNode,
+  FileSystemState,
+  Selector
+} from '@hamak/ui-store-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 class StoreFileSystemFacade<S = any> {
+  constructor(
+    private fileSystemSelector: Selector<S, FileSystemState | undefined>,
+    private adapter : FileSystemAdapter
+  ) {}
+
+  getActions() : FileSystemNodeActions {
+    return this.adapter.getActions()
+  }
+
+  createSelector(path : string | string[]) : Selector<S, FileSystemNode | undefined>{
+    return this.adapter.createSelector(this.fileSystemSelector, path)
+  }
+
+  createFileSelector(path : string | string[]) : Selector<S, FileNode | undefined>{
+    const nodeSelector = this.adapter.createSelector(this.fileSystemSelector, path)
+    return createSelector([nodeSelector], (f: FileSystemNode | undefined) => {
+      if(f?.type === 'file'){
+        return f as FileNode
+      }else {
+        return undefined
+      }
+    })
+  }
+
+  selectFromRoot(state : S, path : string[] = []) : FileSystemNode | undefined {
+    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 as FileSystemNode | undefined)
+    }
+  }
+
+  selectFileFromRoot(state : S, path : string[] = []) : FileNode | undefined {
+    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<S = any> implements PathwayResolver<FileSystemNode> {
+  constructor(private state : S, private fs : StoreFileSystemFacade<S>) {
+  }
+
+  resolve(path: string | string[] | Pathway): FileSystemNode | undefined {
+    const segments = Pathway.of(path).getSegments()
+    return this.fs.selectFromRoot(this.state, segments)
+  }
+
+  relativeTo(path : Path) : RelativePathwayResolver<FileSystemNode> {
+    return new RelativePathwayResolver<FileSystemNode>(this, path)
+  }
+}

package/src/fs/index.ts

@@ -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';
+
+// Utilities
+export * from './utils/data-updater';
+export * from './utils/deep-equal';

package/src/fs/utils/data-updater.ts

@@ -0,0 +1,273 @@
+import { isDraft, original } from 'immer';
+import {
+  Itinerary,
+  StackElement,
+  navigate,
+  ensurePath,
+  areSameItineraryStep,
+  ItineraryStep
+} from '@hamak/shared-utils';
+import {
+  UnitaryStructureNodeCommand,
+  BatchUpdateStructureNodeCommand
+} from '../commands/structure-commands';
+
+/**
+ * Type guard for checking if a value is an object
+ */
+function isObject(o: any): o is Record<any, any> {
+  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: any): o is Array<any> {
+  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
+   */
+  public executeDelete(data: any, itinerary: Itinerary | undefined) {
+    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
+   */
+  public executeSet(data: any, itinerary: Itinerary | undefined, value: any, prototypeToParent?: StackElement<any>) {
+    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
+   */
+  public executeAdd(data: any, itinerary: Itinerary | undefined, value: any, prototypeToParent?: StackElement<any>) {
+    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
+   */
+  public executeInsert(data: any, itinerary: Itinerary, value: any, prototypeToParent?: StackElement<any>) {
+    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.
+   */
+  public rebasePendingCommandOn(
+    alteringCmd: UnitaryStructureNodeCommand,
+    pendingCmd: UnitaryStructureNodeCommand
+  ): UnitaryStructureNodeCommand | null {
+    // Convert itinerary stack to array (root to leaf)
+    function itineraryToArray(it: Itinerary | undefined): ItineraryStep[] {
+      const arr: ItineraryStep[] = [];
+      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: ItineraryStep[]): Itinerary {
+      // Assumes arr.length > 0
+      let it: Itinerary = { 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: ItineraryStep,
+      alteringCmd: UnitaryStructureNodeCommand,
+      pendingStep: ItineraryStep
+    ): ItineraryStep {
+      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
+   */
+  public executeBatch(data: any, command: BatchUpdateStructureNodeCommand): void {
+    const {commands} = command
+    const applied: UnitaryStructureNodeCommand[] = [];
+    for (let i = 0; i < commands.length; i++) {
+      let rebased: UnitaryStructureNodeCommand | null = 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/src/fs/utils/deep-equal.ts

@@ -0,0 +1,35 @@
+/**
+ * Deep equality check for objects and arrays
+ */
+export function deepEqual(obj1: any, obj2: any): boolean {
+  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/src/index.ts

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