solid-js 2.0.0-experimental.5 → 2.0.0-experimental.6

package/types/server/index.d.ts

@@ -1,5 +1,5 @@
-export { $PROXY, $TRACK, $RAW, tryCatch, flatten, isEqual, isWrappable } from "@solidjs/signals";
-export { createAsync, createEffect, createMemo, createRenderEffect, createRoot, createSignal, flushSync, getObserver, getOwner, isPending, latest, mapArray, onCleanup, repeat, resolve, runWithObserver, runWithOwner, untrack } from "./signals.js";
+export { $PROXY, $TRACK, tryCatch, flatten, isEqual, isWrappable } from "@solidjs/signals";
+export { createAsync, createEffect, createMemo, createRenderEffect, createRoot, createSignal, flush, getObserver, getOwner, isPending, latest, mapArray, onCleanup, repeat, resolve, runWithObserver, runWithOwner, untrack } from "./signals.js";
 export { observable, from, children, createContext, onMount, useContext, ssrRunInScope } from "./reactive.js";
 export { createProjection, createStore, unwrap, reconcile, merge, omit } from "./store.js";
 export { createComponent, For, Repeat, Show, Switch, Match, ErrorBoundary, Suspense, enableHydration, createUniqueId, lazy, sharedConfig, ssrHandleError } from "./rendering.js";

package/types/server/reactive.d.ts

@@ -26,4 +26,5 @@ export declare function from<T>(producer: ((setter: Setter<T>) => () => void) |
         unsubscribe: () => void;
     };
 }): Accessor<T>;
-export declare function ssrRunInScope<T>(fn: () => T): () => T;
+export declare function ssrRunInScope(fn: () => any): () => any;
+export declare function ssrRunInScope(array: (() => any)[]): (() => any)[];

package/types/server/rendering.d.ts

@@ -1,7 +1,7 @@
 import { type Accessor } from "@solidjs/signals";
 import type { JSX } from "../jsx.js";
 import type { Component } from "../index.js";
-export declare function ssrHandleError(err: any): true | undefined;
+export declare function ssrHandleError(err: any): Promise<any> | undefined;
 type SharedConfig = {
     context?: HydrationContext;
     getNextContextId(): string;
@@ -13,7 +13,7 @@ export declare function For<T>(props: {
     each: T[];
     fallback?: string;
     children: (item: Accessor<T>, index: Accessor<number>) => string;
-}): () => string[];
+}): Accessor<string[]>;
 export declare function Repeat(props: {
     count: number;
     from?: number | undefined;
@@ -43,9 +43,7 @@ export declare function Match<T>(props: MatchProps<T>): MatchProps<T>;
 export declare function ErrorBoundary(props: {
     fallback: string | ((err: any, reset: () => void) => string);
     children: string;
-}): Accessor<{
-    t: string;
-}>;
+}): Accessor<SSRTemplateObject>;
 export declare function lazy<T extends Component<any>>(fn: () => Promise<{
     default: T;
 }>): T & {
@@ -54,14 +52,20 @@ export declare function lazy<T extends Component<any>>(fn: () => Promise<{
     }>;
 };
 export declare function enableHydration(): void;
+type SSRTemplateObject = {
+    t: string[];
+    h: Function[];
+    p: Promise<any>[];
+};
 type HydrationContext = {
     id: string;
     count: number;
     serialize: (id: string, v: Promise<any> | any, deferStream?: boolean) => void;
-    resolve(value: any): string;
+    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;
-    resources: Record<string, any>;
     registerFragment: (v: string) => (v?: string, err?: any) => boolean;
     async?: boolean;
     noHydrate: boolean;
@@ -69,5 +73,5 @@ type HydrationContext = {
 export declare function Suspense(props: {
     fallback?: string;
     children: string;
-}): any;
+}): string | SSRTemplateObject | undefined;
 export {};

package/types/server/signals.d.ts

@@ -1,5 +1,14 @@
+import { Owner } from "@solidjs/signals";
 export { createRoot, runWithOwner, onCleanup, getOwner } from "@solidjs/signals";
-import type { Accessor, Computation, ComputeFunction, EffectFunction, EffectOptions, MemoOptions, Signal, SignalOptions } from "@solidjs/signals";
+import type { Accessor, ComputeFunction, EffectFunction, EffectOptions, MemoOptions, Signal, SignalOptions } from "@solidjs/signals";
+declare class Computation<T> extends Owner {
+    _value: T;
+    _compute: ComputeFunction<T>;
+    _error: unknown;
+    constructor(initialValue: T, compute: ComputeFunction<T>);
+    update(): void;
+    read(): T;
+}
 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<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
@@ -15,9 +24,9 @@ export declare function createAsync<T>(compute: (prev?: T) => Promise<T> | Async
 export declare function isPending(fn: () => any, fallback?: boolean): boolean;
 export declare function latest<T>(fn: () => T, fallback?: T): T | undefined;
 export declare function resolve(): void;
-export declare function flushSync(): void;
+export declare function flush(): void;
 export declare function getObserver(): Computation<any> | null;
-export declare function runWithObserver<T>(o: Computation, fn: () => T): T | undefined;
+export declare function runWithObserver<T>(o: Computation<any>, fn: () => T): T | undefined;
 export declare function untrack<T>(fn: () => T): T;
 export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: Accessor<number>) => U, options?: {
     fallback?: Accessor<any>;