@hamak/ui-store-impl 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## 0.4.0 (2025-11-10)
+
+### 🚀 Features
+
+- implement notification plugin with UI and backend components ([c19ffcf](https://github.com/amah/app-framework/commit/c19ffcf))
+- add ES2015 build support and fix TypeScript config for logging packages ([be5e45e](https://github.com/amah/app-framework/commit/be5e45e))
+- complete logging system build and add optional console interception ([f390bc6](https://github.com/amah/app-framework/commit/f390bc6))
+- implement core pluggable logging system (Phase 1) ([2abdc1a](https://github.com/amah/app-framework/commit/2abdc1a))
+
+### 🩹 Fixes
+
+- add notification packages to workspaces ([97a234d](https://github.com/amah/app-framework/commit/97a234d))
+
+### ❤️ Thank You
+
+- Amah
+- Claude
+
 ## 0.3.0 (2025-11-06)
 
 ### 🚀 Features

package/dist/es2015/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 === null || child === void 0 ? void 0 : 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 === null || previousFile === void 0 ? void 0 : 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);
+    }
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Helper class for creating structure node commands
+ */
+export class StructureNodeCommandHelper {
+    addNode(itinerary, value, prototypes) {
+        return { name: 'add-at', itinerary, value, prototypes };
+    }
+    insertNode(itinerary, value, prototypes) {
+        return { name: 'insert-at', itinerary, value, prototypes };
+    }
+    setNode(itinerary, value, prototypes) {
+        return { name: 'set-at', itinerary, value, prototypes };
+    }
+    deleteNode(itinerary) {
+        return { name: 'delete-at', itinerary };
+    }
+    batchUpdate(commands, autoRebase = false) {
+        return { name: 'batch-update', commands, autoRebase };
+    }
+}
+export const structs = new StructureNodeCommandHelper();

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

@@ -0,0 +1,123 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { FileSystemCommandHandler, pathSteps } from '../commands/fs-commands';
+import { fileSystemNodeInitialState } from '@hamak/ui-store-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) {
+        this.sliceName = sliceName;
+        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 === null || fs === void 0 ? void 0 : 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) {
+        this.sliceName = sliceName;
+        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.actionTypeSet = new Set([
+            this._mkdirType,
+            this._setFileType,
+            this._removeType,
+            this._updateFileContentType,
+            this._setFileContentType
+        ]);
+    }
+    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;
+    }
+    isFileSystemNodeAction(action) {
+        return this.actionTypeSet.has(action.type);
+    }
+    mkdir(path, parents) {
+        return {
+            type: this.mkdirType,
+            command: { name: 'mkdir', path, parents }
+        };
+    }
+    setFile(path, content, schema, params = { override: true, contentIsPresent: true }) {
+        const { override, contentIsPresent } = params;
+        return {
+            type: this.setFileType,
+            command: { name: 'set-file', path, content, schema, override, contentIsPresent }
+        };
+    }
+    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 }
+        };
+    }
+}

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

@@ -0,0 +1,78 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { Pathway, RelativePathwayResolver } from '@hamak/navigation-utils';
+/**
+ * StoreFileSystemFacade - High-level API for filesystem operations
+ */
+export class StoreFileSystemFacade {
+    constructor(fileSystemSelector, adapter) {
+        this.fileSystemSelector = fileSystemSelector;
+        this.adapter = 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 === null || f === void 0 ? void 0 : 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 !== null && path !== void 0 ? 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) {
+        this.state = state;
+        this.fs = 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/es2015/fs/index.js

@@ -0,0 +1,9 @@
+// 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';