@solidjs/web 2.0.0-beta.17 → 2.0.0-beta.19

package/types-cjs/server-functions/shared.d.cts

@@ -0,0 +1,171 @@
+import { JSONCodecOptions } from "../serializer.cjs";
+
+export type { JSONCodecOptions };
+
+/**
+ * Configures the codec options for the server function wire format (extra
+ * Seroval plugins, feature policy, depth limit). Both peers must configure
+ * identical options or payloads will not round-trip. Usually called
+ * indirectly through `configureServerFunctionsClient` /
+ * `configureServerFunctionsServer` (their `codec` option writes through to
+ * here); call it directly only from universal code configuring both sides
+ * at once.
+ */
+export function configureServerFunctionsCodec(codec: JSONCodecOptions | undefined): void;
+
+/**
+ * The currently configured codec options (set through
+ * `configureServerFunctionsCodec` or the client/server `codec` option), or
+ * undefined when running on the defaults. Integrations pass this to
+ * lower-level codec helpers so custom plugins configured by the app apply.
+ */
+export function getServerFunctionsCodec(): JSONCodecOptions | undefined;
+
+/**
+ * Request header carrying the server function id (`"X-Server-Function-Id"`).
+ * Integrations can read it to identify which function a request targets;
+ * the id also arrives as the `id` query parameter for GET calls and no-JS
+ * form posts.
+ */
+export const FUNCTION_HEADER: string;
+
+/**
+ * Request header carrying a per-call instance id
+ * (`"X-Server-Function-Instance"`). Its presence tells the server the call
+ * came through the client runtime — its absence marks a no-JS form post or
+ * direct HTTP call, which receive plain responses instead of codec-encoded
+ * ones.
+ */
+export const INSTANCE_HEADER: string;
+
+/**
+ * Header carrying the body format tag (a `BodyFormat` value) —
+ * `"X-Server-Function-Format"`.
+ *
+ * Transport wire detail; not meant for hand-written code.
+ * @internal
+ */
+export const BODY_FORMAT_HEADER: string;
+
+/**
+ * FormData key used when a lone File is sent as the argument.
+ *
+ * Transport wire detail; not meant for hand-written code.
+ * @internal
+ */
+export const FILE_FORM_KEY: string;
+
+/**
+ * Wire tags naming how a request/response body was encoded, carried in
+ * `BODY_FORMAT_HEADER`.
+ *
+ * Transport wire detail; not meant for hand-written code.
+ * @internal
+ */
+export const BodyFormat: {
+  readonly Serialized: "0";
+  readonly String: "1";
+  readonly FormData: "2";
+  readonly URLSearchParams: "3";
+  readonly Blob: "4";
+  readonly File: "5";
+  readonly ArrayBuffer: "6";
+  readonly Uint8Array: "7";
+};
+
+/**
+ * Transport wire detail; not meant for hand-written code.
+ * @internal
+ */
+export type BodyFormatValue = (typeof BodyFormat)[keyof typeof BodyFormat];
+
+/**
+ * Picks a direct HTTP encoding (headers + BodyInit) for values that have
+ * one — strings, FormData, URLSearchParams, File, Blob, ArrayBuffer,
+ * Uint8Array. Returns undefined when the value needs the serializer.
+ *
+ * Transport building block used by the fetch transport and the HTTP
+ * handler; not meant for hand-written code.
+ * @internal
+ */
+export function getHeadersAndBody(
+  body: unknown
+): { headers?: Record<string, string>; body: BodyInit } | undefined;
+
+/**
+ * Decodes a Request/Response body according to its `BODY_FORMAT_HEADER`
+ * tag (falling back to content-type sniffing for form posts that never saw
+ * the client runtime). The inverse of `getHeadersAndBody` + the serialized
+ * stream. Resolves undefined for bodies without a recognized encoding.
+ *
+ * Transport building block; use `decodeResponse` from integration code.
+ * @internal
+ */
+export function extractBody(
+  source: Request | Response,
+  codecOptions?: JSONCodecOptions
+): Promise<unknown>;
+
+/**
+ * Serializes a value as a stream of length-prefixed SerovalNode chunks.
+ * Async values (promises, streams) keep the stream open until they settle,
+ * so one connection carries incremental results. Codec options must match
+ * the deserializing peer.
+ *
+ * Transport building block; not meant for hand-written code.
+ * @internal
+ */
+export function serializeStream(
+  value: unknown,
+  codecOptions?: JSONCodecOptions
+): ReadableStream<Uint8Array>;
+
+/**
+ * `serializeStream` drained to a string (async values fully awaited).
+ *
+ * Transport building block; not meant for hand-written code.
+ * @internal
+ */
+export function serializeString(value: unknown, codecOptions?: JSONCodecOptions): Promise<string>;
+
+/**
+ * Decodes a framed chunk stream from a Request/Response body. Resolves with
+ * the first chunk's value (the source value); later chunks settle the async
+ * values referenced inside it as they arrive.
+ *
+ * Transport building block; use `decodeResponse` from integration code.
+ * @internal
+ */
+export function deserializeStream<T = unknown>(
+  source: Request | Response,
+  codecOptions?: JSONCodecOptions
+): Promise<T>;
+
+/**
+ * `deserializeStream` for an already-buffered string.
+ *
+ * Transport building block; not meant for hand-written code.
+ * @internal
+ */
+export function deserializeString<T = unknown>(
+  text: string,
+  codecOptions?: JSONCodecOptions
+): Promise<T>;
+
+/**
+ * Decodes a server function response body using the configured codec. This
+ * is the integration-facing decoder: routers call it on responses the
+ * transport hands over whole — redirects, revalidation, single-flight
+ * payloads — to recover the structured value inside. Resolves undefined for
+ * empty bodies and bodies without a recognized encoding (e.g. a raw user
+ * Response). Renderer- and platform-neutral: safe to use from universal
+ * code.
+ *
+ * @param response the transport response; its body is read from a clone,
+ * so the original stays readable
+ * @param codecOptions overrides the configured codec for this call
+ */
+export function decodeResponse<T = unknown>(
+  response: Response,
+  codecOptions?: JSONCodecOptions
+): Promise<T | undefined>;

