vuefinder 4.1.0 → 4.1.2

package/dist/types/ServiceContainer.d.ts

@@ -0,0 +1,3 @@
+import type { VueFinderProps } from './types';
+declare const _default: (props: VueFinderProps, options: Record<string, unknown>) => any;
+export default _default;

package/dist/types/adapters/Adapter.d.ts

@@ -0,0 +1,106 @@
+import type { Driver, DeleteResult, FileOperationResult, FileContentResult, DeleteParams, ArchiveParams, SaveParams, RenameParams, TransferParams } from './types';
+import type { DirEntry, FsData } from '../types';
+/**
+ * Base abstract adapter class that provides common functionality
+ * for all adapter implementations
+ */
+export declare abstract class BaseAdapter implements Driver {
+    /**
+     * Validate that required parameters are provided
+     */
+    protected validateParam(param: unknown, name: string): void;
+    /**
+     * Validate that a file path is provided
+     */
+    protected validatePath(path: string): void;
+    /**
+     * Extract storage and path from a combined path string
+     * Format: "storage://path" or just "path"
+     */
+    protected parsePath(inputPath?: string): {
+        storage?: string;
+        path?: string;
+    };
+    /**
+     * Combine storage and path into a single path string
+     */
+    protected combinePath(storage?: string, path?: string): string;
+    /**
+     * List files and folders at a given path
+     */
+    abstract list(params?: {
+        path?: string;
+    }): Promise<FsData>;
+    /**
+     * Delete files/folders
+     */
+    abstract delete(params: DeleteParams): Promise<DeleteResult>;
+    /**
+     * Rename a file or folder
+     */
+    abstract rename(params: RenameParams): Promise<FileOperationResult>;
+    /**
+     * Copy files/folders to a destination
+     */
+    abstract copy(params: TransferParams): Promise<FileOperationResult>;
+    /**
+     * Move files/folders to a destination
+     */
+    abstract move(params: TransferParams): Promise<FileOperationResult>;
+    /**
+     * Create a zip archive from files/folders
+     */
+    abstract archive(params: ArchiveParams): Promise<FileOperationResult>;
+    /**
+     * Extract files from a zip archive
+     */
+    abstract unarchive(params: {
+        item: string;
+        path: string;
+    }): Promise<FileOperationResult>;
+    /**
+     * Create a new file
+     */
+    abstract createFile(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    /**
+     * Create a new folder
+     */
+    abstract createFolder(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    /**
+     * Get preview URL for a file
+     */
+    abstract getPreviewUrl(params: {
+        path: string;
+    }): string;
+    /**
+     * Get file content
+     */
+    abstract getContent(params: {
+        path: string;
+    }): Promise<FileContentResult>;
+    /**
+     * Get download URL for a file
+     */
+    abstract getDownloadUrl(params: {
+        path: string;
+    }): string;
+    /**
+     * Search files
+     */
+    abstract search(params: {
+        path?: string;
+        filter: string;
+        deep?: boolean;
+        size?: 'all' | 'small' | 'medium' | 'large';
+    }): Promise<DirEntry[]>;
+    /**
+     * Save content to file
+     */
+    abstract save(params: SaveParams): Promise<string>;
+}

package/dist/types/adapters/AdapterManager.d.ts

@@ -0,0 +1,161 @@
+import { QueryClient } from '@tanstack/vue-query';
+import type { Driver, DeleteResult, FileOperationResult, FileContentResult, DeleteParams, ArchiveParams, SaveParams, RenameParams, TransferParams } from './types';
+import type { FsData } from '../types';
+/**
+ * Configuration for AdapterManager
+ */
+export interface AdapterManagerConfig {
+    /**
+     * Query client for TanStack Query
+     * If not provided, a default one will be created
+     */
+    queryClient?: QueryClient;
+    /**
+     * Whether to enable refetching on window focus
+     */
+    refetchOnWindowFocus?: boolean;
+    /**
+     * Default stale time for queries (in milliseconds)
+     */
+    staleTime?: number;
+    /**
+     * Default cache time for queries (in milliseconds)
+     */
+    cacheTime?: number;
+    /**
+     * Whether to retry failed requests
+     */
+    retry?: boolean | number;
+    /**
+     * Callback to update state when data is fetched
+     * This allows the adapter to trigger state updates without being coupled to VueFinder
+     */
+    onBeforeOpen?: () => void;
+    onAfterOpen?: (data: FsData) => void;
+}
+/**
+ * Keys for query and mutation caching
+ */
+export declare const QueryKeys: {
+    list: (path?: string) => readonly ["adapter", "list", string | undefined];
+    search: (path?: string, filter?: string, deep?: boolean, size?: string) => readonly ["adapter", "search", string | undefined, string | undefined, boolean | undefined, string | undefined];
+    delete: (paths?: string[]) => readonly ["adapter", "delete", string[] | undefined];
+    rename: () => readonly ["adapter", "rename"];
+    copy: () => readonly ["adapter", "copy"];
+    move: () => readonly ["adapter", "move"];
+    archive: () => readonly ["adapter", "archive"];
+    unarchive: () => readonly ["adapter", "unarchive"];
+    createFile: () => readonly ["adapter", "createFile"];
+    createFolder: () => readonly ["adapter", "createFolder"];
+};
+/**
+ * AdapterManager wraps a Driver with TanStack Query for enhanced functionality
+ * including caching, optimistic updates, and error handling.
+ */
+export declare class AdapterManager {
+    private driver;
+    private queryClient;
+    private config;
+    private onBeforeOpen?;
+    private onAfterOpen?;
+    constructor(adapter: Driver, config?: Partial<AdapterManagerConfig>);
+    /**
+     * Get the underlying driver instance
+     */
+    getDriver(): Driver;
+    /**
+     * Get the query client instance
+     */
+    getQueryClient(): QueryClient;
+    /**
+     * List files with caching and automatic refetching
+     */
+    list(path?: string): Promise<FsData>;
+    /**
+     * Open a path and optionally update state
+     * @param path
+     * @returns
+     */
+    open(path?: string): Promise<FsData>;
+    /**
+     * Delete files with optimistic updates
+     */
+    delete(params: DeleteParams): Promise<DeleteResult>;
+    /**
+     * Rename a file or folder
+     */
+    rename(params: RenameParams): Promise<FileOperationResult>;
+    /**
+     * Copy files to a destination
+     */
+    copy(params: TransferParams): Promise<FileOperationResult>;
+    /**
+     * Move files to a destination
+     */
+    move(params: TransferParams): Promise<FileOperationResult>;
+    /**
+     * Create a zip archive
+     */
+    archive(params: ArchiveParams): Promise<FileOperationResult>;
+    /**
+     * Extract files from a zip archive
+     */
+    unarchive(params: {
+        item: string;
+        path: string;
+    }): Promise<FileOperationResult>;
+    /**
+     * Create a new file
+     */
+    createFile(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    /**
+     * Create a new folder
+     */
+    createFolder(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    /**
+     * Get file content (cached)
+     */
+    getContent(params: {
+        path: string;
+    }): Promise<FileContentResult>;
+    /**
+     * Get preview URL
+     */
+    getPreviewUrl(params: {
+        path: string;
+    }): string;
+    /**
+     * Get download URL
+     */
+    getDownloadUrl(params: {
+        path: string;
+    }): string;
+    /**
+     * Search files (cached per path+filter)
+     */
+    search(params: {
+        path?: string;
+        filter: string;
+        deep?: boolean;
+        size?: 'all' | 'small' | 'medium' | 'large';
+    }): Promise<import('../types').DirEntry[]>;
+    /**
+     * Save content to file (and invalidate list cache)
+     */
+    save(params: SaveParams): Promise<string>;
+    /**
+     * Invalidate all list queries
+     */
+    private invalidateListQueries;
+    invalidateListQuery(path?: string): void;
+    /**
+     * Clear all cached queries
+     */
+    clearCache(): void;
+}

package/dist/types/adapters/ArrayDriver.d.ts

@@ -0,0 +1,86 @@
+import { BaseAdapter } from './Adapter';
+import type { DeleteParams, DeleteResult, FileOperationResult, FileContentResult, ArchiveParams, SaveParams, RenameParams, TransferParams } from './types';
+import type { DirEntry, FsData } from '../types';
+type FilesSource = {
+    value: DirEntry[];
+} | DirEntry[];
+export interface ArrayDriverConfig {
+    files: FilesSource;
+    storage?: string;
+    storages?: string[];
+    readOnly?: boolean;
+    contentStore?: Map<string, string | ArrayBuffer>;
+}
+export declare class ArrayDriver extends BaseAdapter {
+    private filesSource;
+    private defaultStorage;
+    private storages;
+    private storagesSet;
+    private readOnly;
+    private contentStore;
+    constructor(config: ArrayDriverConfig);
+    private get files();
+    private set files(value);
+    private ensureWritable;
+    private ensureStorageSupported;
+    private combine;
+    private split;
+    private normalizePath;
+    private parent;
+    private join;
+    private getExtension;
+    private cloneEntry;
+    private findByPath;
+    private listChildren;
+    private replaceAll;
+    private upsert;
+    private removeExact;
+    private removeTree;
+    private isInTree;
+    private getTree;
+    private uniqueName;
+    private topLevelSources;
+    private makeDirEntry;
+    private makeFileEntry;
+    private resultForDir;
+    list(params?: {
+        path?: string;
+    }): Promise<FsData>;
+    delete(params: DeleteParams): Promise<DeleteResult>;
+    rename(params: RenameParams): Promise<FileOperationResult>;
+    copy(params: TransferParams): Promise<FileOperationResult>;
+    move(params: TransferParams): Promise<FileOperationResult>;
+    archive(params: ArchiveParams): Promise<FileOperationResult>;
+    unarchive(params: {
+        item: string;
+        path: string;
+    }): Promise<FileOperationResult>;
+    createFile(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    createFolder(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    getPreviewUrl(_params: {
+        path: string;
+    }): string;
+    getContent(params: {
+        path: string;
+    }): Promise<FileContentResult>;
+    getDownloadUrl(_params: {
+        path: string;
+    }): string;
+    search(params: {
+        path?: string;
+        filter: string;
+        deep?: boolean;
+        size?: 'all' | 'small' | 'medium' | 'large';
+    }): Promise<DirEntry[]>;
+    save(params: SaveParams): Promise<string>;
+    configureUploader?(uppy: any, context: {
+        getTargetPath: () => string;
+    }): void;
+}
+export {};

package/dist/types/adapters/IndexedDBDriver.d.ts

@@ -0,0 +1,71 @@
+import { BaseAdapter } from './Adapter';
+import type { DeleteParams, DeleteResult, FileOperationResult, FileContentResult, ArchiveParams, SaveParams, RenameParams, TransferParams, UploaderContext } from './types';
+import type { DirEntry, FsData } from '../types';
+export interface IndexedDBDriverConfig {
+    dbName?: string;
+    storage?: string;
+    storages?: string[];
+    readOnly?: boolean;
+    version?: number;
+}
+export declare class IndexedDBDriver extends BaseAdapter {
+    private dbName;
+    private defaultStorage;
+    private storages;
+    private storagesSet;
+    private readOnly;
+    private version;
+    private db;
+    private dbPromise;
+    private entries;
+    private contentStore;
+    private driver;
+    private readyPromise;
+    constructor(config?: IndexedDBDriverConfig);
+    private isManagedStorage;
+    private isManagedPath;
+    private initDB;
+    private getDB;
+    private requestToPromise;
+    private waitTransaction;
+    private loadSnapshotFromDB;
+    private persistSnapshot;
+    private ensureReady;
+    list(params?: {
+        path?: string;
+    }): Promise<FsData>;
+    delete(params: DeleteParams): Promise<DeleteResult>;
+    rename(params: RenameParams): Promise<FileOperationResult>;
+    copy(params: TransferParams): Promise<FileOperationResult>;
+    move(params: TransferParams): Promise<FileOperationResult>;
+    archive(params: ArchiveParams): Promise<FileOperationResult>;
+    unarchive(params: {
+        item: string;
+        path: string;
+    }): Promise<FileOperationResult>;
+    createFile(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    createFolder(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    getPreviewUrl(params: {
+        path: string;
+    }): string;
+    getContent(params: {
+        path: string;
+    }): Promise<FileContentResult>;
+    getDownloadUrl(params: {
+        path: string;
+    }): string;
+    search(params: {
+        path?: string;
+        filter: string;
+        deep?: boolean;
+        size?: 'all' | 'small' | 'medium' | 'large';
+    }): Promise<DirEntry[]>;
+    save(params: SaveParams): Promise<string>;
+    configureUploader?(uppy: any, context: UploaderContext): void;
+}

package/dist/types/adapters/RemoteDriver.d.ts

@@ -0,0 +1,75 @@
+import { BaseAdapter } from './Adapter';
+import type { RemoteDriverConfig, FsData, DeleteResult, FileOperationResult, FileContentResult, DeleteParams, ArchiveParams, SaveParams, UploaderContext } from './types';
+import type Uppy from '@uppy/core';
+/**
+ * Remote driver for handling file operations via HTTP requests
+ * This driver makes API calls to backend endpoints
+ */
+export declare class RemoteDriver extends BaseAdapter {
+    private config;
+    /**
+     * Default URL endpoints
+     */
+    private static readonly DEFAULT_URLS;
+    constructor(config: RemoteDriverConfig);
+    /**
+     * Set or update the base URL for API requests
+     */
+    setBaseURL(baseURL?: string): void;
+    /**
+     * Set or update the authentication token
+     * Pass undefined to remove the token
+     */
+    setToken(token?: string): void;
+    configureUploader(uppy: Uppy, context: UploaderContext): void;
+    private getHeaders;
+    private request;
+    list(params?: {
+        path?: string;
+    }): Promise<FsData>;
+    delete(params: DeleteParams): Promise<DeleteResult>;
+    rename(params: {
+        path: string;
+        item: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    copy(params: {
+        path?: string;
+        sources: string[];
+        destination: string;
+    }): Promise<FileOperationResult>;
+    move(params: {
+        path?: string;
+        sources: string[];
+        destination: string;
+    }): Promise<FileOperationResult>;
+    archive(params: ArchiveParams): Promise<FileOperationResult>;
+    unarchive(params: {
+        item: string;
+        path: string;
+    }): Promise<FileOperationResult>;
+    createFile(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    createFolder(params: {
+        path: string;
+        name: string;
+    }): Promise<FileOperationResult>;
+    getPreviewUrl(params: {
+        path: string;
+    }): string;
+    getContent(params: {
+        path: string;
+    }): Promise<FileContentResult>;
+    getDownloadUrl(params: {
+        path: string;
+    }): string;
+    search(params: {
+        path?: string;
+        filter: string;
+        deep?: boolean;
+        size?: 'all' | 'small' | 'medium' | 'large';
+    }): Promise<import('../types').DirEntry[]>;
+    save(params: SaveParams): Promise<string>;
+}

package/dist/types/adapters/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * VueFinder Adapters
+ *
+ * This module provides adapter classes for handling file operations
+ * in different environments (local and cloud).
+ *
+ * @example
+ * // Using RemoteDriver
+ * import { RemoteDriver } from '@vuefinder/adapters';
+ *
+ * const adapter = new RemoteDriver({
+ *   baseURL: '/api/cloud',
+ *   token: 'XYZ',
+ *   url: {
+ *     list: '/api/files',
+ *     upload: '/api/files/upload',
+ *     delete: '/api/files/delete',
+ *     rename: '/api/files/rename',
+ *     archive: '/api/files/archive',
+ *     unarchive: '/api/files/unarchive',
+ *     createFile: '/api/files/create-file',
+ *     createFolder: '/api/files/create-folder',
+ *     preview: '/api/files/preview',
+ *     download: '/api/files/download'
+ *   }
+ * });
+ *
+ * @example
+ * // Using ArrayDriver (in-memory)
+ * import { ArrayDriver } from '@vuefinder/adapters';
+ *
+ * const adapter = new ArrayDriver({
+ *   files: filesArray,
+ *   storage: 'memory'
+ * });
+ *
+ * @example
+ * // Creating a custom adapter
+ * import { BaseAdapter } from '@vuefinder/adapters';
+ *
+ * class MyCustomAdapter extends BaseAdapter {
+ *   async list(params) {
+ *     // Your custom implementation
+ *   }
+ *   // ... implement other required methods
+ * }
+ */
+export { BaseAdapter } from './Adapter';
+export { ArrayDriver } from './ArrayDriver';
+export type { ArrayDriverConfig } from './ArrayDriver';
+export { RemoteDriver } from './RemoteDriver';
+export { IndexedDBDriver } from './IndexedDBDriver';
+export type { IndexedDBDriverConfig } from './IndexedDBDriver';
+export { AdapterManager, QueryKeys } from './AdapterManager';
+export type { AdapterManagerConfig } from './AdapterManager';
+export { parseBackendError } from './types';
+export type { Driver, RemoteDriverConfig, RemoteDriverUrls, DeleteResult, FileOperationResult, FileContentResult, ListParams, DeleteParams, RenameParams, TransferParams, ArchiveParams, AdapterError, FsData, } from './types';