@ricsam/quickjs-fs 0.0.1 → 0.2.1

package/dist/mjs/writable-stream.mjs

@@ -0,0 +1,88 @@
+// @bun
+// packages/fs/src/handles/writable-stream.ts
+import { defineClass } from "@ricsam/quickjs-core";
+import { pendingWritableStreams } from "./file-handle.ts";
+function createFileSystemWritableFileStreamClass(context, stateMap) {
+  return defineClass(context, stateMap, {
+    name: "FileSystemWritableFileStream",
+    construct: (args) => {
+      const streamId = args[0];
+      const hostStream = pendingWritableStreams.get(streamId);
+      if (!hostStream) {
+        throw new Error(`No pending writable stream with ID ${streamId}`);
+      }
+      pendingWritableStreams.delete(streamId);
+      return {
+        hostStream,
+        closed: false
+      };
+    },
+    methods: {
+      async write(data) {
+        if (this.closed) {
+          throw new Error("Stream is closed");
+        }
+        if (data && typeof data === "object" && "type" in data) {
+          const params = data;
+          if (params.type === "seek" && params.position !== undefined) {
+            await this.hostStream.seek(params.position);
+            return;
+          }
+          if (params.type === "truncate" && params.size !== undefined) {
+            await this.hostStream.truncate(params.size);
+            return;
+          }
+          if (params.type === "write" && params.data !== undefined) {
+            await this.hostStream.write(params.data);
+            return;
+          }
+        }
+        if (typeof data === "string") {
+          await this.hostStream.write(data);
+        } else if (data instanceof ArrayBuffer) {
+          await this.hostStream.write(data);
+        } else if (data instanceof Uint8Array) {
+          await this.hostStream.write(data);
+        } else if (data && typeof data === "object" && "parts" in data) {
+          const parts = data.parts;
+          for (const part of parts) {
+            await this.hostStream.write(part);
+          }
+        } else {
+          await this.hostStream.write(String(data));
+        }
+      },
+      async seek(position) {
+        if (this.closed) {
+          throw new Error("Stream is closed");
+        }
+        await this.hostStream.seek(Number(position));
+      },
+      async truncate(size) {
+        if (this.closed) {
+          throw new Error("Stream is closed");
+        }
+        await this.hostStream.truncate(Number(size));
+      },
+      async close() {
+        if (this.closed) {
+          return;
+        }
+        this.closed = true;
+        await this.hostStream.close();
+      },
+      async abort(reason) {
+        if (this.closed) {
+          return;
+        }
+        this.closed = true;
+        await this.hostStream.abort(reason);
+      }
+    }
+  });
+}
+export {
+  createFileSystemWritableFileStreamClass
+};
+
+//# debugId=DEDE1A3875D7952464756E2164756E21

