buritifs 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,303 @@
+declare class ExplorerFile {
+    private base;
+    private storage;
+    readonly ok: true;
+    readonly error: null;
+    readonly type: 'file';
+    get path(): string;
+    constructor(base: string, storage: ExplorerTree);
+    info(): Promise<ReturnedExplorerInfoType>;
+    rename({ name }: {
+        name: string;
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    copy({ to, priority }: {
+        to: string;
+        priority?: 'source' | 'destination';
+    }): Promise<ReturnedExplorerFileType>;
+    move({ to, force }: {
+        to: string;
+        force?: boolean;
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    delete(): Promise<ReturnedErrorOrSucessExplorerType>;
+    exists(): Promise<boolean>;
+    write({ content }: {
+        content: ArrayBuffer | string | object;
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    read(): Promise<ReturnedExplorerReadType>;
+}
+
+declare class ExplorerFolder {
+    private base;
+    private storage;
+    readonly ok: true;
+    readonly error: null;
+    readonly type: 'folder';
+    get path(): string;
+    get tree(): ExplorerTree;
+    constructor(base: string, storage: ExplorerTree);
+    info(): Promise<ReturnedExplorerInfoType>;
+    get({ name }: {
+        name: string;
+    }): Promise<ReturnedExplorerFileType | ReturnedExplorerFolderType>;
+    newFolder({ name }: {
+        name: string;
+    }): Promise<ReturnedExplorerFolderType>;
+    newFile({ name }: {
+        name: string;
+    }): Promise<ReturnedExplorerFileType>;
+    rename({ name }: {
+        name: string;
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    copy({ to, merge, priority }: {
+        to: string;
+        merge?: boolean;
+        priority?: 'source' | 'destination';
+    }): Promise<ReturnedExplorerFolderType>;
+    move({ to, force }: {
+        to: string;
+        force?: boolean;
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    delete(): Promise<ReturnedErrorOrSucessExplorerType>;
+    list({ recursive, limit, page, filter }?: {
+        recursive?: boolean;
+        limit?: number;
+        page?: number;
+        filter?: (item: ListItem) => boolean;
+    }): Promise<ReturnedExplorerListType>;
+    exists(): Promise<boolean>;
+    size({ recursive, filter }?: {
+        recursive?: boolean;
+        filter?: (item: ListItem) => boolean;
+    }): Promise<ReturnedExplorerSizeType>;
+}
+
+type PropsClassMainType = {
+    name: string;
+};
+type PropsClassAddNoteBD = {
+    path: string;
+    type: 'file' | 'folder';
+};
+type ReturnedErrorOrSucessExplorerType = {
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    error: null;
+};
+type ReturnedExplorerReadType = {
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    error: null;
+    content: ArrayBuffer;
+    text: string;
+};
+type ListItem = {
+    path: string;
+    type: 'file' | 'folder';
+    createdAt: number;
+    updatedAt: number;
+};
+type ExplorerInfoData = {
+    path: string;
+    createdAt: number;
+    updatedAt: number;
+};
+type ReturnedExplorerInfoType = {
+    ok: false;
+    error: string;
+} | ({
+    ok: true;
+    error: null;
+} & ExplorerInfoData);
+type ReturnedExplorerListType = {
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    error: null;
+    items: ListItem[];
+};
+type ReturnedExplorerSizeType = {
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    error: null;
+    size: number;
+};
+type ReturnedErrorExplorerType = {
+    ok: false;
+    error: string;
+};
+type ReturnedExplorerFolderType = ReturnedErrorExplorerType | ExplorerFolder;
+type ReturnedExplorerFileType = ReturnedErrorExplorerType | ExplorerFile;
+interface TableBuritiTypeBDBase {
+    path: string;
+    parent: string | null;
+    createdAt: number;
+    updatedAt: number;
+    status: 'pending' | 'ready';
+}
+interface TableBuritiTypeBDFolder extends TableBuritiTypeBDBase {
+    type: 'folder';
+}
+interface TableBuritiTypeBDFile extends TableBuritiTypeBDBase {
+    type: 'file';
+    contentId: string;
+}
+type TableBuritiTypeBD = TableBuritiTypeBDFolder | TableBuritiTypeBDFile;
+
+declare class IDBSetup {
+    private static registry;
+    protected db: IDBDatabase | null;
+    private dbName;
+    private static readonly DB_VERSION;
+    constructor({ name }: PropsClassMainType);
+    protected request<T>(mode: IDBTransactionMode, fn: (store: IDBObjectStore) => IDBRequest<T>): Promise<T>;
+    protected transact(mode: IDBTransactionMode, fn: (store: IDBObjectStore) => void): Promise<void>;
+    protected pathTrated(path: string): Promise<{
+        path: string;
+        parent: string | null;
+        name: string;
+        table: TableBuritiTypeBD | null;
+    }>;
+    protected withWAL(data: TableBuritiTypeBD, action: () => Promise<void>): Promise<void>;
+    protected openDB(): Promise<void>;
+    static close({ name }: {
+        name: string;
+    }): void;
+}
+
+declare class OPFSStorage extends IDBSetup {
+    protected root: FileSystemDirectoryHandle;
+    constructor(props: PropsClassMainType);
+    protected openStorage(): Promise<void>;
+    protected writeStorage(id: string, content: ArrayBuffer | string | object): Promise<void>;
+    protected readStorage(id: string): Promise<ArrayBuffer>;
+    protected readTextStorage(id: string): Promise<string>;
+    protected deleteStorage(id: string): Promise<void>;
+    protected existsStorage(id: string): Promise<boolean>;
+}
+
+declare class IDBNodes extends OPFSStorage {
+    constructor(props: PropsClassMainType);
+    protected getSource(props: {
+        path: string;
+    }): Promise<TableBuritiTypeBD>;
+    protected addNode({ path, type }: PropsClassAddNoteBD): Promise<void>;
+    protected removeNode({ path }: {
+        path: string;
+    }): Promise<void>;
+}
+
+declare class IDBQuery extends IDBNodes {
+    constructor(props: PropsClassMainType);
+    protected existsNode({ path }: {
+        path: string;
+    }): Promise<boolean>;
+    protected sizeNode({ pathRef, recursive, filter, }: {
+        pathRef: string;
+        recursive?: boolean;
+        filter?: (item: ListItem) => boolean;
+    }): Promise<number>;
+    protected listNodes({ pathRef, recursive, limit, page, filter, }: {
+        pathRef: string;
+        recursive?: boolean;
+        limit?: number;
+        page?: number;
+        filter?: (item: ListItem) => boolean;
+    }): Promise<ListItem[]>;
+}
+
+declare class IDBRefactor extends IDBQuery {
+    constructor(props: PropsClassMainType);
+    protected copyNode({ fromPath, toPath, merge, priority, }: {
+        fromPath: string;
+        toPath: string;
+        merge?: boolean;
+        priority?: 'source' | 'destination';
+    }): Promise<void>;
+    protected moveNode({ fromPath, toPath, force, }: {
+        fromPath: string;
+        toPath: string;
+        force?: boolean;
+    }): Promise<void>;
+}
+
+declare class StorageInit extends IDBRefactor {
+    constructor(props: PropsClassMainType);
+    protected initExplorerData(): Promise<void>;
+    private recover;
+    private recoverPending;
+    private recoverOrphans;
+    private recoverBroken;
+}
+
+declare class ExplorerTree extends StorageInit {
+    private listeners;
+    private constructor();
+    subscribe(path: string, fn: () => void): () => void;
+    private parentOf;
+    private notify;
+    static create(props: PropsClassMainType): Promise<ExplorerTree | ReturnedErrorExplorerType>;
+    source({ path }: {
+        path: string;
+    }): Promise<ReturnedExplorerFileType | ReturnedExplorerFolderType>;
+    info({ path }: {
+        path: string;
+    }): Promise<ReturnedExplorerInfoType>;
+    type({ path }: {
+        path: string;
+    }): Promise<string | null>;
+    newFolder({ path }: {
+        path: string;
+    }): Promise<ReturnedExplorerFolderType>;
+    newFile({ path }: {
+        path: string;
+    }): Promise<ReturnedExplorerFileType>;
+    delete({ path }: {
+        path: string;
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    copy({ fromPath, toPath, merge, priority }: {
+        fromPath: string;
+        toPath: string;
+        merge?: boolean;
+        priority?: 'source' | 'destination';
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    move({ fromPath, toPath, force }: {
+        fromPath: string;
+        toPath: string;
+        force?: boolean;
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    rename({ path, name }: {
+        path: string;
+        name: string;
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    list({ path, recursive, limit, page, filter }: {
+        path: string;
+        recursive?: boolean;
+        limit?: number;
+        page?: number;
+        filter?: (item: ListItem) => boolean;
+    }): Promise<ReturnedExplorerListType>;
+    exists({ path }: {
+        path: string;
+    }): Promise<boolean>;
+    size({ path, recursive, filter }: {
+        path: string;
+        recursive?: boolean;
+        filter?: (item: ListItem) => boolean;
+    }): Promise<ReturnedExplorerSizeType>;
+    write({ path, content }: {
+        path: string;
+        content: ArrayBuffer | string | object;
+    }): Promise<ReturnedErrorOrSucessExplorerType>;
+    read({ path }: {
+        path: string;
+    }): Promise<ReturnedExplorerReadType>;
+}
+
+export { ExplorerFile, ExplorerFolder, ExplorerTree, type ListItem, type PropsClassMainType, type ReturnedErrorOrSucessExplorerType, type ReturnedExplorerFileType, type ReturnedExplorerFolderType, type ReturnedExplorerInfoType, type ReturnedExplorerListType, type ReturnedExplorerReadType, type ReturnedExplorerSizeType };

package/dist/index.js

@@ -0,0 +1,11 @@
+import {
+  ExplorerFile,
+  ExplorerFolder,
+  ExplorerTree
+} from "./chunk-QOM3Q3WE.js";
+export {
+  ExplorerFile,
+  ExplorerFolder,
+  ExplorerTree
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}