solid-js 1.1.2 → 1.1.6-beta.0

package/types/reactive/signal.d.ts

@@ -15,7 +15,6 @@ interface Signal<T> {
     observers: Computation<any>[] | null;
     observerSlots: number[] | null;
     pending: T | {};
-    tValue?: T;
     comparator?: (prev: T, next: T) => boolean;
     name?: string;
 }
@@ -33,47 +32,140 @@ interface Owner {
 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;
+    updatedAt: number;
     pure: boolean;
     user?: boolean;
     suspense?: SuspenseContextType;
 }
-interface Memo<T> extends Signal<T>, Computation<T> {
-    tOwned?: Computation<any>[];
-}
 interface Transition {
-    sources: Set<Signal<any>>;
+    sources: Set<Signal<any> | Computation<any>>;
+    lookup: Map<Signal<any> | Computation<any>, Signal<any> | Computation<any>>;
+    updated: Set<Computation<any>>;
     effects: Computation<any>[];
     promises: Set<Promise<any>>;
-    disposed: Set<Computation<any>>;
     queue: Set<Computation<any>>;
     scheduler?: (fn: () => void) => unknown;
     running: boolean;
     cb: (() => void)[];
 }
+/**
+ * Creates a new non-tracked reactive context that doesn't auto-dispose
+ *
+ * @param fn a function in which the reactive state is scoped
+ * @param detachedOwner optional reactive context to bind the root to
+ * @returns the output of `fn`.
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createroot
+ */
 export declare function createRoot<T>(fn: (dispose: () => void) => T, detachedOwner?: Owner): T;
+export declare type SignalOptions<T> = {
+    name?: string;
+    equals?: false | ((prev: T, next: T) => boolean);
+};
+/**
+ * Creates a simple reactive state with a getter and setter
+ * ```typescript
+ * const [state: Accessor<T>, setState: Setter<T>] = createSignal<T>(
+ *  value: T,
+ *  options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * )
+ * ```
+ * @param value initial value of the state; if empty, the state's type will automatically extended with undefined; otherwise you need to extend the type manually if you want setting to undefined not be an error
+ * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
+ *
+ * @returns ```typescript
+ * [state: Accessor<T>, setState: Setter<T>]
+ * ```
+ * * the Accessor is merely a function that returns the current value and registers each call to the reactive root
+ * * the Setter is a function that allows directly setting or mutating the value:
+ * ```typescript
+ * const [count, setCount] = createSignal(0);
+ * setCount(count => count + 1);
+ * ```
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createsignal
+ */
 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>];
+/**
+ * Creates a reactive computation that runs immediately before render, mainly used to write to other reactive primitives
+ * ```typescript
+ * export function createComputed<T>(
+ *   fn: (v: T) => T,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createcomputed
+ */
 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;
+/**
+ * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
+ * ```typescript
+ * export function createRenderEffect<T>(
+ *   fn: (v: T) => T,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createrendereffect
+ */
 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;
+/**
+ * Creates a reactive computation that runs after the render phase
+ * ```typescript
+ * export function createEffect<T>(
+ *   fn: (v: T) => T,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createeffect
+ */
 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;