package/dist/mjs/writable-stream.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/handles/writable-stream.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { StateMap } from \"@ricsam/quickjs-core\";\nimport { defineClass } from \"@ricsam/quickjs-core\";\nimport type {\n  FileSystemWritableFileStreamState,\n  WriteParams,\n  HostWritableFileStream,\n} from \"../types.ts\";\nimport { pendingWritableStreams } from \"./file-handle.ts\";\n\n/**\n * Create the FileSystemWritableFileStream class for QuickJS\n */\nexport function createFileSystemWritableFileStreamClass(\n  context: QuickJSContext,\n  stateMap: StateMap\n): QuickJSHandle {\n  return defineClass<FileSystemWritableFileStreamState>(context, stateMap, {\n    name: \"FileSystemWritableFileStream\",\n    construct: (args) => {\n      const streamId = args[0] as number;\n      const hostStream = pendingWritableStreams.get(streamId);\n      if (!hostStream) {\n        throw new Error(`No pending writable stream with ID ${streamId}`);\n      }\n      pendingWritableStreams.delete(streamId);\n      return {\n        hostStream,\n        closed: false,\n      };\n    },\n    methods: {\n      async write(\n        this: FileSystemWritableFileStreamState,\n        data: unknown\n      ): Promise<void> {\n        if (this.closed) {\n          throw new Error(\"Stream is closed\");\n        }\n\n        // Handle WriteParams\n        if (data && typeof data === \"object\" && \"type\" in data) {\n          const params = data as WriteParams;\n          if (params.type === \"seek\" && params.position !== undefined) {\n            await this.hostStream.seek(params.position);\n            return;\n          }\n          if (params.type === \"truncate\" && params.size !== undefined) {\n            await this.hostStream.truncate(params.size);\n            return;\n          }\n          if (params.type === \"write\" && params.data !== undefined) {\n            await this.hostStream.write(params.data);\n            return;\n          }\n        }\n\n        // Direct data write\n        if (typeof data === \"string\") {\n          await this.hostStream.write(data);\n        } else if (data instanceof ArrayBuffer) {\n          await this.hostStream.write(data);\n        } else if (data instanceof Uint8Array) {\n          await this.hostStream.write(data);\n        } else if (data && typeof data === \"object\" && \"parts\" in data) {\n          // Blob-like\n          const parts = (data as { parts: Uint8Array[] }).parts;\n          for (const part of parts) {\n            await this.hostStream.write(part);\n          }\n        } else {\n          await this.hostStream.write(String(data));\n        }\n      },\n      async seek(\n        this: FileSystemWritableFileStreamState,\n        position: unknown\n      ): Promise<void> {\n        if (this.closed) {\n          throw new Error(\"Stream is closed\");\n        }\n        await this.hostStream.seek(Number(position));\n      },\n      async truncate(\n        this: FileSystemWritableFileStreamState,\n        size: unknown\n      ): Promise<void> {\n        if (this.closed) {\n          throw new Error(\"Stream is closed\");\n        }\n        await this.hostStream.truncate(Number(size));\n      },\n      async close(this: FileSystemWritableFileStreamState): Promise<void> {\n        if (this.closed) {\n          return;\n        }\n        this.closed = true;\n        await this.hostStream.close();\n      },\n      async abort(\n        this: FileSystemWritableFileStreamState,\n        reason?: unknown\n      ): Promise<void> {\n        if (this.closed) {\n          return;\n        }\n        this.closed = true;\n        await this.hostStream.abort(reason);\n      },\n    },\n  });\n}\n"
+  ],
+  "mappings": ";;AAEA;AAMA;AAKO,SAAS,uCAAuC,CACrD,SACA,UACe;AAAA,EACf,OAAO,YAA+C,SAAS,UAAU;AAAA,IACvE,MAAM;AAAA,IACN,WAAW,CAAC,SAAS;AAAA,MACnB,MAAM,WAAW,KAAK;AAAA,MACtB,MAAM,aAAa,uBAAuB,IAAI,QAAQ;AAAA,MACtD,IAAI,CAAC,YAAY;AAAA,QACf,MAAM,IAAI,MAAM,sCAAsC,UAAU;AAAA,MAClE;AAAA,MACA,uBAAuB,OAAO,QAAQ;AAAA,MACtC,OAAO;AAAA,QACL;AAAA,QACA,QAAQ;AAAA,MACV;AAAA;AAAA,IAEF,SAAS;AAAA,WACD,MAAK,CAET,MACe;AAAA,QACf,IAAI,KAAK,QAAQ;AAAA,UACf,MAAM,IAAI,MAAM,kBAAkB;AAAA,QACpC;AAAA,QAGA,IAAI,QAAQ,OAAO,SAAS,YAAY,UAAU,MAAM;AAAA,UACtD,MAAM,SAAS;AAAA,UACf,IAAI,OAAO,SAAS,UAAU,OAAO,aAAa,WAAW;AAAA,YAC3D,MAAM,KAAK,WAAW,KAAK,OAAO,QAAQ;AAAA,YAC1C;AAAA,UACF;AAAA,UACA,IAAI,OAAO,SAAS,cAAc,OAAO,SAAS,WAAW;AAAA,YAC3D,MAAM,KAAK,WAAW,SAAS,OAAO,IAAI;AAAA,YAC1C;AAAA,UACF;AAAA,UACA,IAAI,OAAO,SAAS,WAAW,OAAO,SAAS,WAAW;AAAA,YACxD,MAAM,KAAK,WAAW,MAAM,OAAO,IAAI;AAAA,YACvC;AAAA,UACF;AAAA,QACF;AAAA,QAGA,IAAI,OAAO,SAAS,UAAU;AAAA,UAC5B,MAAM,KAAK,WAAW,MAAM,IAAI;AAAA,QAClC,EAAO,SAAI,gBAAgB,aAAa;AAAA,UACtC,MAAM,KAAK,WAAW,MAAM,IAAI;AAAA,QAClC,EAAO,SAAI,gBAAgB,YAAY;AAAA,UACrC,MAAM,KAAK,WAAW,MAAM,IAAI;AAAA,QAClC,EAAO,SAAI,QAAQ,OAAO,SAAS,YAAY,WAAW,MAAM;AAAA,UAE9D,MAAM,QAAS,KAAiC;AAAA,UAChD,WAAW,QAAQ,OAAO;AAAA,YACxB,MAAM,KAAK,WAAW,MAAM,IAAI;AAAA,UAClC;AAAA,QACF,EAAO;AAAA,UACL,MAAM,KAAK,WAAW,MAAM,OAAO,IAAI,CAAC;AAAA;AAAA;AAAA,WAGtC,KAAI,CAER,UACe;AAAA,QACf,IAAI,KAAK,QAAQ;AAAA,UACf,MAAM,IAAI,MAAM,kBAAkB;AAAA,QACpC;AAAA,QACA,MAAM,KAAK,WAAW,KAAK,OAAO,QAAQ,CAAC;AAAA;AAAA,WAEvC,SAAQ,CAEZ,MACe;AAAA,QACf,IAAI,KAAK,QAAQ;AAAA,UACf,MAAM,IAAI,MAAM,kBAAkB;AAAA,QACpC;AAAA,QACA,MAAM,KAAK,WAAW,SAAS,OAAO,IAAI,CAAC;AAAA;AAAA,WAEvC,MAAK,GAAyD;AAAA,QAClE,IAAI,KAAK,QAAQ;AAAA,UACf;AAAA,QACF;AAAA,QACA,KAAK,SAAS;AAAA,QACd,MAAM,KAAK,WAAW,MAAM;AAAA;AAAA,WAExB,MAAK,CAET,QACe;AAAA,QACf,IAAI,KAAK,QAAQ;AAAA,UACf;AAAA,QACF;AAAA,QACA,KAAK,SAAS;AAAA,QACd,MAAM,KAAK,WAAW,MAAM,MAAM;AAAA;AAAA,IAEtC;AAAA,EACF,CAAC;AAAA;",
+  "debugId": "DEDE1A3875D7952464756E2164756E21",
+  "names": []
+}

