vfs-kit 1.0.1 → 1.0.3

package/dist/VfsAdapter-BWjniD9Y.d.mts

@@ -0,0 +1,57 @@
+import { e as VfsNode, b as VfsFileNode, d as VfsFolderNode, f as VfsNodeOrder, c as VfsFileSnapshot, g as VfsOperation } from './VfsNode-D10gxL5W.mjs';
+
+interface VfsChange {
+    op: VfsOperation;
+    nodeIds: string[];
+    timestamp: number;
+}
+interface VfsSearchOptions {
+    scope?: string | null;
+    kind?: "file" | "folder";
+    includeTrashed?: boolean;
+}
+interface VfsCreateFileParams {
+    parentId: string | null;
+    name: string;
+    mimeType?: string;
+    meta?: Record<string, unknown>;
+}
+interface VfsCreateFolderParams {
+    parentId: string | null;
+    name: string;
+    meta?: Record<string, unknown>;
+}
+declare abstract class VfsAdapter<TMeta = Record<string, unknown>> {
+    abstract readonly supportsHistory: boolean;
+    abstract generateId(): string;
+    abstract getNodes(ids: string[]): Promise<VfsNode<TMeta>[]>;
+    abstract getNodeById(id: string): Promise<VfsNode<TMeta> | null>;
+    abstract getNodeByPath(path: string): Promise<VfsNode<TMeta> | null>;
+    abstract getChildren(parentId: string | null, options?: {
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    abstract getTrashed(): Promise<VfsNode<TMeta>[]>;
+    abstract search(query: string, options?: VfsSearchOptions): Promise<VfsNode<TMeta>[]>;
+    abstract readFile(id: string): Promise<Uint8Array>;
+    abstract writeFile(id: string, content: Uint8Array): Promise<void>;
+    abstract createFile(params: VfsCreateFileParams): Promise<VfsFileNode<TMeta>>;
+    abstract createFolder(params: VfsCreateFolderParams): Promise<VfsFolderNode<TMeta>>;
+    abstract updateNode(id: string, updates: Partial<VfsNode<TMeta>>): Promise<VfsNode<TMeta>>;
+    abstract deleteNode(id: string, permanent?: boolean): Promise<void>;
+    abstract deleteNodes(ids: string[], permanent?: boolean): Promise<void>;
+    abstract restoreNode(id: string): Promise<VfsNode<TMeta>>;
+    abstract purgeNode(id: string): Promise<void>;
+    abstract moveNode(id: string, newParentId: string | null): Promise<VfsNode<TMeta>>;
+    abstract moveNodes(ids: string[], newParentId: string | null): Promise<VfsNode<TMeta>[]>;
+    abstract lockNode(id: string, sessionId: string): Promise<VfsNode<TMeta>>;
+    abstract unlockNode(id: string, sessionId: string): Promise<VfsNode<TMeta>>;
+    abstract getOrder(parentId: string | null): Promise<VfsNodeOrder | null>;
+    abstract setOrder(parentId: string | null, orderedIds: string[]): Promise<void>;
+    getSnapshots(fileId: string): Promise<VfsFileSnapshot[]>;
+    saveSnapshot(fileId: string, content: Uint8Array, label?: string): Promise<VfsFileSnapshot>;
+    restoreSnapshot(fileId: string, index: number): Promise<void>;
+    deleteSnapshot(fileId: string, index: number): Promise<void>;
+    abstract onChanged(callback: (change: VfsChange) => void): () => void;
+}
+
+export { VfsAdapter as V, type VfsChange as a, type VfsCreateFileParams as b, type VfsCreateFolderParams as c, type VfsSearchOptions as d };

package/dist/VfsAdapter-DOBt_TyL.d.ts

@@ -0,0 +1,57 @@
+import { e as VfsNode, b as VfsFileNode, d as VfsFolderNode, f as VfsNodeOrder, c as VfsFileSnapshot, g as VfsOperation } from './VfsNode-D10gxL5W.js';
+
+interface VfsChange {
+    op: VfsOperation;
+    nodeIds: string[];
+    timestamp: number;
+}
+interface VfsSearchOptions {
+    scope?: string | null;
+    kind?: "file" | "folder";
+    includeTrashed?: boolean;
+}
+interface VfsCreateFileParams {
+    parentId: string | null;
+    name: string;
+    mimeType?: string;
+    meta?: Record<string, unknown>;
+}
+interface VfsCreateFolderParams {
+    parentId: string | null;
+    name: string;
+    meta?: Record<string, unknown>;
+}
+declare abstract class VfsAdapter<TMeta = Record<string, unknown>> {
+    abstract readonly supportsHistory: boolean;
+    abstract generateId(): string;
+    abstract getNodes(ids: string[]): Promise<VfsNode<TMeta>[]>;
+    abstract getNodeById(id: string): Promise<VfsNode<TMeta> | null>;
+    abstract getNodeByPath(path: string): Promise<VfsNode<TMeta> | null>;
+    abstract getChildren(parentId: string | null, options?: {
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    abstract getTrashed(): Promise<VfsNode<TMeta>[]>;
+    abstract search(query: string, options?: VfsSearchOptions): Promise<VfsNode<TMeta>[]>;
+    abstract readFile(id: string): Promise<Uint8Array>;
+    abstract writeFile(id: string, content: Uint8Array): Promise<void>;
+    abstract createFile(params: VfsCreateFileParams): Promise<VfsFileNode<TMeta>>;
+    abstract createFolder(params: VfsCreateFolderParams): Promise<VfsFolderNode<TMeta>>;
+    abstract updateNode(id: string, updates: Partial<VfsNode<TMeta>>): Promise<VfsNode<TMeta>>;
+    abstract deleteNode(id: string, permanent?: boolean): Promise<void>;
+    abstract deleteNodes(ids: string[], permanent?: boolean): Promise<void>;
+    abstract restoreNode(id: string): Promise<VfsNode<TMeta>>;
+    abstract purgeNode(id: string): Promise<void>;
+    abstract moveNode(id: string, newParentId: string | null): Promise<VfsNode<TMeta>>;
+    abstract moveNodes(ids: string[], newParentId: string | null): Promise<VfsNode<TMeta>[]>;
+    abstract lockNode(id: string, sessionId: string): Promise<VfsNode<TMeta>>;
+    abstract unlockNode(id: string, sessionId: string): Promise<VfsNode<TMeta>>;
+    abstract getOrder(parentId: string | null): Promise<VfsNodeOrder | null>;
+    abstract setOrder(parentId: string | null, orderedIds: string[]): Promise<void>;
+    getSnapshots(fileId: string): Promise<VfsFileSnapshot[]>;
+    saveSnapshot(fileId: string, content: Uint8Array, label?: string): Promise<VfsFileSnapshot>;
+    restoreSnapshot(fileId: string, index: number): Promise<void>;
+    deleteSnapshot(fileId: string, index: number): Promise<void>;
+    abstract onChanged(callback: (change: VfsChange) => void): () => void;
+}
+
+export { VfsAdapter as V, type VfsChange as a, type VfsCreateFileParams as b, type VfsCreateFolderParams as c, type VfsSearchOptions as d };

package/dist/VfsEngine-B6nhgyjQ.d.mts

@@ -0,0 +1,152 @@
+import { V as VfsAdapter, a as VfsChange } from './VfsAdapter-BWjniD9Y.mjs';
+import { V as VfsEngineConfig, e as VfsNode, c as VfsFileSnapshot } from './VfsNode-D10gxL5W.mjs';
+
+type VfsCommand = {
+    op: "create";
+    kind: "file";
+    parentId: string | null;
+    name: string;
+    mimeType?: string;
+    meta?: Record<string, unknown>;
+} | {
+    op: "create";
+    kind: "folder";
+    parentId: string | null;
+    name: string;
+    meta?: Record<string, unknown>;
+} | {
+    op: "rename";
+    id: string;
+    newName: string;
+} | {
+    op: "delete";
+    ids: string[];
+    permanent?: boolean;
+} | {
+    op: "restore";
+    ids: string[];
+} | {
+    op: "purge";
+    ids: string[];
+} | {
+    op: "move";
+    ids: string[];
+    newParentId: string | null;
+} | {
+    op: "write";
+    id: string;
+    content: Uint8Array;
+} | {
+    op: "lock";
+    ids: string[];
+} | {
+    op: "unlock";
+    ids: string[];
+} | {
+    op: "reorder";
+    parentId: string | null;
+    orderedIds: string[];
+} | {
+    op: "snapshot";
+    fileId: string;
+    label?: string;
+};
+type VfsEventMap<TMeta> = {
+    created: VfsNode<TMeta>;
+    renamed: VfsNode<TMeta>;
+    deleted: {
+        ids: string[];
+        permanent: boolean;
+    };
+    restored: VfsNode<TMeta>[];
+    purged: {
+        ids: string[];
+    };
+    moved: VfsNode<TMeta>[];
+    written: {
+        id: string;
+    };
+    locked: VfsNode<TMeta>[];
+    unlocked: VfsNode<TMeta>[];
+    reordered: {
+        parentId: string | null;
+        orderedIds: string[];
+    };
+    warning: {
+        code: string;
+        tabId?: string;
+        nodeId?: string;
+    };
+    snapshot: VfsFileSnapshot;
+    pending: {
+        command: VfsCommand;
+    };
+    settled: {
+        command: VfsCommand;
+        success: boolean;
+    };
+    error: {
+        command: VfsCommand;
+        error: Error;
+    };
+    change: VfsChange;
+};
+type VfsEventListener<TMeta, K extends keyof VfsEventMap<TMeta>> = (payload: VfsEventMap<TMeta>[K]) => void;
+type CacheStrategy = "eager" | "lazy" | "hybrid";
+declare class VfsEngine<TMeta extends Record<string, unknown> | undefined = Record<string, unknown>> {
+    private adapter;
+    private config;
+    private cache;
+    private listeners;
+    private unsubscribeAdapter;
+    version: number;
+    pending: boolean;
+    lastError: Error | null;
+    constructor(adapter: VfsAdapter<TMeta>, config: Partial<VfsEngineConfig<TMeta>> & {
+        sessionId: string;
+    });
+    init(strategy?: CacheStrategy): Promise<void>;
+    destroy(): void;
+    subscribe(onStoreChange: () => void): () => void;
+    execute(command: VfsCommand): Promise<void>;
+    private runCommand;
+    private runCreate;
+    private runRename;
+    private runDelete;
+    private runRestore;
+    private runPurge;
+    private runMove;
+    private runWrite;
+    private runLock;
+    private runUnlock;
+    private runReorder;
+    private runSnapshot;
+    getNode(id: string): Promise<VfsNode<TMeta> | null>;
+    getChildren(parentId: string | null, options?: {
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    getPath(id: string): Promise<string>;
+    readFile(id: string): Promise<Uint8Array>;
+    search(query: string, options?: {
+        scope?: string | null;
+        kind?: "file" | "folder";
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    getTrashed(): Promise<VfsNode<TMeta>[]>;
+    getSnapshots(fileId: string): Promise<VfsFileSnapshot[]>;
+    private applySortOrder;
+    private autoSort;
+    private loadChildren;
+    private hydrateCache;
+    private cacheNode;
+    private evictNode;
+    private handleAdapterChange;
+    private resolveNode;
+    private assertNoDuplicate;
+    private extractTargetIds;
+    on<K extends keyof VfsEventMap<TMeta>>(event: K, listener: VfsEventListener<TMeta, K>): () => void;
+    emit<K extends keyof VfsEventMap<TMeta>>(event: K, payload: VfsEventMap<TMeta>[K]): void;
+    private emitChange;
+}
+
+export { VfsEngine as V, type VfsCommand as a, type VfsEventMap as b };

package/dist/VfsEngine-DLx0iUpi.d.ts

@@ -0,0 +1,152 @@
+import { V as VfsAdapter, a as VfsChange } from './VfsAdapter-DOBt_TyL.js';
+import { V as VfsEngineConfig, e as VfsNode, c as VfsFileSnapshot } from './VfsNode-D10gxL5W.js';
+
+type VfsCommand = {
+    op: "create";
+    kind: "file";
+    parentId: string | null;
+    name: string;
+    mimeType?: string;
+    meta?: Record<string, unknown>;
+} | {
+    op: "create";
+    kind: "folder";
+    parentId: string | null;
+    name: string;
+    meta?: Record<string, unknown>;
+} | {
+    op: "rename";
+    id: string;
+    newName: string;
+} | {
+    op: "delete";
+    ids: string[];
+    permanent?: boolean;
+} | {
+    op: "restore";
+    ids: string[];
+} | {
+    op: "purge";
+    ids: string[];
+} | {
+    op: "move";
+    ids: string[];
+    newParentId: string | null;
+} | {
+    op: "write";
+    id: string;
+    content: Uint8Array;
+} | {
+    op: "lock";
+    ids: string[];
+} | {
+    op: "unlock";
+    ids: string[];
+} | {
+    op: "reorder";
+    parentId: string | null;
+    orderedIds: string[];
+} | {
+    op: "snapshot";
+    fileId: string;
+    label?: string;
+};
+type VfsEventMap<TMeta> = {
+    created: VfsNode<TMeta>;
+    renamed: VfsNode<TMeta>;
+    deleted: {
+        ids: string[];
+        permanent: boolean;
+    };
+    restored: VfsNode<TMeta>[];
+    purged: {
+        ids: string[];
+    };
+    moved: VfsNode<TMeta>[];
+    written: {
+        id: string;
+    };
+    locked: VfsNode<TMeta>[];
+    unlocked: VfsNode<TMeta>[];
+    reordered: {
+        parentId: string | null;
+        orderedIds: string[];
+    };
+    warning: {
+        code: string;
+        tabId?: string;
+        nodeId?: string;
+    };
+    snapshot: VfsFileSnapshot;
+    pending: {
+        command: VfsCommand;
+    };
+    settled: {
+        command: VfsCommand;
+        success: boolean;
+    };
+    error: {
+        command: VfsCommand;
+        error: Error;
+    };
+    change: VfsChange;
+};
+type VfsEventListener<TMeta, K extends keyof VfsEventMap<TMeta>> = (payload: VfsEventMap<TMeta>[K]) => void;
+type CacheStrategy = "eager" | "lazy" | "hybrid";
+declare class VfsEngine<TMeta extends Record<string, unknown> | undefined = Record<string, unknown>> {
+    private adapter;
+    private config;
+    private cache;
+    private listeners;
+    private unsubscribeAdapter;
+    version: number;
+    pending: boolean;
+    lastError: Error | null;
+    constructor(adapter: VfsAdapter<TMeta>, config: Partial<VfsEngineConfig<TMeta>> & {
+        sessionId: string;
+    });
+    init(strategy?: CacheStrategy): Promise<void>;
+    destroy(): void;
+    subscribe(onStoreChange: () => void): () => void;
+    execute(command: VfsCommand): Promise<void>;
+    private runCommand;
+    private runCreate;
+    private runRename;
+    private runDelete;
+    private runRestore;
+    private runPurge;
+    private runMove;
+    private runWrite;
+    private runLock;
+    private runUnlock;
+    private runReorder;
+    private runSnapshot;
+    getNode(id: string): Promise<VfsNode<TMeta> | null>;
+    getChildren(parentId: string | null, options?: {
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    getPath(id: string): Promise<string>;
+    readFile(id: string): Promise<Uint8Array>;
+    search(query: string, options?: {
+        scope?: string | null;
+        kind?: "file" | "folder";
+        includeTrashed?: boolean;
+    }): Promise<VfsNode<TMeta>[]>;
+    getTrashed(): Promise<VfsNode<TMeta>[]>;
+    getSnapshots(fileId: string): Promise<VfsFileSnapshot[]>;
+    private applySortOrder;
+    private autoSort;
+    private loadChildren;
+    private hydrateCache;
+    private cacheNode;
+    private evictNode;
+    private handleAdapterChange;
+    private resolveNode;
+    private assertNoDuplicate;
+    private extractTargetIds;
+    on<K extends keyof VfsEventMap<TMeta>>(event: K, listener: VfsEventListener<TMeta, K>): () => void;
+    emit<K extends keyof VfsEventMap<TMeta>>(event: K, payload: VfsEventMap<TMeta>[K]): void;
+    private emitChange;
+}
+
+export { VfsEngine as V, type VfsCommand as a, type VfsEventMap as b };

package/dist/VfsNode-D10gxL5W.d.mts

@@ -0,0 +1,48 @@
+interface VfsBaseNode<TMeta = Record<string, unknown>> {
+    id: string;
+    name: string;
+    parentId: string | null;
+    sortIndex: number | null;
+    lockedBy: string | null;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt: number | null;
+    meta: TMeta;
+}
+interface VfsNodeOrder {
+    parentId: string | null;
+    orderedIds: string[];
+}
+interface VfsFileNode<TMeta = Record<string, unknown>> extends VfsBaseNode<TMeta> {
+    kind: "file";
+    mimeType: string;
+    size: number;
+}
+interface VfsFolderNode<TMeta = Record<string, unknown>> extends VfsBaseNode<TMeta> {
+    kind: "folder";
+}
+type VfsNode<TMeta = Record<string, unknown>> = VfsFileNode<TMeta> | VfsFolderNode<TMeta>;
+interface VfsFileSnapshot {
+    id: string;
+    fileId: string;
+    index: number;
+    content: Uint8Array;
+    createdAt: number;
+    label?: string;
+}
+type VfsOperation = "create" | "rename" | "delete" | "restore" | "purge" | "move" | "write" | "lock" | "unlock" | "reorder" | "snapshot";
+interface VfsEngineConfig<TMeta = Record<string, unknown>> {
+    sessionId: string;
+    allowDuplicateNames: boolean;
+    duplicateResolution: "throw" | "auto-rename" | "allow";
+    checkPermission?: (node: VfsNode<TMeta>, op: VfsOperation) => boolean;
+    history?: {
+        maxSnapshots: number;
+        autosave?: {
+            enabled: boolean;
+            intervalMs: number;
+        };
+    };
+}
+
+export type { VfsEngineConfig as V, VfsBaseNode as a, VfsFileNode as b, VfsFileSnapshot as c, VfsFolderNode as d, VfsNode as e, VfsNodeOrder as f, VfsOperation as g };

package/dist/VfsNode-D10gxL5W.d.ts

@@ -0,0 +1,48 @@
+interface VfsBaseNode<TMeta = Record<string, unknown>> {
+    id: string;
+    name: string;
+    parentId: string | null;
+    sortIndex: number | null;
+    lockedBy: string | null;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt: number | null;
+    meta: TMeta;
+}
+interface VfsNodeOrder {
+    parentId: string | null;
+    orderedIds: string[];
+}
+interface VfsFileNode<TMeta = Record<string, unknown>> extends VfsBaseNode<TMeta> {
+    kind: "file";
+    mimeType: string;
+    size: number;
+}
+interface VfsFolderNode<TMeta = Record<string, unknown>> extends VfsBaseNode<TMeta> {
+    kind: "folder";
+}
+type VfsNode<TMeta = Record<string, unknown>> = VfsFileNode<TMeta> | VfsFolderNode<TMeta>;
+interface VfsFileSnapshot {
+    id: string;
+    fileId: string;
+    index: number;
+    content: Uint8Array;
+    createdAt: number;
+    label?: string;
+}
+type VfsOperation = "create" | "rename" | "delete" | "restore" | "purge" | "move" | "write" | "lock" | "unlock" | "reorder" | "snapshot";
+interface VfsEngineConfig<TMeta = Record<string, unknown>> {
+    sessionId: string;
+    allowDuplicateNames: boolean;
+    duplicateResolution: "throw" | "auto-rename" | "allow";
+    checkPermission?: (node: VfsNode<TMeta>, op: VfsOperation) => boolean;
+    history?: {
+        maxSnapshots: number;
+        autosave?: {
+            enabled: boolean;
+            intervalMs: number;
+        };
+    };
+}
+
+export type { VfsEngineConfig as V, VfsBaseNode as a, VfsFileNode as b, VfsFileSnapshot as c, VfsFolderNode as d, VfsNode as e, VfsNodeOrder as f, VfsOperation as g };