@pistonite/pure 0.0.12

package/src/fs/FsImplEntryAPI.ts

@@ -0,0 +1,188 @@
+import { type Ok, tryAsync, errstr } from "../result/index.ts";
+
+import { FsErr, type FsResult, type FsVoid, fsErr, fsFail } from "./FsError.ts";
+import type {
+    FsFileSystem,
+    FsFileSystemUninit,
+    FsCapabilities,
+} from "./FsFileSystem.ts";
+import type { FsFile } from "./FsFile.ts";
+import { fsIsRoot, fsNormalize } from "./FsPath.ts";
+import { FsFileMgr } from "./FsFileMgr.ts";
+import type { FsFileSystemInternal } from "./FsFileSystemInternal.ts";
+
+/** FsFileSystem implementation that uses FileEntry API */
+export class FsImplEntryAPI
+    implements FsFileSystemUninit, FsFileSystem, FsFileSystemInternal
+{
+    public root: string;
+    public capabilities: FsCapabilities;
+
+    private rootEntry: FileSystemDirectoryEntry;
+
+    private mgr: FsFileMgr;
+
+    constructor(root: string, rootEntry: FileSystemDirectoryEntry) {
+        this.root = root;
+        this.rootEntry = rootEntry;
+        this.capabilities = {
+            write: false,
+            live: true,
+        };
+        this.mgr = new FsFileMgr();
+    }
+
+    public init(): Promise<FsResult<FsFileSystem>> {
+        // no init needed
+        return Promise.resolve({ val: this });
+    }
+
+    public async listDir(path: string): Promise<FsResult<string[]>> {
+        const normalized = fsNormalize(path);
+        if (normalized.err) {
+            return normalized;
+        }
+        path = normalized.val;
+
+        const entry = await this.resolveDir(path);
+        if (entry.err) {
+            return entry;
+        }
+
+        const entries = await tryAsync(
+            () =>
+                new Promise<FileSystemEntry[]>((resolve, reject) => {
+                    entry.val.createReader().readEntries(resolve, reject);
+                }),
+        );
+        if ("err" in entries) {
+            const err = fsFail(
+                "Failed to list directory `" +
+                    path +
+                    "`: " +
+                    errstr(entries.err),
+            );
+            return { err };
+        }
+
+        const names = entries.val.map(({ isDirectory, name }) => {
+            if (isDirectory) {
+                return name + "/";
+            }
+            return name;
+        });
+
+        return { val: names };
+    }
+
+    public async read(path: string): Promise<FsResult<File>> {
+        const normalized = fsNormalize(path);
+        if (normalized.err) {
+            return normalized;
+        }
+        path = normalized.val;
+
+        const entry = await this.resolveFile(path);
+        if (entry.err) {
+            return entry;
+        }
+
+        const file = await tryAsync(
+            () =>
+                new Promise<File>((resolve, reject) => {
+                    entry.val.file(resolve, reject);
+                }),
+        );
+        if ("err" in file) {
+            const err = fsFail(
+                "Failed to read file `" + path + "`: " + errstr(file.err),
+            );
+            return { err };
+        }
+
+        return file;
+    }
+
+    public write(): Promise<FsVoid> {
+        const err = fsErr(
+            FsErr.NotSupported,
+            "Write not supported in FileEntry API",
+        );
+        return Promise.resolve({ err });
+    }
+
+    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 a directory entry. Path must be normalized */
+    private async resolveDir(
+        path: string,
+    ): Promise<FsResult<FileSystemDirectoryEntry>> {
+        if (fsIsRoot(path)) {
+            return { val: this.rootEntry };
+        }
+        const entry = await tryAsync(
+            () =>
+                new Promise<FileSystemEntry>((resolve, reject) => {
+                    this.rootEntry.getDirectory(path, {}, resolve, reject);
+                }),
+        );
+        if ("err" in entry) {
+            const err = fsFail(
+                "Failed to resolve directory `" +
+                    path +
+                    "`: " +
+                    errstr(entry.err),
+            );
+            return { err };
+        }
+        if (!entry.val.isDirectory) {
+            const err = fsErr(
+                FsErr.IsFile,
+                "Path `" + path + "` is not a directory",
+            );
+            return { err };
+        }
+        return entry as Ok<FileSystemDirectoryEntry>;
+    }
+
+    /** Resolve a file entry. Path must be normalized */
+    private async resolveFile(
+        path: string,
+    ): Promise<FsResult<FileSystemFileEntry>> {
+        if (fsIsRoot(path)) {
+            const err = fsErr(
+                FsErr.IsDirectory,
+                "Path `" + path + "` is not a file",
+            );
+            return { err };
+        }
+        const entry = await tryAsync(
+            () =>
+                new Promise<FileSystemEntry>((resolve, reject) => {
+                    this.rootEntry.getFile(path, {}, resolve, reject);
+                }),
+        );
+        if ("err" in entry) {
+            const err = fsFail(
+                "Failed to resolve file `" + path + "`: " + errstr(entry.err),
+            );
+            return { err };
+        }
+        if (!entry.val.isFile) {
+            const err = fsErr(
+                FsErr.IsDirectory,
+                "Path `" + path + "` is not a file",
+            );
+            return { err };
+        }
+        return entry as Ok<FileSystemFileEntry>;
+    }
+}