package/dist/types/handles/directory-handle.d.ts

@@ -0,0 +1,12 @@
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { HostDirectoryHandle } from "../types.ts";
+export declare const pendingHostHandles: Map<number, {
+    handle: HostDirectoryHandle;
+    name: string;
+}>;
+export declare function registerHostDirectoryHandle(handle: HostDirectoryHandle): number;
+/**
+ * Create the FileSystemDirectoryHandle class for QuickJS
+ */
+export declare function createFileSystemDirectoryHandleClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;

package/dist/types/handles/file-handle.d.ts

@@ -0,0 +1,14 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+import type { HostFileHandle, HostWritableFileStream } from "../types.ts";
+export declare const pendingFileHandles: Map<number, {
+    handle: HostFileHandle;
+    name: string;
+}>;
+export declare const pendingWritableStreams: Map<number, HostWritableFileStream>;
+export declare function registerHostFileHandle(handle: HostFileHandle): number;
+export declare function registerHostWritableStream(stream: HostWritableFileStream): number;
+/**
+ * Create the FileSystemFileHandle class for QuickJS
+ */
+export declare function createFileSystemFileHandleClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;

package/dist/types/handles/writable-stream.d.ts

@@ -0,0 +1,6 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap } from "@ricsam/quickjs-core";
+/**
+ * Create the FileSystemWritableFileStream class for QuickJS
+ */
+export declare function createFileSystemWritableFileStreamClass(context: QuickJSContext, stateMap: StateMap): QuickJSHandle;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export { setupFs } from "./setup.ts";
+export { createNodeDirectoryHandle } from "./node-adapter.ts";
+export { createMemoryDirectoryHandle } from "./memory-adapter.ts";
+export type { SetupFsOptions, FsHandle, HostDirectoryHandle, HostFileHandle, HostWritableFileStream, WriteParams, } from "./types.ts";

