@solidjs/web 2.0.0-rc.0 → 2.0.0-rc.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (108) hide show
  1. package/README.md +1 -1
  2. package/dist/server.dev.js +4472 -0
  3. package/dist/server.js +1363 -224
  4. package/dist/{server.cjs → server.observe.js} +1563 -424
  5. package/dist/{dev.cjs → web.dev.js} +708 -365
  6. package/dist/web.js +460 -144
  7. package/dist/{dev.js → web.observe.js} +511 -213
  8. package/frames/dist/client.dev.js +464 -72
  9. package/frames/dist/client.js +364 -71
  10. package/frames/dist/{client.dev.cjs → client.observe.js} +487 -134
  11. package/frames/dist/server.dev.js +1713 -0
  12. package/frames/dist/server.js +553 -2495
  13. package/frames/dist/server.observe.js +1713 -0
  14. package/frames/package.json +2 -25
  15. package/package.json +214 -254
  16. package/performance-tracks/dist/performance-tracks.dev.js +678 -0
  17. package/performance-tracks/dist/performance-tracks.js +6 -0
  18. package/performance-tracks/dist/performance-tracks.observe.js +666 -0
  19. package/performance-tracks/package.json +7 -0
  20. package/performance-tracks/types/index.d.ts +67 -0
  21. package/serialization/decode/package.json +2 -15
  22. package/serialization/dist/decode.js +101 -12
  23. package/serialization/dist/serialization.js +112 -20
  24. package/serialization/package.json +2 -15
  25. package/serialization/types/index.d.ts +76 -157
  26. package/serialization/types/serializer-decode.d.ts +149 -112
  27. package/serialization/types/serializer.d.ts +101 -0
  28. package/server-functions/dist/client.dev.js +1364 -0
  29. package/server-functions/dist/client.js +745 -85
  30. package/server-functions/dist/client.observe.js +1343 -0
  31. package/server-functions/dist/server.dev.js +2203 -175
  32. package/server-functions/dist/server.js +2111 -176
  33. package/server-functions/dist/server.observe.js +3043 -0
  34. package/server-functions/package.json +2 -35
  35. package/server-functions/rich-args/package.json +2 -15
  36. package/storage/package.json +2 -15
  37. package/types/client.d.ts +193 -288
  38. package/types/constants.d.ts +20 -0
  39. package/types/cookies.d.ts +32 -84
  40. package/types/diagnostics.d.ts +56 -0
  41. package/types/frames/client.d.ts +1 -1
  42. package/types/frames/frame-client.d.ts +323 -259
  43. package/types/frames/frame-container-plugin.d.ts +72 -0
  44. package/types/frames/frame-sink.d.ts +101 -158
  45. package/types/frames/frame-transport.d.ts +192 -190
  46. package/types/frames/serializer-decode.d.ts +219 -0
  47. package/types/frames/serializer.d.ts +76 -157
  48. package/types/frames/server.d.ts +1 -1
  49. package/types/head.d.ts +19 -0
  50. package/types/index.d.ts +62 -76
  51. package/types/index.server.d.ts +174 -0
  52. package/types/jsx.d.ts +33 -26
  53. package/types/observe.d.ts +358 -0
  54. package/types/reconcile.d.ts +1 -0
  55. package/types/render.d.ts +9 -0
  56. package/types/response.d.ts +75 -150
  57. package/types/serializer-decode.d.ts +149 -112
  58. package/types/serializer.d.ts +76 -157
  59. package/types/server-functions/client.d.ts +202 -174
  60. package/types/server-functions/flash.d.ts +28 -30
  61. package/types/server-functions/registry.d.ts +102 -0
  62. package/types/server-functions/rich-args.d.ts +1 -10
  63. package/types/server-functions/server.d.ts +518 -454
  64. package/types/server-functions/shared.d.ts +366 -425
  65. package/types/server-mock.d.ts +110 -13
  66. package/types/server-observe.d.ts +77 -0
  67. package/types/server.d.ts +425 -425
  68. package/types/trace.d.ts +127 -0
  69. package/LICENSE +0 -21
  70. package/dist/web.cjs +0 -2007
  71. package/frames/dist/client.cjs +0 -1916
  72. package/frames/dist/server.cjs +0 -3667
  73. package/serialization/dist/decode.cjs +0 -110
  74. package/serialization/dist/serialization.cjs +0 -232
  75. package/serialization/types-cjs/index.d.cts +0 -182
  76. package/serialization/types-cjs/package.json +0 -3
  77. package/serialization/types-cjs/serializer-decode.d.cts +0 -182
  78. package/server-functions/dist/client.cjs +0 -646
  79. package/server-functions/dist/rich-args.cjs +0 -11
  80. package/server-functions/dist/server.cjs +0 -1077
  81. package/server-functions/dist/server.dev.cjs +0 -1077
  82. package/storage/dist/storage.cjs +0 -12
  83. package/storage/types-cjs/index.d.cts +0 -28
  84. package/storage/types-cjs/package.json +0 -3
  85. package/types/core.d.ts +0 -6
  86. package/types-cjs/client.d.cts +0 -337
  87. package/types-cjs/cookies.d.cts +0 -93
  88. package/types-cjs/core.d.cts +0 -6
  89. package/types-cjs/frames/client.d.cts +0 -36
  90. package/types-cjs/frames/frame-client.d.cts +0 -338
  91. package/types-cjs/frames/frame-sink.d.cts +0 -194
  92. package/types-cjs/frames/frame-transport.d.cts +0 -222
  93. package/types-cjs/frames/serializer.d.cts +0 -182
  94. package/types-cjs/frames/server.d.cts +0 -52
  95. package/types-cjs/index.d.cts +0 -230
  96. package/types-cjs/jsx-properties.d.cts +0 -93
  97. package/types-cjs/jsx.d.cts +0 -4150
  98. package/types-cjs/package.json +0 -3
  99. package/types-cjs/response.d.cts +0 -174
  100. package/types-cjs/serializer-decode.d.cts +0 -182
  101. package/types-cjs/serializer.d.cts +0 -182
  102. package/types-cjs/server-functions/client.d.cts +0 -201
  103. package/types-cjs/server-functions/flash.d.cts +0 -38
  104. package/types-cjs/server-functions/rich-args.d.cts +0 -10
  105. package/types-cjs/server-functions/server.d.cts +0 -588
  106. package/types-cjs/server-functions/shared.d.cts +0 -523
  107. package/types-cjs/server-mock.d.cts +0 -277
  108. package/types-cjs/server.d.cts +0 -523
