solid-js 1.8.19 → 1.8.21

package/types/reactive/array.d.ts

@@ -29,9 +29,13 @@ SOFTWARE.
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
  */
-export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: T, i: Accessor<number>) => U, options?: {
+export declare function mapArray<T, U>(
+  list: Accessor<readonly T[] | undefined | null | false>,
+  mapFn: (v: T, i: Accessor<number>) => U,
+  options?: {
     fallback?: Accessor<any>;
-}): () => U[];
+  }
+): () => U[];
 /**
  * Reactively maps arrays by index instead of value - underlying helper for the `<Index>` control flow
  *
@@ -39,6 +43,10 @@ export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined |
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/index-array
  */
-export declare function indexArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: number) => U, options?: {
+export declare function indexArray<T, U>(
+  list: Accessor<readonly T[] | undefined | null | false>,
+  mapFn: (v: Accessor<T>, i: number) => U,
+  options?: {
     fallback?: Accessor<any>;
-}): () => U[];
+  }
+): () => U[];

package/types/reactive/observable.d.ts

@@ -1,20 +1,22 @@
 import { Accessor, Setter } from "./signal.js";
 declare global {
-    interface SymbolConstructor {
-        readonly observable: symbol;
-    }
+  interface SymbolConstructor {
+    readonly observable: symbol;
+  }
 }
 interface Observable<T> {
-    subscribe(observer: ObservableObserver<T>): {
-        unsubscribe(): void;
-    };
-    [Symbol.observable](): Observable<T>;
+  subscribe(observer: ObservableObserver<T>): {
+    unsubscribe(): void;
+  };
+  [Symbol.observable](): Observable<T>;
 }
-export type ObservableObserver<T> = ((v: T) => void) | {
-    next?: (v: T) => void;
-    error?: (v: any) => void;
-    complete?: (v: boolean) => void;
-};
+export type ObservableObserver<T> =
+  | ((v: T) => void)
+  | {
+      next?: (v: T) => void;
+      error?: (v: any) => void;
+      complete?: (v: boolean) => void;
+    };
 /**
  * Creates a simple observable from a signal's accessor to be used with the `from` operator of observable libraries like e.g. rxjs
  * ```typescript
@@ -26,9 +28,15 @@ export type ObservableObserver<T> = ((v: T) => void) | {
  * description https://docs.solidjs.com/reference/reactive-utilities/observable
  */
 export declare function observable<T>(input: Accessor<T>): Observable<T>;
-export declare function from<T>(producer: ((setter: Setter<T | undefined>) => () => void) | {
-    subscribe: (fn: (v: T) => void) => (() => void) | {
-        unsubscribe: () => void;
-    };
-}): Accessor<T | undefined>;
+export declare function from<T>(
+  producer:
+    | ((setter: Setter<T | undefined>) => () => void)
+    | {
+        subscribe: (fn: (v: T) => void) =>
+          | (() => void)
+          | {
+              unsubscribe: () => void;
+            };
+      }
+): Accessor<T | undefined>;
 export {};

package/types/reactive/scheduler.d.ts

@@ -1,10 +1,13 @@
 export interface Task {
-    id: number;
-    fn: ((didTimeout: boolean) => void) | null;
-    startTime: number;
-    expirationTime: number;
+  id: number;
+  fn: ((didTimeout: boolean) => void) | null;
+  startTime: number;
+  expirationTime: number;
 }
-export declare function requestCallback(fn: () => void, options?: {
+export declare function requestCallback(
+  fn: () => void,
+  options?: {
     timeout: number;
-}): Task;
+  }
+): Task;
 export declare function cancelCallback(task: Task): void;

package/types/reactive/signal.d.ts

@@ -32,58 +32,61 @@ 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;
 /**
@@ -98,14 +101,16 @@ 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>(...args: undefined extends T ? [] : [value: (prev: T) => U]): undefined extends T ? undefined : U;
-    <U extends T>(value: (prev: T) => U): U;
-    <U extends T>(value: Exclude<U, Function>): U;
-    <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: (prev: T) => U): U;
+  <U extends T>(value: Exclude<U, Function>): U;
+  <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): 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
@@ -133,11 +138,10 @@ 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
@@ -154,8 +158,14 @@ 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
@@ -171,8 +181,14 @@ export declare function createComputed<Next, Init = Next>(fn: EffectFunction<Ini
  *
  * @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
@@ -188,10 +204,16 @@ export declare function createRenderEffect<Next, Init = Next>(fn: EffectFunction
  *
  * @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
@@ -205,13 +227,16 @@ export declare function createEffect<Next, Init = Next>(fn: EffectFunction<Init
  *
  * @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
@@ -228,72 +253,84 @@ 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:
@@ -323,14 +360,28 @@ 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
@@ -345,7 +396,10 @@ 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
@@ -371,7 +425,11 @@ 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
@@ -389,15 +447,28 @@ 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
@@ -425,12 +496,22 @@ export interface OnOptions {
  *
  * @description https://docs.solidjs.com/reference/jsx-attributes/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
@@ -483,19 +564,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
@@ -516,7 +597,10 @@ 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
@@ -530,7 +614,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
@@ -542,22 +626,29 @@ 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