solid-js/types/reactive/signal.d.ts

A declarative JavaScript library for building user interfaces.

import { requestCallback } from "./scheduler";
import type { JSX } from "../jsx";
export declare type Accessor<T> = () => T;
export declare type Setter<T> = undefined extends T ? <U extends T>(v?: (U extends Function ? never : U) | ((prev?: U) => U)) => U : <U extends T>(v: (U extends Function ? never : U) | ((prev: U) => U)) => U;
export declare const equalFn: <T>(a: T, b: T) => boolean;
export declare const $PROXY: unique symbol;
export declare const NOTPENDING: {};
export declare var Owner: Owner | null;
export declare let Transition: Transition | null;
declare global {
    var _$afterUpdate: () => void;
}
interface Signal<T> {
    value?: T;
    observers: Computation<any>[] | null;
    observerSlots: number[] | null;
    pending: T | {};
    tValue?: T;
    comparator?: (prev: T, next: T) => boolean;
    name?: string;
}
interface Owner {
    owned: Computation<any>[] | null;
    cleanups: (() => void)[] | null;
    owner: Owner | null;
    context: any | null;
    sourceMap?: Record<string, {
        value: unknown;
    }>;
    name?: string;
    componentName?: string;
}
interface Computation<T> extends Owner {
    fn: (v?: T) => T;
    state: number;
    tState?: number;
    sources: Signal<T>[] | null;
    sourceSlots: number[] | null;
    value?: T;
    updatedAt: number | null;
    pure: boolean;
    user?: boolean;
    suspense?: SuspenseContextType;
}
interface Memo<T> extends Signal<T>, Computation<T> {
    tOwned?: Computation<any>[];
}
interface Transition {
    sources: Set<Signal<any>>;
    effects: Computation<any>[];
    promises: Set<Promise<any>>;
    disposed: Set<Computation<any>>;
    queue: Set<Computation<any>>;
    scheduler?: (fn: () => void) => unknown;
    running: boolean;
    cb: (() => void)[];
}
export declare function createRoot<T>(fn: (dispose: () => void) => T, detachedOwner?: Owner): T;
export declare function createSignal<T>(): [get: Accessor<T | undefined>, set: Setter<T | undefined>];
export declare function createSignal<T>(value: T, options?: {
    equals?: false | ((prev: T, next: T) => boolean);
    name?: string;
    internal?: boolean;
}): [get: Accessor<T>, set: Setter<T>];
export declare function createComputed<T>(fn: (v?: T) => T | undefined): void;
export declare function createComputed<T>(fn: (v: T) => T, value: T, options?: {
    name?: string;
}): void;
export declare function createRenderEffect<T>(fn: (v?: T) => T | undefined): void;
export declare function createRenderEffect<T>(fn: (v: T) => T, value: T, options?: {
    name?: string;
}): void;
export declare function createEffect<T>(fn: (v?: T) => T | undefined): void;
export declare function createEffect<T>(fn: (v: T) => T, value: T, options?: {
    name?: string;
}): void;
export declare function createMemo<T>(fn: (v?: T) => T, value?: undefined, options?: {
    equals?: false | ((prev: T, next: T) => boolean);
    name?: string;
}): Accessor<T>;
export declare function createMemo<T>(fn: (v: T) => T, value: T, options?: {
    equals?: false | ((prev: T, next: T) => boolean);
    name?: string;
}): Accessor<T>;
export interface Resource<T> extends Accessor<T> {
    loading: boolean;
    error: any;
}
export declare type ResourceReturn<T> = [
    Resource<T>,
    {
        mutate: Setter<T>;
        refetch: () => void;
    }
];
export declare function createResource<T, U = true>(fetcher: (k: U, getPrev: Accessor<T | undefined>) => T | Promise<T>, options?: {
    initialValue?: undefined;
    name?: string;
}): ResourceReturn<T | undefined>;
export declare function createResource<T, U = true>(fetcher: (k: U, getPrev: Accessor<T>) => T | Promise<T>, options: {
    initialValue: T;
    name?: string;
}): ResourceReturn<T>;
export declare function createResource<T, U>(source: U | false | null | (() => U | false | null), fetcher: (k: U, getPrev: Accessor<T | undefined>) => T | Promise<T>, options?: {
    initialValue?: undefined;
    name?: string;
}): ResourceReturn<T | undefined>;
export declare function createResource<T, U>(source: U | false | null | (() => U | false | null), fetcher: (k: U, getPrev: Accessor<T>) => T | Promise<T>, options: {
    initialValue: T;
    name?: string;
}): ResourceReturn<T>;
export declare function createDeferred<T>(source: Accessor<T>, options?: {
    equals?: false | ((prev: T, next: T) => boolean);
    name?: string;
    timeoutMs?: number;
}): Accessor<T>;
export declare function createSelector<T, U>(source: Accessor<T>, fn?: (a: U, b: T) => boolean, options?: {
    name?: string;
}): (key: U) => boolean;
export declare function batch<T>(fn: () => T): T;
export declare function untrack<T>(fn: Accessor<T>): T;
export declare type ReturnTypes<T> = T extends (() => any)[] ? {
    [I in keyof T]: ReturnTypes<T[I]>;
} : T extends () => any ? ReturnType<T> : never;
export declare function on<T extends (() => any)[], U>(deps: [...T], fn: (input: ReturnTypes<T>, prevInput: ReturnTypes<T>, prevValue?: U) => U, options?: {
    defer?: boolean;
}): (prevValue?: U) => U;
export declare function on<T extends () => any, U>(deps: T, fn: (input: ReturnType<T>, prevInput: ReturnType<T>, prevValue?: U) => U, options?: {
    defer?: boolean;
}): (prevValue?: U) => U;
export declare function onMount(fn: () => void): void;
export declare function onCleanup(fn: () => void): () => void;
export declare function onError(fn: (err: any) => void): void;
export declare function getListener(): Computation<any> | null;
export declare function getOwner(): Owner | null;
export declare function runWithOwner(o: Owner, fn: () => any): any;
export declare function enableScheduling(scheduler?: typeof requestCallback): void;
export declare function startTransition(fn: () => void, cb?: () => void): void;
export declare function useTransition(): [Accessor<boolean>, (fn: () => void, cb?: () => void) => void];
export declare function resumeEffects(e: Computation<any>[]): void;
export declare function devComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
export declare function hashValue(v: any): string;
export declare function registerGraph(name: string, value: {
    value: unknown;
}): string;
interface GraphRecord {
    [k: string]: GraphRecord | unknown;
}
export declare function serializeGraph(owner?: Owner | null): GraphRecord;
export interface Context<T> {
    id: symbol;
    Provider: (props: {
        value: T;
        children: any;
    }) => any;
    defaultValue: T;
}
export declare function createContext<T>(): Context<T | undefined>;
export declare function createContext<T>(defaultValue: T): Context<T>;
export declare function useContext<T>(context: Context<T>): T;
export declare function children(fn: Accessor<JSX.Element>): Accessor<JSX.Element>;
declare type SuspenseContextType = {
    increment?: () => void;
    decrement?: () => void;
    inFallback?: () => boolean;
    effects?: Computation<any>[];
    resolved?: boolean;
};
export declare function getSuspenseContext(): Context<SuspenseContextType> & {
    active?(): boolean;
    increment?(): void;
    decrement?(): void;
};
export declare function readSignal(this: Signal<any> | Memo<any>): any;
export declare function writeSignal(node: Signal<any> | Memo<any>, value: any, isComp?: boolean): any;
export {};