@hamak/ui-store-impl 0.4.16 → 0.5.0

package/dist/autosave/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/autosave/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC"}

package/dist/autosave/index.js

@@ -0,0 +1,7 @@
+/**
+ * Autosave Implementation
+ */
+export * from './autosave-registry';
+export * from './autosave-config-resolver';
+export * from './autosave-middleware';
+export * from './autosave-sync-middleware';

package/dist/core/store-manager.d.ts

@@ -1,7 +1,7 @@
 /**
  * Store Manager Implementation
  */
-import { type Store, type Reducer } from 'redux';
+import { type Store, type Reducer } from '@reduxjs/toolkit';
 import type { IStoreManager, StoreConfig, RootState, AppAction } from '@hamak/ui-store-api';
 import { MiddlewareRegistry } from './middleware-registry';
 import { ReducerRegistry } from './reducer-registry';
@@ -11,9 +11,12 @@ export declare class StoreManager implements IStoreManager {
     private reducerRegistry;
     private initialized;
     private config;
+    private fileSystemAdapter;
     constructor();
     getMiddlewareRegistry(): MiddlewareRegistry;
     getReducerRegistry(): ReducerRegistry;
+    setFileSystemAdapter(adapter: any): void;
+    getFileSystemAdapter(): any;
     isInitialized(): boolean;
     initialize(config?: StoreConfig): Store<RootState, AppAction>;
     getStore(): Store<RootState, AppAction>;

package/dist/core/store-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-manager.d.ts","sourceRoot":"","sources":["../../src/core/store-manager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAyC,KAAK,KAAK,EAAE,KAAK,OAAO,EAAE,MAAM,OAAO,CAAC;AACxF,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC5F,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,MAAM,CAA4B;;IAY1C,qBAAqB;IAIrB,kBAAkB;IAIlB,aAAa,IAAI,OAAO;IAIxB,UAAU,CAAC,MAAM,GAAE,WAAgB,GAAG,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC;IA0DjE,QAAQ,IAAI,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC;IAOvC,QAAQ,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;IAI3C,QAAQ,CAAC,CAAC,GAAG,SAAS,KAAK,CAAC;IAI5B,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAI3C,cAAc,CAAC,WAAW,EAAE,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,IAAI;IAIhE,OAAO,IAAI,IAAI;CAKhB"}
+{"version":3,"file":"store-manager.d.ts","sourceRoot":"","sources":["../../src/core/store-manager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAkB,KAAK,KAAK,EAAE,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC5F,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,MAAM,CAA4B;IAC1C,OAAO,CAAC,iBAAiB,CAAoB;;IAY7C,qBAAqB;IAIrB,kBAAkB;IAIlB,oBAAoB,CAAC,OAAO,EAAE,GAAG;IAIjC,oBAAoB;IAIpB,aAAa,IAAI,OAAO;IAIxB,UAAU,CAAC,MAAM,GAAE,WAAgB,GAAG,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC;IAwDjE,QAAQ,IAAI,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC;IAOvC,QAAQ,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;IAI3C,QAAQ,CAAC,CAAC,GAAG,SAAS,KAAK,CAAC;IAI5B,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAI3C,cAAc,CAAC,WAAW,EAAE,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,IAAI;IAIhE,OAAO,IAAI,IAAI;CAKhB"}

package/dist/core/store-manager.js

@@ -1,7 +1,7 @@
 /**
  * Store Manager Implementation
  */
-import { createStore, applyMiddleware, compose } from 'redux';
+import { configureStore } from '@reduxjs/toolkit';
 import { MiddlewareRegistry } from './middleware-registry';
 import { ReducerRegistry } from './reducer-registry';
 export class StoreManager {
@@ -9,6 +9,7 @@ export class StoreManager {
         this.store = null;
         this.initialized = false;
         this.config = null;
+        this.fileSystemAdapter = null;
         this.middlewareRegistry = new MiddlewareRegistry();
         this.reducerRegistry = new ReducerRegistry((rootReducer) => {
             // Hot replacement callback
@@ -23,6 +24,12 @@ export class StoreManager {
     getReducerRegistry() {
         return this.reducerRegistry;
     }
+    setFileSystemAdapter(adapter) {
+        this.fileSystemAdapter = adapter;
+    }
+    getFileSystemAdapter() {
+        return this.fileSystemAdapter;
+    }
     isInitialized() {
         return this.initialized;
     }
@@ -39,20 +46,26 @@ export class StoreManager {
         const rootReducer = this.reducerRegistry.getCombinedReducer();
         // Create enhancers
         const enhancers = config.enhancers || [];
-        // Setup Redux DevTools
-        let composeEnhancers = compose;
-        if (config.devTools !== false && typeof window !== 'undefined') {
-            const devToolsExtension = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__;
-            if (devToolsExtension) {
-                composeEnhancers = devToolsExtension({
-                    trace: true,
-                    traceLimit: 25,
-                });
-            }
-        }
-        // Create store
-        const enhancer = composeEnhancers(applyMiddleware(...middleware), ...enhancers);
-        this.store = createStore(rootReducer, config.preloadedState, enhancer);
+        // Create store using configureStore (modern Redux Toolkit API)
+        this.store = configureStore({
+            reducer: rootReducer,
+            preloadedState: config.preloadedState,
+            // Use only our custom middleware (disabling Redux Toolkit defaults to maintain exact behavior)
+            middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+                // Disable all default middleware to maintain exact parity with old createStore behavior
+                thunk: false,
+                serializableCheck: false,
+                immutableCheck: false,
+                actionCreatorCheck: false,
+            }).concat(...middleware),
+            // Add custom enhancers if provided
+            enhancers: (getDefaultEnhancers) => getDefaultEnhancers().concat(enhancers),
+            // Configure DevTools with trace support
+            devTools: config.devTools !== false ? {
+                trace: true,
+                traceLimit: 25,
+            } : false,
+        });
         this.initialized = true;
         console.log('[StoreManager] Store initialized with:', {
             reducers: this.reducerRegistry.getAllRegistrations().map(r => r.key),

package/dist/es2015/autosave/autosave-config-resolver.js

@@ -0,0 +1,110 @@
+/**
+ * Autosave Configuration Resolver
+ *
+ * Resolves autosave configuration with hierarchical inheritance.
+ * Configuration priority (highest to lowest):
+ * 1. File node extension state config
+ * 2. Parent folder config (recursive, respects inherit flag)
+ * 3. Default config
+ */
+import { AUTOSAVE_EXTENSION_KEY, DEFAULT_AUTOSAVE_CONFIG, } from '@hamak/ui-store-api';
+/**
+ * Get autosave extension state from a node
+ */
+export function getAutosaveExtensionState(node) {
+    var _a;
+    if (!((_a = node === null || node === void 0 ? void 0 : node.state) === null || _a === void 0 ? void 0 : _a.extensionStates)) {
+        return undefined;
+    }
+    return node.state.extensionStates[AUTOSAVE_EXTENSION_KEY];
+}
+/**
+ * Get autosave config from a node's extension state
+ */
+export function getAutosaveConfig(node) {
+    var _a;
+    return (_a = getAutosaveExtensionState(node)) === null || _a === void 0 ? void 0 : _a.config;
+}
+/**
+ * Resolve autosave configuration for a path with inheritance
+ *
+ * @param root - Root directory node
+ * @param path - Path segments to the target node
+ * @param defaultConfig - Default configuration to use if none found
+ * @returns Resolved configuration
+ */
+export function resolveAutosaveConfig(root, path, defaultConfig = DEFAULT_AUTOSAVE_CONFIG) {
+    const configs = [];
+    // Walk down the path, collecting configs
+    let currentNode = root;
+    for (let i = 0; i <= path.length; i++) {
+        if (!currentNode)
+            break;
+        const config = getAutosaveConfig(currentNode);
+        if (config) {
+            configs.push(config);
+            // If inherit is false, stop here
+            if (config.inherit === false) {
+                break;
+            }
+        }
+        // Move to next segment
+        if (i < path.length && currentNode.type === 'directory') {
+            currentNode = currentNode.children[path[i]];
+        }
+    }
+    // Merge configs from root to target (later configs override earlier)
+    // Start with default, then apply each config in order
+    let result = Object.assign({}, defaultConfig);
+    for (const config of configs) {
+        result = mergeConfigs(result, config);
+    }
+    return result;
+}
+/**
+ * Merge two autosave configs (source overrides target for defined values)
+ */
+function mergeConfigs(target, source) {
+    var _a, _b, _c, _d, _e, _f;
+    return {
+        enabled: source.enabled,
+        debounceMs: (_a = source.debounceMs) !== null && _a !== void 0 ? _a : target.debounceMs,
+        maxWaitMs: (_b = source.maxWaitMs) !== null && _b !== void 0 ? _b : target.maxWaitMs,
+        saveOnBlur: (_c = source.saveOnBlur) !== null && _c !== void 0 ? _c : target.saveOnBlur,
+        retryOnFailure: (_d = source.retryOnFailure) !== null && _d !== void 0 ? _d : target.retryOnFailure,
+        maxRetries: (_e = source.maxRetries) !== null && _e !== void 0 ? _e : target.maxRetries,
+        inherit: (_f = source.inherit) !== null && _f !== void 0 ? _f : target.inherit,
+    };
+}
+/**
+ * Check if autosave is effectively enabled for a path
+ */
+export function isAutosaveEnabled(root, path, defaultConfig) {
+    const config = resolveAutosaveConfig(root, path, defaultConfig);
+    return config.enabled;
+}
+/**
+ * Get node at path
+ */
+export function getNodeAtPath(root, path) {
+    let current = root;
+    for (const segment of path) {
+        if (!current || current.type !== 'directory') {
+            return undefined;
+        }
+        current = current.children[segment];
+    }
+    return current;
+}
+/**
+ * Convert path array to string key
+ */
+export function pathToKey(path) {
+    return path.join('/');
+}
+/**
+ * Convert string key back to path array
+ */
+export function keyToPath(key) {
+    return key === '' ? [] : key.split('/');
+}

package/dist/es2015/autosave/autosave-middleware.js

@@ -0,0 +1,311 @@
+/**
+ * Autosave Middleware
+ *
+ * Core middleware that orchestrates autosave operations:
+ * 1. Detects file content changes
+ * 2. Manages debounce timers per file
+ * 3. Delegates save operations to registered providers
+ * 4. Handles retries on failure
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AutosaveActionTypes, autosaveActions, DEFAULT_AUTOSAVE_CONFIG, } from '@hamak/ui-store-api';
+import { resolveAutosaveConfig, getNodeAtPath, pathToKey, } from './autosave-config-resolver';
+/**
+ * Content change action types to monitor
+ */
+const CONTENT_CHANGE_ACTION_TYPES = [
+    'set-file-content',
+    'update-file-content',
+];
+/**
+ * Check if an action is a content change action
+ */
+function isContentChangeAction(action) {
+    // Check for filesystem command actions
+    if (action.type === '@@fs/COMMAND' && action.command) {
+        return CONTENT_CHANGE_ACTION_TYPES.includes(action.command.name);
+    }
+    // Check for direct content change actions from fs-adapter
+    if (typeof action.type === 'string') {
+        const type = action.type.toLowerCase();
+        return (type.includes('setfilecontent') ||
+            type.includes('updatefilecontent') ||
+            type.includes('set_file_content') ||
+            type.includes('update_file_content'));
+    }
+    return false;
+}
+/**
+ * Check if content change is from remote (should not trigger autosave)
+ */
+function isFromRemote(action) {
+    var _a, _b;
+    if (((_a = action.command) === null || _a === void 0 ? void 0 : _a.fromRemote) === true) {
+        return true;
+    }
+    if (((_b = action.payload) === null || _b === void 0 ? void 0 : _b.fromRemote) === true) {
+        return true;
+    }
+    if (action.fromRemote === true) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get path from action
+ */
+function getPathFromAction(action) {
+    var _a, _b;
+    // Try command path
+    if ((_a = action.command) === null || _a === void 0 ? void 0 : _a.path) {
+        return Array.isArray(action.command.path)
+            ? action.command.path
+            : [action.command.path];
+    }
+    // Try payload path
+    if ((_b = action.payload) === null || _b === void 0 ? void 0 : _b.path) {
+        return Array.isArray(action.payload.path)
+            ? action.payload.path
+            : [action.payload.path];
+    }
+    // Try direct path
+    if (action.path) {
+        return Array.isArray(action.path) ? action.path : [action.path];
+    }
+    return undefined;
+}
+/**
+ * Create autosave middleware
+ */
+export function createAutosaveMiddleware(config) {
+    const { registry, fsSliceName = 'fileSystem', defaultConfig = {}, onSaveStart, onSaveSuccess, onSaveError, } = config;
+    const mergedDefaultConfig = Object.assign(Object.assign({}, DEFAULT_AUTOSAVE_CONFIG), defaultConfig);
+    // Track pending saves by path key
+    const pendingSaves = new Map();
+    /**
+     * Get filesystem root from state
+     */
+    function getRoot(state) {
+        var _a;
+        return (_a = state[fsSliceName]) === null || _a === void 0 ? void 0 : _a.root;
+    }
+    /**
+     * Clear timers for a path
+     */
+    function clearTimers(pathKey) {
+        const pending = pendingSaves.get(pathKey);
+        if (pending) {
+            clearTimeout(pending.debounceTimer);
+            if (pending.maxWaitTimer) {
+                clearTimeout(pending.maxWaitTimer);
+            }
+        }
+    }
+    /**
+     * Cancel pending save
+     */
+    function cancelPending(pathKey) {
+        clearTimers(pathKey);
+        pendingSaves.delete(pathKey);
+    }
+    /**
+     * Schedule autosave for a path
+     */
+    function scheduleAutosave(store, path, providerId, config) {
+        var _a, _b, _c;
+        const pathKey = pathToKey(path);
+        const now = Date.now();
+        const debounceMs = (_a = config.debounceMs) !== null && _a !== void 0 ? _a : DEFAULT_AUTOSAVE_CONFIG.debounceMs;
+        const maxWaitMs = (_b = config.maxWaitMs) !== null && _b !== void 0 ? _b : DEFAULT_AUTOSAVE_CONFIG.maxWaitMs;
+        // Clear existing debounce timer (but keep max wait if exists)
+        const existing = pendingSaves.get(pathKey);
+        if (existing) {
+            clearTimeout(existing.debounceTimer);
+        }
+        // Create debounce timer
+        const debounceTimer = setTimeout(() => {
+            store.dispatch(autosaveActions.debounceExpired(path));
+        }, debounceMs);
+        // Create max wait timer if not exists
+        let maxWaitTimer = existing === null || existing === void 0 ? void 0 : existing.maxWaitTimer;
+        if (!maxWaitTimer) {
+            maxWaitTimer = setTimeout(() => {
+                store.dispatch(autosaveActions.debounceExpired(path));
+            }, maxWaitMs);
+        }
+        // Store pending save
+        pendingSaves.set(pathKey, {
+            path,
+            providerId,
+            debounceTimer,
+            maxWaitTimer,
+            retryCount: (_c = existing === null || existing === void 0 ? void 0 : existing.retryCount) !== null && _c !== void 0 ? _c : 0,
+            config,
+        });
+        // Dispatch change detected
+        store.dispatch(autosaveActions.changeDetected(path, now, now + debounceMs, providerId));
+    }
+    /**
+     * Execute save operation
+     */
+    function executeSave(store, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const pathKey = pathToKey(path);
+            const pending = pendingSaves.get(pathKey);
+            if (!pending) {
+                return;
+            }
+            // Clear timers
+            clearTimers(pathKey);
+            // Get current state
+            const state = store.getState();
+            const root = getRoot(state);
+            if (!root) {
+                pendingSaves.delete(pathKey);
+                return;
+            }
+            // Get node
+            const node = getNodeAtPath(root, path);
+            if (!node || node.type !== 'file') {
+                pendingSaves.delete(pathKey);
+                return;
+            }
+            // Get provider
+            const provider = registry.get(pending.providerId);
+            if (!provider) {
+                pendingSaves.delete(pathKey);
+                return;
+            }
+            // Dispatch save started
+            store.dispatch(autosaveActions.saveStarted(path, pending.providerId));
+            onSaveStart === null || onSaveStart === void 0 ? void 0 : onSaveStart(path);
+            try {
+                // Execute save via provider
+                const result = yield provider.save(path, node.content, node, store.dispatch);
+                if (result.success) {
+                    // Success
+                    pendingSaves.delete(pathKey);
+                    store.dispatch(autosaveActions.saveSucceeded(path, result.timestamp));
+                    onSaveSuccess === null || onSaveSuccess === void 0 ? void 0 : onSaveSuccess(path, result);
+                }
+                else {
+                    // Provider reported failure
+                    handleSaveFailure(store, path, (_a = result.error) !== null && _a !== void 0 ? _a : { code: 'UNKNOWN', message: 'Save failed' });
+                }
+            }
+            catch (error) {
+                // Exception during save
+                handleSaveFailure(store, path, {
+                    code: (_b = error.code) !== null && _b !== void 0 ? _b : 'ERROR',
+                    message: (_c = error.message) !== null && _c !== void 0 ? _c : 'Unknown error',
+                });
+            }
+        });
+    }
+    /**
+     * Handle save failure with retry logic
+     */
+    function handleSaveFailure(store, path, error) {
+        var _a;
+        const pathKey = pathToKey(path);
+        const pending = pendingSaves.get(pathKey);
+        if (!pending) {
+            return;
+        }
+        const retryCount = pending.retryCount + 1;
+        const maxRetries = (_a = pending.config.maxRetries) !== null && _a !== void 0 ? _a : DEFAULT_AUTOSAVE_CONFIG.maxRetries;
+        const shouldRetry = pending.config.retryOnFailure !== false && retryCount < maxRetries;
+        // Dispatch failure
+        store.dispatch(autosaveActions.saveFailed(path, error, retryCount));
+        onSaveError === null || onSaveError === void 0 ? void 0 : onSaveError(path, error);
+        if (shouldRetry) {
+            // Schedule retry with exponential backoff
+            const retryDelay = Math.min(1000 * Math.pow(2, retryCount - 1), 10000);
+            const retryAt = Date.now() + retryDelay;
+            store.dispatch(autosaveActions.retryScheduled(path, retryAt, retryCount));
+            // Update pending save with retry timer
+            pending.retryCount = retryCount;
+            pending.debounceTimer = setTimeout(() => {
+                executeSave(store, path);
+            }, retryDelay);
+            pendingSaves.set(pathKey, pending);
+        }
+        else {
+            // No more retries
+            pendingSaves.delete(pathKey);
+        }
+    }
+    /**
+     * The middleware
+     */
+    const autosaveMiddleware = (store) => (next) => (action) => {
+        const result = next(action);
+        const typedAction = action;
+        // ─────────────────────────────────────────────────────────────────
+        // Handle content changes
+        // ─────────────────────────────────────────────────────────────────
+        if (isContentChangeAction(typedAction) && !isFromRemote(typedAction)) {
+            const path = getPathFromAction(typedAction);
+            if (path) {
+                const state = store.getState();
+                const root = getRoot(state);
+                if (root) {
+                    // Resolve config
+                    const autosaveConfig = resolveAutosaveConfig(root, path, mergedDefaultConfig);
+                    if (autosaveConfig.enabled) {
+                        // Get node
+                        const node = getNodeAtPath(root, path);
+                        if (node) {
+                            // Find provider
+                            const provider = registry.findProvider(path, node);
+                            if (provider) {
+                                scheduleAutosave(store, path, provider.id, autosaveConfig);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // ─────────────────────────────────────────────────────────────────
+        // Handle autosave actions
+        // ─────────────────────────────────────────────────────────────────
+        switch (typedAction.type) {
+            case AutosaveActionTypes.DEBOUNCE_EXPIRED: {
+                const path = typedAction.payload.path;
+                void executeSave(store, path);
+                break;
+            }
+            case AutosaveActionTypes.FLUSH_PENDING: {
+                const path = typedAction.payload.path;
+                const pathKey = pathToKey(path);
+                if (pendingSaves.has(pathKey)) {
+                    void executeSave(store, path);
+                }
+                break;
+            }
+            case AutosaveActionTypes.FLUSH_ALL_PENDING: {
+                const paths = Array.from(pendingSaves.values()).map((p) => p.path);
+                for (const path of paths) {
+                    void executeSave(store, path);
+                }
+                break;
+            }
+            case AutosaveActionTypes.CANCEL_PENDING: {
+                const path = typedAction.payload.path;
+                cancelPending(pathToKey(path));
+                break;
+            }
+        }
+        return result;
+    };
+    return autosaveMiddleware;
+}

package/dist/es2015/autosave/autosave-registry.js

@@ -0,0 +1,33 @@
+/**
+ * Autosave Provider Registry Implementation
+ */
+export class AutosaveProviderRegistry {
+    constructor() {
+        this.providers = new Map();
+    }
+    register(provider) {
+        if (this.providers.has(provider.id)) {
+            console.warn(`[AutosaveRegistry] Provider "${provider.id}" already registered, overwriting.`);
+        }
+        this.providers.set(provider.id, provider);
+    }
+    unregister(providerId) {
+        this.providers.delete(providerId);
+    }
+    get(providerId) {
+        return this.providers.get(providerId);
+    }
+    findProvider(path, node) {
+        // Get all providers that support this path, sorted by priority (descending)
+        const supportingProviders = Array.from(this.providers.values())
+            .filter((provider) => provider.supports(path, node))
+            .sort((a, b) => { var _a, _b; return ((_a = b.priority) !== null && _a !== void 0 ? _a : 0) - ((_b = a.priority) !== null && _b !== void 0 ? _b : 0); });
+        return supportingProviders[0];
+    }
+    getAll() {
+        return Array.from(this.providers.values());
+    }
+    has(providerId) {
+        return this.providers.has(providerId);
+    }
+}

package/dist/es2015/autosave/autosave-sync-middleware.js

@@ -0,0 +1,98 @@
+/**
+ * Autosave Sync Middleware
+ *
+ * Updates FileSystemNode extension states based on autosave lifecycle actions.
+ * This middleware runs after the main autosave middleware and updates the
+ * state so components can display autosave status.
+ */
+import { AutosaveActionTypes, autosaveActions, } from '@hamak/ui-store-api';
+/**
+ * Create autosave sync middleware
+ */
+export function createAutosaveSyncMiddleware(config) {
+    const { updateExtensionState } = config;
+    const autosaveSyncMiddleware = (store) => (next) => (action) => {
+        const result = next(action);
+        const typedAction = action;
+        // Only process autosave actions
+        if (!autosaveActions.isAutosaveAction(typedAction)) {
+            return result;
+        }
+        const dispatch = store.dispatch;
+        switch (typedAction.type) {
+            case AutosaveActionTypes.SET_CONFIG: {
+                const { path, config: autosaveConfig } = typedAction.payload;
+                dispatch(updateExtensionState(path, {
+                    config: autosaveConfig,
+                    effectivelyEnabled: autosaveConfig.enabled,
+                    status: autosaveConfig.enabled ? 'idle' : 'disabled',
+                }));
+                break;
+            }
+            case AutosaveActionTypes.CLEAR_CONFIG: {
+                const { path } = typedAction.payload;
+                dispatch(updateExtensionState(path, {
+                    config: undefined,
+                    // Status will be recomputed based on parent config
+                }));
+                break;
+            }
+            case AutosaveActionTypes.CHANGE_DETECTED: {
+                const { path, detectedAt, providerId } = typedAction.payload;
+                dispatch(updateExtensionState(path, {
+                    status: 'pending',
+                    pendingSince: detectedAt,
+                    providerId,
+                }));
+                break;
+            }
+            case AutosaveActionTypes.SAVE_STARTED: {
+                const { path, providerId } = typedAction.payload;
+                dispatch(updateExtensionState(path, {
+                    status: 'saving',
+                    lastSaveAttempt: Date.now(),
+                    providerId,
+                }));
+                break;
+            }
+            case AutosaveActionTypes.SAVE_SUCCEEDED: {
+                const { path, timestamp } = typedAction.payload;
+                dispatch(updateExtensionState(path, {
+                    status: 'idle',
+                    lastSaveSuccess: timestamp,
+                    lastSaveError: undefined,
+                    retryCount: 0,
+                    pendingSince: undefined,
+                }));
+                break;
+            }
+            case AutosaveActionTypes.SAVE_FAILED: {
+                const { path, error } = typedAction.payload;
+                dispatch(updateExtensionState(path, {
+                    status: 'error',
+                    lastSaveError: error,
+                    retryCount: error.attempt,
+                }));
+                break;
+            }
+            case AutosaveActionTypes.RETRY_SCHEDULED: {
+                const { path, attempt } = typedAction.payload;
+                dispatch(updateExtensionState(path, {
+                    status: 'pending',
+                    retryCount: attempt,
+                }));
+                break;
+            }
+            case AutosaveActionTypes.CANCEL_PENDING: {
+                const { path } = typedAction.payload;
+                dispatch(updateExtensionState(path, {
+                    status: 'idle',
+                    pendingSince: undefined,
+                }));
+                break;
+            }
+        }
+        return result;
+    };
+    return autosaveSyncMiddleware;
+}

package/dist/es2015/autosave/index.js

@@ -0,0 +1,7 @@
+/**
+ * Autosave Implementation
+ */
+export * from './autosave-registry';
+export * from './autosave-config-resolver';
+export * from './autosave-middleware';
+export * from './autosave-sync-middleware';