@ricsam/quickjs-core 0.2.13 → 0.2.15

package/dist/types/coerce.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Coercion system for QuickJS class instances
+ *
+ * Provides a Zod-like API for detecting and extracting values from
+ * class instances, plain objects, and primitive values.
+ *
+ * This enables consistent handling of class instances across the codebase,
+ * reducing duplication and ensuring reliable type detection.
+ */
+/**
+ * Result of a coercion attempt
+ */
+export type CoercionResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * A coercer that can transform unknown values into a specific type
+ */
+export interface Coercer<T> {
+    /** The name of this coercer (for error messages) */
+    readonly name: string;
+    /** Attempt to coerce a value, returning a result object */
+    safeParse(value: unknown): CoercionResult<T>;
+    /** Coerce a value, throwing on failure */
+    parse(value: unknown): T;
+    /** Check if a value can be coerced without actually coercing */
+    is(value: unknown): boolean;
+    /** Create a new coercer with a fallback */
+    or<U>(other: Coercer<U>): Coercer<T | U>;
+    /** Transform the coerced value */
+    transform<U>(fn: (value: T) => U): Coercer<U>;
+    /** Make the coercer optional (allows undefined/null) */
+    optional(): Coercer<T | undefined>;
+}
+/**
+ * Create a base coercer from detection and extraction functions
+ */
+export declare function createCoercer<T>(name: string, detect: (value: unknown) => boolean, extract: (value: unknown) => T): Coercer<T>;
+/**
+ * Create a coercer for a QuickJS class instance
+ */
+export declare function classCoercer<TState>(className: string): Coercer<TState>;
+/**
+ * Coerce a value that could be a class instance OR have a specific shape
+ */
+export declare function instanceOrShape<TState, TShape>(className: string, shapeCheck: (value: unknown) => value is TShape, shapeToState: (value: TShape) => TState): Coercer<TState>;
+export interface URLCoerced {
+    href: string;
+    protocol: string;
+    host: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    origin: string;
+    username: string;
+    password: string;
+}
+/** Coerce a value to URL data */
+export declare const coerceURL: Coercer<URLCoerced>;
+/** Get just the href string from a URL-like value */
+export declare function coerceToURLString(value: unknown): string;
+export interface HeadersCoerced {
+    headers: Map<string, string[]>;
+}
+/** Coerce a value to Headers data */
+export declare const coerceHeaders: Coercer<HeadersCoerced>;
+/** Coerce body to Uint8Array */
+export declare function coerceBody(value: unknown): Uint8Array | null;
+export interface RequestInitCoerced {
+    method?: string;
+    headersState?: HeadersCoerced;
+    body?: Uint8Array | null;
+    cache?: string;
+    credentials?: string;
+    destination?: string;
+    integrity?: string;
+    keepalive?: boolean;
+    mode?: string;
+    redirect?: string;
+    referrer?: string;
+    referrerPolicy?: string;
+    signal?: unknown;
+}
+/** Coerce a value to Request init data (for use as RequestInit second arg) */
+export declare const coerceRequestInit: Coercer<RequestInitCoerced>;
+export interface ResponseInitCoerced {
+    status?: number;
+    statusText?: string;
+    headersState?: HeadersCoerced;
+}
+/** Coerce a value to Response init data */
+export declare const coerceResponseInit: Coercer<ResponseInitCoerced>;

package/dist/types/index.d.ts

@@ -36,8 +36,8 @@ export { marshal, isHandle, getHandleType } from "./marshal.ts";
 export { unmarshal, cleanupUnmarshaledHandles } from "./unmarshal.ts";
 export { defineFunction, defineAsyncFunction } from "./function-builder.ts";
 export { defineClass, createStateMap, getState, setState, getInstanceState, setInstanceState, getInstanceStateById, cleanupInstanceState, clearAllInstanceState, } from "./class-builder.ts";
-export { isDefineClassInstance, isInstanceOf, getClassInstanceState, getInstanceId, getClassName, } from "./class-helpers.ts";
-export type { DefineClassInstance } from "./class-helpers.ts";
+export { isDefineClassInstance, isInstanceOf, getClassInstanceState, getInstanceId, getClassName, createClassTypeGuard, isUnmarshalledRequest, isUnmarshalledResponse, isUnmarshalledHeaders, isUnmarshalledFormData, } from "./class-helpers.ts";
+export type { DefineClassInstance, TypedClassInstance } from "./class-helpers.ts";
 export { nextInstanceId, registerInstance, getInstanceMetadata, getInstanceClassName, cleanupInstanceState as cleanupInstanceStateById, } from "./instance-state.ts";
 export type { InstanceMetadata } from "./instance-state.ts";
 export { createReadableStream, consumeReadableStream, } from "./streams/readable-stream.ts";
@@ -46,5 +46,7 @@ export { createBlob } from "./blob.ts";
 export { createFile } from "./file.ts";
 export { createURLSearchParamsClass } from "./url-search-params.ts";
 export type { URLSearchParamsState } from "./url-search-params.ts";
-export { createURLClass, addURLSearchParamsGetter } from "./url.ts";
+export { createURLClass, addURLSearchParamsLinkage, addURLSearchParamsGetter } from "./url.ts";
 export type { URLState } from "./url.ts";
+export { createCoercer, classCoercer, instanceOrShape, coerceURL, coerceToURLString, coerceHeaders, coerceBody, coerceRequestInit, coerceResponseInit, } from "./coerce.ts";
+export type { Coercer, CoercionResult, URLCoerced, HeadersCoerced, RequestInitCoerced, ResponseInitCoerced, } from "./coerce.ts";

package/dist/types/url.d.ts

@@ -26,5 +26,13 @@ export declare function createURLClass(context: QuickJSContext, stateMap: StateM
 /**
  * Add searchParams getter to URL prototype using evalCode
  * This must be called after both URL and URLSearchParams are registered as globals
+ *
+ * The getter creates a URLSearchParams instance on first access and wraps its
+ * mutating methods (set, append, delete, sort) to sync changes back to the URL.
+ * This eliminates cross-module coupling by keeping all sync logic in JavaScript.
+ */
+export declare function addURLSearchParamsLinkage(context: QuickJSContext): void;
+/**
+ * @deprecated Use addURLSearchParamsLinkage instead
  */
-export declare function addURLSearchParamsGetter(context: QuickJSContext): void;
+export declare const addURLSearchParamsGetter: typeof addURLSearchParamsLinkage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/quickjs-core",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "main": "./dist/cjs/index.cjs",
   "types": "./dist/types/index.d.ts",
   "exports": {