@@ -1,182 +1,101 @@
1
- // Serialization surface (published as `@solidjs/web/serialization`): the
2
- // runtime's Seroval machinery, exposed for the runtime's own entries and
3
- // for integrations building transports on the same codec. This is
4
- // INTEGRATION-FACING plumbing, not application API — it is exempt from the
5
- // 2.0 stability guarantee and may change between releases. Application and
6
- // router code should configure `codec` on the server-function entries
7
- // instead of importing from here.
8
- import type { Serializer } from "seroval";
9
- import {
10
- JSONCodecOptions,
11
- PluginInfo,
12
- SerializerPlugin,
13
- SerovalNode
14
- } from "./serializer-decode.js";
15
-
16
- // The decode half — `SerovalNode`, the plugin TYPES, `DEFAULT_WEB_PLUGINS`,
17
- // `resolveSerializerPlugins`, `JSONCodecOptions`, `createJSONDeserializer`,
18
- // `createJSONDataTable` — is declared in serializer-decode.d.ts (published
19
- // as `@solidjs/web/serialization/decode`, the module lazy client consumers
20
- // load) and re-exported here so this remains the full surface.
21
- export * from "./serializer-decode.js";
22
-
23
- // ---- Plugin authoring ----
24
- //
25
- // Unlike the rest of this entry, plugin authoring is APPLICATION-FACING —
26
- // it is the supported way to feed the serializers' `plugins` options and
27
- // the server-function entries' `codec.plugins`. The values re-export
28
- // seroval's own (`createPlugin`, `OpaqueReference` — see serializer.js);
29
- // the plugin TYPES live in serializer-decode.d.ts (hand-declared there —
30
- // see its banner for why).
31
-
32
- /**
33
- * Builds a `SerializerPlugin` — seroval's `createPlugin`, re-exported so
34
- * plugin authors stay on the exact seroval instance/version the runtime
35
- * serializes with. Import it from HERE, not from your own `seroval`
36
- * dependency: a plugin built against a different copy/version would not
37
- * fail the build — it would emit nodes the other peer can't interpret.
38
- *
39
- * Application-facing (see the plugin-authoring banner above).
40
- */
41
- export function createPlugin<Value, Info extends PluginInfo>(
42
- plugin: SerializerPlugin<Value, Info>
43
- ): SerializerPlugin<Value, Info>;
44
-
45
- /**
46
- * Seroval's `OpaqueReference`, re-exported from the runtime's own instance
47
- * (an `OpaqueReference` from another seroval copy fails the serializer's
48
- * instanceof check and serializes as a plain value): wraps a value so it
49
- * crosses the wire as its `replacement` (default `undefined`) while
50
- * staying readable in-process through `.value`.
51
- *
52
- * Application-facing (see the plugin-authoring banner above).
53
- */
54
- export class OpaqueReference<V, R = undefined> {
55
- readonly value: V;
56
- readonly replacement?: R;
57
- constructor(value: V, replacement?: R);
58
- }
59
-
1
+ import { Serializer } from "seroval";
2
+ import type { JSONCodecOptions, PluginInfo, SerializerPlugin, SerovalNode } from "./serializer-decode.js";
3
+ export { DEFAULT_WEB_PLUGINS, createJSONDataTable, createJSONDeserializer, resolveSerializerPlugins } from "./serializer-decode.js";
4
+ export type * from "./serializer-decode.js";
60
5
  /**
61
6
  * Options for `createSerializer`.
62
7
  *
63
8
  * Integration-facing; may change (see the entry banner).
64
9
  */
