solid-js 1.9.0 → 1.9.2

package/types/reactive/signal.d.ts

@@ -33,61 +33,58 @@ export declare var Owner: Owner | null;
 export declare let Transition: TransitionState | null;
 /** Object storing callbacks for debugging during development */
 export declare const DevHooks: {
-  afterUpdate: (() => void) | null;
-  afterCreateOwner: ((owner: Owner) => void) | null;
-  afterCreateSignal: ((signal: SignalState<any>) => void) | null;
+    afterUpdate: (() => void) | null;
+    afterCreateOwner: ((owner: Owner) => void) | null;
+    afterCreateSignal: ((signal: SignalState<any>) => void) | null;
 };
 export type ComputationState = 0 | 1 | 2;
 export interface SourceMapValue {
-  value: unknown;
-  name?: string;
-  graph?: Owner;
+    value: unknown;
+    name?: string;
+    graph?: Owner;
 }
 export interface SignalState<T> extends SourceMapValue {
-  value: T;
-  observers: Computation<any>[] | null;
-  observerSlots: number[] | null;
-  tValue?: T;
-  comparator?: (prev: T, next: T) => boolean;
+    value: T;
+    observers: Computation<any>[] | null;
+    observerSlots: number[] | null;
+    tValue?: T;
+    comparator?: (prev: T, next: T) => boolean;
 }
 export interface Owner {
-  owned: Computation<any>[] | null;
-  cleanups: (() => void)[] | null;
-  owner: Owner | null;
-  context: any | null;
-  sourceMap?: SourceMapValue[];
-  name?: string;
+    owned: Computation<any>[] | null;
+    cleanups: (() => void)[] | null;
+    owner: Owner | null;
+    context: any | null;
+    sourceMap?: SourceMapValue[];
+    name?: string;
 }
 export interface Computation<Init, Next extends Init = Init> extends Owner {
-  fn: EffectFunction<Init, Next>;
-  state: ComputationState;
-  tState?: ComputationState;
-  sources: SignalState<Next>[] | null;
-  sourceSlots: number[] | null;
-  value?: Init;
-  updatedAt: number | null;
-  pure: boolean;
-  user?: boolean;
-  suspense?: SuspenseContextType;
+    fn: EffectFunction<Init, Next>;
+    state: ComputationState;
+    tState?: ComputationState;
+    sources: SignalState<Next>[] | null;
+    sourceSlots: number[] | null;
+    value?: Init;
+    updatedAt: number | null;
+    pure: boolean;
+    user?: boolean;
+    suspense?: SuspenseContextType;
 }
 export interface TransitionState {
-  sources: Set<SignalState<any>>;
-  effects: Computation<any>[];
-  promises: Set<Promise<any>>;
-  disposed: Set<Computation<any>>;
-  queue: Set<Computation<any>>;
-  scheduler?: (fn: () => void) => unknown;
-  running: boolean;
-  done?: Promise<void>;
-  resolve?: () => void;
+    sources: Set<SignalState<any>>;
+    effects: Computation<any>[];
+    promises: Set<Promise<any>>;
+    disposed: Set<Computation<any>>;
+    queue: Set<Computation<any>>;
+    scheduler?: (fn: () => void) => unknown;
+    running: boolean;
+    done?: Promise<void>;
+    resolve?: () => void;
 }
-type ExternalSourceFactory = <Prev, Next extends Prev = Prev>(
-  fn: EffectFunction<Prev, Next>,
-  trigger: () => void
-) => ExternalSource;
+type ExternalSourceFactory = <Prev, Next extends Prev = Prev>(fn: EffectFunction<Prev, Next>, trigger: () => void) => ExternalSource;
 export interface ExternalSource {
-  track: EffectFunction<any, any>;
-  dispose: () => void;
+    track: EffectFunction<any, any>;
+    dispose: () => void;
 }
 export type RootFunction<T> = (dispose: () => void) => T;
 /**
@@ -102,16 +99,14 @@ export type RootFunction<T> = (dispose: () => void) => T;
 export declare function createRoot<T>(fn: RootFunction<T>, detachedOwner?: typeof Owner): T;
 export type Accessor<T> = () => T;
 export type Setter<in out T> = {
-  <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
-  <U extends T>(...args: undefined extends T ? [] : [value: (prev: T) => U]): undefined extends T
-    ? undefined
-    : U;
-  <U extends T>(value: Exclude<U, Function>): U;
-  <U extends T>(value: (prev: T) => U): U;
+    <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
+    <U extends T>(...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]): undefined extends T ? undefined : U;
+    <U extends T>(value: (prev: T) => U): U;
+    <U extends T>(value: Exclude<U, Function>): U;
 };
 export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
 export interface SignalOptions<T> extends MemoOptions<T> {
-  internal?: boolean;
+    internal?: boolean;
 }
 /**
  * Creates a simple reactive state with a getter and setter
@@ -139,10 +134,11 @@ export interface SignalOptions<T> extends MemoOptions<T> {
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
 export interface BaseOptions {
-  name?: string;
+    name?: string;
 }
 export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
-export interface EffectOptions extends BaseOptions {}
+export interface EffectOptions extends BaseOptions {
+}
 export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
 /**
  * Creates a reactive computation that runs immediately before render, mainly used to write to other reactive primitives
@@ -159,14 +155,8 @@ export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-computed
  */