package/dist/types/memory-adapter.d.ts

@@ -0,0 +1,18 @@
+import type { HostDirectoryHandle } from "./types.ts";
+/**
+ * Create an in-memory directory handle
+ * Useful for testing or fully sandboxed environments
+ *
+ * @example
+ * import { createMemoryDirectoryHandle } from "@ricsam/quickjs-fs";
+ *
+ * const memFs = createMemoryDirectoryHandle({
+ *   "config.json": JSON.stringify({ debug: true }),
+ *   "data/users.json": JSON.stringify([]),
+ * });
+ *
+ * const handle = setupFs(context, {
+ *   getDirectory: async (path) => memFs
+ * });
+ */
+export declare function createMemoryDirectoryHandle(initialFiles?: Record<string, string | Uint8Array>): HostDirectoryHandle;

package/dist/types/node-adapter.d.ts

@@ -0,0 +1,23 @@
+import type { HostDirectoryHandle } from "./types.ts";
+/**
+ * Create a directory handle backed by Node.js/Bun fs
+ * Useful for server-side implementations
+ *
+ * @param rootPath - Absolute path to the directory on disk
+ * @returns A HostDirectoryHandle implementation
+ *
+ * @example
+ * import { createNodeDirectoryHandle } from "@ricsam/quickjs-fs";
+ *
+ * const handle = setupFs(context, {
+ *   getDirectory: async (path) => {
+ *     // Only allow access to /sandbox
+ *     if (!path.startsWith("/sandbox")) {
+ *       throw new Error("Access denied");
+ *     }
+ *     const realPath = path.replace("/sandbox", "/var/app/sandbox");
+ *     return createNodeDirectoryHandle(realPath);
+ *   }
+ * });
+ */
+export declare function createNodeDirectoryHandle(rootPath: string): HostDirectoryHandle;

package/dist/types/setup.d.ts

@@ -0,0 +1,56 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+import type { SetupFsOptions, FsHandle } from "./types.ts";
+/**
+ * Setup File System API in a QuickJS context
+ *
+ * Injects the following globals:
+ * - fs.getDirectory(path) - Server-compatible entry point
+ * - FileSystemFileHandle
+ * - FileSystemDirectoryHandle
+ * - FileSystemWritableFileStream
+ *
+ * **Private globals (internal use):**
+ * - `__FileSystemFileHandle__` - For creating file handle instances from wrapper code
+ * - `__FileSystemDirectoryHandle__` - For creating directory handle instances
+ * - `__FileSystemWritableFileStream__` - For creating writable stream instances
+ *
+ * These private globals follow the `__Name__` convention and are required for the
+ * wrapper pattern: public methods call internal methods that return IDs, then use
+ * evalCode with private constructors to create properly-typed class instances.
+ * See PATTERNS.md sections 2 and 5 for details.
+ *
+ * **Wrapper pattern example:**
+ * ```typescript
+ * // Public method (added via evalCode)
+ * FileSystemFileHandle.prototype.createWritable = async function(options) {
+ *   const result = await this._createWritableInternal(options);
+ *   return new __FileSystemWritableFileStream__(result.__writableStreamId);
+ * };
+ * ```
+ *
+ * @example
+ * import { setupFs, createNodeDirectoryHandle } from "@ricsam/quickjs-fs";
+ *
+ * const handle = setupFs(context, {
+ *   getDirectory: async (path) => {
+ *     // Validate and resolve path
+ *     const resolvedPath = resolveSandboxPath(path);
+ *     return createNodeDirectoryHandle(resolvedPath);
+ *   }
+ * });
+ *
+ * context.evalCode(`
+ *   const root = await fs.getDirectory("/data");
+ *   const configHandle = await root.getFileHandle("config.json");
+ *   const file = await configHandle.getFile();
+ *   const text = await file.text();
+ *   console.log(JSON.parse(text));
+ *
+ *   // Write a new file
+ *   const outputHandle = await root.getFileHandle("output.txt", { create: true });
+ *   const writable = await outputHandle.createWritable();
+ *   await writable.write("Hello, World!");
+ *   await writable.close();
+ * `);
+ */
+export declare function setupFs(context: QuickJSContext, options: SetupFsOptions): FsHandle;

