@veryfront/ext-content-mdx 0.1.1186 → 0.1.1189

package/esm/src/platform/adapters/runtime/deno/filesystem-adapter.js

@@ -0,0 +1,291 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { NOT_SUPPORTED } from "../../../../errors/error-registry/general.js";
+import { createFileWatcher } from "../shared/watcher-queue.js";
+import { resolve, sep } from "../../../compat/path/index.js";
+import { validateTempDirectoryPrefix } from "../../../compat/temp-directory-prefix.js";
+import { readBoundedFilePrefix, readFileWithinLimit, withFileHandle, } from "../../bounded-file-read.js";
+import { markNativeFileSystemAdapter } from "../../native-file-system-provenance.js";
+import { NodeCompatibleFileSystemAdapter, } from "../shared/node-filesystem-adapter.js";
+function hasOwn(value, property) {
+    return Object.prototype.hasOwnProperty.call(value, property);
+}
+function getDenoCreateRuntime() {
+    const runtime = dntShim.dntGlobalThis.Deno;
+    return runtime && typeof runtime.open === "function" ? runtime : null;
+}
+async function createDenoFileBytesExclusive(runtime, path, content) {
+    await withFileHandle(() => runtime.open(path, { write: true, createNew: true }), async (file) => {
+        let offset = 0;
+        while (offset < content.byteLength) {
+            const written = await file.write(content.subarray(offset));
+            if (!Number.isSafeInteger(written) || written <= 0 ||
+                written > content.byteLength - offset) {
+                throw new Error("Deno createNew write made no forward progress");
+            }
+            offset += written;
+        }
+    }, "Filesystem exclusive create and handle cleanup both failed");
+}
+function assertDenoRuntime(method) {
+    if (typeof dntShim.Deno === "undefined") {
+        throw NOT_SUPPORTED.create({
+            detail: `DenoFileSystemAdapter.${method}() can only be used in Deno runtime`,
+        });
+    }
+}
+function toFileInfo(stat) {
+    return {
+        size: stat.size,
+        isFile: stat.isFile,
+        isDirectory: stat.isDirectory,
+        isSymlink: stat.isSymlink,
+        mtime: stat.mtime,
+    };
+}
+function toFileChangeKind(kind) {
+    switch (kind) {
+        case "create":
+            return "create";
+        case "modify":
+            return "modify";
+        case "remove":
+            return "delete";
+        default:
+            return "any";
+    }
+}
+function mapNativeWatchPath(path, roots) {
+    for (const root of roots) {
+        if (path === root.nativePath)
+            return root.exposedPath;
+        const prefix = root.nativePath.endsWith(sep) ? root.nativePath : `${root.nativePath}${sep}`;
+        if (path.startsWith(prefix)) {
+            const exposedPrefix = root.exposedPath.endsWith(sep)
+                ? root.exposedPath
+                : `${root.exposedPath}${sep}`;
+            return `${exposedPrefix}${path.slice(prefix.length)}`;
+        }
+    }
+    return path;
+}
+function createClosedWatcher() {
+    const doneResult = {
+        done: true,
+        value: undefined,
+    };
+    const iterator = {
+        next: () => Promise.resolve(doneResult),
+        return: () => Promise.resolve(doneResult),
+    };
+    const watcher = createFileWatcher(iterator, () => { });
+    watcher.ready = Promise.resolve();
+    watcher.done = Promise.resolve();
+    return watcher;
+}
+export class DenoFileSystemAdapter {
+    constructor(options = {}) {
+        const nodeCompatible = new NodeCompatibleFileSystemAdapter(undefined, options);
+        if (Object.hasOwn(nodeCompatible, "readFileSnapshotWithinLimit")) {
+            Object.defineProperty(this, "readFileSnapshotWithinLimit", {
+                value: nodeCompatible.readFileSnapshotWithinLimit,
+                enumerable: true,
+            });
+        }
+        const createRuntime = hasOwn(options, "denoCreateRuntime")
+            ? options.denoCreateRuntime
+            : getDenoCreateRuntime();
+        if (options.exclusiveCreate !== false && createRuntime) {
+            Object.defineProperty(this, "createFileBytesExclusive", {
+                value: (path, content) => createDenoFileBytesExclusive(createRuntime, path, content),
+                enumerable: true,
+            });
+        }
+        if (globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta) === DenoFileSystemAdapter) {
+            markNativeFileSystemAdapter(this);
+        }
+    }
+    async readFile(path) {
+        assertDenoRuntime("readFile");
+        return dntShim.Deno.readTextFile(path);
+    }
+    async readFileBytes(path) {
+        assertDenoRuntime("readFileBytes");
+        return dntShim.Deno.readFile(path);
+    }
+    async readFileBytesBounded(path, byteLimit) {
+        assertDenoRuntime("readFileBytesBounded");
+        return await readBoundedFilePrefix(async () => {
+            const file = await dntShim.Deno.open(path, { read: true });
+            return {
+                close: () => file.close(),
+                read: (buffer) => file.read(buffer),
+            };
+        }, byteLimit);
+    }
+    async readFileBytesWithinLimit(path, byteLimit) {
+        assertDenoRuntime("readFileBytesWithinLimit");
+        return await readFileWithinLimit(async () => {
+            const file = await dntShim.Deno.open(path, { read: true });
+            return {
+                close: () => file.close(),
+                read: (buffer) => file.read(buffer),
+            };
+        }, byteLimit);
+    }
+    async writeFile(path, content) {
+        assertDenoRuntime("writeFile");
+        await dntShim.Deno.writeTextFile(path, content);
+    }
+    async writeFileBytes(path, content) {
+        assertDenoRuntime("writeFileBytes");
+        await dntShim.Deno.writeFile(path, content);
+    }
+    async rename(from, to) {
+        assertDenoRuntime("rename");
+        await dntShim.Deno.rename(from, to);
+    }
+    async exists(path) {
+        assertDenoRuntime("exists");
+        try {
+            await dntShim.Deno.stat(path);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof dntShim.Deno.errors.NotFound)
+                return false;
+            throw error;
+        }
+    }
+    async *readDir(path) {
+        assertDenoRuntime("readDir");
+        for await (const entry of dntShim.Deno.readDir(path)) {
+            yield {
+                name: entry.name,
+                isFile: entry.isFile,
+                isDirectory: entry.isDirectory,
+                isSymlink: entry.isSymlink,
+            };
+        }
+    }
+    async stat(path) {
+        assertDenoRuntime("stat");
+        return toFileInfo(await dntShim.Deno.stat(path));
+    }
+    async lstat(path) {
+        assertDenoRuntime("lstat");
+        return toFileInfo(await dntShim.Deno.lstat(path));
+    }
+    async realPath(path) {
+        assertDenoRuntime("realPath");
+        return await dntShim.Deno.realPath(path);
+    }
+    async mkdir(path, options) {
+        assertDenoRuntime("mkdir");
+        await dntShim.Deno.mkdir(path, options);
+    }
+    async remove(path, options) {
+        assertDenoRuntime("remove");
+        await dntShim.Deno.remove(path, options);
+    }
+    async makeTempDir(prefix) {
+        assertDenoRuntime("makeTempDir");
+        return dntShim.Deno.makeTempDir({ prefix: validateTempDirectoryPrefix(prefix) });
+    }
+    watch(paths, options) {
+        assertDenoRuntime("watch");
+        const signal = options?.signal;
+        if (signal?.aborted)
+            return createClosedWatcher();
+        const pathArray = Array.isArray(paths) ? paths : [paths];
+        const roots = pathArray
+            .map((path) => ({
+            nativePath: dntShim.Deno.realPathSync(path),
+            exposedPath: resolve(path),
+        }))
+            .sort((left, right) => right.nativePath.length - left.nativePath.length);
+        const nativeWatcher = dntShim.Deno.watchFs(pathArray, {
+            recursive: options?.recursive ?? true,
+        });
+        const nativeIterator = nativeWatcher[Symbol.asyncIterator]();
+        const doneResult = {
+            done: true,
+            value: undefined,
+        };
+        let closed = false;
+        let closeFailed = false;
+        let closeError;
+        let terminalFailed = false;
+        let terminalError;
+        let pendingNext;
+        let resolveClosed;
+        const closedSignal = new Promise((resolve) => {
+            resolveClosed = resolve;
+        });
+        const cleanup = () => {
+            if (closed)
+                return;
+            closed = true;
+            signal?.removeEventListener("abort", cleanup);
+            try {
+                nativeWatcher.close();
+            }
+            catch (error) {
+                closeFailed = true;
+                closeError = error;
+            }
+            resolveClosed();
+        };
+        const iterator = {
+            next() {
+                if (closed)
+                    return Promise.resolve(doneResult);
+                if (pendingNext) {
+                    return Promise.reject(new TypeError("FileWatcher does not support concurrent next() calls"));
+                }
+                const operation = nativeIterator.next().then((result) => {
+                    if (result.done || closed) {
+                        cleanup();
+                        return doneResult;
+                    }
+                    return {
+                        done: false,
+                        value: {
+                            kind: toFileChangeKind(result.value.kind),
+                            paths: result.value.paths.map((path) => mapNativeWatchPath(path, roots)),
+                        },
+                    };
+                }, (error) => {
+                    if (closed)
+                        return doneResult;
+                    terminalFailed = true;
+                    terminalError = error;
+                    cleanup();
+                    throw error;
+                });
+                const tracked = operation.finally(() => {
+                    if (pendingNext === tracked)
+                        pendingNext = undefined;
+                });
+                pendingNext = tracked;
+                return tracked;
+            },
+            return() {
+                cleanup();
+                return Promise.resolve(doneResult);
+            },
+        };
+        signal?.addEventListener("abort", cleanup, { once: true });
+        const watcher = createFileWatcher(iterator, cleanup);
+        watcher.ready = Promise.resolve();
+        watcher.done = closedSignal.then(async () => {
+            const operation = pendingNext;
+            if (operation)
+                await operation.catch(() => undefined);
+            if (terminalFailed)
+                throw terminalError;
+            if (closeFailed)
+                throw closeError;
+        });
+        return watcher;
+    }
+}

