@pistonite/pure 0.27.1 → 0.29.0

package/src/fs/FsImplHandleAPI.ts

@@ -1,199 +0,0 @@
-/**
- * FsFileSystem implementation for FileSystemAccess API
- * @module
- */
-
-import { tryAsync, errstr } from "../result/index.ts";
-
-import type { FsFileSystem, FsFileSystemUninit, FsCapabilities } from "./FsFileSystem.ts";
-import { FsErr, type FsResult, type FsVoid, fsErr, fsFail } from "./FsError.ts";
-import type { FsFile } from "./FsFile.ts";
-import { fsComponents, fsGetBase, fsGetName, fsIsRoot, fsNormalize } from "./FsPath.ts";
-import { FsFileMgr } from "./FsFileMgr.ts";
-import type { FsFileSystemInternal } from "./FsFileSystemInternal.ts";
-
-type PermissionStatus = "granted" | "denied" | "prompt";
-
-/**
- * FsFileSystem implementation that uses FileSystem Access API
- * This is only supported in Chrome/Edge
- */
-export class FsImplHandleAPI implements FsFileSystemUninit, FsFileSystem, FsFileSystemInternal {
-    public root: string;
-    public capabilities: FsCapabilities;
-    /** If app requested write access */
-    private writeMode: boolean;
-    private rootHandle: FileSystemDirectoryHandle;
-    private permissionStatus: PermissionStatus;
-
-    private mgr: FsFileMgr;
-
-    constructor(rootPath: string, rootHandle: FileSystemDirectoryHandle, write: boolean) {
-        this.root = rootPath;
-        this.rootHandle = rootHandle;
-        this.writeMode = write;
-        this.permissionStatus = "prompt";
-        this.capabilities = { write, live: true };
-        this.mgr = new FsFileMgr();
-    }
-
-    public async init(): Promise<FsResult<FsFileSystem>> {
-        // @ts-expect-error ts lib does not have requestPermission
-        this.permissionStatus = await this.rootHandle.requestPermission({
-            mode: this.writeMode ? "readwrite" : "read",
-        });
-        if (this.permissionStatus !== "granted") {
-            const err = fsErr(FsErr.PermissionDenied, "User denied permission");
-            return { err };
-        }
-        return { val: this };
-    }
-
-    public async listDir(path: string): Promise<FsResult<string[]>> {
-        const normalized = fsNormalize(path);
-        if (normalized.err) {
-            return normalized;
-        }
-        path = normalized.val;
-
-        const handle = await this.resolveDir(path);
-        if (handle.err) {
-            return handle;
-        }
-
-        const entries = await tryAsync(async () => {
-            const entries: string[] = [];
-            // @ts-expect-error ts lib does not have values()
-            for await (const entry of handle.val.values()) {
-                const { kind, name } = entry;
-                if (kind === "directory") {
-                    entries.push(name + "/");
-                } else {
-                    entries.push(name);
-                }
-            }
-            return entries;
-        });
-        if ("err" in entries) {
-            const err = fsFail(
-                "Error reading entries from directory `" + path + "`: " + errstr(entries.err),
-            );
-            return { err };
-        }
-        return entries;
-    }
-
-    public async read(path: string): Promise<FsResult<File>> {
-        const normalized = fsNormalize(path);
-        if (normalized.err) {
-            return normalized;
-        }
-        path = normalized.val;
-
-        const handle = await this.resolveFile(path);
-        if (handle.err) {
-            return handle;
-        }
-
-        const file = await tryAsync(() => handle.val.getFile());
-        if ("err" in file) {
-            const err = fsFail("Failed to read file `" + path + "`: " + errstr(file.err));
-            return { err };
-        }
-        return file;
-    }
-
-    public async write(path: string, content: Uint8Array): Promise<FsVoid> {
-        if (!this.writeMode) {
-            const err = fsErr(FsErr.PermissionDenied, "Write mode not requested");
-            return { err };
-        }
-        const normalized = fsNormalize(path);
-        if (normalized.err) {
-            return normalized;
-        }
-        path = normalized.val;
-
-        const handle = await this.resolveFile(path);
-        if (handle.err) {
-            return handle;
-        }
-
-        const result = await tryAsync(async () => {
-            const file = await handle.val.createWritable();
-            await file.write(content);
-            await file.close();
-            return {};
-        });
-        if ("err" in result) {
-            const err = fsFail("Failed to write file `" + path + "`: " + errstr(result.err));
-            return { err };
-        }
-        return {};
-    }
-
-    public getFile(path: string): FsFile {
-        return this.mgr.get(this, path);
-    }
-
-    public getOpenedPaths(): string[] {
-        return this.mgr.getOpenedPaths();
-    }
-    public closeFile(path: string): void {
-        this.mgr.close(path);
-    }
-
-    /**
-     * Resolve the FileSystemDirectoryHandle for a directory.
-     * The path must be normalized
-     */
-    private async resolveDir(path: string): Promise<FsResult<FileSystemDirectoryHandle>> {
-        if (fsIsRoot(path)) {
-            return { val: this.rootHandle };
-        }
-        let handle: FileSystemDirectoryHandle = this.rootHandle;
-        const parts: string[] = [];
-        for (const part of fsComponents(path)) {
-            parts.push(part);
-            const next = await tryAsync(() => handle.getDirectoryHandle(part));
-            if ("err" in next) {
-                const dir = parts.join("/");
-                const err = fsFail(
-                    "Failed to resolve directory `" + dir + "`: " + errstr(next.err),
-                );
-                return { err };
-            }
-            handle = next.val;
-        }
-
-        return { val: handle };
-    }
-
-    /**
-     * Resolve the FileSystemFileHandle for a file.
-     * The path must be normalized
-     */
-    private async resolveFile(path: string): Promise<FsResult<FileSystemFileHandle>> {
-        const parent = fsGetBase(path);
-        if (parent.err) {
-            return parent;
-        }
-
-        const name = fsGetName(path);
-        if (name.err) {
-            return name;
-        }
-
-        const handle = await this.resolveDir(parent.val);
-        if (handle.err) {
-            return handle;
-        }
-
-        const file = await tryAsync(() => handle.val.getFileHandle(name.val));
-        if ("err" in file) {
-            const err = fsFail("Failed to resolve file `" + path + "`: " + errstr(file.err));
-            return { err };
-        }
-        return file;
-    }
-}