package/dist/types/types.d.ts

@@ -0,0 +1,85 @@
+import type { StateMap, CoreHandle } from "@ricsam/quickjs-core";
+export type { StateMap, CoreHandle };
+/**
+ * Host-side directory handle interface
+ * Implement this to provide file system access to QuickJS
+ */
+export interface HostDirectoryHandle {
+    readonly kind: "directory";
+    readonly name: string;
+    getFileHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<HostFileHandle>;
+    getDirectoryHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<HostDirectoryHandle>;
+    removeEntry(name: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    resolve(possibleDescendant: HostFileHandle | HostDirectoryHandle): Promise<string[] | null>;
+    entries(): AsyncIterable<[string, HostFileHandle | HostDirectoryHandle]>;
+    keys(): AsyncIterable<string>;
+    values(): AsyncIterable<HostFileHandle | HostDirectoryHandle>;
+}
+/**
+ * Host-side file handle interface
+ */
+export interface HostFileHandle {
+    readonly kind: "file";
+    readonly name: string;
+    getFile(): Promise<File>;
+    createWritable(options?: {
+        keepExistingData?: boolean;
+    }): Promise<HostWritableFileStream>;
+}
+/**
+ * Host-side writable file stream interface
+ */
+export interface HostWritableFileStream {
+    write(data: string | ArrayBuffer | Uint8Array | Blob | WriteParams): Promise<void>;
+    seek(position: number): Promise<void>;
+    truncate(size: number): Promise<void>;
+    close(): Promise<void>;
+    abort(reason?: unknown): Promise<void>;
+}
+export interface WriteParams {
+    type: "write" | "seek" | "truncate";
+    data?: string | ArrayBuffer | Uint8Array | Blob;
+    position?: number;
+    size?: number;
+}
+export interface SetupFsOptions {
+    /**
+     * Handler to resolve paths to directory handles
+     * This is the server-side entry point for file system access
+     *
+     * @param path - The path requested by QuickJS code
+     * @returns A directory handle rooted at this path
+     * @throws If the path is not allowed or doesn't exist
+     */
+    getDirectory: (path: string) => Promise<HostDirectoryHandle>;
+    /** Existing state map */
+    stateMap?: StateMap;
+    /** Existing core handle */
+    coreHandle?: CoreHandle;
+}
+export interface FsHandle {
+    /** State map containing internal states */
+    readonly stateMap: StateMap;
+    /** Dispose all handles */
+    dispose(): void;
+}
+export interface FileSystemFileHandleState {
+    kind: "file";
+    name: string;
+    hostHandle: HostFileHandle;
+}
+export interface FileSystemDirectoryHandleState {
+    kind: "directory";
+    name: string;
+    hostHandle: HostDirectoryHandle;
+}
+export interface FileSystemWritableFileStreamState {
+    hostStream: HostWritableFileStream;
+    closed: boolean;
+}

package/package.json

@@ -1,10 +1,55 @@
 {
   "name": "@ricsam/quickjs-fs",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/quickjs-fs",
+  "version": "0.2.1",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/mjs/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ricsam/quickjs-core": "^0.2.1",
+    "quickjs-emscripten": "^0.31.0"
+  },
+  "peerDependencies": {
+    "quickjs-emscripten": "^0.31.0"
+  },
+  "author": "Richard Samuelsson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/richie-qjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ricsam/richie-qjs/issues"
+  },
+  "homepage": "https://github.com/ricsam/richie-qjs#readme",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
+    "quickjs",
+    "sandbox",
+    "javascript",
+    "runtime",
+    "fetch",
+    "filesystem",
+    "streams",
+    "wasm",
+    "emscripten"
+  ],
+  "description": "File system API implementation for QuickJS runtime",
+  "module": "./dist/mjs/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
   ]
-}
+}