@solidjs/web 2.0.0-experimental.9 → 2.0.0-rc.0

package/types-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/types-cjs/response.d.cts

@@ -0,0 +1,174 @@
+/**
+ * Envelope pairing HTTP metadata (a `Response`) with an in-memory value.
+ * Produced by `respond()` and by server-function `transformResult`
+ * implementations (e.g. single-flight payloads). The HTTP handler forwards
+ * `response`'s headers and (non-redirect) status and encodes `value` as the
+ * body through the codec, while client-only integrations read `value`
+ * directly — no reparse. Mostly consumed by integrations (routers);
+ * application code usually just returns what `respond()` gives it.
+ */
+export class ResponseEnvelope<T = unknown> {
+  constructor(response: Response | undefined, value: T);
+  /** The HTTP metadata: status and headers to forward (body ignored by integrations). */
+  response: Response | undefined;
+  /** The structured value the caller receives. */
+  value: T;
+}
+
+/**
+ * Whether `value` is a `ResponseEnvelope`. Uses a registered-symbol brand
+ * rather than `instanceof`, so it stays correct when separately bundled
+ * entries each carry a copy of the class. Integrations should always use
+ * this over `instanceof`.
+ */
+export function isResponseEnvelope(value: unknown): value is ResponseEnvelope;
+
+/**
+ * Registered-symbol brand (`Symbol.for("solid.Href")`) marking URL-bearing
+ * values. Declared `unique symbol` type-side; the runtime value is the
+ * registered symbol, so separately bundled copies agree on identity.
+ */
+export declare const HREF: unique symbol;
+
+/**
+ * A URL-bearing value: coerces to its URL via `toString()` and carries the
+ * `HREF` registered-symbol brand. Integrations mint these (e.g. a router's
+ * typed path objects answer the brand from their proxy) and URL-accepting
+ * APIs like `redirect()` accept them alongside plain strings. The brand is
+ * what makes the type meaningful — every object has `toString()`.
+ */
+export interface Href {
+  [HREF]: true;
+  toString(): string;
+}
+
+/**
+ * Whether `value` is an `Href`-branded URL-bearing value. Registered-symbol
+ * check, so it stays correct across duplicated module instances — same
+ * rationale as `isResponseEnvelope`.
+ */
+export function isHref(value: unknown): value is Href;
+
+/**
+ * Registered-symbol brand (`Symbol.for("solid.SafeError")`) marking a thrown
+ * value as safe to serialize to the client verbatim. Declared `unique
+ * symbol` type-side; the runtime value is the registered symbol, so
+ * separately bundled copies agree on identity.
+ */
+export declare const SAFE_ERROR: unique symbol;
+
+/**
+ * Marks `error` as safe to serialize to the client verbatim, opting it out
+ * of the server-function handler's production error sanitization.
+ *
+ * By default a plain `Error` thrown from a server function is sanitized to a
+ * generic `Error` outside the dev build (the `development` export condition
+ * selects the full-fidelity copy; every other resolution sanitizes):
+ * its `message`, `stack`, and own-properties are dropped so a driver/ORM
+ * error can't leak a failing query or connection string over the wire.
+ * Dev builds keep full fidelity. This is the escape hatch for errors whose
+ * content is *intentional* client-facing information — brand them and their
+ * message/properties travel intact in every environment.
+ *
+ * The brand is a non-enumerable, symbol-keyed property, so it never itself
+ * serializes as an own-property. Sets the brand and returns the same value.
+ *
+ * @example
+ * ```ts
+ * import { markSafeError } from "@solidjs/web";
+ *
+ * async function transfer(amount: number) {
+ *   "use server";
+ *   if (amount > balance) {
+ *     // The user must see this message; opt out of sanitization.
+ *     throw markSafeError(new Error("Insufficient funds"));
+ *   }
+ * }
+ * ```
+ */
+export function markSafeError<E>(error: E): E;
+
+/**
+ * Whether `value` is branded safe to serialize (via `markSafeError`).
+ * Registered-symbol check, correct across duplicated module instances.
+ */
+export function isSafeError(value: unknown): value is Error;
+
+/**
+ * Response header naming the cache keys a mutation invalidated
+ * (`"X-Revalidate"`), comma separated. The response helpers below set it
+ * from their `revalidate` option; the client transport treats its presence
+ * as control flow, and integrations read it to invalidate their own cache.
+ * Core never inspects the keys, so how they are matched (prefixes, exact
+ * names, namespaces) is the integration's business.
+ */
+export const REVALIDATE_HEADER: string;
+
+/** `ResponseInit` accepted by the response helpers, plus `revalidate`. */
+export interface ResponseHelperInit extends ResponseInit {
+  /**
+   * Cache keys the mutation invalidated, carried in the `X-Revalidate`
+   * header. Opaque to the protocol — the integration's keyed cache (e.g.
+   * the router's `query` cache) assigns them meaning.
+   */
+  revalidate?: string | string[];
+}
+
+/**
+ * Response redirecting to `url` (default status 302). Return (or throw) it
+ * from a server function — the HTTP handler forwards the redirect for the
+ * client integration to follow — or return it from a client-side action,
+ * where the integration interprets it in memory. Same object, same
+ * meaning, both sides.
+ *
+ * @example
+ * ```ts
+ * import { redirect } from "@solidjs/web";
+ *
+ * async function login(form: FormData) {
+ *   "use server";
+ *   // ...
+ *   return redirect("/dashboard", { revalidate: "session" });
+ * }
+ * ```
+ */
+export function redirect(url: string | Href, init?: number | ResponseHelperInit): Response;
+
+/**
+ * Empty response requesting revalidation of the named cache keys — all of
+ * them when omitted. For mutations whose only effect the caller needs is
+ * "refetch your data".
+ *
+ * @example
+ * ```ts
+ * import { reload } from "@solidjs/web";
+ *
+ * async function addTodo(title: string) {
+ *   "use server";
+ *   await db.insert(title);
+ *   return reload({ revalidate: "todos" });
+ * }
+ * ```
+ */
+export function reload(init?: ResponseHelperInit): Response;
+
+/**
+ * A value paired with response metadata (status, headers, `revalidate`) —
+ * for the things a naked return can't express. Scripted callers receive
+ * `value` transparently (the transport unwraps the envelope), and
+ * progressive enhancement stays invisible: the carried response holds a
+ * plain JSON body so consumers without the client runtime (no-JS form
+ * posts, direct HTTP) get real JSON.
+ *
+ * @example
+ * ```ts
+ * import { respond } from "@solidjs/web";
+ *
+ * async function createItem(input: Item) {
+ *   "use server";
+ *   const item = await db.create(input);
+ *   return respond(item, { status: 201, revalidate: "items" });
+ * }
+ * ```
+ */
+export function respond<T>(value: T, init?: ResponseHelperInit): ResponseEnvelope<T>;