package/src/fs/FsImplFileAPI.ts

@@ -0,0 +1,126 @@
+import type { FsFile } from "./FsFile.ts";
+import type {
+    FsFileSystem,
+    FsFileSystemUninit,
+    FsCapabilities,
+} from "./FsFileSystem.ts";
+import { FsErr, type FsResult, type FsVoid, fsErr } from "./FsError.ts";
+import { fsIsRoot, fsNormalize } from "./FsPath.ts";
+import { FsFileMgr } from "./FsFileMgr.ts";
+import type { FsFileSystemInternal } from "./FsFileSystemInternal.ts";
+
+/**
+ * FileSystem implementation that uses a list of Files
+ * This is supported in all browsers, but it is stale.
+ * It's used for Firefox when the File Entries API is not available
+ * i.e. opened from <input type="file">
+ */
+export class FsImplFileAPI
+    implements FsFileSystemUninit, FsFileSystem, FsFileSystemInternal
+{
+    public root: string;
+    public capabilities: FsCapabilities;
+
+    private files: Record<string, File>;
+    private directories: Record<string, string[]>;
+    private mgr: FsFileMgr;
+
+    constructor(files: FileList) {
+        // this seems to also work for windows
+        this.root = files[0].webkitRelativePath.split("/", 1)[0];
+        this.capabilities = {
+            write: false,
+            live: false,
+        };
+        this.files = {};
+        this.directories = {};
+        this.mgr = new FsFileMgr();
+
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            // remove "<root>/"
+            const path = file.webkitRelativePath.slice(this.root.length + 1);
+            const normalized = fsNormalize(path);
+            if (normalized.err) {
+                // shouldn't happen since the path is from the File API
+                console.error("Invalid path: " + path);
+                continue;
+            }
+            this.files[normalized.val] = file;
+        }
+    }
+
+    public init(): Promise<FsResult<FsFileSystem>> {
+        // no init needed
+        return Promise.resolve({ val: this });
+    }
+
+    public listDir(path: string): Promise<FsResult<string[]>> {
+        const normalized = fsNormalize(path);
+        if (normalized.err) {
+            return Promise.resolve(normalized);
+        }
+        path = normalized.val;
+
+        if (path in this.directories) {
+            return Promise.resolve({ val: this.directories[path] });
+        }
+
+        const set = new Set<string>();
+        const prefix = fsIsRoot(path) ? "" : path + "/";
+
+        Object.keys(this.files).forEach((path) => {
+            if (!path.startsWith(prefix)) {
+                return;
+            }
+            const relPath = path.slice(prefix.length);
+            const slashIndex = relPath.indexOf("/");
+            if (slashIndex < 0) {
+                // file
+                set.add(relPath);
+            } else {
+                // directory
+                const dir = relPath.slice(0, slashIndex + 1);
+                set.add(dir);
+            }
+        });
+
+        const paths = Array.from(set);
+        this.directories[path] = paths;
+
+        return Promise.resolve({ val: paths });
+    }
+
+    public read(path: string): Promise<FsResult<File>> {
+        const normalized = fsNormalize(path);
+        if (normalized.err) {
+            return Promise.resolve(normalized);
+        }
+
+        const file = this.files[normalized.val];
+        if (!file) {
+            const err = fsErr(FsErr.NotFound, "File not found: " + path);
+            return Promise.resolve({ err });
+        }
+
+        return Promise.resolve({ val: file });
+    }
+
+    public write(): Promise<FsVoid> {
+        const err = fsErr(
+            FsErr.NotSupported,
+            "Write not supported in File API",
+        );
+        return Promise.resolve({ err });
+    }
+
+    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);
+    }
+}

package/src/fs/FsImplHandleAPI.ts

@@ -0,0 +1,237 @@
+/**
+ * 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;
+    }
+}