@hamak/ui-remote-fs 0.5.1

package/dist/impl/actions/remote-fs-actions.js

@@ -0,0 +1,151 @@
+/**
+ * Remote FS Actions
+ *
+ * Action creators for remote filesystem operations.
+ * Migrated from amk/libs/ui/core/remote-fs/src/lib/remote-fs-actions.ts
+ */
+import { RemoteFsActionTypes } from '../../api';
+/**
+ * Action factory class for creating remote filesystem actions
+ */
+export class RemoteFsActionFactory {
+    constructor() {
+        Object.defineProperty(this, "types", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: RemoteFsActionTypes
+        });
+    }
+    // LS (List) operations
+    ofLsRequest(path, options) {
+        return {
+            type: this.types.LS_REQUEST,
+            payload: { path, options },
+        };
+    }
+    ofLsCompleted(data, request) {
+        return {
+            type: this.types.LS_COMPLETED,
+            payload: { data, request },
+        };
+    }
+    ofLsFailed(error, request) {
+        return {
+            type: this.types.LS_FAILED,
+            payload: { error, request },
+        };
+    }
+    // MKDIR (Make Directory) operations
+    ofMkdirRequest(path, options) {
+        return {
+            type: this.types.MKDIR_REQUEST,
+            payload: { path, options },
+        };
+    }
+    ofMkdirCompleted(data, request) {
+        return {
+            type: this.types.MKDIR_COMPLETED,
+            payload: { data, request },
+        };
+    }
+    ofMkdirFailed(error, request) {
+        return {
+            type: this.types.MKDIR_FAILED,
+            payload: { error, request },
+        };
+    }
+    // GET (Read File) operations
+    ofGetRequest(path, options) {
+        return {
+            type: this.types.GET_REQUEST,
+            payload: { path, options },
+        };
+    }
+    ofGetCompleted(data, request) {
+        return {
+            type: this.types.GET_COMPLETED,
+            payload: { data, request },
+        };
+    }
+    ofGetFailed(error, request) {
+        return {
+            type: this.types.GET_FAILED,
+            payload: { error, request },
+        };
+    }
+    // POST (Create File) operations
+    ofPostRequest(path, content, options) {
+        return {
+            type: this.types.POST_REQUEST,
+            payload: { path, content, options },
+        };
+    }
+    ofPostCompleted(data, request) {
+        return {
+            type: this.types.POST_COMPLETED,
+            payload: { data, request },
+        };
+    }
+    ofPostFailed(error, request) {
+        return {
+            type: this.types.POST_FAILED,
+            payload: { error, request },
+        };
+    }
+    // PUT (Update File) operations
+    ofPutRequest(path, content, options) {
+        return {
+            type: this.types.PUT_REQUEST,
+            payload: { path, content, options },
+        };
+    }
+    ofPutCompleted(data, request) {
+        return {
+            type: this.types.PUT_COMPLETED,
+            payload: { data, request },
+        };
+    }
+    ofPutFailed(error, request) {
+        return {
+            type: this.types.PUT_FAILED,
+            payload: { error, request },
+        };
+    }
+    // DELETE operations
+    ofDeleteRequest(path, options) {
+        return {
+            type: this.types.DELETE_REQUEST,
+            payload: { path, options },
+        };
+    }
+    ofDeleteCompleted(data, request) {
+        return {
+            type: this.types.DELETE_COMPLETED,
+            payload: { data, request },
+        };
+    }
+    ofDeleteFailed(error, request) {
+        return {
+            type: this.types.DELETE_FAILED,
+            payload: { error, request },
+        };
+    }
+    /**
+     * Type guard to check if an action is a remote FS action
+     */
+    isRemoteFsAction(action) {
+        return (action &&
+            typeof action === 'object' &&
+            'type' in action &&
+            Object.values(RemoteFsActionTypes).includes(action.type));
+    }
+}
+/**
+ * Singleton instance of the action factory
+ */
+export const rfsActions = new RemoteFsActionFactory();
+/**
+ * Re-export the action types enum for convenience
+ */
+export { RemoteFsActionTypes };

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

@@ -0,0 +1,5 @@
+/**
+ * Remote FS Autosave
+ */
+export * from './remote-fs-autosave-provider';
+//# 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,+BAA+B,CAAC"}

package/dist/impl/autosave/index.js

@@ -0,0 +1,4 @@
+/**
+ * Remote FS Autosave
+ */
+export * from './remote-fs-autosave-provider';