+/**
+ * Creates a readonly derived reactive memoized signal
+ * ```typescript
+ * export function createMemo<T>(
+ *   fn: (v: T) => T,
+ *   value?: T,
+ *   options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * ): T;
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set a name in dev mode for debugging purposes and use a custom comparison function in equals
+ *
+ * @description https://www.solidjs.com/docs/latest/api#creatememo
+ */
 export declare function createMemo<T>(fn: (v?: T) => T, value?: undefined, options?: {
     equals?: false | ((prev: T, next: T) => boolean);
     name?: string;
@@ -86,56 +178,183 @@ 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;
+export declare type ResourceActions<T> = {
+    mutate: Setter<T>;
+    refetch: () => void;
+};
+export declare type ResourceReturn<T> = [Resource<T>, ResourceActions<T>];
+export declare type ResourceSource<S> = S | false | null | (() => S | false | null);
+export declare type ResourceFetcher<S, T> = (k: S, getPrev: Accessor<T>) => T | Promise<T>;
+export declare type ResourceOptions<T> = T extends undefined ? {
+    initialValue?: T;
     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>;
+};
+/**
+ * Creates a resource that wraps a repeated promise in a reactive pattern:
+ * ```typescript
+ * const [resource, { mutate, refetch }] = crateResource(source, fetcher, options);
+ * ```
+ * @param source - reactive data function to toggle the request, optional
+ * @param fetcher - function that receives the source (or true) and an accessor for the last or initial value and returns a value or a Promise with the value:
+ * ```typescript
+ * const fetcher: ResourceFetcher<S, T, > = (
+ *   sourceOutput: ReturnValue<typeof source>,
+ *   getPrev: Accessor<T>
+ * ) => T | Promise<T>;
+ * ```
+ * @param options - an optional object with the initialValue and the name (for debugging purposes)
+ *
+ * @returns ```typescript
+ * [Resource<T>, { mutate: Setter<T>, refetch: () => void }]
+ * ```
+ *
+ * * Setting an `initialValue` in the options will mean that both the prev() accessor and the resource should never return undefined (if that is wanted, you need to extend the type with undefined)
+ * * `mutate` allows to manually overwrite the resource without calling the fetcher
+ * * `refetch` will re-run the fetcher without changing the source
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createresource
+ */
+export declare function createResource<T extends any, S = true>(fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): [Resource<T | undefined>, ResourceActions<T | undefined>];
+export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): [Resource<T>, ResourceActions<T>];
+export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): [Resource<T | undefined>, ResourceActions<T | undefined>];
+export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): [Resource<T>, ResourceActions<T>];
+/**
+ * Creates a reactive computation that only runs and notifies the reactive context when the browser is idle
+ * ```typescript
+ * export function createDeferred<T>(
+ *   fn: (v: T) => T,
+ *   value?: T,
+ *   options?: { timeoutMs?: number, name?: string, equals?: false | ((prev: T, next: T) => boolean) }
+ * ): () => T);
+ * ```
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param options allows to set the timeout in milliseconds, use a custom comparison function and set a name in dev mode for debugging purposes
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createdeferred
+ */
 export declare function createDeferred<T>(source: Accessor<T>, options?: {
     equals?: false | ((prev: T, next: T) => boolean);
     name?: string;
     timeoutMs?: number;
 }): Accessor<T>;
+/**
+ * Creates a conditional signal that only notifies subscribers when entering or exiting their key matching the value
+ * ```typescript
+ * export function createRenderEffect<T, U>(
+ *   source: () => T
+ *   fn: (a: U, b: T) => boolean,
+ *   options?: { name?: string }
+ * ): (k: U) => boolean;
+ * ```
+ * @param source
+ * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param options allows to set a name in dev mode for debugging purposes, optional
+ *
+ * ```typescript
+ * const isSelected = createSelector(selectedId);
+ * <For each={list()}>
+ *   {(item) => <li classList={{ active: isSelected(item.id) }}>{item.name}</li>}
+ * </For>
+ * ```
+ *
+ * This makes the operation O(2) instead of O(n).
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createrendereffect
+ */
 export declare function createSelector<T, U>(source: Accessor<T>, fn?: (a: U, b: T) => boolean, options?: {
     name?: string;
 }): (key: U) => boolean;
+/**
+ * Holds changes inside the block before the reactive context is updated
+ * @param fn wraps the reactive updates that should be batched
+ * @returns the return value from `fn`
+ *
+ * @description https://www.solidjs.com/docs/latest/api#batch
+ */
 export declare function batch<T>(fn: () => T): T;
+/**
+ * Ignores tracking context inside its scope
+ * @param fn the scope that is out of the tracking context
+ * @returns the return value of `fn`
+ *
+ * @description https://www.solidjs.com/docs/latest/api#untrack
+ */
 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;