-export declare function createComputed<Next>(
-  fn: EffectFunction<undefined | NoInfer<Next>, Next>
-): void;
-export declare function createComputed<Next, Init = Next>(
-  fn: EffectFunction<Init | Next, Next>,
-  value: Init,
-  options?: EffectOptions
-): void;
+export declare function createComputed<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
+export declare function createComputed<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
  * ```typescript
@@ -182,14 +172,8 @@ export declare function createComputed<Next, Init = Next>(
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
  */
-export declare function createRenderEffect<Next>(
-  fn: EffectFunction<undefined | NoInfer<Next>, Next>
-): void;
-export declare function createRenderEffect<Next, Init = Next>(
-  fn: EffectFunction<Init | Next, Next>,
-  value: Init,
-  options?: EffectOptions
-): void;
+export declare function createRenderEffect<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
+export declare function createRenderEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
 /**
  * Creates a reactive computation that runs after the render phase
  * ```typescript
@@ -205,16 +189,10 @@ export declare function createRenderEffect<Next, Init = Next>(
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
-export declare function createEffect<Next>(
-  fn: EffectFunction<undefined | NoInfer<Next>, Next>
-): void;
-export declare function createEffect<Next, Init = Next>(
-  fn: EffectFunction<Init | Next, Next>,
-  value: Init,
-  options?: EffectOptions & {
+export declare function createEffect<Next>(fn: EffectFunction<undefined | NoInfer<Next>, Next>): void;
+export declare function createEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions & {
     render?: boolean;
-  }
-): void;
+}): void;
 /**
  * Creates a reactive computation that runs after the render phase with flexible tracking
  * ```typescript
@@ -228,16 +206,13 @@ export declare function createEffect<Next, Init = Next>(
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
  */
-export declare function createReaction(
-  onInvalidate: () => void,
-  options?: EffectOptions
-): (tracking: () => void) => void;
+export declare function createReaction(onInvalidate: () => void, options?: EffectOptions): (tracking: () => void) => void;
 export interface Memo<Prev, Next = Prev> extends SignalState<Next>, Computation<Next> {
-  value: Next;
-  tOwned?: Computation<Prev | Next, Next>[];
+    value: Next;
+    tOwned?: Computation<Prev | Next, Next>[];
 }
 export interface MemoOptions<T> extends EffectOptions {
-  equals?: false | ((prev: T, next: T) => boolean);
+    equals?: false | ((prev: T, next: T) => boolean);
 }
 /**
  * Creates a readonly derived reactive memoized signal
@@ -254,84 +229,72 @@ export interface MemoOptions<T> extends EffectOptions {
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
  */
