npm - @solidjs/web - Versions diffs - 2.0.0-experimental.8 → 2.0.0-rc.0 - Mend

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

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 (85) hide show

package/README.md +22 -4
package/dist/dev.cjs +1585 -225
package/dist/dev.js +1510 -201
package/dist/server.cjs +2642 -264
package/dist/server.js +2542 -217
package/dist/web.cjs +1523 -218
package/dist/web.js +1448 -194
package/frames/dist/client.cjs +1916 -0
package/frames/dist/client.dev.cjs +1933 -0
package/frames/dist/client.dev.js +1921 -0
package/frames/dist/client.js +1904 -0
package/frames/dist/server.cjs +3667 -0
package/frames/dist/server.js +3654 -0
package/frames/package.json +30 -0
package/package.json +349 -37
package/serialization/decode/package.json +20 -0
package/serialization/dist/decode.cjs +110 -0
package/serialization/dist/decode.js +104 -0
package/serialization/dist/serialization.cjs +232 -0
package/serialization/dist/serialization.js +215 -0
package/serialization/package.json +20 -0
package/serialization/types/index.d.ts +182 -0
package/serialization/types/serializer-decode.d.ts +182 -0
package/serialization/types-cjs/index.d.cts +182 -0
package/serialization/types-cjs/package.json +3 -0
package/serialization/types-cjs/serializer-decode.d.cts +182 -0
package/server-functions/dist/client.cjs +646 -0
package/server-functions/dist/client.js +617 -0
package/server-functions/dist/rich-args.cjs +11 -0
package/server-functions/dist/rich-args.js +9 -0
package/server-functions/dist/server.cjs +1077 -0
package/server-functions/dist/server.dev.cjs +1077 -0
package/server-functions/dist/server.dev.js +1045 -0
package/server-functions/dist/server.js +1045 -0
package/server-functions/package.json +40 -0
package/server-functions/rich-args/package.json +20 -0
package/storage/package.json +8 -3
package/storage/types/index.d.ts +26 -0
package/storage/types-cjs/index.d.cts +28 -0
package/storage/types-cjs/package.json +3 -0
package/types/client.d.ts +290 -27
package/types/cookies.d.ts +93 -0
package/types/core.d.ts +6 -2
package/types/frames/client.d.ts +36 -0
package/types/frames/frame-client.d.ts +338 -0
package/types/frames/frame-sink.d.ts +194 -0
package/types/frames/frame-transport.d.ts +222 -0
package/types/frames/serializer.d.ts +182 -0
package/types/frames/server.d.ts +52 -0
package/types/index.d.ts +209 -24
package/types/jsx-properties.d.ts +93 -0
package/types/jsx.d.ts +4150 -1
package/types/response.d.ts +174 -0
package/types/serializer-decode.d.ts +182 -0
package/types/serializer.d.ts +182 -0
package/types/server-functions/client.d.ts +201 -0
package/types/server-functions/flash.d.ts +38 -0
package/types/server-functions/rich-args.d.ts +10 -0
package/types/server-functions/server.d.ts +588 -0
package/types/server-functions/shared.d.ts +523 -0
package/types/server-mock.d.ts +249 -12
package/types/server.d.ts +424 -51
package/types-cjs/client.d.cts +337 -0
package/types-cjs/cookies.d.cts +93 -0
package/types-cjs/core.d.cts +6 -0
package/types-cjs/frames/client.d.cts +36 -0
package/types-cjs/frames/frame-client.d.cts +338 -0
package/types-cjs/frames/frame-sink.d.cts +194 -0
package/types-cjs/frames/frame-transport.d.cts +222 -0
package/types-cjs/frames/serializer.d.cts +182 -0
package/types-cjs/frames/server.d.cts +52 -0
package/types-cjs/index.d.cts +230 -0
package/types-cjs/jsx-properties.d.cts +93 -0
package/types-cjs/jsx.d.cts +4150 -0
package/types-cjs/package.json +3 -0
package/types-cjs/response.d.cts +174 -0
package/types-cjs/serializer-decode.d.cts +182 -0
package/types-cjs/serializer.d.cts +182 -0
package/types-cjs/server-functions/client.d.cts +201 -0
package/types-cjs/server-functions/flash.d.cts +38 -0
package/types-cjs/server-functions/rich-args.d.cts +10 -0
package/types-cjs/server-functions/server.d.cts +588 -0
package/types-cjs/server-functions/shared.d.cts +523 -0
package/types-cjs/server-mock.d.cts +277 -0
package/types-cjs/server.d.cts +523 -0