package/dist/impl/autosave/remote-fs-autosave-provider.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Remote FS Autosave Provider
+ *
+ * Implements autosave for files managed by the remote filesystem plugin.
+ * Uses PUT_REQUEST actions to save files to the remote server.
+ */
+import type { Dispatch, AnyAction } from 'redux';
+import type { FileSystemNode } from '@hamak/shared-utils';
+import type { IAutosaveProvider, AutosaveResult } from '@hamak/ui-store-spi';
+import type { IPathTranslator } from '../../spi';
+/**
+ * Configuration for RemoteFsAutosaveProvider
+ */
+export interface RemoteFsAutosaveProviderConfig {
+    /** Path translator to check if path is under remote mount point */
+    pathTranslator: IPathTranslator;
+}
+/**
+ * Autosave provider for remote filesystem
+ *
+ * This provider handles autosave for files that are mounted via the
+ * remote filesystem plugin. It checks if a file path falls under the
+ * configured mount point and uses PUT_REQUEST to save changes.
+ */
+export declare class RemoteFsAutosaveProvider implements IAutosaveProvider {
+    readonly id = "remote-fs";
+    readonly priority = 10;
+    private pathTranslator;
+    constructor(config: RemoteFsAutosaveProviderConfig);
+    /**
+     * Check if this provider supports a given path.
+     * Returns true if the path is under the remote mount point.
+     */
+    supports(path: string[], _node: FileSystemNode): boolean;
+    /**
+     * Save file content to remote server.
+     * Dispatches PUT_REQUEST action which will be handled by remote-fs middleware.
+     */
+    save(path: string[], content: unknown, _node: FileSystemNode, dispatch: Dispatch<AnyAction>): Promise<AutosaveResult>;
+    /**
+     * Cancel is a no-op for remote-fs since we don't track in-flight requests here.
+     * The remote-fs middleware handles the actual HTTP requests.
+     */
+    cancel(_path: string[]): void;
+}
+//# sourceMappingURL=remote-fs-autosave-provider.d.ts.map

package/dist/impl/autosave/remote-fs-autosave-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-fs-autosave-provider.d.ts","sourceRoot":"","sources":["../../../src/impl/autosave/remote-fs-autosave-provider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAGjD;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C,mEAAmE;IACnE,cAAc,EAAE,eAAe,CAAC;CACjC;AAED;;;;;;GAMG;AACH,qBAAa,wBAAyB,YAAW,iBAAiB;IAChE,QAAQ,CAAC,EAAE,eAAe;IAC1B,QAAQ,CAAC,QAAQ,MAAM;IAEvB,OAAO,CAAC,cAAc,CAAkB;gBAE5B,MAAM,EAAE,8BAA8B;IAIlD;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO;IAQxD;;;OAGG;IACG,IAAI,CACR,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,cAAc,EACrB,QAAQ,EAAE,QAAQ,CAAC,SAAS,CAAC,GAC5B,OAAO,CAAC,cAAc,CAAC;IAwB1B;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;CAG9B"}

package/dist/impl/autosave/remote-fs-autosave-provider.js

@@ -0,0 +1,80 @@
+/**
+ * Remote FS Autosave Provider
+ *
+ * Implements autosave for files managed by the remote filesystem plugin.
+ * Uses PUT_REQUEST actions to save files to the remote server.
+ */
+import { rfsActions } from '../actions/remote-fs-actions';
+/**
+ * Autosave provider for remote filesystem
+ *
+ * This provider handles autosave for files that are mounted via the
+ * remote filesystem plugin. It checks if a file path falls under the
+ * configured mount point and uses PUT_REQUEST to save changes.
+ */
+export class RemoteFsAutosaveProvider {
+    constructor(config) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'remote-fs'
+        });
+        Object.defineProperty(this, "priority", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10
+        });
+        Object.defineProperty(this, "pathTranslator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.pathTranslator = config.pathTranslator;
+    }
+    /**
+     * Check if this provider supports a given path.
+     * Returns true if the path is under the remote mount point.
+     */
+    supports(path, _node) {
+        // Check if path translator can translate this path to a remote path
+        const remotePath = this.pathTranslator.toRemotePath({ getSegments: () => path });
+        return remotePath !== undefined;
+    }
+    /**
+     * Save file content to remote server.
+     * Dispatches PUT_REQUEST action which will be handled by remote-fs middleware.
+     */
+    async save(path, content, _node, dispatch) {
+        try {
+            // Dispatch PUT request to save content
+            dispatch(rfsActions.ofPutRequest(path, content));
+            // Note: The actual HTTP request is async and handled by remote-fs middleware.
+            // Success/failure will be tracked by the middleware dispatching
+            // PUT_COMPLETED or PUT_FAILED actions.
+            // For now, we return optimistic success.
+            return {
+                success: true,
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    code: error.code ?? 'SAVE_ERROR',
+                    message: error.message ?? 'Failed to dispatch save action',
+                },
+            };
+        }
+    }
+    /**
+     * Cancel is a no-op for remote-fs since we don't track in-flight requests here.
+     * The remote-fs middleware handles the actual HTTP requests.
+     */
+    cancel(_path) {
+        // No-op: remote-fs middleware handles request lifecycle
+    }
+}

