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

package/types-cjs/index.d.cts

@@ -118,6 +118,12 @@ export declare const hydrate: typeof hydrateCore;
  * still participates in the parent's reactive scope and disposes when the
  * parent does.
  *
+ * Portals are client-only islands: the server renders nothing for them, and
+ * under hydration the children render fresh once hydration settles. Async
+ * read inside a portal therefore starts on the client — data that should be
+ * fetched on the server belongs above the portal (hoist the read, not the
+ * render), and async UI inside one wants its own `<Loading>` boundary.
+ *
  * @example
  * ```tsx
  * <Portal mount={document.getElementById("modal-root")!}>
@@ -127,7 +133,7 @@ export declare const hydrate: typeof hydrateCore;
  *
  * @description https://docs.solidjs.com/reference/components/portal
  */
-export declare function Portal<T extends boolean = false, S extends boolean = false>(props: {
+export declare function Portal(props: {
     mount?: Element;
     children: JSX.Element;
 }): JSX.Element;

package/types-cjs/serializer.d.cts

@@ -0,0 +1,97 @@
+import { Plugin, Serializer, SerovalNode } from "seroval";
+
+export type { SerovalNode };
+
+/** A Seroval plugin usable with the web serializers. */
+export type SerializerPlugin = Plugin<any, any>;
+
+/**
+ * Baseline plugin set for serializing web-platform values (AbortSignal,
+ * Event, FormData, Headers, ReadableStream, Request, Response, URL, ...).
+ */
+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.
+ */
+export function resolveSerializerPlugins(customPlugins?: SerializerPlugin[]): SerializerPlugin[];
+
+export interface WebSerializerOptions {
+  /** Name of the global object the emitted scripts write resolved values into. */
+  globalIdentifier: string;
+  scopeId?: string;
+  /**
+   * Seroval feature bitflags to exclude from output. Defaults to disabling
+   * post-ES2017 features (AggregateError, BigInt typed arrays).
+   */
+  disabledFeatures?: number;
+  /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
+  plugins?: SerializerPlugin[];
+  onData: (result: string) => void;
+  onError?: (error: unknown) => void;
+  onDone?: () => void;
+}
+
+/**
+ * Creates a streaming Seroval serializer preconfigured with the web plugin
+ * set and the default feature policy.
+ */
+export function createSerializer(options: WebSerializerOptions): Serializer;
+
+export type HydrationSerializerOptions = Omit<
+  WebSerializerOptions,
+  "globalIdentifier" | "disabledFeatures"
+>;
+
+/**
+ * Serializer for SSR hydration output. Pins the hydration global (`_$HY.r`)
+ * and feature policy — only the wiring options (callbacks, scope, extra
+ * plugins) are configurable.
+ */
+export function createHydrationSerializer(options: HydrationSerializerOptions): Serializer;
+
+/** Returns the cross-reference bootstrap script for a render scope. */
+export function getLocalHeaderScript(id?: string): string;
+
+// ---- JSON codec (server function transports) ----
+
+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.
+   */
+  disabledFeatures?: number;
+  /** Maximum parse/deserialize depth. Defaults to 64. Must match on both peers. */
+  depthLimit?: number;
+}
+
+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`.
+ * Wire framing of the nodes is the transport's concern. Returns a cancel
+ * function that aborts pending async serialization.
+ */
+export function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
+
+/**
+ * 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.
+ */
+export function createJSONDeserializer(options?: JSONCodecOptions): <T>(node: SerovalNode) => T;

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;

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-cjs/src/client.d.cts

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