package/types-cjs/server.d.cts

@@ -1,4 +1,5 @@
 import { JSX } from "./jsx.cjs";
+import { SerializerPlugin } from "./serializer.cjs";
 export const DOMWithState: Record<string, Record<string, 1 | 2>>;
 export const ChildProperties: Set<string>;
 export const DelegatedEvents: Set<string>;
@@ -11,17 +12,59 @@ export const Namespaces: Record<string, string>;
 
 type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
 
+/** Static asset manifest produced by a build (e.g. parsed Vite manifest.json). */
+export type AssetManifest = Record<
+  string,
+  { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
+> & { _base?: string };
+
+/** Inline style content, e.g. dev CSS collected from a bundler's module graph. */
+export type InlineStyleAsset = {
+  id: string;
+  content: string;
+  attrs?: Record<string, string>;
+};
+
+export type ResolvedAssets = {
+  js: string[];
+  css: (string | InlineStyleAsset)[];
+};
+
+/**
+ * Resolver form of the manifest option — the primitive a dev server
+ * implements against its live module graph (a static manifest object is
+ * normalized into a sync resolver internally). `resolve` may return a
+ * promise (async resolvers require streaming rendering); CSS entries may be
+ * URL strings (emitted as load-gated `<link>` tags) or inline-style
+ * descriptors (emitted as `<style>` tags). A bare `resolve`-shaped function
+ * is accepted as shorthand for `{ resolve }`.
+ */
+export type AssetResolver = {
+  resolve(
+    key: string
+  ): ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
+  /**
+   * Synchronous fast path answering with whatever is knowable without async
+   * work (typically js URLs, omitting css). Sync consumers — e.g. a lazy
+   * component's `moduleUrl` getter used by islands — use this when `resolve`
+   * would return a promise, so adapters should provide it whenever possible.
+   */
+  resolveSync?(key: string): ResolvedAssets | null | undefined;
+};
+
+/** Bare-function shorthand for `AssetResolver` (no sync fast path). */
+export type AssetResolverFn = (
+  key: string
+) => ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
+
 export function renderToString<T>(
   fn: () => T,
   options?: {
     nonce?: string;
     renderId?: string;
     noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<
-      string,
-      { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
-    > & { _base?: string };
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onError?: (err: any) => void;
   }
 ): string;
@@ -33,11 +76,8 @@ export function renderToStringAsync<T>(
     nonce?: string;
     renderId?: string;
     noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<
-      string,
-      { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
-    > & { _base?: string };
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onError?: (err: any) => void;
   }
 ): Promise<string>;
@@ -47,11 +87,8 @@ export function renderToStream<T>(
     nonce?: string;
     renderId?: string;
     noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<
-      string,
-      { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
-    > & { _base?: string };
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onCompleteShell?: (info: { write: (v: string) => void }) => void;
     onCompleteAll?: (info: { write: (v: string) => void }) => void;
     onError?: (err: any) => void;
@@ -95,11 +132,29 @@ export function generateHydrationScript(options?: {
   nonce?: string;
   eventNames?: string[];
 }): string;
+/**
+ * Registered symbol (`Symbol.for("solid.RequestContext")`) naming the
+ * global slot where `provideRequestEvent` parks the AsyncLocalStorage that
+ * scopes request events. Integration plumbing — application code reads the
+ * event through `getRequestEvent()` instead.
+ * @internal
+ */
 export declare const RequestContext: unique symbol;
+/**
+ * The per-request context available on the server: the incoming `Request`
+ * and a `locals` bag integrations and middleware can hang state on.
+ * Frameworks typically extend this shape with richer fields.
+ */
 export interface RequestEvent {
   request: Request;
   locals: Record<string | number | symbol, any>;
 }
+/**
+ * The current request event, when called on the server inside a request
+ * scope (established by `provideRequestEvent` from `@solidjs/web/storage`
+ * or by the framework). Undefined on the client and outside a request.
+ * Read it above `await` boundaries in partially-polyfilled environments.
+ */
 export function getRequestEvent(): RequestEvent | undefined;
 
 export function Assets(props: { children?: JSX.Element }): JSX.Element;

package/storage/types/src/client.d.ts

@@ -1 +0,0 @@
-export * from "@dom-expressions/runtime/src/client.js";

package/storage/types/src/index.d.ts

@@ -1,171 +0,0 @@
-import { hydrate as hydrateCore } from "./client.js";
-import { Component } from "solid-js";
-import type { JSX } from "./jsx.js";
-export * from "./client.js";
-export * from "./server-mock.js";
-export type { JSX } from "./jsx.js";
-export { For, Show, Switch, Match, Errored, Loading, Repeat, Reveal, NoHydration, Hydration } from "solid-js";
-import { merge } from "solid-js";
-/**
- * Compiler-emitted prop-spread helper. The JSX transform (in
- * `dom-expressions`) emits `mergeProps(...)` calls when compiling prop
- * spreads on components — it is *not* a user-facing API. Application code
- * should import `merge` from `solid-js` directly.
- *
- * @internal
- */
-export declare const mergeProps: typeof merge;
-/**
- * Build-time constant indicating whether code is running on the server. This
- * client entry sets it to `false`; the matching server entry (`@solidjs/web`
- * resolved through the `solid` server export condition) sets it to `true`.
- *
- * Bundlers can dead-code-eliminate branches gated on `isServer`, so guarding
- * browser-only code with `if (!isServer) {…}` keeps it out of the SSR bundle
- * entirely.
- *
- * @example
- * ```ts
- * import { isServer } from "@solidjs/web";
- *
- * if (!isServer) {
- *   // Browser-only: tree-shaken out of the SSR bundle.
- *   window.addEventListener("resize", onResize);
- * }
- * ```
- */
-export declare const isServer: boolean;
-/**
- * Build-time constant indicating whether code is running in a dev build.
- * Replaced statically (`_SOLID_DEV_`) by the bundler integration, so guards
- * like `if (isDev) {…}` are stripped from production builds.
- *
- * Use this to gate dev-only diagnostics, warnings, or expensive invariants
- * that should never ship to production.
- *
- * @example
- * ```ts
- * import { isDev } from "@solidjs/web";
- *
- * if (isDev) {
- *   console.warn("debug-only path");
- * }
- * ```
- */
-export declare const isDev: boolean;
-type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
-export type IntrinsicElement = Extract<keyof JSX.IntrinsicElements, string>;
-export type ValidComponent = IntrinsicElement | Component<any> | (string & {});
-export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
-export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
-    [K in keyof P]: P[K];
-} & {
-    component: T | null | undefined | false;
-};
-/**
- * Renders a component tree into a DOM element. Returns a dispose function
- * that tears the tree down and cleans up reactive scopes when called.
- *
- * @example
- * ```tsx
- * import { render } from "@solidjs/web";
- *
- * const dispose = render(() => <App />, document.getElementById("root")!);
- *
- * // Later, to unmount:
- * dispose();
- * ```
- *
- * @remarks
- * The top-level insert is queued via `insertOptions: { schedule: true }` so
- * its initial DOM attach goes through the effect queue rather than executing
- * inline. This lets the mount participate in transitions: if an uncaught
- * async read surfaces during the initial render (no `Loading` ancestor
- * absorbs it), the mount is held by the transition and attaches atomically
- * once all pending settles. On the no-async happy path the tail `flush()`
- * drains the queued callback so the attach is synchronous by the time
- * `render()` returns. The dev enforcement window scopes
- * `ASYNC_OUTSIDE_LOADING_BOUNDARY` to the initial mount only.
- */
-export declare function render(code: () => JSX.Element, element: MountableElement, init?: unknown, options?: {
-    renderId?: string;
-}): () => void;
-/**
- * Resumes a server-rendered tree on the client, attaching event listeners
- * and reactive bindings without reconstructing the DOM. Returns a `dispose`
- * function that tears down reactive scopes (DOM nodes are left in place).
- *
- * Use this when the page HTML was produced by `renderToString`,
- * `renderToStringAsync`, or `renderToStream`. For client-only apps, use
- * `render` instead.
- *
- * Pass `options.renderId` to hydrate one of multiple roots emitted by a
- * server render that used the same id.
- *
- * @example
- * ```tsx
- * import { hydrate } from "@solidjs/web";
- *
- * hydrate(() => <App />, document.getElementById("root")!);
- * ```
- */
-export declare const hydrate: typeof hydrateCore;
-/**
- * Renders its children into a different part of the DOM (modal roots,
- * tooltips, layers that need to escape an `overflow: hidden` ancestor).
- *
- * If `mount` is omitted, the portal attaches to `document.body`. The portal
- * still participates in the parent's reactive scope and disposes when the
- * parent does.
- *
- * @example
- * ```tsx
- * <Portal mount={document.getElementById("modal-root")!}>
- *   <Dialog />
- * </Portal>
- * ```
- *
- * @description https://docs.solidjs.com/reference/components/portal
- */
-export declare function Portal<T extends boolean = false, S extends boolean = false>(props: {
-    mount?: Element;
-    children: JSX.Element;
-}): JSX.Element;
-/**
- * Returns a stable `Component` whose identity is driven by a reactive (and
- * optionally async) `source`. The returned component can be used anywhere a
- * normal component is used; children and props flow through JSX as usual.
- *
- * `source` may return a component, a native tag name (`'input'`, `'textarea'`,
- * etc.), `undefined`, or a `Promise` of any of the above. A pending promise
- * propagates as `NotReadyError` through the surrounding reactive scope, so
- * async swaps compose with `<Loading>` boundaries the same way as `lazy`.
- *
- * @example
- * ```tsx
- * // `source` can return either a custom Component or a native tag
- * // name — they're interchangeable, and the returned reference is a
- * // stable Component you can use anywhere a normal one would go.
- * const Field = dynamic(() => multiline() ? RichTextEditor : "input");
- * return <Field value={value()} onInput={onInput} />;
- * ```
- *
- * @description https://docs.solidjs.com/reference/components/dynamic
- */
-export declare function dynamic<T extends ValidComponent>(source: () => T | Promise<T> | null | undefined | false): Component<ComponentProps<T>>;
-/**
- * Renders an arbitrary custom or native component and forwards the other
- * props. JSX form of `dynamic()` — same primitive, picked at the JSX site.
- *
- * @example
- * ```tsx
- * <Dynamic
- *   component={multiline() ? RichTextEditor : "input"}
- *   value={value()}
- *   onInput={onInput}
- * />
- * ```
- *
- * @description https://docs.solidjs.com/reference/components/dynamic
- */
-export declare function Dynamic<T extends ValidComponent>(props: DynamicProps<T>): JSX.Element;

package/storage/types/src/server-mock.d.ts

@@ -1,161 +0,0 @@
-/**
- * Renders a component tree synchronously to an HTML string. Async reads inside
- * `<Loading>` boundaries emit their `fallback` content; for full-graph
- * resolution use `renderToStringAsync` instead.
- *
- * Pair the returned HTML with `hydrate()` on the client.
- *
- * @example
- * ```tsx
- * import { renderToString } from "@solidjs/web";
- *
- * const html = renderToString(() => <App />);
- * res.send(`<!doctype html><html><body><div id="root">${html}</div></body></html>`);
- * ```
- */
-export declare function renderToString<T>(fn: () => T, options?: {
-    nonce?: string;
-    renderId?: string;
-    noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<string, {
-        file: string;
-        css?: string[];
-        isEntry?: boolean;
-        isDynamicEntry?: boolean;
-        imports?: string[];
-    }>;
-    onError?: (err: any) => void;
-}): string;
-/**
- * Renders a component tree to an HTML string and awaits all async reads in the
- * subtree before resolving. The returned HTML reflects the fully-settled state
- * — no `<Loading>` fallbacks appear in the output.
- *
- * Use this when you want a complete page in one round-trip. For incremental
- * streaming with progressive boundary resolution, use `renderToStream`.
- *
- * @example
- * ```tsx
- * import { renderToStringAsync } from "@solidjs/web";
- *
- * const html = await renderToStringAsync(() => <App />);
- * ```
- */
-export declare function renderToStringAsync<T>(fn: () => T, options?: {
-    timeoutMs?: number;
-    nonce?: string;
-    renderId?: string;
-    noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<string, {
-        file: string;
-        css?: string[];
-        isEntry?: boolean;
-        isDynamicEntry?: boolean;
-        imports?: string[];
-    }>;
-    onError?: (err: any) => void;
-}): Promise<string>;
-/**
- * Streams an HTML response, flushing the synchronous shell first and then
- * progressively emitting async-resolved fragments as their `<Loading>`
- * boundaries settle. Good for time-to-first-byte sensitive pages.
- *
- * Returns an object with `pipe`/`pipeTo` for piping to a Node `Writable` or
- * a Web `WritableStream`, plus a `then` for awaiting full completion.
- *
- * @example
- * ```tsx
- * import { renderToStream } from "@solidjs/web";
- *
- * // Node:
- * renderToStream(() => <App />).pipe(res);
- *
- * // Web (Workers / Deno):
- * await renderToStream(() => <App />).pipeTo(stream.writable);
- * ```
- */
-export declare function renderToStream<T>(fn: () => T, options?: {
-    nonce?: string;
-    renderId?: string;
-    noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<string, {
-        file: string;
-        css?: string[];
-        isEntry?: boolean;
-        isDynamicEntry?: boolean;
-        imports?: string[];
-    }>;
-    onCompleteShell?: (info: {
-        write: (v: string) => void;
-    }) => void;
-    onCompleteAll?: (info: {
-        write: (v: string) => void;
-    }) => void;
-    onError?: (err: any) => void;
-}): {
-    then: (fn: (html: string) => void) => void;
-    pipe: (writable: {
-        write: (v: string) => void;
-        end: () => void;
-    }) => void;
-    pipeTo: (writable: WritableStream) => Promise<void>;
-};
-/**
- * Compiler primitive — emitted by JSX-DOM-Expressions for tagged-template
- * SSR output. Not meant for hand-written code.
- * @internal
- */
-export declare function ssr(template: string[] | string, ...nodes: any[]): {
-    t: string;
-};
-/**
- * Compiler primitive — emitted by JSX-DOM-Expressions for SSR element
- * output. Not meant for hand-written code.
- * @internal
- */
-export declare function ssrElement(name: string, props: any, children: any, needsId: boolean): {
-    t: string;
-};
-/**
- * Compiler primitive — serializes a classList object for SSR output. Not
- * meant for hand-written code.
- * @internal
- */
-export declare function ssrClassList(value: {
-    [k: string]: boolean;
-}): string;
-/**
- * Compiler primitive — serializes a style object for SSR output. Not meant
- * for hand-written code.
- * @internal
- */
-export declare function ssrStyle(value: {
-    [k: string]: string;
-}): string;
-/**
- * Compiler primitive — serializes a boolean attribute for SSR output. Not
- * meant for hand-written code.
- * @internal
- */
-export declare function ssrAttribute(key: string, value: boolean): string;
-/**
- * Compiler primitive — generates the hydration-key attribute for SSR
- * output. Not meant for hand-written code.
- * @internal
- */
-export declare function ssrHydrationKey(): string;
-/**
- * Compiler primitive — collapses an SSR-shaped node into its HTML string.
- * Not meant for hand-written code.
- * @internal
- */
-export declare function resolveSSRNode(node: any): string;
-/**
- * Escapes a string for safe inclusion in HTML output. Used by the SSR
- * runtime; not generally part of user code.
- * @internal
- */
-export declare function escape(html: string): string;

package/storage/types/storage/src/index.d.ts

@@ -1,2 +0,0 @@
-import type { RequestEvent } from "@solidjs/web";
-export declare function provideRequestEvent<T extends RequestEvent, U>(init: T, cb: () => U): U;

package/storage/types-cjs/src/client.d.cts

@@ -1 +0,0 @@
-export * from "@dom-expressions/runtime/src/client.js";