-export declare function createMemo<Next extends Prev, Prev = Next>(
-  fn: EffectFunction<undefined | NoInfer<Prev>, Next>
-): Accessor<Next>;
-export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(
-  fn: EffectFunction<Init | Prev, Next>,
-  value: Init,
-  options?: MemoOptions<Next>
-): Accessor<Next>;
+export declare function createMemo<Next extends Prev, Prev = Next>(fn: EffectFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
+export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(fn: EffectFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
 interface Unresolved {
-  state: "unresolved";
-  loading: false;
-  error: undefined;
-  latest: undefined;
-  (): undefined;
+    state: "unresolved";
+    loading: false;
+    error: undefined;
+    latest: undefined;
+    (): undefined;
 }
 interface Pending {
-  state: "pending";
-  loading: true;
-  error: undefined;
-  latest: undefined;
-  (): undefined;
+    state: "pending";
+    loading: true;
+    error: undefined;
+    latest: undefined;
+    (): undefined;
 }
 interface Ready<T> {
-  state: "ready";
-  loading: false;
-  error: undefined;
-  latest: T;
-  (): T;
+    state: "ready";
+    loading: false;
+    error: undefined;
+    latest: T;
+    (): T;
 }
 interface Refreshing<T> {
-  state: "refreshing";
-  loading: true;
-  error: undefined;
-  latest: T;
-  (): T;
+    state: "refreshing";
+    loading: true;
+    error: undefined;
+    latest: T;
+    (): T;
 }
 interface Errored {
-  state: "errored";
-  loading: false;
-  error: any;
-  latest: never;
-  (): never;
+    state: "errored";
+    loading: false;
+    error: any;
+    latest: never;
+    (): never;
 }
 export type Resource<T> = Unresolved | Pending | Ready<T> | Refreshing<T> | Errored;
 export type InitializedResource<T> = Ready<T> | Refreshing<T> | Errored;
 export type ResourceActions<T, R = unknown> = {
-  mutate: Setter<T>;
-  refetch: (info?: R) => T | Promise<T> | undefined | null;
+    mutate: Setter<T>;
+    refetch: (info?: R) => T | Promise<T> | undefined | null;
 };
 export type ResourceSource<S> = S | false | null | undefined | (() => S | false | null | undefined);
-export type ResourceFetcher<S, T, R = unknown> = (
-  k: S,
-  info: ResourceFetcherInfo<T, R>
-) => T | Promise<T>;
+export type ResourceFetcher<S, T, R = unknown> = (k: S, info: ResourceFetcherInfo<T, R>) => T | Promise<T>;
 export type ResourceFetcherInfo<T, R = unknown> = {
-  value: T | undefined;
-  refetching: R | boolean;
+    value: T | undefined;
+    refetching: R | boolean;
 };
 export type ResourceOptions<T, S = unknown> = {
-  initialValue?: T;
-  name?: string;
-  deferStream?: boolean;
-  ssrLoadFrom?: "initial" | "server";
-  storage?: (init: T | undefined) => [Accessor<T | undefined>, Setter<T | undefined>];
-  onHydrated?: (
-    k: S | undefined,
-    info: {
-      value: T | undefined;
-    }
-  ) => void;
+    initialValue?: T;
+    name?: string;
+    deferStream?: boolean;
+    ssrLoadFrom?: "initial" | "server";
+    storage?: (init: T | undefined) => [Accessor<T | undefined>, Setter<T | undefined>];
+    onHydrated?: (k: S | undefined, info: {
+        value: T | undefined;
+    }) => void;
 };
 export type InitializedResourceOptions<T, S = unknown> = ResourceOptions<T, S> & {
-  initialValue: T;
+    initialValue: T;
 };
 export type ResourceReturn<T, R = unknown> = [Resource<T>, ResourceActions<T | undefined, R>];
 export type InitializedResourceReturn<T, R = unknown> = [
-  InitializedResource<T>,
-  ResourceActions<T, R>
+    InitializedResource<T>,
+    ResourceActions<T, R>
 ];
 /**
  * Creates a resource that wraps a repeated promise in a reactive pattern:
@@ -361,28 +324,14 @@ export type InitializedResourceReturn<T, R = unknown> = [
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-resource
  */
-export declare function createResource<T, R = unknown>(
-  fetcher: ResourceFetcher<true, T, R>,
-  options: InitializedResourceOptions<NoInfer<T>, true>
-): InitializedResourceReturn<T, R>;
-export declare function createResource<T, R = unknown>(
-  fetcher: ResourceFetcher<true, T, R>,
-  options?: ResourceOptions<NoInfer<T>, true>
-): ResourceReturn<T, R>;
-export declare function createResource<T, S, R = unknown>(
-  source: ResourceSource<S>,
-  fetcher: ResourceFetcher<S, T, R>,
-  options: InitializedResourceOptions<NoInfer<T>, S>
-): InitializedResourceReturn<T, R>;
-export declare function createResource<T, S, R = unknown>(
-  source: ResourceSource<S>,
-  fetcher: ResourceFetcher<S, T, R>,
-  options?: ResourceOptions<NoInfer<T>, S>
-): ResourceReturn<T, R>;
+export declare function createResource<T, R = unknown>(fetcher: ResourceFetcher<true, T, R>, options: InitializedResourceOptions<NoInfer<T>, true>): InitializedResourceReturn<T, R>;
+export declare function createResource<T, R = unknown>(fetcher: ResourceFetcher<true, T, R>, options?: ResourceOptions<NoInfer<T>, true>): ResourceReturn<T, R>;
+export declare function createResource<T, S, R = unknown>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T, R>, options: InitializedResourceOptions<NoInfer<T>, S>): InitializedResourceReturn<T, R>;
+export declare function createResource<T, S, R = unknown>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T, R>, options?: ResourceOptions<NoInfer<T>, S>): ResourceReturn<T, R>;
 export interface DeferredOptions<T> {
-  equals?: false | ((prev: T, next: T) => boolean);
-  name?: string;
-  timeoutMs?: number;
+    equals?: false | ((prev: T, next: T) => boolean);
+    name?: string;
+    timeoutMs?: number;
 }
 /**
  * Creates a reactive computation that only runs and notifies the reactive context when the browser is idle
@@ -397,10 +346,7 @@ export interface DeferredOptions<T> {
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-deferred
  */
