@pistonite/pure 0.27.1 → 0.29.0

package/src/fs/FsFileStandaloneImplFileAPI.ts

@@ -1,54 +0,0 @@
-import { ilog } from "../log/internal.ts";
-import { errstr } from "../result";
-
-import { fsErr, FsErr, fsFail, type FsVoid, type FsResult } from "./FsError.ts";
-import type { FsFileStandalone } from "./FsFileStandalone.ts";
-
-export class FsFileStandaloneImplFileAPI implements FsFileStandalone {
-    public name: string;
-    private size: number;
-    private lastModified: number;
-    private file: File;
-
-    constructor(file: File) {
-        this.name = file.name;
-        this.size = file.size;
-        this.lastModified = file.lastModified;
-        this.file = file;
-    }
-
-    public async isWritable(): Promise<boolean> {
-        return false;
-    }
-
-    public async getSize(): Promise<FsResult<number>> {
-        return { val: this.size };
-    }
-
-    public async getBytes(): Promise<FsResult<Uint8Array>> {
-        try {
-            const data = await this.file.arrayBuffer();
-            return { val: new Uint8Array(data) };
-        } catch (e) {
-            ilog.error(e);
-            return { err: fsFail(errstr(e)) };
-        }
-    }
-    public async getLastModified(): Promise<FsResult<number>> {
-        return { val: this.lastModified };
-    }
-    public async getText(): Promise<FsResult<string>> {
-        try {
-            const data = await this.file.text();
-            return { val: data };
-        } catch (e) {
-            ilog.error(e);
-            return { err: fsFail(errstr(e)) };
-        }
-    }
-    public async write(): Promise<FsVoid> {
-        return {
-            err: fsErr(FsErr.NotSupported, "Write not supported in File API"),
-        };
-    }
-}

package/src/fs/FsFileStandaloneImplHandleAPI.ts

@@ -1,147 +0,0 @@
-import { ilog } from "../log/internal.ts";
-import { errstr } from "../result";
-
-import { fsErr, FsErr, fsFail, type FsVoid, type FsResult } from "./FsError.ts";
-import type { FsFileStandalone } from "./FsFileStandalone.ts";
-
-export class FsFileStandaloneImplHandleAPI implements FsFileStandalone {
-    name: string;
-    private handle: FileSystemFileHandle;
-    constructor(handle: FileSystemFileHandle) {
-        this.name = handle.name;
-        this.handle = handle;
-    }
-
-    public async isWritable(): Promise<boolean> {
-        if (
-            !("queryPermission" in this.handle) ||
-            !(typeof this.handle.queryPermission === "function")
-        ) {
-            return false;
-        }
-        try {
-            const permission = await this.handle.queryPermission({
-                mode: "readwrite",
-            });
-            if (permission === "granted") {
-                return true;
-            }
-            if (permission === "denied") {
-                return false;
-            }
-            if (
-                !("requestPermission" in this.handle) ||
-                !(typeof this.handle.requestPermission === "function")
-            ) {
-                return false;
-            }
-            const requestedPermission = await this.handle.requestPermission({
-                mode: "readwrite",
-            });
-            return requestedPermission === "granted";
-        } catch (e) {
-            ilog.error(e);
-            return false;
-        }
-    }
-
-    private async getFile(): Promise<FsResult<File>> {
-        try {
-            return { val: await this.handle.getFile() };
-        } catch (e) {
-            if (e && typeof e === "object" && "name" in e) {
-                if (e.name === "NotAllowedError") {
-                    return {
-                        err: fsErr(FsErr.PermissionDenied, "Permission denied"),
-                    };
-                }
-                if (e.name === "NotFoundError") {
-                    return { err: fsErr(FsErr.NotFound, "File not found") };
-                }
-            }
-            ilog.error(e);
-            return { err: fsFail(errstr(e)) };
-        }
-    }
-
-    public async getSize(): Promise<FsResult<number>> {
-        const file = await this.getFile();
-        if (file.err) {
-            return file;
-        }
-        return { val: file.val.size };
-    }
-    public async getBytes(): Promise<FsResult<Uint8Array>> {
-        const file = await this.getFile();
-        if (file.err) {
-            return file;
-        }
-        try {
-            const data = await file.val.arrayBuffer();
-            return { val: new Uint8Array(data) };
-        } catch (e) {
-            ilog.error(e);
-            return { err: fsFail(errstr(e)) };
-        }
-    }
-    public async getLastModified(): Promise<FsResult<number>> {
-        const file = await this.getFile();
-        if (file.err) {
-            return file;
-        }
-        return { val: file.val.lastModified };
-    }
-    public async getText(): Promise<FsResult<string>> {
-        const file = await this.getFile();
-        if (file.err) {
-            return file;
-        }
-        try {
-            const data = await file.val.text();
-            return { val: data };
-        } catch (e) {
-            ilog.error(e);
-            return { err: fsFail(errstr(e)) };
-        }
-    }
-    public async write(content: Uint8Array | string): Promise<FsVoid> {
-        const writable = await this.isWritable();
-        if (!writable) {
-            return {
-                err: fsErr(FsErr.NotSupported, "Permission was not granted or API not supported"),
-            };
-        }
-        try {
-            const stream = await this.handle.createWritable();
-            await stream.write(content);
-            await stream.close();
-            return {};
-        } catch (e) {
-            if (e && typeof e === "object" && "name" in e) {
-                if (e.name === "NotAllowedError") {
-                    return {
-                        err: fsErr(FsErr.PermissionDenied, "Permission denied"),
-                    };
-                }
-                if (e.name === "NotFoundError") {
-                    return { err: fsErr(FsErr.NotFound, "File not found") };
-                }
-                if (e.name === "NoMidificationAllowedError") {
-                    return {
-                        err: fsErr(FsErr.PermissionDenied, "Failed to acquire write lock"),
-                    };
-                }
-                if (e.name === "AbortError") {
-                    return { err: fsErr(FsErr.UserAbort, "User abort") };
-                }
-                if (e.name === "QuotaExceededError") {
-                    return {
-                        err: fsErr(FsErr.PermissionDenied, "Quota exceeded"),
-                    };
-                }
-            }
-            ilog.error(e);
-            return { err: fsFail(errstr(e)) };
-        }
-    }
-}

