solid-js 2.0.0-experimental.14 → 2.0.0-experimental.16

package/types/index.d.ts

@@ -1,10 +1,10 @@
-export { $PROXY, $TRACK, action, createEffect, createReaction, createRenderEffect, createRoot, createTrackedEffect, deep, flatten, flush, getObserver, getOwner, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, untrack } from "@solidjs/signals";
-export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, Merge, NoInfer, NotWrappable, Omit, Owner, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter } from "@solidjs/signals";
+export { $PROXY, $TRACK, action, createOwner, createReaction, createRoot, createTrackedEffect, deep, flatten, flush, getNextChildId, getObserver, getOwner, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, latest, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, storePath, untrack } from "@solidjs/signals";
+export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, Merge, NoInfer, NotWrappable, Omit, Owner, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter } from "@solidjs/signals";
 export { $DEVCOMP, children, createContext, useContext } from "./client/core.js";
 export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedJSXElement } from "./client/core.js";
 export * from "./client/component.js";
 export * from "./client/flow.js";
-export { sharedConfig, Loading, enableHydration, createMemo, createSignal, createStore, createProjection, createOptimistic, createOptimisticStore } from "./client/hydration.js";
+export { sharedConfig, Loading, enableHydration, createMemo, createSignal, createStore, createProjection, createOptimistic, createOptimisticStore, createRenderEffect, createEffect } from "./client/hydration.js";
 export declare function ssrHandleError(): void;
 export declare function ssrRunInScope(): void;
 import type { JSX } from "./jsx.js";

package/types/jsx.d.ts

@@ -232,40 +232,19 @@ export namespace JSX {
     [SERIALIZABLE]: never;
   }
 
+  type RefCallback<T> = (el: T) => void;
+  type Ref<T> = T | RefCallback<T> | (RefCallback<T> | Ref<T>)[];
+
   interface IntrinsicAttributes {
-    ref?: unknown | ((e: unknown) => void) | undefined;
+    ref?: Ref<unknown> | undefined;
   }
   interface CustomAttributes<T> {
-    ref?: T | ((el: T) => void) | undefined;
+    ref?: Ref<T> | undefined;
     children?: Element | undefined;
     $ServerOnly?: boolean | undefined;
   }
-  type Accessor<T> = () => T;
-  interface Directives {}
-  interface DirectiveFunctions {
-    [x: string]: (el: DOMElement, accessor: Accessor<any>) => void;
-  }
   interface ExplicitProperties {}
   interface CustomEvents {}
-  type DirectiveAttributes = {
-    [Key in keyof Directives as `use:${Key}`]?: Directives[Key];
-  };
-  type DirectiveFunctionAttributes<T> = {
-    [K in keyof DirectiveFunctions as string extends K
-      ? never
-      : `use:${K}`]?: DirectiveFunctions[K] extends (
-      el: infer E, // will be unknown if not provided
-      ...rest: infer R // use rest so that we can check whether it's provided or not
-    ) => void
-      ? T extends E // everything extends unknown if E is unknown
-        ? R extends [infer A] // check if has accessor provided
-          ? A extends Accessor<infer V>
-            ? V // it's an accessor
-            : never // it isn't, type error
-          : true // no accessor provided
-        : never // T is the wrong element
-      : never; // it isn't a function
-  };
   type PropAttributes = {
     [Key in keyof ExplicitProperties as `prop:${Key}`]?: ExplicitProperties[Key];
   };
@@ -1033,8 +1012,6 @@ export namespace JSX {
    */
   interface ElementAttributes<T>
     extends CustomAttributes<T>,
-      DirectiveAttributes,
-      DirectiveFunctionAttributes<T>,
       PropAttributes,
       OnAttributes<T>,
       EventHandlersElement<T>,

package/types/server/component.d.ts

@@ -50,11 +50,15 @@ export type Ref<T> = T | ((val: T) => void);
 export declare function createComponent<T extends Record<string, any>>(Comp: Component<T>, props: T): JSX.Element;
 /**
  * Lazy load a function component asynchronously.
- * On server, caches the promise and throws NotReadyError if not yet loaded.
+ * On server, returns a createMemo that throws NotReadyError until the module resolves,
+ * allowing resolveSSRNode to capture it as a fine-grained hole. The memo naturally
+ * scopes the owner so hydration IDs align with the client's createMemo in lazy().
+ * Requires `moduleUrl` for SSR — the bundler plugin injects the module specifier
+ * so the server can look up client chunk URLs from the asset manifest.
  */
 export declare function lazy<T extends Component<any>>(fn: () => Promise<{
     default: T;
-}>): T & {
+}>, moduleUrl?: string): T & {
     preload: () => Promise<{
         default: T;
     }>;

package/types/server/core.d.ts

@@ -36,8 +36,9 @@ export type ChildrenReturn = Accessor<ResolvedChildren> & {
  */
 export declare function children(fn: Accessor<JSX.Element>): ChildrenReturn;
 /**
- * Runs functions with an isolated owner scope for SSR.
- * Used by dom-expressions to run event handlers and other code in scope.
+ * Pass-through for SSR dynamic expressions.
+ * On the client, insert() render effects are transparent (0 owner slots),
+ * so the server doesn't need to create owners for these either.
  */
 export declare function ssrRunInScope(fn: () => any): () => any;
 export declare function ssrRunInScope(array: (() => any)[]): (() => any)[];

package/types/server/index.d.ts

@@ -1,5 +1,5 @@
-export { $PROXY, $TRACK, action, createEffect, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getObserver, getOwner, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, untrack } from "./signals.js";
-export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, Merge, NoInfer, NotWrappable, Omit, Owner, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter } from "./signals.js";
+export { $PROXY, $TRACK, action, createEffect, createMemo, createOptimistic, createOptimisticStore, createOwner, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getNextChildId, getObserver, getOwner, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, latest, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, storePath, createDeepProxy, untrack } from "./signals.js";
+export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, Merge, NoInfer, NotWrappable, Omit, Owner, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter, PatchOp } from "./signals.js";
 export { $DEVCOMP, children, createContext, useContext, ssrRunInScope } from "./core.js";
 export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedJSXElement } from "./core.js";
 export * from "./component.js";