65
10
  export interface WebSerializerOptions {
66
- /** Name of the global object the emitted scripts write resolved values into. */
67
- globalIdentifier: string;
68
- /** Cross-reference scope id, for isolating multiple streams on one page. */
69
- scopeId?: string;
70
- /**
71
- * Seroval feature bitflags to exclude from output. Defaults to disabling
72
- * post-ES2017 features (AggregateError, BigInt typed arrays). Outside
73
- * development, `Error.prototype.stack` is additionally stripped on top of
74
- * any override — serialized stacks leak server paths to the client.
75
- */
76
- disabledFeatures?: number;
77
- /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
78
- plugins?: SerializerPlugin[];
79
- /** Receives each emitted script chunk. */
80
- onData: (result: string) => void;
81
- onError?: (error: unknown) => void;
82
- /** Fires once all async values have settled. */
83
- onDone?: () => void;
11
+ /** Name of the global object the emitted scripts write resolved values into. */
12
+ globalIdentifier: string;
13
+ /** Cross-reference scope id, for isolating multiple streams on one page. */
14
+ scopeId?: string;
15
+ /**
16
+ * Seroval feature bitflags to exclude from output. Defaults to disabling
17
+ * post-ES2017 features (AggregateError, BigInt typed arrays). Outside
18
+ * development, `Error.prototype.stack` is additionally stripped on top of
19
+ * any override — serialized stacks leak server paths to the client.
20
+ */
21
+ disabledFeatures?: number;
22
+ /**
23
+ * Whether serialized `Error`s carry their `.stack`. Defaults to
24
+ * `NODE_ENV === "development"`; set `false` to pin production disclosure
25
+ * to the deployment rather than the ambient variable (#3152 — see
26
+ * `JSONCodecOptions.serializeErrorStacks`).
27
+ */
28
+ serializeErrorStacks?: boolean;
29
+ /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
30
+ plugins?: SerializerPlugin[];
31
+ /** Receives each emitted script chunk. */
32
+ onData: (result: string) => void;
33
+ onError?: (error: unknown) => void;
34
+ /** Fires once all async values have settled. */
35
+ onDone?: () => void;
84
36
  }
