@lapis-notes/api 0.1.0

package/dist/storage/browser.d.ts

@@ -0,0 +1,153 @@
+import type { DataAdapter, DataWriteOptions, ListedFiles, Stat, AsyncResourceAdapter, VaultIdentityAdapter } from "./fs";
+import { ScopedVaultStore, type KeyValueStore, type VaultProfile } from "./vault-state";
+export type BrowserFileSystemPermissionMode = "read" | "readwrite";
+export type BrowserFileSystemPermissionState = "granted" | "denied" | "prompt";
+export interface BrowserFileSystemPermissionDescriptor {
+    mode?: BrowserFileSystemPermissionMode;
+}
+export interface BrowserFileSystemHandle {
+    kind: "file" | "directory";
+    name: string;
+    queryPermission?(descriptor?: BrowserFileSystemPermissionDescriptor): Promise<BrowserFileSystemPermissionState>;
+    requestPermission?(descriptor?: BrowserFileSystemPermissionDescriptor): Promise<BrowserFileSystemPermissionState>;
+}
+export interface BrowserFileSystemWritableFileStream {
+    write(data: ArrayBuffer | Blob | string | Uint8Array): Promise<void>;
+    seek(position: number): Promise<void>;
+    close(): Promise<void>;
+}
+export interface BrowserFileSystemCreateWritableOptions {
+    keepExistingData?: boolean;
+}
+export interface BrowserFileSystemFileHandle extends BrowserFileSystemHandle {
+    kind: "file";
+    getFile(): Promise<Blob & {
+        lastModified?: number;
+        name?: string;
+    }>;
+    createWritable(options?: BrowserFileSystemCreateWritableOptions): Promise<BrowserFileSystemWritableFileStream>;
+}
+export interface BrowserFileSystemDirectoryHandle extends BrowserFileSystemHandle {
+    kind: "directory";
+    getFileHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<BrowserFileSystemFileHandle>;
+    getDirectoryHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<BrowserFileSystemDirectoryHandle>;
+    removeEntry(name: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    entries?(): AsyncIterableIterator<[
+        string,
+        BrowserFileSystemFileHandle | BrowserFileSystemDirectoryHandle
+    ]>;
+    [Symbol.asyncIterator]?(): AsyncIterableIterator<[
+        string,
+        BrowserFileSystemFileHandle | BrowserFileSystemDirectoryHandle
+    ]>;
+}
+export interface BrowserVaultAdapterOptions {
+    vaultId?: string;
+    name?: string;
+    stateStore?: KeyValueStore;
+}
+export interface BrowserDirectoryImportProgress {
+    totalFiles: number;
+    importedFiles: number;
+    currentPath: string | null;
+}
+export interface BrowserDirectoryImportOptions {
+    onProgress?: (progress: BrowserDirectoryImportProgress) => void | Promise<void>;
+}
+export interface BrowserDirectoryExportProgress {
+    totalFiles: number;
+    exportedFiles: number;
+    currentPath: string | null;
+}
+export interface BrowserDirectoryExportOptions {
+    onProgress?: (progress: BrowserDirectoryExportProgress) => void | Promise<void>;
+}
+export declare function importDirectoryHandleToAdapter(source: BrowserFileSystemDirectoryHandle, target: DataAdapter, options?: BrowserDirectoryImportOptions): Promise<BrowserDirectoryImportProgress>;
+export declare function exportAdapterToDirectoryHandle(source: DataAdapter, target: BrowserFileSystemDirectoryHandle, options?: BrowserDirectoryExportOptions): Promise<BrowserDirectoryExportProgress>;
+export declare class BrowserHandleVaultAdapter implements DataAdapter, VaultIdentityAdapter, AsyncResourceAdapter {
+    readonly kind: "opfs" | "file-system-access";
+    protected readonly stats: ScopedVaultStore;
+    private readonly locks;
+    protected root: BrowserFileSystemDirectoryHandle;
+    constructor(root: BrowserFileSystemDirectoryHandle, kind: "opfs" | "file-system-access", options?: BrowserVaultAdapterOptions);
+    protected readonly vaultId: string;
+    protected readonly name: string;
+    getName(): string;
+    getVaultId(): string;
+    getCapabilities(): {
+        persistent: boolean;
+        userVisibleFiles: boolean;
+        requiresPermission: boolean;
+        nativeWatch: boolean;
+        resourceUrls: boolean;
+        systemTrash: boolean;
+    };
+    protected refreshRootHandleIfNeeded(): Promise<void>;
+    private withPathLock;
+    private withHandleRetry;
+    private getDirectory;
+    private getParentDirectory;
+    private getHandle;
+    private readStoredStat;
+    private writeStoredStat;
+    private deleteStoredStats;
+    private moveStoredStats;
+    exists(normalizedPath: string, sensitive?: boolean): Promise<boolean>;
+    stat(normalizedPath: string): Promise<Stat | null>;
+    read(normalizedPath: string): Promise<string>;
+    readBinary(normalizedPath: string): Promise<ArrayBuffer>;
+    write(normalizedPath: string, data: string, options?: DataWriteOptions): Promise<void>;
+    writeBinary(normalizedPath: string, data: ArrayBuffer, options?: DataWriteOptions): Promise<void>;
+    private writeFile;
+    append(normalizedPath: string, data: string, options?: DataWriteOptions): Promise<void>;
+    appendBinary(normalizedPath: string, data: ArrayBuffer, options?: DataWriteOptions): Promise<void>;
+    process(normalizedPath: string, fn: (data: string) => string, options?: DataWriteOptions): Promise<string>;
+    list(normalizedPath: string): Promise<ListedFiles>;
+    mkdir(normalizedPath: string, options?: Partial<{
+        recursive: boolean;
+        mode: string;
+    }>): Promise<void>;
+    rmdir(normalizedPath: string, recursive: boolean): Promise<void>;
+    remove(normalizedPath: string): Promise<void>;
+    rename(normalizedPath: string, normalizedNewPath: string): Promise<void>;
+    copy(normalizedPath: string, normalizedNewPath: string): Promise<void>;
+    getResourcePath(normalizedPath: string): string;
+    getResourceUrl(normalizedPath: string): Promise<string>;
+    revokeResourceUrl(url: string): void;
+    trashSystem(normalizedPath: string): Promise<boolean>;
+    trashLocal(normalizedPath: string): Promise<void>;
+}
+export declare function humanizeOpfsVaultId(vaultId: string): string;
+export declare function listOpfsVaultIds(): Promise<string[]>;
+export declare function listOrphanOpfsVaultIds(stateStore?: KeyValueStore): Promise<string[]>;
+export declare function createOpfsVault(options: {
+    name: string;
+    vaultId?: string;
+    stateStore?: KeyValueStore;
+}): Promise<OpfsVaultAdapter>;
+export declare class OpfsVaultAdapter extends BrowserHandleVaultAdapter {
+    static create(options?: BrowserVaultAdapterOptions): Promise<OpfsVaultAdapter>;
+    protected refreshRootHandleIfNeeded(): Promise<void>;
+    private constructor();
+}
+export declare class FileSystemAccessAdapter extends BrowserHandleVaultAdapter {
+    static fromHandle(handle: BrowserFileSystemDirectoryHandle, options?: BrowserVaultAdapterOptions): Promise<FileSystemAccessAdapter>;
+    private constructor();
+}
+export declare function pickFileSystemAccessDirectoryHandle(options?: {
+    id?: string;
+    mode?: BrowserFileSystemPermissionMode;
+}): Promise<BrowserFileSystemDirectoryHandle>;
+export declare function pickFileSystemAccessVault(options?: BrowserVaultAdapterOptions): Promise<FileSystemAccessAdapter>;
+export declare function deleteBrowserLocalVault(profile: Pick<VaultProfile, "id" | "kind">, options?: {
+    stateStore?: KeyValueStore;
+}): Promise<void>;
+export declare function deleteOrphanOpfsVault(vaultId: string, options?: {
+    stateStore?: KeyValueStore;
+}): Promise<void>;