@hamak/ui-store-impl 0.4.7 → 0.4.16

package/src/extensions/store-extensions.ts

@@ -1,90 +0,0 @@
-/**
- * Store extensions collector
- */
-
-import type {
-  IMiddlewareRegistry,
-  IReducerRegistry,
-  StoreExtensionsRegistry,
-  StorePluginExtensions,
-  StoreMiddlewareExtension,
-} from '@hamak/ui-store-api';
-
-interface StoreExtensionsEntry {
-  source: string;
-  extensions: StorePluginExtensions;
-}
-
-/**
- * Collects middleware and reducer contributions until the store boots
- */
-export class StoreExtensionsCollector implements StoreExtensionsRegistry {
-  private entries: StoreExtensionsEntry[] = [];
-
-  register(source: string, extensions: StorePluginExtensions): void {
-    const hasMiddleware = Boolean(extensions.middleware?.length);
-    const hasReducers = Boolean(extensions.reducers && Object.keys(extensions.reducers).length);
-
-    if (!hasMiddleware && !hasReducers) {
-      return;
-    }
-
-    this.entries.push({
-      source,
-      extensions: {
-        middleware: extensions.middleware,
-        reducers: extensions.reducers,
-      },
-    });
-  }
-
-  /**
-   * Drain collected extensions (used internally by the plugin)
-   */
-  drain(): StoreExtensionsEntry[] {
-    const snapshot = this.entries;
-    this.entries = [];
-    return snapshot;
-  }
-}
-
-function withSourceMetadata(
-  middleware: StoreMiddlewareExtension | undefined,
-  source: string
-): StoreMiddlewareExtension | undefined {
-  if (!middleware) {
-    return undefined;
-  }
-
-  return {
-    plugin: middleware.plugin ?? source,
-    ...middleware,
-  };
-}
-
-export function applyStoreExtensions(
-  collector: StoreExtensionsCollector,
-  middlewareRegistry: IMiddlewareRegistry,
-  reducerRegistry: IReducerRegistry
-): void {
-  const entries = collector.drain();
-
-  entries.forEach(({ source, extensions }) => {
-    extensions.middleware?.forEach((mw) => {
-      const middleware = withSourceMetadata(mw, source);
-      if (middleware) {
-        middlewareRegistry.register(middleware);
-      }
-    });
-
-    if (extensions.reducers) {
-      Object.entries(extensions.reducers).forEach(([key, reducer]) => {
-        reducerRegistry.register(key, reducer);
-      });
-    }
-  });
-}
-
-export function createStoreExtensionsCollector(): StoreExtensionsCollector {
-  return new StoreExtensionsCollector();
-}

package/src/fs/commands/fs-commands.ts