85
-
86
- /**
87
- * Creates a streaming Seroval serializer preconfigured with the web plugin
88
- * set and the default feature policy. Emits JavaScript chunks (through
89
- * `onData`) that reconstruct the values under `globalIdentifier` when
90
- * evaluated — the script-injection form of serialization renderers build
91
- * on. For a JSON-based wire codec (no eval on the receiving side), use
92
- * `serializeJSON` / `createJSONDeserializer` instead.
93
- *
94
- * Integration-facing; may change (see the entry banner).
95
- */
96
- export function createSerializer(options: WebSerializerOptions): Serializer;
97
-
98
37
  /**
99
38
  * Options for `createHydrationSerializer` — `WebSerializerOptions` minus
100
39
  * the knobs hydration pins (`globalIdentifier`, `disabledFeatures`).
101
40
  * @internal
102
41
  */
103
- export type HydrationSerializerOptions = Omit<
104
- WebSerializerOptions,
105
- "globalIdentifier" | "disabledFeatures"
106
- >;
107
-
108
- /**
109
- * Renderer primitive — the serializer SSR uses for hydration output. Pins
110
- * the hydration global (`_$HY.r`) and feature policy; only the wiring
111
- * options (callbacks, scope, extra plugins) are configurable. Not meant
112
- * for hand-written code — custom serialization should use
113
- * `createSerializer` or the JSON codec.
114
- * @internal
115
- */
116
- export function createHydrationSerializer(options: HydrationSerializerOptions): Serializer;
117
-
118
- /**
119
- * Renderer primitive — returns the cross-reference bootstrap script SSR
120
- * emits ahead of hydration data for a render scope. Not meant for
121
- * hand-written code.
122
- * @internal
123
- */
124
- export function getLocalHeaderScript(id?: string): string;
125
-
126
- // ---- JSON codec (server function transports) ----
127
- // (`JSONCodecOptions` and the decode half are declared in
128
- // serializer-decode.d.ts and re-exported above.)
129
-
42
+ export type HydrationSerializerOptions = Omit<WebSerializerOptions, "globalIdentifier" | "disabledFeatures">;
130
43
  /**
131
44
  * Options for `serializeJSON`.
132
45
  *
133
46
  * Integration-facing; may change (see the entry banner).
134
47
  */
135
48
  export interface JSONSerializeOptions extends JSONCodecOptions {
136
- /**
137
- * Receives each serialized node; `initial` is true for the first chunk
138
- * (the source value itself). Async values produce additional chunks as
139
- * they resolve.
140
- */
141
- onParse: (node: SerovalNode, initial: boolean) => void;
142
- onError?: (error: unknown) => void;
143
- /** Fires once all async values have settled. */
144
- onDone?: () => void;
49
+ /**
50
+ * Receives each serialized node; `initial` is true for the first chunk
51
+ * (the source value itself). Async values produce additional chunks as
52
+ * they resolve.
53
+ */
54
+ onParse: (node: SerovalNode, initial: boolean) => void;
55
+ onError?: (error: unknown) => void;
56
+ /** Fires once all async values have settled. */
57
+ onDone?: () => void;
145
58
  }
146
-
147
- /**
148
- * Serializes `value` as SerovalNode chunks delivered through `onParse` —
149
- * the encoding half of the eval-free JSON codec (RPC-style transports;
150
- * the deserializing peer needs no script evaluation, so CSP-safe). Wire
151
- * framing of the nodes is the transport's concern. Returns a cancel
152
- * function that aborts pending async serialization.
153
- *
154
- * Integration-facing; may change (see the entry banner).
155
- */
156
- export function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
157
-
158
59
  /** Options for `createJSONSerializer`. */
