solid-js 2.0.0-beta.7 → 2.0.0-beta.8

package/types/server/hydration.d.ts

@@ -4,10 +4,27 @@ export { sharedConfig, NoHydrateContext } from "./shared.js";
 export type { HydrationContext, SSRTemplateObject } from "./shared.js";
 export type ServerRevealGroup = {
     id: string;
+    /**
+     * Register a child fragment (Loading) or composite child (inner Reveal).
+     * Returns `collapseFallback` (hide fallback visually, used for collapsed-sequential
+     * tail) and `held` (stash `revealFragments` swaps until the parent releases us).
+     * `held` only applies when the caller is a nested Reveal — Loadings ignore it.
+     */
     register(key: string, options?: {
         onActivate?: () => void;
-    }): boolean;
+    }): {
+        collapseFallback: boolean;
+        held: boolean;
+    };
+    /** Called by a child when its subtree is fully resolved. */
     onResolved(key: string): void;
+    /**
+     * Called by a nested Reveal when it becomes "minimally resolved" under its own
+     * order (together: fully resolved; sequential: first registered fragment resolved;
+     * natural: any fragment resolved). Loadings don't fire this — their `onResolved`
+     * implies minimal readiness at the same time.
+     */
+    onMinimallyResolved?(key: string): void;
 };
 export declare const RevealGroupContext: Context<ServerRevealGroup | null>;
 /**

package/types/server/signals.d.ts

@@ -12,27 +12,46 @@ interface ServerComputation<T = any> {
     computed: boolean;
     disposed: boolean;
 }
+type SsrSourceMode = "server" | "hybrid" | "client";
+type ServerSsrOptions = {
+    deferStream?: boolean;
+    ssrSource?: SsrSourceMode;
+};
+type ServerClientMemoOptions<T> = Omit<MemoOptions<T>, "ssrSource"> & {
+    ssrSource: "client";
+};
+type ServerMemoOptions<T> = Omit<MemoOptions<T>, "ssrSource"> & {
+    ssrSource?: "server" | "hybrid";
+};
+type ServerClientSignalOptions<T> = Omit<SignalOptions<T>, "ssrSource"> & {
+    ssrSource: "client";
+};
+type ServerSignalOptions<T> = Omit<SignalOptions<T>, "ssrSource"> & {
+    ssrSource?: "server" | "hybrid";
+};
 export declare function getObserver(): ServerComputation<any> | null;
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createSignal<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: SignalOptions<T>): Signal<T>;
-export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: MemoOptions<T>): Accessor<T>;
+export declare function createSignal<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options: ServerClientSignalOptions<T>): Signal<T | undefined>;
+export declare function createSignal<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: ServerSignalOptions<T>): Signal<T>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options: ServerClientMemoOptions<T>): Accessor<T | undefined>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: ServerMemoOptions<T>): Accessor<T>;
 export type PatchOp = [path: PropertyKey[]] | [path: PropertyKey[], value: any] | [path: PropertyKey[], value: any, insert: 1];
 export declare function createDeepProxy<T extends object>(target: T, patches: PatchOp[], basePath?: PropertyKey[]): T;
 export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effect: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
 export declare function createRenderEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
-export declare function createTrackedEffect(compute: () => void | (() => void), options?: EffectOptions): void;
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: {
+    name?: string;
+}): void;
 export declare function createReaction(effectFn: EffectFunction<undefined> | EffectBundle<undefined>, options?: EffectOptions): (tracking: () => void) => void;
 export declare function createOptimistic<T>(): Signal<T | undefined>;
 export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createOptimistic<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: SignalOptions<T>): Signal<T>;
+export declare function createOptimistic<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options: ServerClientSignalOptions<T>): Signal<T | undefined>;
+export declare function createOptimistic<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: ServerSignalOptions<T>): Signal<T>;
 export declare function createStore<T extends object>(store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
 export declare function createStore<T extends object>(fn: (store: T) => void | T | Promise<void | T>, store: Partial<T> | Store<T>): [get: Store<T>, set: StoreSetter<T>];
 export declare const createOptimisticStore: typeof createStore;
-export declare function createProjection<T extends object>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue: Partial<T>, options?: {
-    deferStream?: boolean;
-    ssrSource?: string;
-}): Store<T>;
+export declare function createProjection<T extends object>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue: Partial<T>, options?: ServerSsrOptions): Store<T>;
 export declare function reconcile<T extends U, U extends object>(value: T): (state: U) => T;
 export declare function deep<T extends object>(store: Store<T>): Store<T>;
 export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: Accessor<number>) => U, options?: {
@@ -51,8 +70,9 @@ export declare function createErrorBoundary<U>(fn: () => any, fallback: (error:
 export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
     on?: () => any;
 }): () => unknown;
+export type RevealOrder = "sequential" | "together" | "natural";
 export declare function createRevealOrder<T>(fn: () => T, _options?: {
-    together?: () => boolean;
+    order?: () => RevealOrder;
     collapsed?: () => boolean;
 }): T;
 export declare function untrack<T>(fn: () => T): T;

package/types-cjs/client/flow.d.cts

@@ -1,4 +1,5 @@
-import type { Accessor } from "@solidjs/signals";
+import type { Accessor, RevealOrder } from "@solidjs/signals";
+export type { RevealOrder };
 import type { JSX } from "../jsx.cjs";
 type NonZeroParams<T extends (...args: any[]) => any> = Parameters<T>["length"] extends 0 ? never : T;
 type ConditionalRenderCallback<T> = (item: Accessor<NonNullable<T>>) => JSX.Element;
@@ -117,26 +118,46 @@ export declare function Loading(props: {
     on?: any;
     children: JSX.Element;
 }): JSX.Element;
+export type RevealProps = {
+    order?: RevealOrder;
+    collapsed?: boolean;
+    children: JSX.Element;
+};
 /**
  * Coordinates the reveal timing of sibling `<Loading>` boundaries.
  *
- * - **Sequential** (default): boundaries reveal in DOM order as each resolves.
- * - **Together** (`together`): all boundaries wait until the group is ready, then reveal at once.
- * - **Collapsed** (`collapsed`, sequential only): only the frontier boundary shows its fallback;
- *   later boundaries produce nothing until their turn.
+ * The `order` prop picks the reveal policy:
+ * - `"sequential"` (default) — boundaries reveal in registration order; later boundaries
+ *   stay on their fallback until earlier ones resolve.
+ * - `"together"` — every direct slot stays on its fallback until the whole group is
+ *   "minimally ready" (every direct slot has its own first visible content available),
+ *   then the group releases in one cohesive reveal.
+ * - `"natural"` — each boundary reveals as its own data resolves. At the top level
+ *   this is equivalent to omitting `<Reveal>`; the mode exists for nesting, where
+ *   the group registers as a single composite slot in an enclosing `<Reveal>`.
+ *
+ * The `collapsed` prop is only consulted when `order="sequential"` (the default);
+ * it is ignored under `"together"` and `"natural"`. When set, tail boundaries past
+ * the frontier suppress their own fallback output.
+ *
+ * Nested `<Reveal>` groups compose: the inner group is one slot in the outer order
+ * and is held on its fallbacks until the outer releases the slot. Once released, the
+ * inner group runs its own `order` locally over whatever is still pending. There is
+ * no escape hatch — nesting under an outer group means participating in its ordering.
+ * See `documentation/solid-2.0/03-control-flow.md` for the full nesting matrix and the
+ * "minimally ready" definition per order.
  *
  * ```typescript
- * <Reveal>
+ * <Reveal order="sequential">
  *   <Loading fallback={<Skeleton />}><ProfileHeader /></Loading>
- *   <Loading fallback={<Skeleton />}><Posts /></Loading>
+ *   <Reveal order="natural">
+ *     <Loading fallback={<Skeleton />}><PostA /></Loading>
+ *     <Loading fallback={<Skeleton />}><PostB /></Loading>
+ *   </Reveal>
+ *   <Loading fallback={<Skeleton />}><Comments /></Loading>
  * </Reveal>
  * ```
  *
  * @description https://docs.solidjs.com/reference/components/reveal
  */