package/types-cjs/serializer-decode.d.cts

@@ -0,0 +1,182 @@
+// The DECODE half of the serialization surface (published as
+// `@solidjs/web/serialization/decode`): what reading a serialized payload
+// needs — `fromCrossJSON`-backed deserializers and the shared plugin set —
+// with none of the encode machinery. Lazy client consumers (the frames
+// data tables, `deserializeStream`) load this module so the encode half
+// never ships to a browser that only reads. The full serializer.d.ts
+// re-exports everything here; see its banner for the stability contract
+// (integration-facing, exempt from the 2.0 stability guarantee).
+// ---- Plugin types ----
+//
+// Declared here by hand (seroval's published d.ts use extensionless
+// ESM-relative imports that `moduleResolution: "nodenext"` cannot follow —
+// a bare type re-export would silently degrade the surface to `any` under
+// skipLibCheck, and an import would make every entry whose types reach
+// this module — the MAIN client entry included, via the server-function
+// seam's `JSONCodecOptions` — unimportable from a strict Node16 CJS
+// consumer). The declarations mirror seroval ~1.5 exactly; the `~` pin is
+// what makes mirroring safe. Plugin AUTHORING (`createPlugin`,
+// `OpaqueReference`) lives on the full serialization entry.
+
+/**
+ * Seroval's node shape — the intermediate representation `serializeJSON`
+ * emits and `createJSONDeserializer` consumes. Safe to `JSON.stringify`.
+ * Declared by hand like the plugin types below (same rationale): the
+ * observable envelope — a numeric type tag, an optional reference id —
+ * with the rest owned by the codec. Real seroval nodes satisfy it; treat
+ * it as an opaque token.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export interface SerovalNode {
+  /** Node type tag (seroval-internal enum). */
+  t: number;
+  /** Reference id, when the node participates in cross-referencing. */
+  i?: number | undefined;
+  [key: string]: unknown;
+}
+
+/** Per-plugin bookkeeping seroval hands each plugin callback. */
+export interface PluginData {
+  id: number;
+}
+
+/**
+ * The shape of a plugin's parsed payload: a map of `SerovalNode`s produced
+ * by the parse contexts, consumed by `serialize`/`deserialize`.
+ */
+export type PluginInfo = { [key: string]: SerovalNode };
+
+/** Parse context for `parse.sync`: turns child values into nodes. */
+export interface SyncParsePluginContext {
+  parse<T>(current: T): SerovalNode;
+}
+
+/** Parse context for `parse.async`: like sync, but child parses await. */
+export interface AsyncParsePluginContext {
+  parse<T>(current: T): Promise<SerovalNode>;
+}
+
+/**
+ * Parse context for `parse.stream`: sync parsing plus the streaming
+ * lifecycle (pending-state tracking, late node emission, cleanup).
+ */
+export interface StreamParsePluginContext {
+  parse<T>(current: T): SerovalNode;
+  parseWithError<T>(current: T): SerovalNode | undefined;
+  isAlive(): boolean;
+  pushPendingState(): void;
+  popPendingState(): void;
+  onParse(node: SerovalNode): void;
+  onError(error: unknown): void;
+  addCleanup(callback: () => void): void;
+}
+
+/** Serialize context: renders child nodes to JS source. */
+export interface SerializePluginContext {
+  serialize(node: SerovalNode): string;
+}
+
+/** Deserialize context: revives child nodes to runtime values. */
+export interface DeserializePluginContext {
+  deserialize<T>(node: SerovalNode): T;
+}
+
+/**
+ * A Seroval plugin usable with the web serializers — teaches the codec how
+ * to encode/decode a custom value type (`Value` is the value it matches,
+ * `Info` its parsed payload). Supply matching plugins on both peers of a
+ * transport. Bare `SerializerPlugin` (both parameters defaulted to `any`)
+ * is the list-element type every `plugins` option accepts.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export interface SerializerPlugin<Value = any, Info extends PluginInfo = any> {
+  /** A unique string identifying the plugin — namespace it (`"app/Thing"`). */
+  tag: string;
+  /** Dependency plugins, resolved ahead of this one. */
+  extends?: SerializerPlugin[];
+  /** Whether `value` is this plugin's to encode. */
+  test(value: unknown): boolean;
+  /** Parsing modes — provide the ones the transports you target use. */
+  parse: {
+    sync?: (value: Value, ctx: SyncParsePluginContext, data: PluginData) => Info;
+    async?: (value: Value, ctx: AsyncParsePluginContext, data: PluginData) => Promise<Info>;
+    stream?: (value: Value, ctx: StreamParsePluginContext, data: PluginData) => Info;
+  };
+  /** Renders the parsed payload as JS source (script-injection form). */
+  serialize(node: Info, ctx: SerializePluginContext, data: PluginData): string;
+  /** Revives the parsed payload back into the runtime value. */
+  deserialize(node: Info, ctx: DeserializePluginContext, data: PluginData): Value;
+}
+
+/**
+ * Baseline plugin set for serializing web-platform values (AbortSignal,
+ * Event, FormData, Headers, ReadableStream, Request, Response, URL, ...).
+ * Applied by every serializer in this module; custom plugins compose ahead
+ * of it via `resolveSerializerPlugins`.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export const DEFAULT_WEB_PLUGINS: readonly SerializerPlugin[];
+
+/**
+ * Composes custom plugins with `DEFAULT_WEB_PLUGINS`. Custom plugins come
+ * first so they can shadow a default for values both would match. Returns a
+ * fresh array; the defaults are never mutated. Useful when handing a full
+ * plugin list to another serialization layer.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export function resolveSerializerPlugins(customPlugins?: SerializerPlugin[]): SerializerPlugin[];
+
+/**
+ * Options shared by both halves of the JSON codec. All of them must match
+ * on the serializing and deserializing peer or payloads will not
+ * round-trip — for server functions, set them once through the
+ * client/server `codec` config option.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export interface JSONCodecOptions {
+  /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. Must match on both peers. */
+  plugins?: SerializerPlugin[];
+  /**
+   * Seroval feature bitflags to exclude. Defaults to disabling `RegExp`
+   * (payloads may come from an untrusted peer). Must match on both peers.
+   * Outside development, the encoding side additionally strips
+   * `Error.prototype.stack` on top of any override — serialized stacks leak
+   * server paths to the client. Decoding stays permissive, so payloads from
+   * a development peer still round-trip.
+   */
+  disabledFeatures?: number;
+  /** Maximum parse/deserialize depth. Defaults to 64. Must match on both peers. */
+  depthLimit?: number;
+}
+
+/**
+ * Creates the decoding counterpart of `serializeJSON`. Cross-references
+ * between chunks resolve through state shared across calls, so all chunks
+ * from one stream must go through the same deserializer instance. The first
+ * chunk's return value is the decoded source value; feeding later chunks
+ * settles the async values referenced inside it.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export function createJSONDeserializer(options?: JSONCodecOptions): <T>(node: SerovalNode) => T;
+
+/**
+ * A resident, response-scoped decode table over the keyed JSON codec: apply
+ * each frame `data` chunk with `apply`, resolve `{ $ref }` slot args with
+ * `resolve`. The frames client host wires one per response
+ * (`applyData: c => table.apply(c)`).
+ *
+ * Integration-facing; may change (see the entry banner). This serialization
+ * entry is the single home of the data table — the frames client consumes
+ * it internally rather than re-exporting it.
+ */
+export interface JSONDataTable {
+  apply(chunk: { key?: string; node?: unknown; initial?: boolean }): void;
+  resolve<T = unknown>(ref: { $ref: string }): T;
+}
+export function createJSONDataTable(options?: JSONCodecOptions): JSONDataTable;

