npm - @solidjs/web - Versions diffs - 2.0.0-beta.2 → 2.0.0-beta.20 - Mend

@solidjs/web 2.0.0-beta.2 → 2.0.0-beta.20

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

package/README.md +27 -4
package/dist/dev.cjs +783 -223
package/dist/dev.js +757 -217
package/dist/server.cjs +742 -186
package/dist/server.js +714 -183
package/dist/web.cjs +772 -196
package/dist/web.js +746 -190
package/package.json +193 -38
package/serialization/dist/serialization.cjs +83 -0
package/serialization/dist/serialization.js +75 -0
package/serialization/package.json +20 -0
package/serialization/types/index.d.ts +139 -0
package/serialization/types-cjs/index.d.cts +139 -0
package/serialization/types-cjs/package.json +3 -0
package/server-functions/dist/client.cjs +370 -0
package/server-functions/dist/client.js +363 -0
package/server-functions/dist/server.cjs +542 -0
package/server-functions/dist/server.js +531 -0
package/server-functions/package.json +30 -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 +64 -21
package/types/core.d.ts +3 -3
package/types/index.d.ts +156 -24
package/types/jsx-properties.d.ts +93 -0
package/types/jsx.d.ts +4135 -1
package/types/response.d.ts +93 -0
package/types/serializer.d.ts +139 -0
package/types/server-functions/client.d.ts +63 -0
package/types/server-functions/server.d.ts +188 -0
package/types/server-functions/shared.d.ts +171 -0
package/types/server-mock.d.ts +89 -0
package/types/server.d.ts +123 -28
package/types-cjs/client.d.cts +131 -0
package/types-cjs/core.d.cts +3 -0
package/types-cjs/index.d.cts +178 -0
package/types-cjs/jsx-properties.d.cts +93 -0
package/types-cjs/jsx.d.cts +4135 -0
package/types-cjs/package.json +3 -0
package/types-cjs/response.d.cts +93 -0
package/types-cjs/serializer.d.cts +139 -0
package/types-cjs/server-functions/client.d.cts +63 -0
package/types-cjs/server-functions/server.d.cts +188 -0
package/types-cjs/server-functions/shared.d.cts +171 -0
package/types-cjs/server-mock.d.cts +161 -0
package/types-cjs/server.d.cts +251 -0
package/storage/types/src/client.d.ts +0 -1
package/storage/types/src/index.d.ts +0 -46
package/storage/types/src/server-mock.d.ts +0 -72
package/storage/types/storage/src/index.d.ts +0 -2

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