-export declare function createDeferred<T>(
-  source: Accessor<T>,
-  options?: DeferredOptions<T>
-): Accessor<T>;
+export declare function createDeferred<T>(source: Accessor<T>, options?: DeferredOptions<T>): Accessor<T>;
 export type EqualityCheckerFunction<T, U> = (a: U, b: T) => boolean;
 /**
  * Creates a conditional signal that only notifies subscribers when entering or exiting their key matching the value
@@ -426,11 +372,7 @@ export type EqualityCheckerFunction<T, U> = (a: U, b: T) => boolean;
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-selector
  */
-export declare function createSelector<T, U = T>(
-  source: Accessor<T>,
-  fn?: EqualityCheckerFunction<T, U>,
-  options?: BaseOptions
-): (key: U) => boolean;
+export declare function createSelector<T, U = T>(source: Accessor<T>, fn?: EqualityCheckerFunction<T, U>, options?: BaseOptions): (key: U) => boolean;
 /**
  * Holds changes inside the block before the reactive context is updated
  * @param fn wraps the reactive updates that should be batched
@@ -448,28 +390,15 @@ export declare function batch<T>(fn: Accessor<T>): T;
  */
 export declare function untrack<T>(fn: Accessor<T>): T;
 /** @deprecated */
-export type ReturnTypes<T> = T extends readonly Accessor<unknown>[]
-  ? {
-      [K in keyof T]: T[K] extends Accessor<infer I> ? I : never;
-    }
-  : T extends Accessor<infer I>
-  ? I
-  : never;
-export type AccessorArray<T> = [
-  ...Extract<
-    {
-      [K in keyof T]: Accessor<T[K]>;
-    },
-    readonly unknown[]
-  >
-];
-export type OnEffectFunction<S, Prev, Next extends Prev = Prev> = (
-  input: S,
-  prevInput: S | undefined,
-  prev: Prev
-) => Next;
+export type ReturnTypes<T> = T extends readonly Accessor<unknown>[] ? {
+    [K in keyof T]: T[K] extends Accessor<infer I> ? I : never;
+} : T extends Accessor<infer I> ? I : never;
+export type AccessorArray<T> = [...Extract<{
+    [K in keyof T]: Accessor<T[K]>;
+}, readonly unknown[]>];
+export type OnEffectFunction<S, Prev, Next extends Prev = Prev> = (input: S, prevInput: S | undefined, prev: Prev) => Next;
 export interface OnOptions {
-  defer?: boolean;
+    defer?: boolean;
 }
 /**
  * Makes dependencies of a computation explicit
@@ -497,22 +426,12 @@ export interface OnOptions {
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/on
  */