-export declare function Reveal(props: {
-    together?: boolean;
-    collapsed?: boolean;
-    children: JSX.Element;
-}): JSX.Element;
-export {};
+export declare function Reveal(props: RevealProps): JSX.Element;

package/types-cjs/client/hydration.d.cts

@@ -1,8 +1,8 @@
-import { createErrorBoundary as coreErrorBoundary, createMemo as coreMemo, createSignal as coreSignal, createOptimistic as coreOptimistic, createRenderEffect as coreRenderEffect, createEffect as coreEffect, $REFRESH, type ProjectionOptions, type Store, type StoreSetter, type Context } from "@solidjs/signals";
+import { createErrorBoundary as coreErrorBoundary, createRenderEffect as coreRenderEffect, createEffect as coreEffect, $REFRESH, type Accessor, type ComputeFunction, type MemoOptions, type NoInfer, type ProjectionOptions, type Signal, type SignalOptions, type Store, type StoreSetter, type Context } from "@solidjs/signals";
 import { JSX } from "../jsx.cjs";
 type HydrationSsrFields = {
     deferStream?: boolean;
-    ssrSource?: "server" | "hybrid" | "initial" | "client";
+    ssrSource?: "server" | "hybrid" | "client";
 };
 declare module "@solidjs/signals" {
     interface MemoOptions<T> extends HydrationSsrFields {
@@ -13,7 +13,19 @@ declare module "@solidjs/signals" {
     }
 }
 export type HydrationProjectionOptions = ProjectionOptions & {
-    ssrSource?: "server" | "hybrid" | "initial" | "client";
+    ssrSource?: "server" | "hybrid" | "client";
+};
+type HydrationClientMemoOptions<T> = Omit<MemoOptions<T>, "ssrSource"> & {
+    ssrSource: "client";
+};
+type HydrationMemoOptions<T> = Omit<MemoOptions<T>, "ssrSource"> & {
+    ssrSource?: "server" | "hybrid";
+};
+type HydrationClientSignalOptions<T> = Omit<SignalOptions<T> & MemoOptions<T>, "ssrSource"> & {
+    ssrSource: "client";
+};
+type HydrationSignalOptions<T> = Omit<SignalOptions<T> & MemoOptions<T>, "ssrSource"> & {
+    ssrSource?: "server" | "hybrid";
 };
 export type HydrationContext = {};
 export declare const NoHydrateContext: Context<boolean>;
@@ -42,10 +54,23 @@ export declare const sharedConfig: SharedConfig;
  */
 export declare function onHydrationEnd(callback: () => void): void;
 export declare function enableHydration(): void;
-export declare const createMemo: typeof coreMemo;
-export declare const createSignal: typeof coreSignal;
+export declare const createMemo: {
+    <T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options: HydrationClientMemoOptions<T>): Accessor<T | undefined>;
+    <T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: HydrationMemoOptions<T>): Accessor<T>;
+};
+export declare const createSignal: {
+    <T>(): Signal<T | undefined>;
+    <T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+    <T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options: HydrationClientSignalOptions<T>): Signal<T | undefined>;
+    <T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: HydrationSignalOptions<T>): Signal<T>;
+};
 export declare const createErrorBoundary: typeof coreErrorBoundary;
-export declare const createOptimistic: typeof coreOptimistic;
+export declare const createOptimistic: {
+    <T>(): Signal<T | undefined>;
+    <T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+    <T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options: HydrationClientSignalOptions<T>): Signal<T | undefined>;
+    <T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: HydrationSignalOptions<T>): Signal<T>;
+};
 export declare const createProjection: <T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue: T, options?: HydrationProjectionOptions) => Store<T> & {
     [$REFRESH]: any;
 };

package/types-cjs/jsx-properties.d.cts

@@ -41,11 +41,8 @@ export type PropValue =
  *   narrowing
  * - other types pass through unchanged
  */
-export type WidenPropValue<V> = [V] extends [string]
-  ? string extends V
-    ? string | number
-    : V
-  : V;
+type WidenString<V> = string extends V ? string | number : V;
+export type WidenPropValue<V> = [V] extends [string] ? WidenString<V> : V;
 
 /**
  * Structurally identical → `Y`; distinct → `N`. Used by `IsReadonlyKey` to detect