package/src/fs/FsOpen.ts

@@ -1,271 +0,0 @@
-import { tryCatch, tryAsync, errstr } from "../result/index.ts";
-
-import type { FsFileSystem, FsFileSystemUninit } from "./FsFileSystem.ts";
-import { FsErr, type FsError, type FsResult, fsErr, fsFail } from "./FsError.ts";
-import { fsGetSupportStatus } from "./FsSupportStatus.ts";
-import { FsImplFileAPI } from "./FsImplFileAPI.ts";
-import { FsImplEntryAPI } from "./FsImplEntryAPI.ts";
-import { FsImplHandleAPI } from "./FsImplHandleAPI.ts";
-
-/** Handle for handling top level open errors, and decide if the operation should be retried */
-export type FsOpenRetryHandler = (error: FsError, attempt: number) => Promise<FsResult<boolean>>;
-
-const MAX_RETRY = 10;
-
-/** Open a file system for read-only access with a directory picker dialog */
-export async function fsOpenRead(
-    retryHandler?: FsOpenRetryHandler,
-): Promise<FsResult<FsFileSystem>> {
-    const fs = await createWithPicker(false, retryHandler);
-    if (fs.err) {
-        return fs;
-    }
-    return await init(fs.val, retryHandler);
-}
-
-/** Open a file system for read-write access with a directory picker dialog */
-export async function fsOpenReadWrite(
-    retryHandler?: FsOpenRetryHandler,
-): Promise<FsResult<FsFileSystem>> {
-    const fs = await createWithPicker(true, retryHandler);
-    if (fs.err) {
-        return fs;
-    }
-    return await init(fs.val, retryHandler);
-}
-
-/** Open a file system for read-only access from a DataTransferItem from a drag and drop event */
-export async function fsOpenReadFrom(
-    item: DataTransferItem,
-    retryHandler?: FsOpenRetryHandler,
-): Promise<FsResult<FsFileSystem>> {
-    const fs = await createFromDataTransferItem(item, false, retryHandler);
-    if (fs.err) {
-        return fs;
-    }
-    return await init(fs.val, retryHandler);
-}
-
-/** Open a file system for read-write access from a DataTransferItem from a drag and drop event */
-export async function fsOpenReadWriteFrom(
-    item: DataTransferItem,
-    retryHandler?: FsOpenRetryHandler,
-): Promise<FsResult<FsFileSystem>> {
-    const fs = await createFromDataTransferItem(item, true, retryHandler);
-    if (fs.err) {
-        return fs;
-    }
-    return await init(fs.val, retryHandler);
-}
-
-async function createWithPicker(
-    write: boolean,
-    retryHandler: FsOpenRetryHandler | undefined,
-): Promise<FsResult<FsFileSystemUninit>> {
-    for (let attempt = 1; attempt <= MAX_RETRY; attempt++) {
-        const { implementation } = fsGetSupportStatus();
-        if (implementation === "FileSystemAccess") {
-            const handle = await tryAsync(() => showDirectoryPicker(write));
-            if (handle.val) {
-                return createFromFileSystemHandle(handle.val, write);
-            }
-            if (retryHandler) {
-                const error = isAbortError(handle.err)
-                    ? fsErr(FsErr.UserAbort, "User cancelled the operation")
-                    : fsFail(errstr(handle.err));
-                const shouldRetry = await retryHandler(error, attempt);
-                if (shouldRetry.err) {
-                    // retry handler failed
-                    return shouldRetry;
-                }
-                if (!shouldRetry.val) {
-                    // don't retry
-                    return { err: error };
-                }
-            }
-            // Retry with FileSystemAccess API
-            continue;
-        }
-
-        // FileEntry API only supported through drag and drop
-        // so fallback to File API
-        const inputElement = document.createElement("input");
-        inputElement.id = "temp";
-        inputElement.style.display = "none";
-        document.body.appendChild(inputElement);
-        inputElement.type = "file";
-        inputElement.webkitdirectory = true;
-
-        const fsUninit = await new Promise<FsResult<FsFileSystemUninit>>((resolve) => {
-            inputElement.addEventListener("change", (event) => {
-                const files = (event.target as HTMLInputElement).files;
-                if (!files) {
-                    const err = fsFail("Failed to get files from input element");
-                    return resolve({ err });
-                }
-                resolve(createFromFileList(files));
-            });
-            inputElement.addEventListener("cancel", () => {
-                resolve({
-                    err: fsErr(FsErr.UserAbort, "User cancelled the operation"),
-                });
-            });
-            inputElement.click();
-        });
-        inputElement.remove();
-
-        if (fsUninit.val) {
-            return fsUninit;
-        }
-
-        if (retryHandler) {
-            const shouldRetry = await retryHandler(fsUninit.err, attempt);
-            if (shouldRetry.err) {
-                // retry handler failed
-                return shouldRetry;
-            }
-            if (!shouldRetry.val) {
-                // don't retry
-                return fsUninit;
-            }
-            // fall through to retry
-        }
-    }
-    return { err: fsFail("Max retry count reached") };
-}
-
-async function createFromDataTransferItem(
-    item: DataTransferItem,
-    write: boolean,
-    retryHandler: FsOpenRetryHandler | undefined,
-): Promise<FsResult<FsFileSystemUninit>> {
-    for (let attempt = 1; attempt <= MAX_RETRY; attempt++) {
-        let error: FsError | undefined = undefined;
-        const { implementation } = fsGetSupportStatus();
-        // Prefer File System Access API since it supports writing
-        if ("getAsFileSystemHandle" in item && implementation === "FileSystemAccess") {
-            const handle = await tryAsync(() => getAsFileSystemHandle(item));
-            if (handle.val) {
-                return createFromFileSystemHandle(handle.val, write);
-            }
-            error = fsFail("Failed to get handle from DataTransferItem: " + errstr(handle.err));
-        } else if ("webkitGetAsEntry" in item && implementation === "FileEntry") {
-            const entry = tryCatch(() => webkitGetAsEntry(item));
-            if (entry.val) {
-                return createFromFileSystemEntry(entry.val);
-            }
-            error = fsFail("Failed to get entry from DataTransferItem: " + errstr(entry.err));
-        }
-        if (!error) {
-            const err = fsErr(FsErr.NotSupported, "No supported API found on the DataTransferItem");
-            return { err };
-        }
-        // handle error
-        if (retryHandler) {
-            const shouldRetry = await retryHandler(error, attempt);
-            if (shouldRetry.err) {
-                // retry handler failed
-                return shouldRetry;
-            }
-            if (!shouldRetry.val) {
-                // don't retry
-                return { err: error };
-            }
-            // fall through to retry
-        }
-    }
-    return { err: fsFail("Max retry count reached") };
-}
-
-async function init(
-    fs: FsFileSystemUninit,
-    retryHandler: FsOpenRetryHandler | undefined,
-): Promise<FsResult<FsFileSystem>> {
-    let attempt = -1;
-    while (true) {
-        attempt++;
-        const inited = await fs.init();
-        if (!inited.err) {
-            return inited;
-        }
-        if (!retryHandler) {
-            return inited;
-        }
-        const shouldRetry = await retryHandler(inited.err, attempt);
-        if (shouldRetry.err) {
-            // retry handler failed
-            return shouldRetry;
-        }
-        if (!shouldRetry.val) {
-            // should not retry
-            return inited;
-        }
-    }
-}
-
-/** Wrapper for window.showDirectoryPicker */
-function showDirectoryPicker(write: boolean): Promise<FileSystemHandle> {
-    // @ts-expect-error showDirectoryPicker is not in the TS lib
-    return globalThis.showDirectoryPicker({
-        mode: write ? "readwrite" : "read",
-    });
-}
-
-/**
- * Check if an error is an AbortError from Chromium
- *
- * @param e The error to check
- */
-function isAbortError(e: unknown): boolean {
-    return !!e && typeof e === "object" && "name" in e && e.name === "AbortError";
-}
-
-/** Wrapper for DataTransferItem.getAsFileSystemHandle */
-async function getAsFileSystemHandle(item: DataTransferItem): Promise<FileSystemHandle> {
-    // @ts-expect-error getAsFileSystemHandle is not in the TS lib
-    const handle = await item.getAsFileSystemHandle();
-    if (!handle) {
-        throw new Error("handle is null");
-    }
-    return handle;
-}
-
-/** Wrapper for DataTransferItem.webkitGetAsEntry */
-function webkitGetAsEntry(item: DataTransferItem): FileSystemEntry {
-    const entry = item.webkitGetAsEntry();
-    if (!entry) {
-        throw new Error("entry is null");
-    }
-    return entry;
-}
-
-function createFromFileSystemHandle(
-    handle: FileSystemHandle,
-    write: boolean,
-): FsResult<FsFileSystemUninit> {
-    if (handle.kind !== "directory") {
-        const err = fsErr(FsErr.IsFile, "Expected directory");
-        return { err };
-    }
-
-    const fs = new FsImplHandleAPI(handle.name, handle as FileSystemDirectoryHandle, write);
-
-    return { val: fs };
-}
-
-function createFromFileSystemEntry(entry: FileSystemEntry): FsResult<FsFileSystemUninit> {
-    if (entry.isFile || !entry.isDirectory) {
-        const err = fsErr(FsErr.IsFile, "Expected directory");
-        return { err };
-    }
-    const fs = new FsImplEntryAPI(entry.name, entry as FileSystemDirectoryEntry);
-    return { val: fs };
-}
-
-function createFromFileList(files: FileList): FsResult<FsFileSystemUninit> {
-    if (!files.length) {
-        const err = fsFail("Expected at least one file");
-        return { err };
-    }
-    return { val: new FsImplFileAPI(files) };
-}