-export declare function on<S, Next extends Prev, Prev = Next>(
-  deps: AccessorArray<S> | Accessor<S>,
-  fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>,
-  options?: OnOptions & {
+export declare function on<S, Next extends Prev, Prev = Next>(deps: AccessorArray<S> | Accessor<S>, fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>, options?: OnOptions & {
     defer?: false;
-  }
-): EffectFunction<undefined | NoInfer<Next>, NoInfer<Next>>;
-export declare function on<S, Next extends Prev, Prev = Next>(
-  deps: AccessorArray<S> | Accessor<S>,
-  fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>,
-  options:
-    | OnOptions
-    | {
-        defer: true;
-      }
-): EffectFunction<undefined | NoInfer<Next>>;
+}): EffectFunction<undefined | NoInfer<Next>, NoInfer<Next>>;
+export declare function on<S, Next extends Prev, Prev = Next>(deps: AccessorArray<S> | Accessor<S>, fn: OnEffectFunction<S, undefined | NoInfer<Prev>, Next>, options: OnOptions | {
+    defer: true;
+}): EffectFunction<undefined | NoInfer<Next>>;
 /**
  * Runs an effect only after initial render on mount
  * @param fn an effect that should run only once on mount
@@ -566,19 +485,19 @@ export type Transition = [Accessor<boolean>, (fn: () => void) => Promise<void>];
 export declare function useTransition(): Transition;
 export declare function resumeEffects(e: Computation<any>[]): void;
 export interface DevComponent<T> extends Memo<unknown> {
-  props: T;
-  name: string;
-  component: (props: T) => unknown;
+    props: T;
+    name: string;
+    component: (props: T) => unknown;
 }
 export declare function devComponent<P, V>(Comp: (props: P) => V, props: P): V;
 export declare function registerGraph(value: SourceMapValue): void;
 export type ContextProviderComponent<T> = FlowComponent<{
-  value: T;
+    value: T;
 }>;
 export interface Context<T> {
-  id: symbol;
-  Provider: ContextProviderComponent<T>;
-  defaultValue: T;
+    id: symbol;
+    Provider: ContextProviderComponent<T>;
+    defaultValue: T;
 }
 /**
  * Creates a Context to handle a state scoped for the children of a component
@@ -599,10 +518,7 @@ export interface Context<T> {
  *
  * @description https://docs.solidjs.com/reference/component-apis/create-context
  */
-export declare function createContext<T>(
-  defaultValue?: undefined,
-  options?: EffectOptions
-): Context<T | undefined>;
+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
@@ -616,7 +532,7 @@ 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[];
+    toArray: () => ResolvedJSXElement[];
 };
 /**
  * Resolves child elements to help interact with children
@@ -628,29 +544,22 @@ export type ChildrenReturn = Accessor<ResolvedChildren> & {
  */
 export declare function children(fn: Accessor<JSX.Element>): ChildrenReturn;
 export type SuspenseContextType = {
-  increment?: () => void;
-  decrement?: () => void;
-  inFallback?: () => boolean;
-  effects?: Computation<any>[];
-  resolved?: boolean;
+    increment?: () => void;
+    decrement?: () => void;
+    inFallback?: () => boolean;
+    effects?: Computation<any>[];
+    resolved?: boolean;
 };
 type SuspenseContext = Context<SuspenseContextType | undefined> & {
-  active?(): boolean;
-  increment?(): void;
-  decrement?(): void;
+    active?(): boolean;
+    increment?(): void;
+    decrement?(): void;
 };
 declare let SuspenseContext: SuspenseContext;
 export declare function getSuspenseContext(): SuspenseContext;
-export declare function enableExternalSource(
-  factory: ExternalSourceFactory,
-  untrack?: <V>(fn: () => V) => V
-): void;
+export declare function enableExternalSource(factory: ExternalSourceFactory, untrack?: <V>(fn: () => V) => V): void;
 export declare function readSignal(this: SignalState<any> | Memo<any>): any;
-export declare function writeSignal(
-  node: SignalState<any> | Memo<any>,
-  value: any,
-  isComp?: boolean
-): any;
+export declare function writeSignal(node: SignalState<any> | Memo<any>, value: any, isComp?: boolean): any;
 /**
  * @deprecated since version 1.7.0 and will be removed in next major - use catchError instead
  * onError - run an effect whenever an error is thrown within the context of the child scopes

package/types/render/Suspense.d.ts

@@ -5,9 +5,9 @@ import type { JSX } from "../jsx.js";
  * @description https://docs.solidjs.com/reference/components/suspense-list
  */
 export declare function SuspenseList(props: {
-  children: JSX.Element;
-  revealOrder: "forwards" | "backwards" | "together";
-  tail?: "collapsed" | "hidden";
+    children: JSX.Element;
+    revealOrder: "forwards" | "backwards" | "together";
+    tail?: "collapsed" | "hidden";
 }): JSX.Element;
 /**
  * Tracks all resources inside a component and renders a fallback until they are all resolved
@@ -21,6 +21,6 @@ export declare function SuspenseList(props: {
  * @description https://docs.solidjs.com/reference/components/suspense
  */
 export declare function Suspense(props: {
-  fallback?: JSX.Element;
-  children: JSX.Element;
+    fallback?: JSX.Element;
+    children: JSX.Element;
 }): JSX.Element;