+/**
+ * on - make dependencies of a computation explicit
+ * ```typescript
+ * export function on<T extends Array<() => any> | (() => any), U>(
+ *   deps: T | T[],
+ *   fn: (input: T, prevInput: T, prevValue?: U) => U,
+ *   options?: { defer?: boolean } = {}
+ * ): (prevValue?: U) => U | undefined;
+ * ```
+ * @param deps list of reactive dependencies or a single reactive dependency
+ * @param fn computation on input; the current previous content(s) of input and the previous value are given as arguments and it returns a new value
+ * @param options optional, allows deferred computation until at the end of the next change
+ * ```typescript
+ * createEffect(on(a, (v) => console.log(v, b())));
+ *
+ * // is equivalent to:
+ * createEffect(() => {
+ *   const v = a();
+ *   untrack(() => console.log(v, b()));
+ * });
+ * ```
+ *
+ * @description https://www.solidjs.com/docs/latest/api#on
+ */
 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;
+/**
+ * onMount - run an effect only after initial render on mount
+ * @param fn an effect that should run only once on mount
+ *
+ * @description https://www.solidjs.com/docs/latest/api#onmount
+ */
 export declare function onMount(fn: () => void): void;
+/**
+ * onCleanup - run an effect once before the reactive scope is disposed
+ * @param fn an effect that should run only once on cleanup
+ *
+ * @description https://www.solidjs.com/docs/latest/api#oncleanup
+ */
 export declare function onCleanup(fn: () => void): () => void;
+/**
+ * onError - run an effect whenever an error is thrown within the context of the child scopes
+ * @param fn an error handler that receives the error
+ *
+ * * If the error is thrown again inside the error handler, it will trigger the next available parent handler
+ *
+ * @description https://www.solidjs.com/docs/latest/api#onerror
+ */
 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;
+/**
+ * ```typescript
+ * export function useTransition(): [
+ *   () => boolean,
+ *   (fn: () => void, cb?: () => void) => void
+ * ];
+ * @returns a tuple; first value is an accessor if the transition is pending and a callback to start the transition
+ *
+ * @description https://www.solidjs.com/docs/latest/api#usetransition
+ */
 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;
@@ -155,9 +374,40 @@ export interface Context<T> {
     }) => any;
     defaultValue: T;
 }
+/**
+ * Creates a Context to handle a state scoped for the children of a component
+ * ```typescript
+ * interface Context<T> {
+ *   id: symbol;
+ *   Provider: (props: { value: T; children: any }) => any;
+ *   defaultValue: T;
+ * }
+ * export function createContext<T>(defaultValue?: T): Context<T | undefined>;
+ * ```
+ * @param defaultValue optional default to inject into context
+ * @returns The context that contains the Provider Component and that can be used with `useContext`
+ *
+ * @description https://www.solidjs.com/docs/latest/api#createcontext
+ */
 export declare function createContext<T>(): Context<T | undefined>;
 export declare function createContext<T>(defaultValue: T): Context<T>;
+/**
+ * use 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
+ *
+ * @description https://www.solidjs.com/docs/latest/api#usecontext
+ */
 export declare function useContext<T>(context: Context<T>): T;
