@hamak/ui-store 0.5.1

package/dist/impl/autosave/autosave-config-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autosave-config-resolver.d.ts","sourceRoot":"","sources":["../../../src/impl/autosave/autosave-config-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAG5B,MAAM,WAAW,CAAC;AAEnB;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,cAAc,GAAG,SAAS,GAC/B,sBAAsB,GAAG,SAAS,CAOpC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,cAAc,GAAG,SAAS,GAC/B,cAAc,GAAG,SAAS,CAE5B;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,MAAM,EAAE,EACd,aAAa,GAAE,cAAwC,GACtD,cAAc,CAkChB;AAoBD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,MAAM,EAAE,EACd,aAAa,CAAC,EAAE,cAAc,GAC7B,OAAO,CAGT;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,MAAM,EAAE,GACb,cAAc,GAAG,SAAS,CAW5B;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAE/C"}

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

@@ -0,0 +1,107 @@
+/**
+ * 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 '../../api';
+/**
+ * Get autosave extension state from a node
+ */
+export function getAutosaveExtensionState(node) {
+    if (!node?.state?.extensionStates) {
+        return undefined;
+    }
+    return node.state.extensionStates[AUTOSAVE_EXTENSION_KEY];
+}
+/**
+ * Get autosave config from a node's extension state
+ */
+export function getAutosaveConfig(node) {
+    return getAutosaveExtensionState(node)?.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 = { ...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) {
+    return {
+        enabled: source.enabled,
+        debounceMs: source.debounceMs ?? target.debounceMs,
+        maxWaitMs: source.maxWaitMs ?? target.maxWaitMs,
+        saveOnBlur: source.saveOnBlur ?? target.saveOnBlur,
+        retryOnFailure: source.retryOnFailure ?? target.retryOnFailure,
+        maxRetries: source.maxRetries ?? target.maxRetries,
+        inherit: source.inherit ?? 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/impl/autosave/autosave-middleware.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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
+ */
+import type { Middleware } from 'redux';
+import type { IAutosaveProviderRegistry, AutosaveResult } from '../../spi';
+import { type AutosaveConfig } from '../../api';
+/**
+ * Autosave middleware configuration
+ */
+export interface AutosaveMiddlewareConfig {
+    /** Autosave provider registry */
+    registry: IAutosaveProviderRegistry;
+    /** Redux slice name for filesystem state. Default: 'fileSystem' */
+    fsSliceName?: string;
+    /** Default autosave configuration */
+    defaultConfig?: Partial<AutosaveConfig>;
+    /** Callback when save starts */
+    onSaveStart?: (path: string[]) => void;
+    /** Callback when save succeeds */
+    onSaveSuccess?: (path: string[], result: AutosaveResult) => void;
+    /** Callback when save fails */
+    onSaveError?: (path: string[], error: {
+        code: string;
+        message: string;
+    }) => void;
+}
+/**
+ * Create autosave middleware
+ */
+export declare function createAutosaveMiddleware(config: AutosaveMiddlewareConfig): Middleware;
+//# sourceMappingURL=autosave-middleware.d.ts.map

package/dist/impl/autosave/autosave-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autosave-middleware.d.ts","sourceRoot":"","sources":["../../../src/impl/autosave/autosave-middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,UAAU,EAA4B,MAAM,OAAO,CAAC;AAElE,OAAO,KAAK,EAAE,yBAAyB,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3E,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,WAAW,CAAC;AAgFnB;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,iCAAiC;IACjC,QAAQ,EAAE,yBAAyB,CAAC;IAEpC,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,qCAAqC;IACrC,aAAa,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IAExC,gCAAgC;IAChC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAEvC,kCAAkC;IAClC,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAEjE,+BAA+B;IAC/B,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CAClF;AAcD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,wBAAwB,GAC/B,UAAU,CA6RZ"}

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

@@ -0,0 +1,297 @@
+/**
+ * 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
+ */
+import { AutosaveActionTypes, autosaveActions, DEFAULT_AUTOSAVE_CONFIG, } from '../../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) {
+    if (action.command?.fromRemote === true) {
+        return true;
+    }
+    if (action.payload?.fromRemote === true) {
+        return true;
+    }
+    if (action.fromRemote === true) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get path from action
+ */
+function getPathFromAction(action) {
+    // Try command path
+    if (action.command?.path) {
+        return Array.isArray(action.command.path)
+            ? action.command.path
+            : [action.command.path];
+    }
+    // Try payload path
+    if (action.payload?.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 = {
+        ...DEFAULT_AUTOSAVE_CONFIG,
+        ...defaultConfig,
+    };
+    // Track pending saves by path key
+    const pendingSaves = new Map();
+    /**
+     * Get filesystem root from state
+     */
+    function getRoot(state) {
+        return state[fsSliceName]?.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) {
+        const pathKey = pathToKey(path);
+        const now = Date.now();
+        const debounceMs = config.debounceMs ?? DEFAULT_AUTOSAVE_CONFIG.debounceMs;
+        const maxWaitMs = config.maxWaitMs ?? 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?.maxWaitTimer;
+        if (!maxWaitTimer) {
+            maxWaitTimer = setTimeout(() => {
+                store.dispatch(autosaveActions.debounceExpired(path));
+            }, maxWaitMs);
+        }
+        // Store pending save
+        pendingSaves.set(pathKey, {
+            path,
+            providerId,
+            debounceTimer,
+            maxWaitTimer,
+            retryCount: existing?.retryCount ?? 0,
+            config,
+        });
+        // Dispatch change detected
+        store.dispatch(autosaveActions.changeDetected(path, now, now + debounceMs, providerId));
+    }
+    /**
+     * Execute save operation
+     */
+    async function executeSave(store, path) {
+        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?.(path);
+        try {
+            // Execute save via provider
+            const result = await provider.save(path, node.content, node, store.dispatch);
+            if (result.success) {
+                // Success
+                pendingSaves.delete(pathKey);
+                store.dispatch(autosaveActions.saveSucceeded(path, result.timestamp));
+                onSaveSuccess?.(path, result);
+            }
+            else {
+                // Provider reported failure
+                handleSaveFailure(store, path, result.error ?? { code: 'UNKNOWN', message: 'Save failed' });
+            }
+        }
+        catch (error) {
+            // Exception during save
+            handleSaveFailure(store, path, {
+                code: error.code ?? 'ERROR',
+                message: error.message ?? 'Unknown error',
+            });
+        }
+    }
+    /**
+     * Handle save failure with retry logic
+     */
+    function handleSaveFailure(store, path, error) {
+        const pathKey = pathToKey(path);
+        const pending = pendingSaves.get(pathKey);
+        if (!pending) {
+            return;
+        }
+        const retryCount = pending.retryCount + 1;
+        const maxRetries = pending.config.maxRetries ?? DEFAULT_AUTOSAVE_CONFIG.maxRetries;
+        const shouldRetry = pending.config.retryOnFailure !== false && retryCount < maxRetries;
+        // Dispatch failure
+        store.dispatch(autosaveActions.saveFailed(path, error, retryCount));
+        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/impl/autosave/autosave-registry.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Autosave Provider Registry Implementation
+ */
+import type { FileSystemNode } from '@hamak/shared-utils';
+import type { IAutosaveProvider, IAutosaveProviderRegistry } from '../../spi';
+export declare class AutosaveProviderRegistry implements IAutosaveProviderRegistry {
+    private providers;
+    register(provider: IAutosaveProvider): void;
+    unregister(providerId: string): void;
+    get(providerId: string): IAutosaveProvider | undefined;
+    findProvider(path: string[], node: FileSystemNode): IAutosaveProvider | undefined;
+    getAll(): IAutosaveProvider[];
+    has(providerId: string): boolean;
+}
+//# sourceMappingURL=autosave-registry.d.ts.map

package/dist/impl/autosave/autosave-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autosave-registry.d.ts","sourceRoot":"","sources":["../../../src/impl/autosave/autosave-registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAE9E,qBAAa,wBAAyB,YAAW,yBAAyB;IACxE,OAAO,CAAC,SAAS,CAAwC;IAEzD,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAS3C,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAIpC,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAItD,YAAY,CACV,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,EAAE,cAAc,GACnB,iBAAiB,GAAG,SAAS;IAShC,MAAM,IAAI,iBAAiB,EAAE;IAI7B,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;CAGjC"}

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

@@ -0,0 +1,38 @@
+/**
+ * Autosave Provider Registry Implementation
+ */
+export class AutosaveProviderRegistry {
+    constructor() {
+        Object.defineProperty(this, "providers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 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) => (b.priority ?? 0) - (a.priority ?? 0));
+        return supportingProviders[0];
+    }
+    getAll() {
+        return Array.from(this.providers.values());
+    }
+    has(providerId) {
+        return this.providers.has(providerId);
+    }
+}

package/dist/impl/autosave/autosave-sync-middleware.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 type { Middleware, AnyAction } from 'redux';
+import { type AutosaveExtensionState } from '../../api';
+/**
+ * Autosave sync middleware configuration
+ */
+export interface AutosaveSyncMiddlewareConfig {
+    /**
+     * Function to dispatch extension state update.
+     * This should update the node's extensionStates[AUTOSAVE_EXTENSION_KEY].
+     */
+    updateExtensionState: (path: string[], state: Partial<AutosaveExtensionState>) => AnyAction;
+}
+/**
+ * Create autosave sync middleware
+ */
+export declare function createAutosaveSyncMiddleware(config: AutosaveSyncMiddlewareConfig): Middleware;
+//# sourceMappingURL=autosave-sync-middleware.d.ts.map

package/dist/impl/autosave/autosave-sync-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autosave-sync-middleware.d.ts","sourceRoot":"","sources":["../../../src/impl/autosave/autosave-sync-middleware.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACnD,OAAO,EAGL,KAAK,sBAAsB,EAE5B,MAAM,WAAW,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;OAGG;IACH,oBAAoB,EAAE,CACpB,IAAI,EAAE,MAAM,EAAE,EACd,KAAK,EAAE,OAAO,CAAC,sBAAsB,CAAC,KACnC,SAAS,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,4BAA4B,GACnC,UAAU,CAmHZ"}

package/dist/impl/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 '../../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/impl/autosave/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Autosave Implementation
+ */
+export * from './autosave-registry';
+export * from './autosave-config-resolver';
+export * from './autosave-middleware';
+export * from './autosave-sync-middleware';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/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/impl/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/impl/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from './store-manager';
+export * from './middleware-registry';
+export * from './reducer-registry';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC"}

package/dist/impl/core/index.js

@@ -0,0 +1,3 @@
+export * from './store-manager';
+export * from './middleware-registry';
+export * from './reducer-registry';