package/dist/impl/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * UI Remote FS Implementation
+ * HTTP-based remote filesystem implementation
+ */
+export * from '../api';
+export * from '../spi/providers';
+export type { RemoteFsMiddlewareFactory, StoreSyncMiddlewareFactory } from '../spi/middleware';
+export * from './actions';
+export * from './middleware';
+export * from './providers';
+export * from './plugin';
+export * from './services';
+export * from './autosave';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/impl/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AAIjC,YAAY,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAE/F,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/dist/impl/index.js

@@ -0,0 +1,13 @@
+/**
+ * UI Remote FS Implementation
+ * HTTP-based remote filesystem implementation
+ */
+// Re-export API and SPI for convenience
+export * from '../api';
+export * from '../spi/providers';
+export * from './actions';
+export * from './middleware';
+export * from './providers';
+export * from './plugin';
+export * from './services';
+export * from './autosave';

package/dist/impl/middleware/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remote FS Middleware
+ */
+export * from './remote-fs-middleware';
+export * from './store-sync-middleware';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/middleware/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC"}

package/dist/impl/middleware/index.js

@@ -0,0 +1,5 @@
+/**
+ * Remote FS Middleware
+ */
+export * from './remote-fs-middleware';
+export * from './store-sync-middleware';

package/dist/impl/middleware/remote-fs-middleware.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Remote FS Middleware
+ *
+ * Redux middleware for handling remote filesystem operations via HTTP client.
+ * Migrated from amk/libs/ui/core/remote-fs/src/lib/remote-fs-middleware.ts
+ */
+import { AnyAction, Middleware } from '@reduxjs/toolkit';
+import type { IWorkspaceClient, IPathTranslator } from '../../spi';
+import { type ErrorObject } from '../../api';
+/**
+ * Configuration for remote FS middleware
+ */
+export interface RemoteFsMiddlewareConfig {
+    client: IWorkspaceClient;
+    pathTranslator: IPathTranslator;
+    onError?: (error: ErrorObject, action: AnyAction) => void;
+    onSuccess?: (result: any, action: AnyAction) => void;
+}
+/**
+ * Create remote filesystem middleware
+ *
+ * This middleware intercepts remote FS actions and executes them via the provided
+ * workspace client. It handles path translation from local mount point to remote paths.
+ *
+ * @param config Middleware configuration
+ * @returns Redux middleware
+ *
+ * @example
+ * ```typescript
+ * const middleware = createRemoteFsMiddleware({
+ *   client: new HttpWorkspaceClient({ workspaceId: '0' }),
+ *   pathTranslator: new PathTranslator(Pathway.ofRoot().resolve('remote'))
+ * });
+ * ```
+ */
+export declare function createRemoteFsMiddleware<S = any>(config: RemoteFsMiddlewareConfig): Middleware<{}, S>;
+export default createRemoteFsMiddleware;
+//# sourceMappingURL=remote-fs-middleware.d.ts.map

package/dist/impl/middleware/remote-fs-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-fs-middleware.d.ts","sourceRoot":"","sources":["../../../src/impl/middleware/remote-fs-middleware.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACnE,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAWlE;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,gBAAgB,CAAC;IACzB,cAAc,EAAE,eAAe,CAAC;IAChC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;IAC1D,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;CACtD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,GAAG,GAAG,EAC9C,MAAM,EAAE,wBAAwB,GAC/B,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CA8LnB;AAED,eAAe,wBAAwB,CAAC"}

package/dist/impl/middleware/remote-fs-middleware.js