@@ -1,389 +0,0 @@
-import {
-  DirectoryNode,
-  FileNode,
-  FileSystemNode,
-  FileSystemState,
-  FileContentSchema,
-  fileSystemNodeInitialState,
-  FileSystemNodeState
-} from '@hamak/ui-store-api';
-import { Pathway, Holder, pathSteps, parentPathSteps } from '@hamak/shared-utils';
-import { StructureNodeCommand } from './structure-commands';
-import { DataUpdater } from '../utils/data-updater';
-import { produce, current, isDraft, original } from 'immer';
-import { deepEqual } from '../utils/deep-equal';
-
-/**
- * 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
-
-// Re-export path utilities from shared-utils for internal use
-export { pathSteps, parentPathSteps } from '@hamak/shared-utils';
-
-/**
- * Get filesystem node at path
- */
-export function getFileSystemNode(fsNode: FileSystemNode, path : string | string[]) : FileSystemNode | undefined {
-  const steps = pathSteps(path)
-  let result : FileSystemNode | undefined = 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: string) : DirectoryNode{
-  return {
-    type: 'directory',
-    state: fileSystemNodeInitialState(),
-    name: step,
-    children: {}
-  };
-}
-
-/**
- * Create a file node
- */
-function createFileNode(name: string, content : any, schema : FileContentSchema, state : FileSystemNodeState) : FileNode{
-  return {type: 'file', name, content, schema, state};
-}
-
-/**
- * FileSystem command handler - executes filesystem operations
- */
-export class FileSystemCommandHandler {
-  readonly contentCommandHandler = new FileContentCommandHandler()
-
-  execute(state: FileSystemState, command: FileSystemCommand): FileSystemState {
-    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)
-    }
-  }
-
-  private executeMkdir(state: FileSystemState, command : MkdirCommand) : FileSystemState{
-    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
-        }
-      }
-    })
-  }
-
-
-  private executeRemove(state: FileSystemState, command : RemoveCommand) : FileSystemState{
-    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]
-      }
-    })
-  }
-
-  private executeSetFile(state: FileSystemState, command : SetFileCommand) : FileSystemState{
-    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)
-      }
-    })
-  }
-
-
-  private executeContentCommand(state: FileSystemState, command : UpdateFileContentCommand) : FileSystemState{
-    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)
-      }
-
-    })
-  }
-
-
-  private contentMayChange(fileNode: 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))
-      }
-    }
-  }
-
-  private executeSetContentCommand(state: FileSystemState, command : SetFileContentCommand) : FileSystemState{
-    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)
-      }
-
-    })
-  }
-
-  protected current<T = any>(o : T):T{
-    if(o === null || o === undefined){
-      return o
-    }
-
-    return isDraft(o) ? current(o) : o
-  }
-
-  protected original<T = any>(o : T):T | undefined{
-    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 {
-  readonly updater = new DataUpdater()
-
-  execute(file : FileNode, command: StructureNodeCommand) {
-    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
-    }
-  }
-
-  private executeDelete(file : FileNode, command: any) {
-    const {itinerary} = command
-    if (itinerary === undefined) {
-      file.content = undefined
-    }
-
-    const {content} = file
-    this.updater.executeDelete(content, itinerary)
-  }
-
-  private executeSet(file : FileNode, command: any) {
-    const {itinerary, value} = command
-    if (itinerary === undefined) {
-      file.content = value
-    }
-
-    const {content} = file
-    this.updater.executeSet(content, itinerary, value)
-  }
-
-  private executeAdd(file: FileNode, command: any) {
-    const {itinerary, value} = command
-
-    const {content} = file
-    this.updater.executeAdd(content, itinerary, value)
-  }
-
-  private executeInsert(file: FileNode, command: any) {
-    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.
-   */
-  public executeBatch(file: FileNode, command: any): void {
-    const { content } = file;
-    this.updater.executeBatch(content, command);
-  }
-
-}

package/src/fs/commands/structure-commands.ts

@@ -1,105 +0,0 @@
-import { Itinerary, StackElement } from '@hamak/shared-utils';
-
-/**
- * Base interface for structure node commands
- */
-export interface StructureNodeCommandBase {
-  name: "add-at" | "set-at" | "delete-at" | 'insert-at' | "batch-update"
-}
-
-/**
- * Base interface for unitary (single operation) commands
- */
-export interface UnitaryStructureNodeCommandBase extends StructureNodeCommandBase {
-  name: "add-at" | "set-at" | "delete-at" | 'insert-at'
-  itinerary: Itinerary
-}
-
-/**
- * Base interface for commands that insert/update values
- */
-export interface StructureNodeUpsertCommandBase extends UnitaryStructureNodeCommandBase{
-  name: "add-at" | "set-at" | 'insert-at'
-  prototypes? : StackElement<any>
-}
-
-/**
- * Add a value at the specified itinerary
- */
-export interface AddStructureNodeCommand extends StructureNodeUpsertCommandBase {
-  name: "add-at"
-  value: any
-}
-
-/**
- * Insert a value at the specified position
- */
-export interface InsertStructureNodeCommand extends StructureNodeUpsertCommandBase {
-  name: "insert-at"
-  value: any
-}
-
-/**
- * Set a value at the specified itinerary
- */
-export interface SetStructureNodeCommand extends StructureNodeUpsertCommandBase {
-  name: "set-at"
-  value: any
-}
-
-/**
- * Delete a value at the specified itinerary
- */
-export interface DeleteStructureNodeCommand extends UnitaryStructureNodeCommandBase {
-  name: "delete-at"
-}
-
-/**
- * Batch update multiple operations
- */
-export interface BatchUpdateStructureNodeCommand extends StructureNodeCommandBase {
-  name: "batch-update"
-  autoRebase?: boolean
-  commands: UnitaryStructureNodeCommand[]
-}
-
-/**
- * Union type for unitary structure node commands
- */
-export type UnitaryStructureNodeCommand =
-  | AddStructureNodeCommand
-  | InsertStructureNodeCommand
-  | SetStructureNodeCommand
-  | DeleteStructureNodeCommand
-
-/**
- * Union type for all structure node commands
- */
-export type StructureNodeCommand = UnitaryStructureNodeCommand | BatchUpdateStructureNodeCommand
-
-/**
- * Helper class for creating structure node commands
- */
-export class StructureNodeCommandHelper {
-  addNode(itinerary : Itinerary, value : any, prototypes?: StackElement<any>) : AddStructureNodeCommand{
-    return {name:'add-at', itinerary, value, prototypes}
-  }
-
-  insertNode(itinerary : Itinerary, value : any, prototypes?: StackElement<any>) : InsertStructureNodeCommand{
-    return {name:'insert-at', itinerary, value, prototypes}
-  }
-
-  setNode(itinerary : Itinerary, value : any, prototypes?: StackElement<any>) : SetStructureNodeCommand{
-    return {name:'set-at', itinerary, value, prototypes}
-  }
-
-  deleteNode(itinerary : Itinerary) : DeleteStructureNodeCommand{
-    return {name:'delete-at', itinerary}
-  }
-
-  batchUpdate(commands : UnitaryStructureNodeCommand[], autoRebase = false) : BatchUpdateStructureNodeCommand{
-    return {name:'batch-update', commands, autoRebase}
-  }
-}
-
-export const structs = new StructureNodeCommandHelper()