159
60
  export interface JSONSerializerOptions extends JSONCodecOptions {
160
- /**
161
- * Receives each keyed record — `initial` is true for a key's first node
162
- * (the written value itself); async values patch through later records
163
- * under the same key. The decoding peer is `createJSONDataTable`.
164
- */
165
- onData: (record: { key: string; node: SerovalNode; initial: boolean }) => void;
166
- onError?: (error: unknown) => void;
167
- /** Fires once `flush()` has been called and every pending value settled. */
168
- onDone?: () => void;
61
+ /**
62
+ * Receives each keyed record — `initial` is true for a key's first node
63
+ * (the written value itself); async values patch through later records
64
+ * under the same key. The decoding peer is `createJSONDataTable`.
65
+ */
66
+ onData: (record: {
67
+ key: string;
68
+ node: SerovalNode;
69
+ initial: boolean;
70
+ }) => void;
71
+ onError?: (error: unknown) => void;
72
+ /** Fires once `flush()` has been called and every pending value settled. */
73
+ onDone?: () => void;
74
+ }
75
+ export declare const createPlugin: <Value, Info extends PluginInfo>(plugin: SerializerPlugin<Value, Info>) => SerializerPlugin<Value, Info>;
76
+ export interface OpaqueReference<V = unknown, R = undefined> {
77
+ readonly value: V;
78
+ readonly replacement?: R;
169
79
  }
170
-
80
+ export declare const OpaqueReference: {
81
+ new <V, R = undefined>(value: V, replacement?: R): OpaqueReference<V, R>;
82
+ };
171
83
  /**
172
- * The keyed, streaming encoder of the eval-free JSON codec — the render
173
- * stream's data serializer (frames default to it). Each `write(key, value)`
174
- * shares one reference space, so cross-record identity holds; `flush()`
175
- * marks the write set complete (writes after it are dropped, mirroring the
176
- * hydration serializer); `close()` aborts pending async serialization.
84
+ * Creates a streaming Seroval serializer preconfigured with the web plugin
85
+ * set and the default feature policy. Emits JavaScript chunks (through
86
+ * `onData`) that reconstruct the values under `globalIdentifier` when
87
+ * evaluated — the script-injection form of serialization renderers build
88
+ * on. For a JSON-based wire codec (no eval on the receiving side), use
89
+ * `serializeJSON` / `createJSONDeserializer` instead.
90
+ *
91
+ * Integration-facing; may change (see the entry banner).
177
92
  */
