@ricsam/quickjs-core 0.2.0 → 0.2.2

package/dist/mjs/url.mjs

@@ -0,0 +1,152 @@
+// @bun
+// packages/core/src/url.ts
+import { defineClass } from "./class-builder.mjs";
+function createURLClass(context, stateMap) {
+  return defineClass(context, stateMap, {
+    name: "URL",
+    construct: (args) => {
+      const urlString = args[0];
+      const base = args[1];
+      if (urlString === undefined) {
+        throw new TypeError("Failed to construct 'URL': 1 argument required, but only 0 present.");
+      }
+      let parsed;
+      try {
+        if (base !== undefined) {
+          const baseStr = typeof base === "object" && base !== null && "href" in base ? base.href : String(base);
+          parsed = new globalThis.URL(String(urlString), baseStr);
+        } else {
+          parsed = new globalThis.URL(String(urlString));
+        }
+      } catch (e) {
+        throw new TypeError(`Failed to construct 'URL': Invalid URL`);
+      }
+      return {
+        hash: parsed.hash,
+        host: parsed.host,
+        hostname: parsed.hostname,
+        href: parsed.href,
+        origin: parsed.origin,
+        password: parsed.password,
+        pathname: parsed.pathname,
+        port: parsed.port,
+        protocol: parsed.protocol,
+        search: parsed.search,
+        username: parsed.username
+      };
+    },
+    properties: {
+      hash: {
+        get() {
+          return this.hash;
+        }
+      },
+      host: {
+        get() {
+          return this.host;
+        }
+      },
+      hostname: {
+        get() {
+          return this.hostname;
+        }
+      },
+      href: {
+        get() {
+          return this.href;
+        }
+      },
+      origin: {
+        get() {
+          return this.origin;
+        }
+      },
+      password: {
+        get() {
+          return this.password;
+        }
+      },
+      pathname: {
+        get() {
+          return this.pathname;
+        }
+      },
+      port: {
+        get() {
+          return this.port;
+        }
+      },
+      protocol: {
+        get() {
+          return this.protocol;
+        }
+      },
+      search: {
+        get() {
+          return this.search;
+        }
+      },
+      username: {
+        get() {
+          return this.username;
+        }
+      }
+    },
+    methods: {
+      toString() {
+        return this.href;
+      },
+      toJSON() {
+        return this.href;
+      },
+      __getSearch__() {
+        return this.search;
+      }
+    },
+    staticMethods: {
+      canParse(url, base) {
+        try {
+          if (base !== undefined) {
+            new globalThis.URL(String(url), String(base));
+          } else {
+            new globalThis.URL(String(url));
+          }
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    }
+  });
+}
+function addURLSearchParamsGetter(context) {
+  const result = context.evalCode(`
+    (function() {
+      const searchParamsCache = new Map();
+
+      Object.defineProperty(URL.prototype, 'searchParams', {
+        get: function() {
+          const instanceId = this.__instanceId__;
+          if (!searchParamsCache.has(instanceId)) {
+            searchParamsCache.set(instanceId, new URLSearchParams(this.__getSearch__()));
+          }
+          return searchParamsCache.get(instanceId);
+        },
+        enumerable: true,
+        configurable: true
+      });
+    })();
+  `);
+  if (result.error) {
+    const err = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to add searchParams getter: ${JSON.stringify(err)}`);
+  }
+  result.value.dispose();
+}
+export {
+  createURLClass,
+  addURLSearchParamsGetter
+};
+
+//# debugId=8408820A4441CF3264756E2164756E21

package/dist/mjs/url.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/url.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport type { StateMap } from \"./types.mjs\";\nimport { defineClass } from \"./class-builder.mjs\";\n\n/**\n * Internal state for URL\n */\nexport interface URLState {\n  hash: string;\n  host: string;\n  hostname: string;\n  href: string;\n  origin: string;\n  password: string;\n  pathname: string;\n  port: string;\n  protocol: string;\n  search: string;\n  username: string;\n}\n\n/**\n * Create the URL class for QuickJS\n *\n * Note: The searchParams property is added separately via evalCode\n * after this class is registered, as it needs to return a URLSearchParams instance.\n */\nexport function createURLClass(\n  context: QuickJSContext,\n  stateMap: StateMap\n): QuickJSHandle {\n  return defineClass<URLState>(context, stateMap, {\n    name: \"URL\",\n    construct: (args) => {\n      const urlString = args[0];\n      const base = args[1];\n\n      if (urlString === undefined) {\n        throw new TypeError(\"Failed to construct 'URL': 1 argument required, but only 0 present.\");\n      }\n\n      let parsed: globalThis.URL;\n      try {\n        if (base !== undefined) {\n          // Handle base URL\n          const baseStr = typeof base === \"object\" && base !== null && \"href\" in base\n            ? (base as URLState).href\n            : String(base);\n          parsed = new globalThis.URL(String(urlString), baseStr);\n        } else {\n          parsed = new globalThis.URL(String(urlString));\n        }\n      } catch (e) {\n        throw new TypeError(`Failed to construct 'URL': Invalid URL`);\n      }\n\n      return {\n        hash: parsed.hash,\n        host: parsed.host,\n        hostname: parsed.hostname,\n        href: parsed.href,\n        origin: parsed.origin,\n        password: parsed.password,\n        pathname: parsed.pathname,\n        port: parsed.port,\n        protocol: parsed.protocol,\n        search: parsed.search,\n        username: parsed.username,\n      };\n    },\n    properties: {\n      hash: {\n        get(this: URLState) {\n          return this.hash;\n        },\n      },\n      host: {\n        get(this: URLState) {\n          return this.host;\n        },\n      },\n      hostname: {\n        get(this: URLState) {\n          return this.hostname;\n        },\n      },\n      href: {\n        get(this: URLState) {\n          return this.href;\n        },\n      },\n      origin: {\n        get(this: URLState) {\n          return this.origin;\n        },\n      },\n      password: {\n        get(this: URLState) {\n          return this.password;\n        },\n      },\n      pathname: {\n        get(this: URLState) {\n          return this.pathname;\n        },\n      },\n      port: {\n        get(this: URLState) {\n          return this.port;\n        },\n      },\n      protocol: {\n        get(this: URLState) {\n          return this.protocol;\n        },\n      },\n      search: {\n        get(this: URLState) {\n          return this.search;\n        },\n      },\n      username: {\n        get(this: URLState) {\n          return this.username;\n        },\n      },\n    },\n    methods: {\n      toString(this: URLState): string {\n        return this.href;\n      },\n      toJSON(this: URLState): string {\n        return this.href;\n      },\n      // Private method to get search for URLSearchParams creation\n      __getSearch__(this: URLState): string {\n        return this.search;\n      },\n    },\n    staticMethods: {\n      canParse(url: unknown, base?: unknown): boolean {\n        try {\n          if (base !== undefined) {\n            new globalThis.URL(String(url), String(base));\n          } else {\n            new globalThis.URL(String(url));\n          }\n          return true;\n        } catch {\n          return false;\n        }\n      },\n    },\n  });\n}\n\n/**\n * Add searchParams getter to URL prototype using evalCode\n * This must be called after both URL and URLSearchParams are registered as globals\n */\nexport function addURLSearchParamsGetter(context: QuickJSContext): void {\n  // Use a WeakMap-like pattern with a Map keyed by instance ID\n  // Each URL instance will cache its URLSearchParams\n  const result = context.evalCode(`\n    (function() {\n      const searchParamsCache = new Map();\n\n      Object.defineProperty(URL.prototype, 'searchParams', {\n        get: function() {\n          const instanceId = this.__instanceId__;\n          if (!searchParamsCache.has(instanceId)) {\n            searchParamsCache.set(instanceId, new URLSearchParams(this.__getSearch__()));\n          }\n          return searchParamsCache.get(instanceId);\n        },\n        enumerable: true,\n        configurable: true\n      });\n    })();\n  `);\n\n  if (result.error) {\n    const err = context.dump(result.error);\n    result.error.dispose();\n    throw new Error(`Failed to add searchParams getter: ${JSON.stringify(err)}`);\n  }\n  result.value.dispose();\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "8408820A4441CF3264756E2164756E21",
+  "names": []
+}

package/dist/mjs/writable-stream.mjs

@@ -0,0 +1,482 @@
+// @bun
+// packages/core/src/streams/writable-stream.ts
+import { defineClass, getInstanceStateById } from "../class-builder.mjs";
+import { marshal } from "../marshal.mjs";
+import { unmarshal } from "../unmarshal.mjs";
+function createWritableStreamDefaultWriterClass(context, stateMap) {
+  return defineClass(context, stateMap, {
+    name: "WritableStreamDefaultWriter",
+    construct: () => {
+      let resolveClosedPromise;
+      let rejectClosedPromise;
+      let resolveReadyPromise;
+      let rejectReadyPromise;
+      const state = {
+        stream: null,
+        closedPromiseResolvers: {
+          resolve: () => resolveClosedPromise?.(),
+          reject: (e) => rejectClosedPromise?.(e)
+        },
+        readyPromiseResolvers: {
+          resolve: () => resolveReadyPromise?.(),
+          reject: (e) => rejectReadyPromise?.(e)
+        }
+      };
+      Object.defineProperty(state, "_closedPromise", {
+        value: undefined,
+        writable: true,
+        enumerable: false
+      });
+      Object.defineProperty(state, "_readyPromise", {
+        value: undefined,
+        writable: true,
+        enumerable: false
+      });
+      Object.defineProperty(state, "getClosedPromise", {
+        value: function() {
+          if (!this._closedPromise) {
+            this._closedPromise = new Promise((resolve, reject) => {
+              resolveClosedPromise = resolve;
+              rejectClosedPromise = reject;
+            });
+          }
+          return this._closedPromise;
+        },
+        enumerable: false
+      });
+      Object.defineProperty(state, "getReadyPromise", {
+        value: function() {
+          if (!this._readyPromise) {
+            this._readyPromise = new Promise((resolve, reject) => {
+              resolveReadyPromise = resolve;
+              rejectReadyPromise = reject;
+            });
+          }
+          return this._readyPromise;
+        },
+        enumerable: false
+      });
+      return state;
+    },
+    properties: {
+      closed: {
+        get() {
+          return this.getClosedPromise();
+        }
+      },
+      ready: {
+        get() {
+          return this.getReadyPromise();
+        }
+      },
+      desiredSize: {
+        get() {
+          if (!this.stream)
+            return null;
+          if (this.stream.errored)
+            return null;
+          if (this.stream.closeRequested)
+            return 0;
+          return 1 - this.stream.writeRequests.length;
+        }
+      }
+    },
+    methods: {
+      write(chunk) {
+        if (!this.stream) {
+          return Promise.reject(new TypeError("Writer has no stream"));
+        }
+        if (this.stream.errored) {
+          return Promise.reject(this.stream.errorValue);
+        }
+        if (this.stream.closeRequested || this.stream.closed) {
+          return Promise.reject(new TypeError("Cannot write to a closed stream"));
+        }
+        const self = this;
+        return new Promise((resolve, reject) => {
+          self.stream.writeRequests.push({ chunk, resolve, reject });
+          processWriteRequests.call(self);
+        });
+      },
+      close() {
+        if (!this.stream) {
+          return Promise.reject(new TypeError("Writer has no stream"));
+        }
+        if (this.stream.closeRequested || this.stream.closed) {
+          return Promise.reject(new TypeError("Stream is already closing or closed"));
+        }
+        this.stream.closeRequested = true;
+        return new Promise((resolve, reject) => {
+          const checkWritesComplete = () => {
+            if (this.stream.writeRequests.length === 0 && !this.stream.inFlightWriteRequest) {
+              if (this.stream.sink?.close) {
+                try {
+                  const result = this.stream.sink.close();
+                  if (result instanceof Promise) {
+                    result.then(() => {
+                      this.stream.closed = true;
+                      this.closedPromiseResolvers.resolve();
+                      resolve();
+                    }).catch((e) => {
+                      this.stream.errored = true;
+                      this.stream.errorValue = e;
+                      this.closedPromiseResolvers.reject(e);
+                      reject(e);
+                    });
+                    return;
+                  }
+                } catch (e) {
+                  this.stream.errored = true;
+                  this.stream.errorValue = e;
+                  this.closedPromiseResolvers.reject(e);
+                  reject(e);
+                  return;
+                }
+              }
+              this.stream.closed = true;
+              this.closedPromiseResolvers.resolve();
+              resolve();
+            } else {
+              setTimeout(checkWritesComplete, 0);
+            }
+          };
+          checkWritesComplete();
+        });
+      },
+      abort(reason) {
+        if (!this.stream) {
+          return Promise.reject(new TypeError("Writer has no stream"));
+        }
+        return new Promise((resolve, reject) => {
+          try {
+            this.stream.writeRequests.forEach((req) => req.reject(reason));
+            this.stream.writeRequests = [];
+            if (this.stream.sink?.abort) {
+              const result = this.stream.sink.abort(reason);
+              if (result instanceof Promise) {
+                result.then(resolve).catch(reject);
+                return;
+              }
+            }
+            this.stream.errored = true;
+            this.stream.errorValue = reason;
+            this.closedPromiseResolvers.reject(reason);
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+      },
+      releaseLock() {
+        if (!this.stream)
+          return;
+        this.stream.locked = false;
+        this.stream.writer = null;
+      }
+    }
+  });
+}
+function processWriteRequests() {
+  if (this.stream.inFlightWriteRequest || this.stream.writeRequests.length === 0 || !this.stream.started) {
+    return;
+  }
+  const request = this.stream.writeRequests.shift();
+  this.stream.inFlightWriteRequest = request;
+  if (this.stream.sink?.write) {
+    try {
+      const result = this.stream.sink.write(request.chunk, this.stream.controller);
+      if (result instanceof Promise) {
+        result.then(() => {
+          this.stream.inFlightWriteRequest = null;
+          request.resolve();
+          processWriteRequests.call(this);
+        }).catch((e) => {
+          this.stream.inFlightWriteRequest = null;
+          this.stream.errored = true;
+          this.stream.errorValue = e;
+          request.reject(e);
+          this.stream.writeRequests.forEach((req) => req.reject(e));
+          this.stream.writeRequests = [];
+        });
+        return;
+      }
+    } catch (e) {
+      this.stream.inFlightWriteRequest = null;
+      this.stream.errored = true;
+      this.stream.errorValue = e;
+      request.reject(e);
+      return;
+    }
+  }
+  this.stream.inFlightWriteRequest = null;
+  request.resolve();
+  processWriteRequests.call(this);
+}
+function createWritableStreamClass(context, stateMap, writerClass) {
+  const classHandle = defineClass(context, stateMap, {
+    name: "WritableStream",
+    construct: (args) => {
+      const underlyingSink = args[0];
+      const state = {
+        locked: false,
+        writer: null,
+        controller: null,
+        closed: false,
+        errored: false,
+        errorValue: undefined,
+        closeRequested: false,
+        inFlightWriteRequest: null,
+        writeRequests: [],
+        sink: underlyingSink,
+        started: false
+      };
+      state.controller = {
+        error(e) {
+          if (state.errored || state.closed)
+            return;
+          state.errored = true;
+          state.errorValue = e;
+          state.writeRequests.forEach((req) => req.reject(e));
+          state.writeRequests = [];
+          if (state.writer) {
+            state.writer.closedPromiseResolvers.reject(e);
+            state.writer.readyPromiseResolvers.reject(e);
+          }
+        }
+      };
+      if (underlyingSink?.start) {
+        try {
+          const startResult = underlyingSink.start(state.controller);
+          if (startResult instanceof Promise) {
+            startResult.then(() => {
+              state.started = true;
+              if (state.writer) {
+                state.writer.readyPromiseResolvers.resolve();
+              }
+            }).catch((e) => {
+              state.errored = true;
+              state.errorValue = e;
+            });
+          } else {
+            state.started = true;
+          }
+        } catch (e) {
+          state.errored = true;
+          state.errorValue = e;
+        }
+      } else {
+        state.started = true;
+      }
+      return state;
+    },
+    properties: {
+      locked: {
+        get() {
+          return this.locked;
+        }
+      }
+    },
+    methods: {
+      __linkWriter__(writerObj) {
+        if (this.locked) {
+          throw new TypeError("WritableStream is locked");
+        }
+        this.locked = true;
+        const writerId = writerObj.__instanceId__;
+        const writerState = getInstanceStateById(writerId);
+        if (!writerState) {
+          throw new Error("Writer instance state not found");
+        }
+        writerState.stream = this;
+        this.writer = writerState;
+        if (this.started) {
+          writerState.readyPromiseResolvers.resolve();
+        }
+      },
+      abort(reason) {
+        if (this.locked) {
+          return Promise.reject(new TypeError("Cannot abort a locked stream"));
+        }
+        return new Promise((resolve, reject) => {
+          try {
+            this.writeRequests.forEach((req) => req.reject(reason));
+            this.writeRequests = [];
+            if (this.sink?.abort) {
+              const result = this.sink.abort(reason);
+              if (result instanceof Promise) {
+                result.then(resolve).catch(reject);
+                return;
+              }
+            }
+            this.errored = true;
+            this.errorValue = reason;
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+      },
+      close() {
+        if (this.locked) {
+          return Promise.reject(new TypeError("Cannot close a locked stream"));
+        }
+        if (this.closeRequested || this.closed) {
+          return Promise.reject(new TypeError("Stream is already closing or closed"));
+        }
+        this.closeRequested = true;
+        return new Promise((resolve, reject) => {
+          if (this.sink?.close) {
+            try {
+              const result = this.sink.close();
+              if (result instanceof Promise) {
+                result.then(() => {
+                  this.closed = true;
+                  resolve();
+                }).catch(reject);
+                return;
+              }
+            } catch (e) {
+              reject(e);
+              return;
+            }
+          }
+          this.closed = true;
+          resolve();
+        });
+      }
+    }
+  });
+  const prototypeHandle = context.getProp(classHandle, "prototype");
+  const getWriterCode = `(function() {
+    const writer = new WritableStreamDefaultWriter();
+    this.__linkWriter__(writer);
+    return writer;
+  })`;
+  const getWriterResult = context.evalCode(getWriterCode);
+  if (!getWriterResult.error) {
+    context.setProp(prototypeHandle, "getWriter", getWriterResult.value);
+    getWriterResult.value.dispose();
+  } else {
+    getWriterResult.error.dispose();
+  }
+  prototypeHandle.dispose();
+  return classHandle;
+}
+function createWritableStream(context, stateMap, sink) {
+  const sinkObj = context.newObject();
+  if (sink.start) {
+    const startFn = context.newFunction("start", (controllerHandle) => {
+      const controller = {
+        signal: new AbortController().signal,
+        error: (e) => {
+          const errorFn = context.getProp(controllerHandle, "error");
+          const errorHandle = marshal(context, e);
+          context.callFunction(errorFn, controllerHandle, errorHandle);
+          errorHandle.dispose();
+          errorFn.dispose();
+        }
+      };
+      const result2 = sink.start(controller);
+      if (result2 instanceof Promise) {
+        const deferred = context.newPromise();
+        result2.then(() => {
+          deferred.resolve(context.undefined);
+          context.runtime.executePendingJobs();
+        }).catch((e) => {
+          deferred.reject(marshal(context, e));
+          context.runtime.executePendingJobs();
+        });
+        return deferred.handle;
+      }
+      return context.undefined;
+    });
+    context.setProp(sinkObj, "start", startFn);
+    startFn.dispose();
+  }
+  if (sink.write) {
+    const writeFn = context.newFunction("write", (chunkHandle, controllerHandle) => {
+      const chunk = unmarshal(context, chunkHandle);
+      const controller = {
+        signal: new AbortController().signal,
+        error: (e) => {
+          const errorFn = context.getProp(controllerHandle, "error");
+          const errorHandle = marshal(context, e);
+          context.callFunction(errorFn, controllerHandle, errorHandle);
+          errorHandle.dispose();
+          errorFn.dispose();
+        }
+      };
+      const result2 = sink.write(chunk, controller);
+      if (result2 instanceof Promise) {
+        const deferred = context.newPromise();
+        result2.then(() => {
+          deferred.resolve(context.undefined);
+          context.runtime.executePendingJobs();
+        }).catch((e) => {
+          deferred.reject(marshal(context, e));
+          context.runtime.executePendingJobs();
+        });
+        return deferred.handle;
+      }
+      return context.undefined;
+    });
+    context.setProp(sinkObj, "write", writeFn);
+    writeFn.dispose();
+  }
+  if (sink.close) {
+    const closeFn = context.newFunction("close", () => {
+      const result2 = sink.close();
+      if (result2 instanceof Promise) {
+        const deferred = context.newPromise();
+        result2.then(() => {
+          deferred.resolve(context.undefined);
+          context.runtime.executePendingJobs();
+        }).catch((e) => {
+          deferred.reject(marshal(context, e));
+          context.runtime.executePendingJobs();
+        });
+        return deferred.handle;
+      }
+      return context.undefined;
+    });
+    context.setProp(sinkObj, "close", closeFn);
+    closeFn.dispose();
+  }
+  if (sink.abort) {
+    const abortFn = context.newFunction("abort", (reasonHandle) => {
+      const reason = unmarshal(context, reasonHandle);
+      const result2 = sink.abort(reason);
+      if (result2 instanceof Promise) {
+        const deferred = context.newPromise();
+        result2.then(() => {
+          deferred.resolve(context.undefined);
+          context.runtime.executePendingJobs();
+        }).catch((e) => {
+          deferred.reject(marshal(context, e));
+          context.runtime.executePendingJobs();
+        });
+        return deferred.handle;
+      }
+      return context.undefined;
+    });
+    context.setProp(sinkObj, "abort", abortFn);
+    abortFn.dispose();
+  }
+  const WritableStreamConstructor = context.getProp(context.global, "WritableStream");
+  const result = context.callFunction(WritableStreamConstructor, context.undefined, sinkObj);
+  WritableStreamConstructor.dispose();
+  sinkObj.dispose();
+  if (result.error) {
+    const error = context.dump(result.error);
+    result.error.dispose();
+    throw new Error(`Failed to create WritableStream: ${error}`);
+  }
+  return result.value;
+}
+export {
+  createWritableStreamDefaultWriterClass,
+  createWritableStreamClass,
+  createWritableStream
+};
+
+//# debugId=4988BE2712D0F31C64756E2164756E21