+/**
+ * Resolves child elements to help interact with children
+ *
+ * @param fn an accessor for the children
+ * @returns a accessor of the same children, but resolved
+ *
+ * @description https://www.solidjs.com/docs/latest/api#children
+ */
 export declare function children(fn: Accessor<JSX.Element>): Accessor<JSX.Element>;
 declare type SuspenseContextType = {
     increment?: () => void;
@@ -171,6 +421,5 @@ export declare function getSuspenseContext(): Context<SuspenseContextType> & {
     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 declare function writeSignal(node: Signal<any>, value: any): any;
 export {};

package/types/render/Suspense.d.ts

@@ -1,9 +1,25 @@
 import type { JSX } from "../jsx";
+/**
+ * **[experimental]** controls the order in which suspended content is rendered
+ *
+ * @description https://www.solidjs.com/docs/latest/api#%3Csuspenselist%3E-(experimental)
+ */
 export declare function SuspenseList(props: {
     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
+ * ```typescript
+ * const AsyncComponent = lazy(() => import('./component'));
+ *
+ * <Suspense fallback={<LoadingIndicator />}>
+ *   <AsyncComponent />
+ * </Suspense>
+ * ```
+ * @description https://www.solidjs.com/docs/latest/api#%3Csuspense%3E
+ */
 export declare function Suspense(props: {
     fallback?: JSX.Element;
     children: JSX.Element;

package/types/render/component.d.ts

@@ -12,10 +12,15 @@ export declare type Component<P = {}> = (props: PropsWithChildren<P>) => JSX.Ele
  */
 export declare type ComponentProps<T extends keyof JSX.IntrinsicElements | Component<any>> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : {};
 export declare function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
-export declare function mergeProps<T>(source: T): T;
-export declare function mergeProps<T, U>(source: T, source1: U): T & U;
-export declare function mergeProps<T, U, V>(source: T, source1: U, source2: V): T & U & V;
-export declare function mergeProps<T, U, V, W>(source: T, source1: U, source2: V, source3: W): T & U & V & W;
+declare type BoxedTupleTypes<T extends any[]> = {
+    [P in keyof T]: [T[P]];
+}[Exclude<keyof T, keyof any[]>];
+declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+declare type UnboxIntersection<T> = T extends {
+    0: infer U;
+} ? U : never;
+declare type MergeProps<T extends any[]> = UnboxIntersection<UnionToIntersection<BoxedTupleTypes<T>>>;
+export declare function mergeProps<T extends any[]>(...sources: T): MergeProps<T>;
 export declare function splitProps<T extends object, K1 extends keyof T>(props: T, ...keys: [K1[]]): [Pick<T, K1>, Omit<T, K1>];
 export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T>(props: T, ...keys: [K1[], K2[]]): [Pick<T, K1>, Pick<T, K2>, Omit<T, K1 | K2>];
 export declare function splitProps<T extends object, K1 extends keyof T, K2 extends keyof T, K3 extends keyof T>(props: T, ...keys: [K1[], K2[], K3[]]): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Omit<T, K1 | K2 | K3>];
@@ -34,3 +39,4 @@ export declare function lazy<T extends Component<any>>(fn: () => Promise<{
     preload: () => void;
 };
 export declare function createUniqueId(): string;
+export {};

package/types/render/flow.d.ts

@@ -1,29 +1,97 @@
 import { Accessor } from "../reactive/signal";
 import type { JSX } from "../jsx";
+/**
+ * creates a list elements from a list
+ *
+ * it receives a map function as its child that receives a list element and an accessor with the index and returns a JSX-Element; if the list is empty, an optional fallback is returned:
+ * ```typescript
+ * <For each={items} fallback={<div>No items</div>}>
+ *   {(item, index) => <div data-index={index()}>{item}</div>}
+ * </For>
+ * ```
+ * If you have a list with fixed indices and changing values, consider using `<Index>` instead.
+ *
+ * @description https://www.solidjs.com/docs/latest/api#%3Cfor%3E
+ */
 export declare function For<T, U extends JSX.Element>(props: {
     each: readonly T[] | undefined | null | false;
     fallback?: JSX.Element;
     children: (item: T, index: Accessor<number>) => U;
 }): Accessor<U[]>;
+/**
+ * Non-keyed iteration over a list creating elements from its items
+ *
+ * To be used if you have a list with fixed indices, but changing values.
+ * ```typescript
+ * <Index each={items} fallback={<div>No items</div>}>
+ *   {(item, index) => <div data-index={index}>{item()}</div>}
+ * </Index>
+ * ```
+ * If you have a list with changing indices, better use `<For>`.
+ *
+ * @description https://www.solidjs.com/docs/latest/api#%3Cindex%3E
+ */
 export declare function Index<T, U extends JSX.Element>(props: {
     each: readonly T[] | undefined | null | false;
     fallback?: JSX.Element;
     children: (item: Accessor<T>, index: number) => U;
 }): Accessor<U[]>;
+/**
+ * Conditionally render its children or an optional fallback component
+ * @description https://www.solidjs.com/docs/latest/api#%3Cshow%3E
+ */
 export declare function Show<T>(props: {
     when: T | undefined | null | false;
     fallback?: JSX.Element;
-    children: JSX.Element | ((item: T) => JSX.Element);
+    children: JSX.Element | ((item: NonNullable<T>) => JSX.Element);
 }): () => JSX.Element;
+/**
+ * switches between content based on mutually exclusive conditions
+ * ```typescript
+ * <Switch fallback={<FourOhFour />}>
+ *   <Match when={state.route === 'home'}>
+ *     <Home />
+ *   </Match>
+ *   <Match when={state.route === 'settings'}>
+ *     <Settings />
+ *   </Match>
+ * </Switch>
+ * ```
+ * @description https://www.solidjs.com/docs/latest/api#%3Cswitch%3E%2F%3Cmatch%3E
+ */
 export declare function Switch(props: {
     fallback?: JSX.Element;
     children: JSX.Element;
 }): Accessor<JSX.Element>;
 export declare type MatchProps<T> = {
     when: T | undefined | null | false;
-    children: JSX.Element | ((item: T) => JSX.Element);
+    children: JSX.Element | ((item: NonNullable<T>) => JSX.Element);
 };
+/**
+ * selects a content based on condition when inside a `<Switch>` control flow
+ * ```typescript
+ * <Match when={condition()}>
+ *   <Content/>
+ * </Match>
+ * ```
+ * @description https://www.solidjs.com/docs/latest/api#%3Cswitch%3E%2F%3Cmatch%3E
+ */
 export declare function Match<T>(props: MatchProps<T>): JSX.Element;
+/**
+ * catches uncaught errors inside components and renders a fallback content
+ *
+ * Also supports a callback form that passes the error and a reset function:
+ * ```typescript
+ * <ErrorBoundary fallback={
+ *   (err, reset) => <div onClick={reset}>Error: {err.toString()}</div>
+ * }>
+ *   <MyComp />
+ * </ErrorBoundary>
+ * ```
+ * Errors thrown from the fallback can be caught by a parent ErrorBoundary
+ *
+ * @description https://www.solidjs.com/docs/latest/api#%3Cerrorboundary%3E
+ */
 export declare function ErrorBoundary(props: {
     fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
     children: JSX.Element;

package/web/dist/dev.cjs

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var solidJs = require('solid-js');
 
-const booleans = ["allowfullscreen", "allowpaymentrequest", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "ismap", "itemscope", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected", "truespeed"];
-const Properties = new Set(["className", "indeterminate", "value", "readOnly", ...booleans]);
+const booleans = ["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "indeterminate", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected"];
+const Properties = new Set(["className", "value", "readOnly", "formNoValidate", "isMap", "noModule", "playsInline", ...booleans]);
 const ChildProperties = new Set(["innerHTML", "textContent", "innerText", "children"]);
 const Aliases = {
   className: "class",
@@ -13,6 +13,10 @@ const Aliases = {
 };
 const PropAliases = {
   class: "className",
+  formnovalidate: "formNoValidate",
+  ismap: "isMap",
+  nomodule: "noModule",
+  playsinline: "playsInline",
   readonly: "readOnly"
 };
 const DelegatedEvents = new Set(["beforeinput", "click", "dblclick", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"]);
@@ -142,27 +146,27 @@ function addEventListener(node, name, handler, delegate) {
   } else node.addEventListener(name, handler);
 }
 function classList(node, value, prev = {}) {
-  const classKeys = Object.keys(value),
+  const classKeys = Object.keys(value || {}),
         prevKeys = Object.keys(prev);
   let i, len;
   for (i = 0, len = prevKeys.length; i < len; i++) {
     const key = prevKeys[i];
-    if (!key || key === "undefined" || key in value) continue;
+    if (!key || key === "undefined" || value[key]) continue;
     toggleClassKey(node, key, false);
     delete prev[key];
   }
   for (i = 0, len = classKeys.length; i < len; i++) {
     const key = classKeys[i],
           classValue = !!value[key];
-    if (!key || key === "undefined" || prev[key] === classValue) continue;
-    toggleClassKey(node, key, classValue);
+    if (!key || key === "undefined" || prev[key] === classValue || !classValue) continue;
+    toggleClassKey(node, key, true);
     prev[key] = classValue;
   }
   return prev;
 }
 function style(node, value, prev = {}) {
   const nodeStyle = node.style;
-  if (typeof value === "string") return nodeStyle.cssText = value;
+  if (value == null || typeof value === "string") return nodeStyle.cssText = value;
   typeof prev === "string" && (prev = {});
   let v, s;
   for (s in prev) {