package/types-cjs/serializer.d.cts

@@ -0,0 +1,182 @@
+// Serialization surface (published as `@solidjs/web/serialization`): the
+// runtime's Seroval machinery, exposed for the runtime's own entries and
+// for integrations building transports on the same codec. This is
+// INTEGRATION-FACING plumbing, not application API — it is exempt from the
+// 2.0 stability guarantee and may change between releases. Application and
+// router code should configure `codec` on the server-function entries
+// instead of importing from here.
+import type { Serializer } from "seroval";
+import {
+  JSONCodecOptions,
+  PluginInfo,
+  SerializerPlugin,
+  SerovalNode
+} from "./serializer-decode.cjs";
+
+// The decode half — `SerovalNode`, the plugin TYPES, `DEFAULT_WEB_PLUGINS`,
+// `resolveSerializerPlugins`, `JSONCodecOptions`, `createJSONDeserializer`,
+// `createJSONDataTable` — is declared in serializer-decode.d.ts (published
+// as `@solidjs/web/serialization/decode`, the module lazy client consumers
+// load) and re-exported here so this remains the full surface.
+export * from "./serializer-decode.cjs";
+
+// ---- Plugin authoring ----
+//
+// Unlike the rest of this entry, plugin authoring is APPLICATION-FACING —
+// it is the supported way to feed the serializers' `plugins` options and
+// the server-function entries' `codec.plugins`. The values re-export
+// seroval's own (`createPlugin`, `OpaqueReference` — see serializer.js);
+// the plugin TYPES live in serializer-decode.d.ts (hand-declared there —
+// see its banner for why).
+
+/**
+ * Builds a `SerializerPlugin` — seroval's `createPlugin`, re-exported so
+ * plugin authors stay on the exact seroval instance/version the runtime
+ * serializes with. Import it from HERE, not from your own `seroval`
+ * dependency: a plugin built against a different copy/version would not
+ * fail the build — it would emit nodes the other peer can't interpret.
+ *
+ * Application-facing (see the plugin-authoring banner above).
+ */
+export function createPlugin<Value, Info extends PluginInfo>(
+  plugin: SerializerPlugin<Value, Info>
+): SerializerPlugin<Value, Info>;
+
+/**
+ * Seroval's `OpaqueReference`, re-exported from the runtime's own instance
+ * (an `OpaqueReference` from another seroval copy fails the serializer's
+ * instanceof check and serializes as a plain value): wraps a value so it
+ * crosses the wire as its `replacement` (default `undefined`) while
+ * staying readable in-process through `.value`.
+ *
+ * Application-facing (see the plugin-authoring banner above).
+ */
+export class OpaqueReference<V, R = undefined> {
+  readonly value: V;
+  readonly replacement?: R;
+  constructor(value: V, replacement?: R);
+}
+
+/**
+ * Options for `createSerializer`.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export interface WebSerializerOptions {
+  /** Name of the global object the emitted scripts write resolved values into. */
+  globalIdentifier: string;
+  /** Cross-reference scope id, for isolating multiple streams on one page. */
+  scopeId?: string;
+  /**
+   * Seroval feature bitflags to exclude from output. Defaults to disabling
+   * post-ES2017 features (AggregateError, BigInt typed arrays). Outside
+   * development, `Error.prototype.stack` is additionally stripped on top of
+   * any override — serialized stacks leak server paths to the client.
+   */
+  disabledFeatures?: number;
+  /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
+  plugins?: SerializerPlugin[];
+  /** Receives each emitted script chunk. */
+  onData: (result: string) => void;
+  onError?: (error: unknown) => void;
+  /** Fires once all async values have settled. */
+  onDone?: () => void;
+}
+
+/**
+ * Creates a streaming Seroval serializer preconfigured with the web plugin
+ * set and the default feature policy. Emits JavaScript chunks (through
+ * `onData`) that reconstruct the values under `globalIdentifier` when
+ * evaluated — the script-injection form of serialization renderers build
+ * on. For a JSON-based wire codec (no eval on the receiving side), use
+ * `serializeJSON` / `createJSONDeserializer` instead.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export function createSerializer(options: WebSerializerOptions): Serializer;
+
+/**
+ * Options for `createHydrationSerializer` — `WebSerializerOptions` minus
+ * the knobs hydration pins (`globalIdentifier`, `disabledFeatures`).
+ * @internal
+ */
+export type HydrationSerializerOptions = Omit<
+  WebSerializerOptions,
+  "globalIdentifier" | "disabledFeatures"
+>;
+
+/**
+ * Renderer primitive — the serializer SSR uses for hydration output. Pins
+ * the hydration global (`_$HY.r`) and feature policy; only the wiring
+ * options (callbacks, scope, extra plugins) are configurable. Not meant
+ * for hand-written code — custom serialization should use
+ * `createSerializer` or the JSON codec.
+ * @internal
+ */
+export function createHydrationSerializer(options: HydrationSerializerOptions): Serializer;
+
+/**
+ * Renderer primitive — returns the cross-reference bootstrap script SSR
+ * emits ahead of hydration data for a render scope. Not meant for
+ * hand-written code.
+ * @internal
+ */
+export function getLocalHeaderScript(id?: string): string;
+
+// ---- JSON codec (server function transports) ----
+// (`JSONCodecOptions` and the decode half are declared in
+// serializer-decode.d.ts and re-exported above.)
+
+/**
+ * Options for `serializeJSON`.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export interface JSONSerializeOptions extends JSONCodecOptions {
+  /**
+   * Receives each serialized node; `initial` is true for the first chunk
+   * (the source value itself). Async values produce additional chunks as
+   * they resolve.
+   */
+  onParse: (node: SerovalNode, initial: boolean) => void;
+  onError?: (error: unknown) => void;
+  /** Fires once all async values have settled. */
+  onDone?: () => void;
+}
+
+/**
+ * Serializes `value` as SerovalNode chunks delivered through `onParse` —
+ * the encoding half of the eval-free JSON codec (RPC-style transports;
+ * the deserializing peer needs no script evaluation, so CSP-safe). Wire
+ * framing of the nodes is the transport's concern. Returns a cancel
+ * function that aborts pending async serialization.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
+
+/** Options for `createJSONSerializer`. */
+export interface JSONSerializerOptions extends JSONCodecOptions {
+  /**
+   * Receives each keyed record — `initial` is true for a key's first node
+   * (the written value itself); async values patch through later records
+   * under the same key. The decoding peer is `createJSONDataTable`.
+   */
+  onData: (record: { key: string; node: SerovalNode; initial: boolean }) => void;
+  onError?: (error: unknown) => void;
+  /** Fires once `flush()` has been called and every pending value settled. */
+  onDone?: () => void;
+}
+
+/**
+ * The keyed, streaming encoder of the eval-free JSON codec — the render
+ * stream's data serializer (frames default to it). Each `write(key, value)`
+ * shares one reference space, so cross-record identity holds; `flush()`
+ * marks the write set complete (writes after it are dropped, mirroring the
+ * hydration serializer); `close()` aborts pending async serialization.
+ */
+export function createJSONSerializer(options: JSONSerializerOptions): {
+  write(key: string, value: unknown): void;
+  flush(): void;
+  close(): void;
+};