package/esm/src/platform/adapters/runtime/shared/node-filesystem-adapter.d.ts

@@ -0,0 +1,71 @@
+import type { DirEntry, FileInfo, FileSystemAdapter, FileWatcher, WatchOptions } from "../../base.js";
+import { setupNodeFsWatcher } from "./shared-watcher.js";
+export interface NodeFileSystemLogger {
+    error(message: string, context?: Record<string, unknown>): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+}
+interface NodeFileSnapshotStat {
+    readonly dev: bigint;
+    readonly ino: bigint;
+    readonly size: bigint;
+    readonly mtimeNs: bigint;
+    readonly ctimeNs: bigint;
+    isFile(): boolean;
+    isSymbolicLink(): boolean;
+}
+interface NodeFileHandle {
+    stat(): Promise<NodeFileSnapshotStat>;
+    read(buffer: Uint8Array, offset: number, length: number, position: number): Promise<{
+        bytesRead: number;
+    }>;
+    writeFile(content: Uint8Array): Promise<void>;
+    close(): Promise<void>;
+}
+export interface NodeFileSystemOperations {
+    realpath(path: string): Promise<string>;
+    lstat(path: string): Promise<NodeFileSnapshotStat>;
+    open(path: string, flags: number | string): Promise<NodeFileHandle>;
+}
+export interface NodeFileSystemCapabilityOptions {
+    /** Test seam for runtime constants. An own undefined value means unavailable. */
+    readonly noFollow?: number;
+    /** Test seam for create-new primitive availability. */
+    readonly exclusiveCreate?: boolean;
+    /** Test seam for deterministic filesystem races and write failures. */
+    readonly operations?: Partial<NodeFileSystemOperations>;
+}
+/**
+ * Filesystem implementation shared by runtimes that provide Node-compatible
+ * `node:fs` APIs (currently Node.js and Bun).
+ */
+export declare class NodeCompatibleFileSystemAdapter implements FileSystemAdapter {
+    private readonly logger;
+    constructor(logger?: NodeFileSystemLogger, options?: NodeFileSystemCapabilityOptions);
+    readFile(path: string): Promise<string>;
+    readFileBytes(path: string): Promise<Uint8Array>;
+    readFileBytesBounded(path: string, byteLimit: number): Promise<Uint8Array>;
+    readFileBytesWithinLimit(path: string, byteLimit: number): Promise<Uint8Array>;
+    writeFile(path: string, content: string): Promise<void>;
+    writeFileBytes(path: string, content: Uint8Array): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    readDir(path: string): AsyncIterable<DirEntry>;
+    stat(path: string): Promise<FileInfo>;
+    lstat(path: string): Promise<FileInfo>;
+    realPath(path: string): Promise<string>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    remove(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    makeTempDir(prefix: string): Promise<string>;
+    protected setupWatcher(path: string, options: Parameters<typeof setupNodeFsWatcher>[1]): Promise<void>;
+    watch(paths: string | string[], options?: WatchOptions): FileWatcher;
+}
+export interface NodeCompatibleFileSystemAdapter {
+    readFileSnapshotWithinLimit?(path: string, containmentRoot: string, byteLimit: number): Promise<Uint8Array>;
+    createFileBytesExclusive?(path: string, content: Uint8Array): Promise<void>;
+}
+export {};
+//# sourceMappingURL=node-filesystem-adapter.d.ts.map

package/esm/src/platform/adapters/runtime/shared/node-filesystem-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-filesystem-adapter.d.ts","sourceRoot":"","sources":["../../../../../../src/src/platform/adapters/runtime/shared/node-filesystem-adapter.ts"],"names":[],"mappings":"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"}