package/types-cjs/server-mock.d.cts ADDED Viewed

@@ -0,0 +1,277 @@
+import type { RequestEvent, RequestEventLocals, ResponseStub } from "./client.cjs";
+/** 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>;
+/**
+ * Renders a component tree synchronously to an HTML string. Async reads inside
+ * `<Loading>` boundaries emit their `fallback` content; for full-graph
+ * resolution await `renderToStream` 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?: AssetManifest | AssetResolver | AssetResolverFn;
+    onError?: (err: any) => void;
+    /**
+     * Embedded-render contract for hosts that own the document. When the
+     * render output contains no `</head>`, everything head-bound (resolved
+     * `useHead` winners, eager resources, tracked asset links, inline
+     * styles) is delivered here as one HTML string — prelude (charset/base)
+     * first — for the host to splice into its own `<head>` template, instead
+     * of being dropped. Called synchronously before `renderToString`
+     * returns; not called when the output has a `</head>` (splicing is
+     * automatic then).
+     */
+    onHead?: (head: string) => void;
+}): 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`, a lazy `readable` byte-stream view for
+ * `new Response(stream.readable)`, plus a thenable for awaiting full
+ * completion — `await renderToStream(...)` resolves with the settled HTML
+ * (the fully-resolved-string form of the render). `pipe`, `pipeTo`, and
+ * `readable` each consume the render — use exactly one of the three.
+ *
+ * @example
+ * ```tsx
+ * import { renderToStream } from "@solidjs/web";
+ *
+ * // Node:
+ * renderToStream(() => <App />).pipe(res);
+ *
+ * // Web (Workers / Deno):
+ * return new Response(renderToStream(() => <App />).readable);
+ *
+ * // Fully settled string:
+ * const html = await renderToStream(() => <App />);
+ * ```
+ */
+export declare function renderToStream<T>(fn: () => T, options?: {
+    nonce?: string;
+    renderId?: string;
+    noScripts?: boolean;
+    plugins?: any[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
+    onCompleteShell?: (info: {
+        write: (v: string) => void;
+    }) => void;
+    onCompleteAll?: (info: {
+        write: (v: string) => void;
+    }) => void;
+    onError?: (err: any) => void;
+    /**
+     * Embedded-render contract for hosts that own the document. When the
+     * shell contains no `</head>`, everything head-bound at first flush
+     * (resolved `useHead` winners, eager resources, tracked asset links,
+     * inline styles) is delivered here as one HTML string — prelude first —
+     * before the shell chunk is emitted, so the host can write its own
+     * `<head>` ahead of piping the stream. Post-shell head updates flow
+     * through the stream itself and apply in the browser. Not called when
+     * the shell has a `</head>` (splicing is automatic then).
+     */
+    onHead?: (head: string) => void;
+}): {
+    /**
+     * Awaiting the stream resolves with the complete HTML once every boundary
+     * settles — the fully-settled-string form of the render. Render errors
+     * route through `onError` and the promise resolves with whatever HTML the
+     * render produced; it never rejects.
+     */
+    then<TResult1 = string, TResult2 = never>(onfulfilled?: ((html: string) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    pipe: (writable: {
+        write: (v: string) => void;
+        end: () => void;
+    }) => void;
+    pipeTo: (writable: WritableStream) => Promise<void>;
+    readonly readable: ReadableStream<Uint8Array>;
+};
+/**
+ * Fetch-style middleware: receives the `Request` and a `next` continuation
+ * (pass a `Request` to substitute it downstream) and returns the `Response`.
+ * Composed with `composeMiddleware`; runs inside the request-event scope, so
+ * `getRequestEvent()` works exactly as in application code.
+ */
+export type FetchMiddleware = (request: Request, next: (request?: Request) => Promise<Response>) => Response | Promise<Response>;
+/**
+ * Creates a fresh, uncommitted {@link ResponseStub}. Server-only.
+ */
+export declare function createResponseStub(): ResponseStub;
+/**
+ * Builds the canonical request event — a web-standard `Request`, a `locals`
+ * bag, and a stub-backed `response` head — for `provideRequestEvent`.
+ * Server-only: on the client the request event belongs to the server that
+ * rendered the page.
+ */
+export declare function createRequestEvent<T extends object = {}>(request: Request, init?: T): {
+    request: Request;
+    locals: RequestEventLocals;
+    response: ResponseStub;
+} & T;
+/**
+ * The HTTP status a redirect should use: the stub's own status when it is a
+ * redirect status (301/302/303/307/308), 302 otherwise. Server-only.
+ */
+export declare function getExpectedRedirectStatus(response: ResponseStub): number;
+/**
+ * Derives the outgoing `Response` for an SSR render result, running the
+ * response-head lifecycle against `event.response`: the stub commits at
+ * shell flush, a pre-flush `Location` becomes a real redirect
+ * (`getExpectedRedirectStatus`), and a post-flush one appends the
+ * nonce-aware `<script>window.location=...</script>` fallback. String
+ * results return a `Response` synchronously; stream results resolve at
+ * shell flush. Server-only.
+ */
+export declare function createSSRResponse(result: string, event: RequestEvent | undefined, options?: {
+    responseInit?: ResponseInit;
+    nonce?: string;
+    transformChunk?: (chunk: string) => string;
+}): Response;
+export declare function createSSRResponse(result: {
+    pipe(writable: {
+        write: (v: string) => void;
+        end: () => void;
+    }): void;
+}, event: RequestEvent | undefined, options?: {
+    responseInit?: ResponseInit;
+    nonce?: string;
+    transformChunk?: (chunk: string) => string;
+}): Promise<Response>;
+/**
+ * Handler-lifecycle plumbing — the exit for a `Response` that did not go
+ * through `createSSRResponse` (a middleware early return, an API result):
+ * folds the request event's response stub onto it (cookies append
+ * entry-by-entry, other headers gap-fill, status never) and commits the
+ * stub. Already-committed stubs pass the response through untouched, so
+ * handlers apply it unconditionally after their middleware chain unwinds.
+ * `event` defaults to the ambient `getRequestEvent()`. Application
+ * middleware never calls this. Server-only.
+ */
+export declare function commitEventResponse(response: Response, event?: RequestEvent): Response;
+/**
+ * Composes fetch-style middleware — `(request, next) => Response` — into a
+ * single function of the same shape. Nothing reaches the wire until the
+ * outermost middleware returns, so headers on the returned `Response` stay
+ * mutable through the whole unwind, streamed bodies included. Server-only.
+ */
+export declare function composeMiddleware(middlewares: FetchMiddleware[]): (request: Request, next: (request?: Request) => Response | Promise<Response>) => Promise<Response>;
+/**
+ * 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 class value (string, object map, or
+ * array) for SSR output. Not meant for hand-written code.
+ * @internal
+ */
+export declare function ssrClassName(value: string | {
+    [k: string]: boolean;
+} | Array<any>): string;
+/**
+ * Compiler primitive — serializes a style value for SSR output. Not meant
+ * for hand-written code.
+ * @internal
+ */
+export declare function ssrStyle(value: string | {
+    [k: string]: string;
+}): string;
+/**
+ * Compiler primitive — serializes one style property for SSR output. Not
+ * meant for hand-written code.
+ * @internal
+ */
+export declare function ssrStyleProperty(name: string, value: any): string;
+/**
+ * Compiler primitive — serializes an attribute for SSR output. Not meant
+ * for hand-written code.
+ * @internal
+ */
+export declare function ssrAttribute(key: string, value: any): string;
+/**
+ * Compiler primitive — wraps a template-group closure for SSR output. Not
+ * meant for hand-written code.
+ * @internal
+ */
+export declare function ssrGroup<T extends () => any[]>(fn: T, n: number): T;
+/**
+ * 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, result?: any, top?: boolean): any;
+/**
+ * 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(s: any, attr?: boolean): any;