@@ -0,0 +1,192 @@
+/**
+ * Remote FS Middleware
+ *
+ * Redux middleware for handling remote filesystem operations via HTTP client.
+ * Migrated from amk/libs/ui/core/remote-fs/src/lib/remote-fs-middleware.ts
+ */
+import { Pathway } from '@hamak/shared-utils';
+import { RemoteFsActionTypes } from '../../api';
+import { rfsActions, } from '../actions/remote-fs-actions';
+/**
+ * Create remote filesystem middleware
+ *
+ * This middleware intercepts remote FS actions and executes them via the provided
+ * workspace client. It handles path translation from local mount point to remote paths.
+ *
+ * @param config Middleware configuration
+ * @returns Redux middleware
+ *
+ * @example
+ * ```typescript
+ * const middleware = createRemoteFsMiddleware({
+ *   client: new HttpWorkspaceClient({ workspaceId: '0' }),
+ *   pathTranslator: new PathTranslator(Pathway.ofRoot().resolve('remote'))
+ * });
+ * ```
+ */
+export function createRemoteFsMiddleware(config) {
+    const { client, pathTranslator, onError, onSuccess } = config;
+    /**
+     * Translate local path to remote path
+     */
+    const toRemotePath = (path) => {
+        const pathway = Array.isArray(path) ? Pathway.of(path) : Pathway.of([path]);
+        return pathTranslator.toRemotePath(pathway);
+    };
+    /**
+     * Handle errors and convert to ErrorObject
+     */
+    const handleError = (error) => {
+        if (error && typeof error === 'object' && 'code' in error && 'message' in error) {
+            return error;
+        }
+        return {
+            code: error?.code || 'UNKNOWN',
+            message: error?.message || 'Unknown error',
+        };
+    };
+    const remoteFsMiddleware = (store) => (next) => (action) => {
+        const result = next(action);
+        const dispatch = store.dispatch;
+        const anyAction = action;
+        switch (anyAction.type) {
+            case RemoteFsActionTypes.LS_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.listFiles(remotePath.getSegments(), requestAction.payload.options);
+                        const completedAction = rfsActions.ofLsCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofLsFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.MKDIR_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.createDirectory(remotePath.getSegments(), requestAction.payload.options);
+                        const completedAction = rfsActions.ofMkdirCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofMkdirFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.GET_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.readFile(remotePath.getSegments(), requestAction.payload.options);
+                        const completedAction = rfsActions.ofGetCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofGetFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.POST_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.putFile(remotePath.getSegments(), requestAction.payload.content, requestAction.payload.options);
+                        const completedAction = rfsActions.ofPostCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofPostFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.PUT_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.putFile(remotePath.getSegments(), requestAction.payload.content, requestAction.payload.options);
+                        const completedAction = rfsActions.ofPutCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofPutFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.DELETE_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.deleteFile(remotePath.getSegments(), requestAction.payload.options);
+                        const completedAction = rfsActions.ofDeleteCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofDeleteFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            default:
+                break;
+        }
+        return result;
+    };
+    return remoteFsMiddleware;
+}
+export default createRemoteFsMiddleware;

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

@@ -0,0 +1,35 @@
+/**
+ * Store Sync Middleware
+ *
+ * Redux middleware for synchronizing remote filesystem operations to Redux Store FS.
+ * This middleware listens to remote FS completion actions and updates the Store FS accordingly.
+ * Migrated from amk/libs/ui/core/remote-fs/src/lib/store-fs-adapter-middleware.ts
+ */
+import { Middleware } from '@reduxjs/toolkit';
+import { StoreSyncMiddlewareConfig } from '../../spi';
+/**
+ * Create store sync middleware
+ *
+ * This middleware intercepts remote FS completion actions and synchronizes them
+ * to the Redux Store FileSystem. It handles:
+ * - LS_COMPLETED: Creates directories and file entries in Store FS
+ * - MKDIR_COMPLETED: Creates directory in Store FS
+ * - GET_COMPLETED: Creates/updates file content in Store FS
+ * - POST/PUT_COMPLETED: Reloads file content from remote
+ * - DELETE_COMPLETED: Removes node from Store FS
+ *
+ * @param config Middleware configuration
+ * @returns Redux middleware
+ *
+ * @example
+ * ```typescript
+ * const middleware = createStoreSyncMiddleware({
+ *   fileSystemAdapter: storeFs,
+ *   pathTranslator: new PathTranslator(Pathway.ofRoot().resolve('remote')),
+ *   autoReload: true
+ * });
+ * ```
+ */
+export declare function createStoreSyncMiddleware<S = any>(config: StoreSyncMiddlewareConfig): Middleware<{}, S>;
+export default createStoreSyncMiddleware;
+//# sourceMappingURL=store-sync-middleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store-sync-middleware.d.ts","sourceRoot":"","sources":["../../../src/impl/middleware/store-sync-middleware.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAa,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGzD,OAAO,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAWtD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,GAAG,EAC/C,MAAM,EAAE,yBAAyB,GAChC,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CA8HnB;AAED,eAAe,yBAAyB,CAAC"}