178
- export function createJSONSerializer(options: JSONSerializerOptions): {
179
- write(key: string, value: unknown): void;
180
- flush(): void;
181
- close(): void;
93
+ export declare function createSerializer(options: WebSerializerOptions): Serializer;
94
+ export declare function createHydrationSerializer(options: HydrationSerializerOptions): Serializer;
95
+ export declare function getLocalHeaderScript(id?: string): string;
96
+ export declare function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
97
+ export declare function createJSONSerializer(options: JSONSerializerOptions): {
98
+ write(key: string, value: unknown): void;
99
+ flush(): void;
100
+ close(): void;
182
101
  };
@@ -49,4 +49,4 @@ export type Slot<P = {}> = (props: P & {
49
49
  */
50
50
  export declare function asyncArg<T>(value: PromiseLike<T> | AsyncIterable<T>): T;
51
51
  export { renderToFrameStream, renderServerComponent, serverComponentResponse, frameTransformResult, frameTransformFlightResult, createFrameSink, frameTransformDirectResult, ServerComponentPlugin, SERVER_COMPONENT_BOOTSTRAP } from "./frame-sink.js";
52
- export { FRAME_STREAM_HEADER, isFrameStreamResponse } from "./frame-transport.js";
52
+ export { FRAME_STREAM_HEADER, FRAME_HAVE_HEADER, FRAME_HAVE_BUDGET, isFrameStreamResponse } from "./frame-transport.js";
@@ -0,0 +1,19 @@
1
+ export declare const HEAD_ELIGIBLE_TAGS: Set<string>;
2
+ export declare const HEAD_ATTR_NAME: RegExp;
3
+ export declare const RESOURCE_LINK_RELS: Set<string>;
4
+ export declare const RESOURCE_QUALIFIERS: string[];
5
+ export declare const STYLESHEET_FETCH_META: Set<string>;
6
+ export declare function evalHeadValue(v: any): any;
7
+ export declare function evalHeadProps(props: any, presets: any): {};
8
+ export declare function classifyHeadTag(desc: any): {
9
+ resource: boolean;
10
+ rel: any;
11
+ } | {
12
+ resource: boolean;
13
+ rel?: undefined;
14
+ };
15
+ export declare function qualifierValue(name: any, value: any): any;
16
+ export declare function asciiLowerCase(value: any): any;
17
+ export declare function resourceIdentity(tag: any, props: any): string;
18
+ export declare function replaceableIdentity(tag: any, props: any, key: any, unique: any): any;
19
+ export declare function resolveHead(groups: any): Map<any, any>;
package/types/index.d.ts CHANGED
@@ -1,4 +1,3 @@
1
- import { hydrate as hydrateCore } from "./client.js";
2
1
  import { Component } from "solid-js";
3
2
  import type { JSX } from "./jsx.js";
4
3
  export * from "./client.js";
@@ -6,16 +5,6 @@ export * from "./server-mock.js";
6
5
  export * from "./response.js";
7
6
  export type { JSX } from "./jsx.js";
8
7
  export { For, Show, Switch, Match, Errored, Loading, Repeat, Reveal, NoHydration, Hydration } from "solid-js";
9
- import { merge } from "solid-js";
10
- /**
11
- * Compiler-emitted prop-spread helper. The JSX transform (in
12
- * `dom-expressions`) emits `mergeProps(...)` calls when compiling prop
13
- * spreads on components — it is *not* a user-facing API. Application code
14
- * should import `merge` from `solid-js` directly.
15
- *
16
- * @internal
17
- */
18
- export declare const mergeProps: typeof merge;
19
8
  /**
20
9
  * Build-time constant indicating whether code is running on the server. This
21
10
  * client entry sets it to `false`; the matching server entry (`@solidjs/web`
@@ -54,62 +43,15 @@ export declare const isServer: boolean;
54
43
  * ```
55
44
  */
56
45
  export declare const isDev: boolean;
57
- type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
58
46
  export type IntrinsicElement = Extract<keyof JSX.IntrinsicElements, string>;
59
47
  export type ValidComponent = IntrinsicElement | Component<any> | (string & {});
60
48
  export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
49
+ /** @deprecated Props of the deprecated `<Dynamic>`; see `dynamic()`. */
61
50
  export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
62
51
  [K in keyof P]: P[K];
63
52
  } & {
64
53
  component: T | null | undefined | false;
65
54
  };
66
- /**
67
- * Renders a component tree into a DOM element. Returns a dispose function
68
- * that tears the tree down and cleans up reactive scopes when called.
69
- *
70
- * @example
71
- * ```tsx
72
- * import { render } from "@solidjs/web";
73
- *
74
- * const dispose = render(() => <App />, document.getElementById("root")!);
75
- *
76
- * // Later, to unmount:
77
- * dispose();
78
- * ```
79
- *
80
- * @remarks
81
- * The top-level insert is queued via `insertOptions: { schedule: true }` so
82
- * its initial DOM attach goes through the effect queue rather than executing
83
- * inline. This lets the mount participate in transitions: if an uncaught
84
- * async read surfaces during the initial render (no `Loading` ancestor
85
- * absorbs it), the mount is held by the transition and attaches atomically
86
- * once all pending settles. On the no-async happy path the tail `flush()`
87
- * drains the queued callback so the attach is synchronous by the time
88
- * `render()` returns. The dev enforcement window scopes
89
- * `ASYNC_OUTSIDE_LOADING_BOUNDARY` to the initial mount only.
90
- */
91
- export declare function render(code: () => JSX.Element, element: MountableElement, init?: unknown, options?: {
92
- renderId?: string;
93
- }): () => void;
94
- /**
95
- * Resumes a server-rendered tree on the client, attaching event listeners
96
- * and reactive bindings without reconstructing the DOM. Returns a `dispose`
97
- * function that tears down reactive scopes (DOM nodes are left in place).
98
- *
99
- * Use this when the page HTML was produced by `renderToString` or
100
- * `renderToStream`. For client-only apps, use `render` instead.
101
- *
102
- * Pass `options.renderId` to hydrate one of multiple roots emitted by a
103
- * server render that used the same id.
104
- *
105
- * @example
106
- * ```tsx
107
- * import { hydrate } from "@solidjs/web";
108
- *
109
- * hydrate(() => <App />, document.getElementById("root")!);
110
- * ```
111
- */
112
- export declare const hydrate: typeof hydrateCore;
113
55
  /**
114
56
  * Renders its children into a different part of the DOM (modal roots,
115
57
  * tooltips, layers that need to escape an `overflow: hidden` ancestor).
@@ -137,21 +79,55 @@ export declare function Portal(props: {
137
79
  mount?: Element;
138
80
  children: JSX.Element;
139
81
  }): JSX.Element;
140
- export declare function dynamic<T extends ValidComponent>(source: () => T | Promise<T> | null | undefined | false): Component<ComponentProps<T>>;
82
+ export interface DynamicOptions {
83
+ /**
84
+ * SSR only: hold the document's first flush until the source settles, so
85
+ * the resolved component renders into the shell instead of streaming in
86
+ * behind its boundary's fallback. Same meaning as `createMemo`'s
87
+ * `deferStream`. Ignored on the client.
88
+ */
89
+ deferStream?: boolean;
90
+ /**
91
+ * The source cannot change: call it once, untracked, now, and render the
92
+ * result with no computation per instance (see `dynamic`). The source must
93
+ * resolve synchronously.
94
+ */
95
+ static?: boolean;
96
+ }
141
97
  /**
142
- * Renders an arbitrary custom or native component and forwards the other
143
- * props. JSX form of `dynamic()` — same primitive, picked at the JSX site.
98
+ * A component from a reactive source. The source may answer with the
99
+ * component itself, a promise of it, or an async iterable of it — a `live`
100
+ * server component reference's answer is the last: the memo underneath pumps
101
+ * the iterable as it pumps any async source, and its value is the component
102
+ * the server answered with (a reconnect re-yields the same binding and is
103
+ * equality-quiet; nothing here re-mounts).
104
+ *
105
+ * Under SSR an async answer is an ordinary async memo's: its landing is
106
+ * serialized per instance and adopted here at hydration, so the source may
107
+ * stay async only when what it resolves to can cross — a server component
108
+ * (as a reference) or a serializable value (a tag name). A promise of a
109
+ * client component function is a dev error on the server
110
+ * (`DYNAMIC_ASYNC_COMPONENT`): resolve the async upstream, or use `lazy()`.
111
+ */
112
+ export declare function dynamic<T extends ValidComponent>(source: () => T | Promise<T> | AsyncIterable<T> | null | undefined | false, options?: DynamicOptions): Component<ComponentProps<T>>;
113
+ /**
114
+ * @deprecated Use `dynamic()`. `<Dynamic>` is the same primitive, but its
115
+ * shape puts the tag in the same bag as the element's props: every instance
116
+ * merges `component` in at the call site, `omit()`s it back out here, and
117
+ * builds a fresh `dynamic()` factory (with its memo) because there is nowhere
118
+ * to hoist one. `dynamic()` has none of that and is one line longer:
144
119
  *
145
- * @example
146
120
  * ```tsx
147
- * <Dynamic
148
- * component={multiline() ? RichTextEditor : "input"}
149
- * value={value()}
150
- * onInput={onInput}
151
- * />
121
+ * // before
122
+ * <Dynamic component={multiline() ? RichTextEditor : "input"} value={value()} />
123
+ *
124
+ * // after — hoist per component instance (or per module for a constant)
125
+ * const Field = dynamic(() => multiline() ? RichTextEditor : "input");
126
+ * <Field value={value()} />
152
127
  * ```
153
128
  *
154
- * @description https://docs.solidjs.com/reference/components/dynamic
129
+ * Remains available in 2.0 (deprecated, no runtime warning); prefer `dynamic()`
130
+ * in new code.
155
131
  */
156
132
  export declare function Dynamic<T extends ValidComponent>(props: DynamicProps<T>): JSX.Element;
157
133
  /**
@@ -170,7 +146,8 @@ export declare function Dynamic<T extends ValidComponent>(props: DynamicProps<T>
170
146
  *
171
147
  * By default the import starts as soon as `clientOnly` is called (module
172
148
  * load); pass `{ lazy: true }` to defer the import to the component's first
173
- * render.
149
+ * render. Pass `{ export: "Name" }` to use a named export of the resolved
150
+ * module instead of its default (mirrors `lazy()`'s option).
174
151
  *
175
152
  * @example
176
153
  * ```tsx
@@ -178,11 +155,18 @@ export declare function Dynamic<T extends ValidComponent>(props: DynamicProps<T>
178
155
  * // <Chart fallback={<div>Loading chart…</div>} data={data()} />
179
156
  * ```
180
157
  */
158
+ export declare function clientOnly<M extends Record<string, any>, K extends keyof M & string>(fn: () => Promise<M>, options: {
159
+ lazy?: boolean;
160
+ export: K;
161
+ }, moduleUrl?: string): Component<ComponentProps<M[K]> & {
162
+ fallback?: JSX.Element;
163
+ }>;
181
164
  export declare function clientOnly<T extends Component<any>>(fn: () => Promise<{
182
165
  default: T;
183
166
  }>, options?: {
184
167
  lazy?: boolean;
185
- }, _moduleUrl?: string): Component<ComponentProps<T> & {
168
+ export?: string;
169
+ }, moduleUrl?: string): Component<ComponentProps<T> & {
186
170
  fallback?: JSX.Element;
187
171
  }>;
