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

package/dist/solid.js

@@ -1,5 +1,5 @@
-import { getContext, createMemo, flatten, createRoot, setContext, NotReadyError, getOwner, getNextChildId, createLoadBoundary, createSignal, flush, runWithOwner, untrack, mapArray, repeat, createErrorBoundary, createBoundary } from '@solidjs/signals';
-export { $PROXY, $TRACK, createEffect, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getObserver, getOwner, isEqual, isPending, isRefreshing, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, refresh, repeat, resolve, runWithOwner, snapshot, untrack } from '@solidjs/signals';
+import { getContext, createMemo as createMemo$1, flatten, createRoot, setContext, getOwner, getNextChildId, createSignal as createSignal$1, createLoadBoundary, flush, runWithOwner, untrack, mapArray, repeat, createErrorBoundary } from '@solidjs/signals';
+export { $PROXY, $TRACK, NotReadyError, action, createEffect, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createStore, createTrackedEffect, deep, flatten, flush, getObserver, getOwner, isEqual, isPending, isRefreshing, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, refresh, repeat, resolve, runWithOwner, snapshot, untrack } from '@solidjs/signals';
 
 const $DEVCOMP = Symbol(0);
 function createContext(defaultValue, options) {
@@ -18,8 +18,8 @@ function useContext(context) {
   return getContext(context);
 }
 function children(fn) {
-  const children = createMemo(fn);
-  const memo = createMemo(() => flatten(children()));
+  const children = createMemo$1(fn);
+  const memo = createMemo$1(() => flatten(children()));
   memo.toArray = () => {
     const c = memo();
     return Array.isArray(c) ? c : c != null ? [c] : [];
@@ -27,27 +27,6 @@ function children(fn) {
   return memo;
 }
 
-function tryCatch(fn) {
-  try {
-    const v = fn();
-    if (v instanceof Promise) {
-      return v.then(v => [undefined, v], e => {
-        if (e instanceof NotReadyError) throw e;
-        return [e];
-      });
-    }
-    return [undefined, v];
-  } catch (e) {
-    if (e instanceof NotReadyError) throw e;
-    return [e];
-  }
-}
-function reducer(source, reducerFn) {
-  return [source[0], action => {
-    source[1](s => reducerFn(s, action));
-  }];
-}
-
 const sharedConfig = {
   hydrating: false,
   registry: undefined,
@@ -58,19 +37,90 @@ const sharedConfig = {
     return getNextChildId(o);
   }
 };
+let _createMemo;
+let _createSignal;
+class MockPromise {
+  static all() {
+    return new MockPromise();
+  }
+  static allSettled() {
+    return new MockPromise();
+  }
+  static any() {
+    return new MockPromise();
+  }
+  static race() {
+    return new MockPromise();
+  }
+  static reject() {
+    return new MockPromise();
+  }
+  static resolve() {
+    return new MockPromise();
+  }
+  catch() {
+    return new MockPromise();
+  }
+  then() {
+    return new MockPromise();
+  }
+  finally() {
+    return new MockPromise();
+  }
+}
+function subFetch(fn, prev) {
+  const ogFetch = fetch;
+  const ogPromise = Promise;
+  try {
+    window.fetch = () => new MockPromise();
+    Promise = MockPromise;
+    return fn(prev);
+  } finally {
+    window.fetch = ogFetch;
+    Promise = ogPromise;
+  }
+}
+function hydratedCreateMemo(compute, value, options) {
+  if (!sharedConfig.hydrating) return createMemo$1(compute, value, options);
+  return createMemo$1(prev => {
+    const o = getOwner();
+    if (!sharedConfig.hydrating) return compute(prev);
+    let initP;
+    if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
+    const init = initP?.v ?? initP;
+    return init != null ? (subFetch(compute, prev), init) : compute(prev);
+  }, value, options);
+}
+function hydratedCreateSignal(fn, second, third) {
+  if (typeof fn !== "function" || !sharedConfig.hydrating) return createSignal$1(fn, second, third);
+  return createSignal$1(prev => {
+    if (!sharedConfig.hydrating) return fn(prev);
+    const o = getOwner();
+    let initP;
+    if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
+    const init = initP?.v ?? initP;
+    return init != null ? (subFetch(fn, prev), init) : fn(prev);
+  }, second, third);
+}
+function enableHydration() {
+  _createMemo = hydratedCreateMemo;
+  _createSignal = hydratedCreateSignal;
+}
+const createMemo = (...args) => (_createMemo || createMemo$1)(...args);
+const createSignal = (...args) => (_createSignal || createSignal$1)(...args);
 function Loading(props) {
   if (!sharedConfig.hydrating) return createLoadBoundary(() => props.children, () => props.fallback);
-  return createMemo(() => {
+  return createMemo$1(() => {
     const o = getOwner();
     const id = o.id;
     if (sharedConfig.hydrating && sharedConfig.has(id)) {
       let ref = sharedConfig.load(id);
       let p;
       if (ref) {
-        if (typeof ref !== "object" || ref.s !== "success") p = ref;else sharedConfig.gather(id);
+        if (typeof ref !== "object" || ref.s !== 1) p = ref;else sharedConfig.gather(id);
       }
       if (p) {
-        const [s, set] = createSignal(undefined, {
+        const [s, set] = createSignal$1(undefined, {
           equals: false
         });
         s();
@@ -92,8 +142,6 @@ function Loading(props) {
   });
 }
 
-function enableHydration() {
-}
 function createComponent(Comp, props) {
   return untrack(() => Comp(props || {}));
 }
@@ -101,9 +149,9 @@ function lazy(fn) {
   let comp;
   let p;
   const wrap = props => {
-    comp = createMemo(() => (p || (p = fn())).then(mod => mod.default));
+    comp = createMemo$1(() => (p || (p = fn())).then(mod => mod.default));
     let Comp;
-    return createMemo(() => (Comp = comp()) ? untrack(() => {
+    return createMemo$1(() => (Comp = comp()) ? untrack(() => {
       return Comp(props);
     }) : "");
   };
@@ -134,11 +182,11 @@ function Repeat(props) {
 }
 function Show(props) {
   const keyed = props.keyed;
-  const conditionValue = createMemo(() => props.when, undefined, undefined);
-  const condition = keyed ? conditionValue : createMemo(conditionValue, undefined, {
+  const conditionValue = createMemo$1(() => props.when, undefined, undefined);
+  const condition = keyed ? conditionValue : createMemo$1(conditionValue, undefined, {
     equals: (a, b) => !a === !b
   });
-  return createMemo(() => {
+  return createMemo$1(() => {
     const c = condition();
     if (c) {
       const child = props.children;
@@ -153,22 +201,22 @@ function Show(props) {
 }
 function Switch(props) {
   const chs = children(() => props.children);
-  const switchFunc = createMemo(() => {
+  const switchFunc = createMemo$1(() => {
     const mps = chs.toArray();
     let func = () => undefined;
     for (let i = 0; i < mps.length; i++) {
       const index = i;
       const mp = mps[i];
       const prevFunc = func;
-      const conditionValue = createMemo(() => prevFunc() ? undefined : mp.when, undefined, undefined);
-      const condition = mp.keyed ? conditionValue : createMemo(conditionValue, undefined, {
+      const conditionValue = createMemo$1(() => prevFunc() ? undefined : mp.when, undefined, undefined);
+      const condition = mp.keyed ? conditionValue : createMemo$1(conditionValue, undefined, {
         equals: (a, b) => !a === !b
       });
       func = () => prevFunc() || (condition() ? [index, conditionValue, mp] : undefined);
     }
     return func;
   });
-  return createMemo(() => {
+  return createMemo$1(() => {
     const sel = switchFunc()();
     if (!sel) return props.fallback;
     const [index, conditionValue, mp] = sel;
@@ -189,12 +237,9 @@ function Errored(props) {
     return typeof f === "function" && f.length ? f(err, reset) : f;
   });
 }
-function Boundary(props) {
-  return createBoundary(() => props.children, () => props.mode);
-}
 
 function ssrHandleError() {}
 function ssrRunInScope() {}
 const DEV = undefined;
 
-export { $DEVCOMP, Boundary, DEV, Errored, For, Loading, Match, Repeat, Show, Switch, children, createComponent, createContext, createUniqueId, enableHydration, lazy, reducer, sharedConfig, ssrHandleError, ssrRunInScope, tryCatch, useContext };
+export { $DEVCOMP, DEV, Errored, For, Loading, Match, Repeat, Show, Switch, children, createComponent, createContext, createMemo, createSignal, createUniqueId, enableHydration, lazy, sharedConfig, ssrHandleError, ssrRunInScope, useContext };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "solid-js",
   "description": "A declarative JavaScript library for building user interfaces.",
-  "version": "2.0.0-experimental.12",
+  "version": "2.0.0-experimental.14",
   "author": "Ryan Carniato",
   "license": "MIT",
   "homepage": "https://solidjs.com",
@@ -79,10 +79,10 @@
     "performance"
   ],
   "dependencies": {
-    "@solidjs/signals": "^0.9.0",
+    "@solidjs/signals": "^0.10.2",
     "csstype": "^3.1.0",
-    "seroval": "~1.3.0",
-    "seroval-plugins": "~1.3.0"
+    "seroval": "~1.5.0",
+    "seroval-plugins": "~1.5.0"
   },
   "scripts": {
     "build": "npm-run-all -nl build:*",

package/types/client/component.d.ts

@@ -1,5 +1,4 @@
 import type { JSX } from "../jsx.js";
-export declare function enableHydration(): void;
 /**
  * A general `Component` has no implicit `children` prop.  If desired, you can
  * specify one as in `Component<{name: String, children: JSX.Element}>`.

package/types/client/flow.d.ts

@@ -1,4 +1,4 @@
-import type { Accessor, BoundaryMode } from "@solidjs/signals";
+import type { Accessor } from "@solidjs/signals";
 import type { JSX } from "../jsx.js";
 /**
  * Creates a list of elements from a list
@@ -98,7 +98,3 @@ export declare function Errored(props: {
     fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
     children: JSX.Element;
 }): JSX.Element;
-export declare function Boundary(props: {
-    mode: BoundaryMode;
-    children: JSX.Element;
-}): JSX.Element;

package/types/client/hydration.d.ts

@@ -1,4 +1,6 @@
+import { createMemo as coreMemo, createSignal as coreSignal } from "@solidjs/signals";
 import { JSX } from "../jsx.js";
+export { createStore, createProjection, createOptimistic, createOptimisticStore } from "@solidjs/signals";
 export type HydrationContext = {};
 type SharedConfig = {
     hydrating: boolean;
@@ -13,6 +15,9 @@ type SharedConfig = {
     getNextContextId(): string;
 };
 export declare const sharedConfig: SharedConfig;
+export declare function enableHydration(): void;
+export declare const createMemo: typeof coreMemo;
+export declare const createSignal: typeof coreSignal;
 /**
  * Tracks all resources inside a component and renders a fallback until they are all resolved
  * ```typescript
@@ -28,4 +33,3 @@ export declare function Loading(props: {
     fallback?: JSX.Element;
     children: JSX.Element;
 }): JSX.Element;
-export {};

package/types/index.d.ts

@@ -1,11 +1,10 @@
-export { $PROXY, $TRACK, 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, runWithOwner, snapshot, untrack } from "@solidjs/signals";
-export type { Accessor, BoundaryMode, ComputeFunction, EffectFunction, EffectOptions, Merge, NoInfer, NotWrappable, Omit, Owner, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter } from "@solidjs/signals";
+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 { $DEVCOMP, children, createContext, useContext } from "./client/core.js";
 export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedJSXElement } from "./client/core.js";
-export * from "./utilities.js";
 export * from "./client/component.js";
 export * from "./client/flow.js";
-export { sharedConfig, Loading } from "./client/hydration.js";
+export { sharedConfig, Loading, enableHydration, createMemo, createSignal, createStore, createProjection, createOptimistic, createOptimisticStore } from "./client/hydration.js";
 export declare function ssrHandleError(): void;
 export declare function ssrRunInScope(): void;
 import type { JSX } from "./jsx.js";

package/types/server/component.d.ts

@@ -0,0 +1,62 @@
+import type { JSX } from "../jsx.js";
+export declare function enableHydration(): void;
+/**
+ * A general `Component` has no implicit `children` prop.  If desired, you can
+ * specify one as in `Component<{name: String, children: JSX.Element}>`.
+ */
+export type Component<P extends Record<string, any> = {}> = (props: P) => JSX.Element;
+/**
+ * Extend props to forbid the `children` prop.
+ */
+export type VoidProps<P extends Record<string, any> = {}> = P & {
+    children?: never;
+};
+/**
+ * `VoidComponent` forbids the `children` prop.
+ */
+export type VoidComponent<P extends Record<string, any> = {}> = Component<VoidProps<P>>;
+/**
+ * Extend props to allow an optional `children` prop with the usual type in JSX.
+ */
+export type ParentProps<P extends Record<string, any> = {}> = P & {
+    children?: JSX.Element;
+};
+/**
+ * `ParentComponent` allows an optional `children` prop with the usual type in JSX.
+ */
+export type ParentComponent<P extends Record<string, any> = {}> = Component<ParentProps<P>>;
+/**
+ * Extend props to require a `children` prop with the specified type.
+ */
+export type FlowProps<P extends Record<string, any> = {}, C = JSX.Element> = P & {
+    children: C;
+};
+/**
+ * `FlowComponent` requires a `children` prop with the specified type.
+ */
+export type FlowComponent<P extends Record<string, any> = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
+export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
+/**
+ * Takes the props of the passed component and returns its type
+ */
+export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
+/**
+ * Type of `props.ref`, for use in `Component` or `props` typing.
+ */
+export type Ref<T> = T | ((val: T) => void);
+/**
+ * Creates a component. On server, just calls the function directly (no untrack needed).
+ */
+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.
+ */
+export declare function lazy<T extends Component<any>>(fn: () => Promise<{
+    default: T;
+}>): T & {
+    preload: () => Promise<{
+        default: T;
+    }>;
+};
+export declare function createUniqueId(): string;

package/types/server/core.d.ts

@@ -0,0 +1,43 @@
+import type { Accessor, EffectOptions } from "./signals.js";
+import type { JSX } from "../jsx.js";
+import type { FlowComponent } from "./component.js";
+export declare const $DEVCOMP: unique symbol;
+export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
+export type ContextProviderComponent<T> = FlowComponent<{
+    value: T;
+}>;
+export interface Context<T> extends ContextProviderComponent<T> {
+    id: symbol;
+    defaultValue: T;
+}
+/**
+ * Creates a Context to handle a state scoped for the children of a component
+ * @param defaultValue optional default to inject into context
+ * @param options allows to set a name in dev mode for debugging purposes
+ * @returns The context that contains the Provider Component and that can be used with `useContext`
+ */
+export declare function createContext<T>(defaultValue?: undefined, options?: EffectOptions): Context<T | undefined>;
+export declare function createContext<T>(defaultValue: T, options?: EffectOptions): Context<T>;
+/**
+ * Uses a context to receive a scoped state from a parent's Context.Provider
+ * @param context Context object made by `createContext`
+ * @returns the current or `defaultValue`, if present
+ */
+export declare function useContext<T>(context: Context<T>): T;
+export type ResolvedJSXElement = Exclude<JSX.Element, JSX.ArrayElement>;
+export type ResolvedChildren = ResolvedJSXElement | ResolvedJSXElement[];
+export type ChildrenReturn = Accessor<ResolvedChildren> & {
+    toArray: () => ResolvedJSXElement[];
+};
+/**
+ * Resolves child elements to help interact with children
+ * @param fn an accessor for the children
+ * @returns a accessor of the same children, but resolved
+ */
+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.
+ */
+export declare function ssrRunInScope(fn: () => any): () => any;
+export declare function ssrRunInScope(array: (() => any)[]): (() => any)[];

package/types/server/flow.d.ts

@@ -0,0 +1,60 @@
+import type { Accessor } from "./signals.js";
+import type { JSX } from "../jsx.js";
+/**
+ * Creates a list of elements from a list
+ *
+ * @description https://docs.solidjs.com/reference/components/for
+ */
+export declare function For<T extends readonly any[], U extends JSX.Element>(props: {
+    each: T | undefined | null | false;
+    fallback?: JSX.Element;
+    keyed?: boolean | ((item: T[number]) => any);
+    children: (item: Accessor<T[number]>, index: Accessor<number>) => U;
+}): JSX.Element;
+/**
+ * Creates a list elements from a count
+ *
+ * @description https://docs.solidjs.com/reference/components/repeat
+ */
+export declare function Repeat<T extends JSX.Element>(props: {
+    count: number;
+    from?: number | undefined;
+    fallback?: JSX.Element;
+    children: ((index: number) => T) | T;
+}): JSX.Element;
+/**
+ * Conditionally render its children or an optional fallback component
+ * @description https://docs.solidjs.com/reference/components/show
+ */
+export declare function Show<T>(props: {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    fallback?: JSX.Element;
+    children: JSX.Element | ((item: Accessor<NonNullable<T>>) => JSX.Element);
+}): JSX.Element;
+/**
+ * Switches between content based on mutually exclusive conditions
+ * @description https://docs.solidjs.com/reference/components/switch-and-match
+ */
+export declare function Switch(props: {
+    fallback?: JSX.Element;
+    children: JSX.Element;
+}): JSX.Element;
+export type MatchProps<T> = {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    children: JSX.Element | ((item: Accessor<NonNullable<T>>) => JSX.Element);
+};
+/**
+ * Selects a content based on condition when inside a `<Switch>` control flow
+ * @description https://docs.solidjs.com/reference/components/switch-and-match
+ */
+export declare function Match<T>(props: MatchProps<T>): JSX.Element;
+/**
+ * Catches uncaught errors inside components and renders a fallback content
+ * @description https://docs.solidjs.com/reference/components/error-boundary
+ */
+export declare function Errored(props: {
+    fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
+    children: JSX.Element;
+}): JSX.Element;

package/types/server/hydration.d.ts

@@ -0,0 +1,21 @@
+import type { JSX } from "../jsx.js";
+export { sharedConfig } from "./shared.js";
+export type { HydrationContext } from "./shared.js";
+/**
+ * Handles errors during SSR rendering.
+ * Returns the promise source for NotReadyError (for async handling),
+ * or delegates to the ErrorContext handler.
+ */
+export declare function ssrHandleError(err: any): Promise<any> | undefined;
+/**
+ * Tracks all resources inside a component and renders a fallback until they are all resolved
+ *
+ * On the server, this is SSR-aware: it handles async mode (streaming) by registering
+ * fragments and resolving asynchronously, and sync mode by serializing fallback markers.
+ *
+ * @description https://docs.solidjs.com/reference/components/suspense
+ */
+export declare function Loading(props: {
+    fallback?: JSX.Element;
+    children: JSX.Element;
+}): JSX.Element;

package/types/server/index.d.ts

@@ -1 +1,12 @@
-export {};
+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 { $DEVCOMP, children, createContext, useContext, ssrRunInScope } from "./core.js";
+export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedJSXElement } from "./core.js";
+export * from "./component.js";
+export * from "./flow.js";
+export { sharedConfig, Loading, ssrHandleError } from "./hydration.js";
+export type { HydrationContext } from "./hydration.js";
+import type { JSX } from "../jsx.js";
+type JSXElement = JSX.Element;
+export type { JSXElement, JSX };
+export declare const DEV: undefined;

package/types/server/shared.d.ts

@@ -0,0 +1,24 @@
+type SSRTemplateObject = {
+    t: string[];
+    h: Function[];
+    p: Promise<any>[];
+};
+export type HydrationContext = {
+    id: string;
+    count: number;
+    serialize: (id: string, v: Promise<any> | 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;
+    async?: boolean;
+    noHydrate: boolean;
+};
+type SharedConfig = {
+    context?: HydrationContext;
+    getNextContextId(): string;
+};
+export declare const sharedConfig: SharedConfig;
+export {};

package/types/server/signals.d.ts

@@ -0,0 +1,54 @@
+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";
+import type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, SignalOptions, Signal, Owner, Store, StoreSetter, Context } from "@solidjs/signals";
+interface ServerComputation<T = any> {
+    owner: Owner;
+    value: T;
+    compute: ComputeFunction<any, T>;
+    error: unknown;
+    computed: boolean;
+}
+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<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 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;
+export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effectFn: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: EffectOptions): 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<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 const createOptimisticStore: typeof createStore;
+export declare function createProjection<T extends object>(fn: (draft: T) => void, initialValue?: T): 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?: {
+    keyed?: boolean | ((item: T) => any);
+    fallback?: Accessor<any>;
+}): () => U[];
+export declare function repeat<T>(count: Accessor<number>, mapFn: (i: number) => T, options?: {
+    fallback?: Accessor<any>;
+    from?: Accessor<number | undefined>;
+}): () => T[];
+declare const ErrorContext: Context<((err: any) => void) | null>;
+export { ErrorContext };
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => unknown;
+export declare function createLoadBoundary(fn: () => any, fallback: () => any): () => unknown;
+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 isRefreshing(): boolean;
+export declare function refresh<T>(fn: () => T): T;
+export declare function action<T extends (...args: any[]) => any>(fn: T): T;
+export declare function onSettled(callback: () => void | (() => void)): void;
+type NoInfer<T extends any> = [T][T extends any ? 0 : never];

package/types/utilities.d.ts

@@ -1,36 +0,0 @@
-import { Accessor, Signal, Store, StoreSetter } from "@solidjs/signals";
-/**
- * Runs the given function and returns a tuple with the result or an error.
- * If the function throws an error, it will be caught and returned as the first element of the tuple.
- * If the function returns a promise, it will resolve to a tuple with the result or an error.
- *
- * @param fn The function to run.
- * @returns A tuple with either [undefined, result] or [error].
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/try-catch
- */
-export type TryCatchResult<T, E> = [undefined, T] | [E];
-export declare function tryCatch<T, E = Error>(fn: () => Promise<T>): Promise<TryCatchResult<T, E>>;
-export declare function tryCatch<T, E = Error>(fn: () => T): TryCatchResult<T, E>;
-/**
- * Simple reducer utility for Signals and Stores
- * ```typescript
- * const [state, dispatch] = reducer(createSignal({ count: 0 }), (state, action) => {
- *   switch (action.type) {
- *     case "increment":
- *       return { count: state.count + 1 };
- *     case "decrement":
- *       return { count: state.count - 1 };
- *     default:
- *       return state;
- *   }
- * });
- * ```
- * @param source Signal or Store tuple
- * @param reducerFn reducer function that receives the current value and an action, and returns the new value for signals or void for stores
- * @returns a tuple with the current value accessor and a dispatch function to send actions to the reducer
- *
- * @description https://docs.solidjs.com/reference/reactive-utilities/reducer
- */
-export declare function reducer<T, A>(source: Signal<T>, reducerFn: (value: T, action: A) => T): [Accessor<T>, (action: A) => void];
-export declare function reducer<T, A>(source: [Store<T>, StoreSetter<T>], reducerFn: (value: T, action: A) => T | void): [Store<T>, (action: A) => void];