package/types/server/shared.d.ts

@@ -6,13 +6,34 @@ type SSRTemplateObject = {
 export type HydrationContext = {
     id: string;
     count: number;
-    serialize: (id: string, v: Promise<any> | any, deferStream?: boolean) => void;
+    /**
+     * Serialize a value for client hydration.
+     * In renderToStream (async: true), accepts promises and async iterables.
+     * In renderToString (async: false), only synchronous values are allowed —
+     * passing async values will throw.
+     */
+    serialize: (id: string, v: any, deferStream?: boolean) => void;
     resolve(value: any): SSRTemplateObject;
     ssr(template: string[], ...values: any[]): SSRTemplateObject;
     escape(value: any): string;
     replace: (id: string, replacement: () => any) => void;
     block: (p: Promise<any>) => void;
     registerFragment: (v: string) => (v?: string, err?: any) => boolean;
+    /** Register a client-side asset URL discovered during SSR (e.g. from lazy()). */
+    registerAsset?: (type: "module" | "style", url: string) => void;
+    /** Register a moduleUrl-to-entryUrl mapping for the current boundary. */
+    registerModule?: (moduleUrl: string, entryUrl: string) => void;
+    /** Resolve a module's JS and CSS assets from the asset manifest. Set by dom-expressions. */
+    resolveAssets?: (moduleUrl: string) => {
+        js: string[];
+        css: string[];
+    } | null;
+    /** Retrieve the moduleUrl-to-entryUrl map for a boundary. */
+    getBoundaryModules?: (id: string) => Record<string, string> | null;
+    /** @internal Tracks which Loading boundary is currently rendering. Set by dom-expressions via applyAssetTracking(). */
+    _currentBoundaryId?: string | null;
+    assets: any[];
+    /** True only in renderToStream — enables async data serialization and streaming. */
     async?: boolean;
     noHydrate: boolean;
 };

package/types/server/signals.d.ts

@@ -1,7 +1,7 @@
 export { createRoot, createOwner, runWithOwner, getOwner, onCleanup, getNextChildId, createContext, setContext, getContext, NotReadyError, NoOwnerError, ContextNotFoundError, isEqual, isWrappable, SUPPORTS_PROXY } from "@solidjs/signals";
 export { flatten } from "@solidjs/signals";
-export { snapshot, merge, omit, $PROXY, $TRACK } from "@solidjs/signals";
-export type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, NoInfer, SignalOptions, Setter, Signal, Owner, Maybe, Store, StoreSetter, StoreNode, NotWrappable, SolidStore, Merge, Omit, Context, ContextRecord, IQueue } from "@solidjs/signals";
+export { snapshot, merge, omit, storePath, $PROXY, $TRACK } from "@solidjs/signals";
+export type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, NoInfer, SignalOptions, Setter, Signal, Owner, Maybe, Store, StoreSetter, StoreNode, NotWrappable, SolidStore, Merge, Omit, Context, ContextRecord, IQueue, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter } from "@solidjs/signals";
 import type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, SignalOptions, Signal, Owner, Store, StoreSetter, Context } from "@solidjs/signals";
 interface ServerComputation<T = any> {
     owner: Owner;
@@ -9,6 +9,7 @@ interface ServerComputation<T = any> {
     compute: ComputeFunction<any, T>;
     error: unknown;
     computed: boolean;
+    disposed: boolean;
 }
 export declare function getObserver(): ServerComputation<any> | null;
 export declare function createSignal<T>(): Signal<T | undefined>;
@@ -16,6 +17,8 @@ export declare function createSignal<T>(value: Exclude<T, Function>, options?: S
 export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
 export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
 export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+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<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next> | EffectBundle<NoInfer<Next>, Next>): void;
 export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next> | EffectBundle<Next, Next>, value: Init, options?: EffectOptions): void;
 export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next>): void;
@@ -25,9 +28,12 @@ export declare function createReaction(effectFn: EffectFunction<undefined> | Eff
 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<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
-export declare function createStore<T extends object>(state: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object>(first: T | Store<T> | ((store: T) => void | T | Promise<void | T>), second?: 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, initialValue?: T): Store<T>;
+export declare function createProjection<T extends object>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: {
+    deferStream?: boolean;
+    ssrSource?: string;
+}): 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?: {
@@ -46,7 +52,7 @@ export declare function untrack<T>(fn: () => T): T;
 export declare function flush(): void;
 export declare function resolve<T>(fn: () => T): Promise<T>;
 export declare function isPending(fn: () => any, fallback?: boolean): boolean;
-export declare function pending<T>(fn: () => T): T;
+export declare function latest<T>(fn: () => T): T;
 export declare function isRefreshing(): boolean;
 export declare function refresh<T>(fn: () => T): T;
 export declare function action<T extends (...args: any[]) => any>(fn: T): T;