188
172
  /**
@@ -202,9 +186,10 @@ export declare function clientOnly<T extends Component<any>>(fn: () => Promise<{
202
186
  * `event.response` status at write time and restores it when the owning
203
187
  * scope is disposed — so a boundary that errored, declared a status, and
204
188
  * then recovered retracts its write instead of stomping a status a
205
- * surviving part of the tree legitimately set. Once the integration marks
206
- * the response head `committed` (head derived/sent), writes and
207
- * retractions are no-ops.
189
+ * surviving part of the tree legitimately set. Once the response head is
190
+ * `committed` (head derived/sent — the shell flush of a piped
191
+ * `renderToStream`, the completion of an awaited one or of
192
+ * `renderToString`), writes and retractions are no-ops.
208
193
  */
209
194
  export declare function httpStatus(_code: number, _text?: string): void;
210
195
  /**
@@ -222,8 +207,9 @@ export declare function httpStatus(_code: number, _text?: string): void;
222
207
  * Retraction semantics (server): the header's prior value is snapshotted at
223
208
  * write time and restored when the owning scope is disposed (deleted if
224
209
  * there was none) — a boundary that errors or recovers retracts its writes.
225
- * Once the integration marks the response head `committed` (head
226
- * derived/sent), writes and retractions are no-ops.
210
+ * Once the response head is `committed` (head derived/sent — the shell
211
+ * flush of a piped `renderToStream`, the completion of an awaited one or
212
+ * of `renderToString`), writes and retractions are no-ops.
227
213
  */
228
214
  export declare function httpHeader(_name: string, _value: string, _options?: {
229
215
  append?: boolean;