@@ -0,0 +1,161 @@
+/**
+ * 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/types-cjs/server.d.cts ADDED Viewed

@@ -0,0 +1,251 @@
+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>;
+export const DOMElements: Set<string>;
+export const SVGElements: Set<string>;
+export const MathMLElements: Set<string>;
+export const VoidElements: Set<string>;
+export const RawTextElements: Set<string>;
+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?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
+    onError?: (err: any) => void;
+  }
+): string;
+/** @deprecated use renderToStream which also returns a promise */
+export function renderToStringAsync<T>(
+  fn: () => T,
+  options?: {
+    timeoutMs?: number;
+    nonce?: string;
+    renderId?: string;
+    noScripts?: boolean;
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
+    onError?: (err: any) => void;
+  }
+): Promise<string>;
+export function renderToStream<T>(
+  fn: () => T,
+  options?: {
+    nonce?: string;
+    renderId?: string;
+    noScripts?: boolean;
+    plugins?: SerializerPlugin[];
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
+    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>;
+};
+export function HydrationScript(props: { nonce?: string; eventNames?: string[] }): JSX.Element;
+export function ssr(template: string[] | string, ...nodes: any[]): { t: string };
+export function ssrElement(
+  name: string,
+  props: any,
+  children: any,
+  needsId: boolean
+): { t: string };
+export function ssrClassName(value: string | { [k: string]: boolean } | Array<any>): string;
+export function ssrStyle(value: string | { [k: string]: string }): string;
+export function ssrStyleProperty(name: string, value: any): string;
+export function ssrAttribute(key: string, value: any): string;
+export function ssrGroup<T extends () => any[]>(fn: T, n: number): T;
+export function scope<T>(fn: () => T): () => unknown;
+export function ssrHydrationKey(): string;
+export function resolveSSRNode(node: any, result?: any, top?: boolean): any;
+export function escape(s: any, attr?: boolean): any;
+export function applyRef(
+  r: ((element: any) => void) | ((element: any) => void)[],
+  element: any
+): void;
+export function useAssets(fn: () => JSX.Element): void;
+export function getAssets(): string;
+export function getHydrationKey(): string | undefined;
+export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void): void;
+export function memo<T>(fn: () => T, equal: boolean): () => T;
+export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
+export function mergeProps(...sources: unknown[]): unknown;
+export function getOwner(): unknown;
+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;
+export function untrack<T>(fn: () => T): T;
+// client-only APIs
+/** @deprecated not supported on the server side */
+export function style(
+  node: Element,
+  value: { [k: string]: string },
+  prev?: { [k: string]: string }
+): void;
+/** @deprecated not supported on the server side */
+export function insert<T>(
+  parent: MountableElement,
+  accessor: (() => T) | T,
+  marker?: Node | null,
+  init?: JSX.Element
+): JSX.Element;
+/** @deprecated not supported on the server side */
+export function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
+/** @deprecated not supported on the server side */
+export function delegateEvents(eventNames: string[]): void;
+/** @deprecated not supported on the server side */
+export function registerDelegatedRoot(root: MountableElement): void;
+/** @deprecated not supported on the server side */
+export function unregisterDelegatedRoot(root: MountableElement): void;
+/** @deprecated not supported on the server side */
+export function registerDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+/** @deprecated not supported on the server side */
+export function unregisterDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+/** @deprecated not supported on the server side */
+export function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
+/** @deprecated not supported on the server side */
+export function dynamicProperty(props: unknown, key: string): unknown;
+/** @deprecated not supported on the server side */
+export function setAttribute(node: Element, name: string, value: string): void;
+/** @deprecated not supported on the server side */
+export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
+/** @deprecated not supported on the server side */
+export function addEvent(node: Element, name: string, handler: () => void, delegate: boolean): void;
+/** @deprecated not supported on the server side */
+export function render(code: () => JSX.Element, element: MountableElement): () => void;
+/**
+ * @deprecated not supported on the server side
+ * @param flag
+ * - `undefined` — clone the template as-is (uses `cloneNode`).
+ * - `1` — use `document.importNode` instead of `cloneNode`.
+ * - `2` — the template html is wrapped; the outer tag is stripped at clone time.
+ */
+export function template(html: string, flag?: 1 | 2): () => Element;
+/** @deprecated not supported on the server side */
+export function setProperty(node: Element, name: string, value: any): void;
+/** @deprecated not supported on the server side */
+export function className(node: Element, value: string): void;
+/** @deprecated not supported on the server side */
+export function assign(node: Element, props: any, skipChildren?: Boolean): void;
+/** @deprecated not supported on the server side */
+export function hydrate(
+  fn: () => JSX.Element,
+  node: MountableElement,
+  options?: { renderId?: string; owner?: unknown }
+): () => void;
+/** @deprecated not supported on the server side */
+export function getNextElement(template?: () => Element): Element;
+/** @deprecated not supported on the server side */
+export function getNextMatch(start: Node, elementName: string): Element;
+/** @deprecated not supported on the server side */
+export function getNextMarker(start: Node): [Node, Array<Node>];
+/** @deprecated not supported on the server side */
+export function runHydrationEvents(): void;
+/** @deprecated not supported on the server side */
+export function ref(
+  fn: () => ((element: Element) => void) | ((element: Element) => void)[],
+  element: Element
+): void;
+/** @deprecated not supported on the server side */
+export function setStyleProperty(node: Element, name: string, value: any): void;
+/** @deprecated not supported on the server side — register assets through the render context instead */
+export function acquireAsset(descriptor: unknown): () => void;

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

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

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

@@ -1,46 +0,0 @@
-import { hydrate as hydrateCore, render as renderCore } from "./client.js";
-import { JSX, ComponentProps, ValidComponent } from "solid-js";
-export * from "./client.js";
-export declare function render(...args: Parameters<typeof renderCore>): ReturnType<typeof renderCore>;
-export { For, Show, Switch, Match, Errored, Loading, NoHydration, Hydration, merge as mergeProps } from "solid-js";
-export * from "./server-mock.js";
-export declare const isServer: boolean;
-export declare const isDev: boolean;
-export declare const hydrate: typeof hydrateCore;
-/**
- * Renders components somewhere else in the DOM
- *
- * Useful for inserting modals and tooltips outside of an cropping layout. If no mount point is given, the portal is inserted in document.body; it is wrapped in a `<div>` unless the target is document.head or `isSVG` is true. setting `useShadow` to true places the element in a shadow root to isolate styles.
- *
- * @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;
-}): Text;
-export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
-    [K in keyof P]: P[K];
-} & {
-    component: T | undefined;
-};
-/**
- * Renders an arbitrary component or element with the given props
- *
- * This is a lower level version of the `Dynamic` component, useful for
- * performance optimizations in libraries. Do not use this unless you know
- * what you are doing.
- * ```typescript
- * const element = () => multiline() ? 'textarea' : 'input';
- * createDynamic(element, { value: value() });
- * ```
- * @description https://docs.solidjs.com/reference/components/dynamic
- */
-export declare function createDynamic<T extends ValidComponent>(component: () => T | undefined, props: ComponentProps<T>): JSX.Element;
-/**
- * Renders an arbitrary custom or native component and passes the other props
- * ```typescript
- * <Dynamic component={multiline() ? 'textarea' : 'input'} value={value()} />
- * ```
- * @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 DELETED Viewed

@@ -1,72 +0,0 @@
-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;
-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>;
-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>;
-};
-export declare function ssr(template: string[] | string, ...nodes: any[]): {
-    t: string;
-};
-export declare function ssrElement(name: string, props: any, children: any, needsId: boolean): {
-    t: string;
-};
-export declare function ssrClassList(value: {
-    [k: string]: boolean;
-}): string;
-export declare function ssrStyle(value: {
-    [k: string]: string;
-}): string;
-export declare function ssrAttribute(key: string, value: boolean): string;
-export declare function ssrHydrationKey(): string;
-export declare function resolveSSRNode(node: any): string;
-export declare function escape(html: string): string;

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

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