package/src/fs/FsFileSystem.ts

@@ -1,71 +0,0 @@
-import type { FsFile } from "./FsFile.ts";
-import type { FsResult } from "./FsError.ts";
-
-/**
- * File system before it is initialized
- *
- * This is an internal type used inside fsOpen functions
- */
-export interface FsFileSystemUninit {
-    /// Initialize the file system
-    init(): Promise<FsResult<FsFileSystem>>;
-}
-
-/** Initialized file system */
-export interface FsFileSystem {
-    /**
-     * Get the root path of the file system for display
-     *
-     * The returned string has no significance in the file system itself.
-     * It should only be used as an indicator to the user.
-     */
-    readonly root: string;
-
-    /**
-     * Capabilities of this file system implementation
-     * See README.md for more information
-     */
-    readonly capabilities: FsCapabilities;
-
-    /**
-     * List files in a directory
-     *
-     * The input path should be relative to the root (of the uploaded directory).
-     *
-     * Returns a list of file names in the directory (not full paths).
-     * Directory names end with a slash.
-     *
-     * Returns Fail if the underlying file system operation fails.
-     */
-    listDir: (path: string) => Promise<FsResult<string[]>>;
-
-    /**
-     * Get a file object for operations
-     *
-     * The returned object can store temporary state for the file, such
-     * as newer content. Calling openFile with the same path will
-     * return the same object.
-     *
-     * Note that opening a file doesn't actually block the file
-     * from being modified by programs other than the browser.
-     *
-     * You can make the FsFileSystem forget about the file by
-     * calling `close` on the file object.
-     */
-    getFile: (path: string) => FsFile;
-
-    /** Get all paths that `getFile` has been called with but not `close`d */
-    getOpenedPaths: () => string[];
-}
-
-/** Capabilities of the file system implementation */
-export type FsCapabilities = {
-    /** Can the browser directly write to the file system */
-    write: boolean;
-    /**
-     * Can the browser detect live updates:
-     * - Change of modified time
-     * - Change of directory structure (new, renamed, deleted files)
-     */
-    live: boolean;
-};

package/src/fs/FsFileSystemInternal.ts

@@ -1,30 +0,0 @@
-import type { FsResult, FsVoid } from "./FsError.ts";
-
-/** Internal APIs for FsFileSystem */
-export interface FsFileSystemInternal {
-    /**
-     * Read the file as a File object
-     *
-     * Returns Fail if the underlying file system operation fails.
-     */
-    read: (path: string) => Promise<FsResult<File>>;
-
-    /**
-     * Write content to a file on disk
-     *
-     * Writes the content to the path specified.
-     * If the content is a string, UTF-8 encoding is used.
-     *
-     * Will overwrite existing file.
-     *
-     * Returns Fail if the underlying file system operation fails.
-     * Returns NotSupported if the browser does not support this
-     * Returns PermissionDenied if the operation is supported, but permission is not given
-     */
-    write: (path: string, content: Uint8Array) => Promise<FsVoid>;
-
-    /**
-     * Forget about a file
-     */
-    closeFile: (path: string) => void;
-}

package/src/fs/FsImplEntryAPI.ts

@@ -1,149 +0,0 @@
-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

@@ -1,116 +0,0 @@
-import { ilog } from "../log/internal.ts";
-
-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
-                ilog.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);
-    }
-}