solid-js 1.9.0 → 1.9.2

package/types/render/component.d.ts

@@ -4,43 +4,43 @@ 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 = {}> = (props: P) => JSX.Element;
+export type Component<P extends Record<string, any> = {}> = (props: P) => JSX.Element;
 /**
  * Extend props to forbid the `children` prop.
  * Use this to prevent accidentally passing `children` to components that
  * would silently throw them away.
  */
-export type VoidProps<P = {}> = P & {
-  children?: never;
+export type VoidProps<P extends Record<string, any> = {}> = P & {
+    children?: never;
 };
 /**
  * `VoidComponent` forbids the `children` prop.
  * Use this to prevent accidentally passing `children` to components that
  * would silently throw them away.
  */
-export type VoidComponent<P = {}> = Component<VoidProps<P>>;
+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, `JSX.Element` (which allows elements, arrays, functions, etc.).
  * Use this for components that you want to accept children.
  */
-export type ParentProps<P = {}> = P & {
-  children?: JSX.Element;
+export type ParentProps<P extends Record<string, any> = {}> = P & {
+    children?: JSX.Element;
 };
 /**
  * `ParentComponent` allows an optional `children` prop with the usual
  * type in JSX, `JSX.Element` (which allows elements, arrays, functions, etc.).
  * Use this for components that you want to accept children.
  */
-export type ParentComponent<P = {}> = Component<ParentProps<P>>;
+export type ParentComponent<P extends Record<string, any> = {}> = Component<ParentProps<P>>;
 /**
  * Extend props to require a `children` prop with the specified type.
  * Use this for components where you need a specific child type,
  * typically a function that receives specific argument types.
  * Note that all JSX <Elements> are of the type `JSX.Element`.
  */
-export type FlowProps<P = {}, C = JSX.Element> = P & {
-  children: C;
+export type FlowProps<P extends Record<string, any> = {}, C = JSX.Element> = P & {
+    children: C;
 };
 /**
  * `FlowComponent` requires a `children` prop with the specified type.
@@ -48,9 +48,9 @@ export type FlowProps<P = {}, C = JSX.Element> = P & {
  * typically a function that receives specific argument types.
  * Note that all JSX <Elements> are of the type `JSX.Element`.
  */
-export type FlowComponent<P = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
+export type FlowComponent<P extends Record<string, any> = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
 /** @deprecated: use `ParentProps` instead */
-export type PropsWithChildren<P = {}> = ParentProps<P>;
+export type PropsWithChildren<P extends Record<string, any> = {}> = ParentProps<P>;
 export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
 /**
  * Takes the props of the passed component and returns its type
@@ -59,84 +59,53 @@ export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (str
  * ComponentProps<typeof Portal> // { mount?: Node; useShadow?: boolean; children: JSX.Element }
  * ComponentProps<'div'> // JSX.HTMLAttributes<HTMLDivElement>
  */
-export type ComponentProps<T extends ValidComponent> = T extends Component<infer P>
-  ? P
-  : T extends keyof JSX.IntrinsicElements
-  ? JSX.IntrinsicElements[T]
-  : Record<string, unknown>;
+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.
  *
  * @example Component<{ref: Ref<Element>}>
  */
 export type Ref<T> = T | ((val: T) => void);
-export declare function createComponent<T>(Comp: Component<T>, props: T): JSX.Element;
+export declare function createComponent<T extends Record<string, any>>(Comp: Component<T>, props: T): JSX.Element;
 type DistributeOverride<T, F> = T extends undefined ? F : T;
-type Override<T, U> = T extends any
-  ? U extends any
-    ? {
-        [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
-      } & {
-        [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
-      }
-    : T & U
-  : T & U;
-type OverrideSpread<T, U> = T extends any
-  ? {
-      [K in keyof ({
+type Override<T, U> = T extends any ? U extends any ? {
+    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
+} & {
+    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
+} : T & U : T & U;
+type OverrideSpread<T, U> = T extends any ? {
+    [K in keyof ({
         [K in keyof T]: any;
-      } & {
+    } & {
         [K in keyof U]?: any;
-      } & {
+    } & {
         [K in U extends any ? keyof U : keyof U]?: any;
-      })]: K extends keyof T
-        ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K]
-        : U extends any
-        ? U[K & keyof U]
-        : never;
-    }
-  : T & U;
-type Simplify<T> = T extends any
-  ? {
-      [K in keyof T]: T[K];
-    }
-  : T;
+    })]: K extends keyof T ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K] : U extends any ? U[K & keyof U] : never;
+} : T & U;
+type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
 type _MergeProps<T extends unknown[], Curr = {}> = T extends [
-  infer Next | (() => infer Next),
-  ...infer Rest
-]
-  ? _MergeProps<Rest, Override<Curr, Next>>
-  : T extends [...infer Rest, infer Next | (() => infer Next)]
-  ? Override<_MergeProps<Rest, Curr>, Next>
-  : T extends []
-  ? Curr
-  : T extends (infer I | (() => infer I))[]
-  ? OverrideSpread<Curr, I>
-  : Curr;
+    infer Next | (() => infer Next),
+    ...infer Rest
+] ? _MergeProps<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_MergeProps<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
 export type MergeProps<T extends unknown[]> = Simplify<_MergeProps<T>>;
 export declare function mergeProps<T extends unknown[]>(...sources: T): MergeProps<T>;
 export type SplitProps<T, K extends (readonly (keyof T)[])[]> = [
-  ...{
-    [P in keyof K]: P extends `${number}`
-      ? Pick<T, Extract<K[P], readonly (keyof T)[]>[number]>
-      : never;
-  },
-  {
-    [P in keyof T as Exclude<P, K[number][number]>]: T[P];
-  }
+    ...{
+        [P in keyof K]: P extends `${number}` ? Pick<T, Extract<K[P], readonly (keyof T)[]>[number]> : never;
+    },
+    {
+        [P in keyof T as Exclude<P, K[number][number]>]: T[P];
+    }
 ];
-export declare function splitProps<
-  T extends Record<any, any>,
-  K extends [readonly (keyof T)[], ...(readonly (keyof T)[])[]]
->(props: T, ...keys: K): SplitProps<T, K>;
-export declare function lazy<T extends Component<any>>(
-  fn: () => Promise<{
-    default: T;
-  }>
-): T & {
-  preload: () => Promise<{
+export declare function splitProps<T extends Record<any, any>, K extends [readonly (keyof T)[], ...(readonly (keyof T)[])[]]>(props: T, ...keys: K): SplitProps<T, K>;
+export declare function lazy<T extends Component<any>>(fn: () => Promise<{
     default: T;
-  }>;
+}>): T & {
+    preload: () => Promise<{
+        default: T;
+    }>;
 };
 export declare function createUniqueId(): string;
 export {};

package/types/render/flow.d.ts

@@ -14,9 +14,9 @@ import type { JSX } from "../jsx.js";
  * @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;
-  children: (item: T[number], index: Accessor<number>) => U;
+    each: T | undefined | null | false;
+    fallback?: JSX.Element;
+    children: (item: T[number], index: Accessor<number>) => U;
 }): JSX.Element;
 /**
  * Non-keyed iteration over a list creating elements from its items
@@ -32,32 +32,26 @@ export declare function For<T extends readonly any[], U extends JSX.Element>(pro
  * @description https://docs.solidjs.com/reference/components/index
  */
 export declare function Index<T extends readonly any[], U extends JSX.Element>(props: {
-  each: T | undefined | null | false;
-  fallback?: JSX.Element;
-  children: (item: Accessor<T[number]>, index: number) => U;
+    each: T | undefined | null | false;
+    fallback?: JSX.Element;
+    children: (item: Accessor<T[number]>, index: number) => U;
 }): JSX.Element;
 type RequiredParameter<T> = T extends () => unknown ? never : T;
 /**
  * Conditionally render its children or an optional fallback component
  * @description https://docs.solidjs.com/reference/components/show
  */
-export declare function Show<
-  T,
-  TRenderFunction extends (item: Accessor<NonNullable<T>>) => JSX.Element
->(props: {
-  when: T | undefined | null | false;
-  keyed?: false;
-  fallback?: JSX.Element;
-  children: JSX.Element | RequiredParameter<TRenderFunction>;
+export declare function Show<T, TRenderFunction extends (item: Accessor<NonNullable<T>>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    fallback?: JSX.Element;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
 }): JSX.Element;
-export declare function Show<
-  T,
-  TRenderFunction extends (item: NonNullable<T>) => JSX.Element
->(props: {
-  when: T | undefined | null | false;
-  keyed: true;
-  fallback?: JSX.Element;
-  children: JSX.Element | RequiredParameter<TRenderFunction>;
+export declare function Show<T, TRenderFunction extends (item: NonNullable<T>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    fallback?: JSX.Element;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
 }): JSX.Element;
 /**
  * Switches between content based on mutually exclusive conditions
@@ -74,13 +68,13 @@ export declare function Show<
  * @description https://docs.solidjs.com/reference/components/switch-and-match
  */
 export declare function Switch(props: {
-  fallback?: JSX.Element;
-  children: JSX.Element;
+    fallback?: JSX.Element;
+    children: JSX.Element;
 }): JSX.Element;
 export type MatchProps<T> = {
-  when: T | undefined | null | false;
-  keyed?: boolean;
-  children: JSX.Element | ((item: NonNullable<T> | Accessor<NonNullable<T>>) => JSX.Element);
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    children: JSX.Element | ((item: NonNullable<T> | Accessor<NonNullable<T>>) => JSX.Element);
 };
 /**
  * Selects a content based on condition when inside a `<Switch>` control flow
@@ -91,21 +85,15 @@ export type MatchProps<T> = {
  * ```
  * @description https://docs.solidjs.com/reference/components/switch-and-match
  */
-export declare function Match<
-  T,
-  TRenderFunction extends (item: Accessor<NonNullable<T>>) => JSX.Element
->(props: {
-  when: T | undefined | null | false;
-  keyed?: false;
-  children: JSX.Element | RequiredParameter<TRenderFunction>;
+export declare function Match<T, TRenderFunction extends (item: Accessor<NonNullable<T>>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed?: false;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
 }): JSX.Element;
-export declare function Match<
-  T,
-  TRenderFunction extends (item: NonNullable<T>) => JSX.Element
->(props: {
-  when: T | undefined | null | false;
-  keyed: true;
-  children: JSX.Element | RequiredParameter<TRenderFunction>;
+export declare function Match<T, TRenderFunction extends (item: NonNullable<T>) => JSX.Element>(props: {
+    when: T | undefined | null | false;
+    keyed: true;
+    children: JSX.Element | RequiredParameter<TRenderFunction>;
 }): JSX.Element;
 export declare function resetErrorBoundaries(): void;
 /**
@@ -124,7 +112,7 @@ export declare function resetErrorBoundaries(): void;
  * @description https://docs.solidjs.com/reference/components/error-boundary
  */
 export declare function ErrorBoundary(props: {
-  fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
-  children: JSX.Element;
+    fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
+    children: JSX.Element;
 }): JSX.Element;
 export {};

package/types/render/hydration.d.ts

@@ -1,22 +1,22 @@
 import { Computation } from "../reactive/signal.js";
 export type HydrationContext = {
-  id: string;
-  count: number;
+    id: string;
+    count: number;
 };
 type SharedConfig = {
-  context?: HydrationContext;
-  resources?: {
-    [key: string]: any;
-  };
-  load?: (id: string) => Promise<any> | any;
-  has?: (id: string) => boolean;
-  gather?: (key: string) => void;
-  registry?: Map<string, Element>;
-  done?: boolean;
-  count?: number;
-  effects?: Computation<any, any>[];
-  getContextId(): string;
-  getNextContextId(): string;
+    context?: HydrationContext;
+    resources?: {
+        [key: string]: any;
+    };
+    load?: (id: string) => Promise<any> | any;
+    has?: (id: string) => boolean;
+    gather?: (key: string) => void;
+    registry?: Map<string, Element>;
+    done?: boolean;
+    count?: number;
+    effects?: Computation<any, any>[];
+    getContextId(): string;
+    getNextContextId(): string;
 };
 export declare const sharedConfig: SharedConfig;
 export declare function setHydrateContext(context?: HydrationContext): void;

package/types/server/index.d.ts

@@ -1,58 +1,3 @@
-export {
-  catchError,
-  createRoot,
-  createSignal,
-  createComputed,
-  createRenderEffect,
-  createEffect,
-  createReaction,
-  createDeferred,
-  createSelector,
-  createMemo,
-  getListener,
-  onMount,
-  onCleanup,
-  onError,
-  untrack,
-  batch,
-  on,
-  children,
-  createContext,
-  useContext,
-  getOwner,
-  runWithOwner,
-  equalFn,
-  requestCallback,
-  mapArray,
-  indexArray,
-  observable,
-  from,
-  $PROXY,
-  $DEVCOMP,
-  $TRACK,
-  DEV,
-  enableExternalSource
-} from "./reactive.js";
-export {
-  mergeProps,
-  splitProps,
-  createComponent,
-  For,
-  Index,
-  Show,
-  Switch,
-  Match,
-  ErrorBoundary,
-  Suspense,
-  SuspenseList,
-  createResource,
-  resetErrorBoundaries,
-  enableScheduling,
-  enableHydration,
-  startTransition,
-  useTransition,
-  createUniqueId,
-  lazy,
-  sharedConfig
-} from "./rendering.js";
+export { catchError, createRoot, createSignal, createComputed, createRenderEffect, createEffect, createReaction, createDeferred, createSelector, createMemo, getListener, onMount, onCleanup, onError, untrack, batch, on, children, createContext, useContext, getOwner, runWithOwner, equalFn, requestCallback, mapArray, indexArray, observable, from, $PROXY, $DEVCOMP, $TRACK, DEV, enableExternalSource } from "./reactive.js";
+export { mergeProps, splitProps, createComponent, For, Index, Show, Switch, Match, ErrorBoundary, Suspense, SuspenseList, createResource, resetErrorBoundaries, enableScheduling, enableHydration, startTransition, useTransition, createUniqueId, lazy, sharedConfig } from "./rendering.js";
 export type { Component, Resource } from "./rendering.js";

package/types/server/reactive.d.ts

@@ -4,118 +4,87 @@ export declare const $TRACK: unique symbol;
 export declare const $DEVCOMP: unique symbol;
 export declare const DEV: undefined;
 export type Accessor<T> = () => T;
-export type Setter<T> = undefined extends T
-  ? <U extends T>(value?: (U extends Function ? never : U) | ((prev?: T) => U)) => U
-  : <U extends T>(value: (U extends Function ? never : U) | ((prev: T) => U)) => U;
+export type Setter<T> = undefined extends T ? <U extends T>(value?: (U extends Function ? never : U) | ((prev?: T) => U)) => U : <U extends T>(value: (U extends Function ? never : U) | ((prev: T) => U)) => U;
 export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
 export declare function castError(err: unknown): Error;
 export declare let Owner: Owner | null;
 interface Owner {
-  owner: Owner | null;
-  context: any | null;
-  owned: Owner[] | null;
-  cleanups: (() => void)[] | null;
+    owner: Owner | null;
+    context: any | null;
+    owned: Owner[] | null;
+    cleanups: (() => void)[] | null;
 }
 export declare function createOwner(): Owner;
-export declare function createRoot<T>(
-  fn: (dispose: () => void) => T,
-  detachedOwner?: typeof Owner
-): T;
-export declare function createSignal<T>(
-  value: T,
-  options?: {
+export declare function createRoot<T>(fn: (dispose: () => void) => T, detachedOwner?: typeof Owner): T;
+export declare function createSignal<T>(value: T, options?: {
     equals?: false | ((prev: T, next: T) => boolean);
     name?: string;
-  }
-): [get: () => T, set: (v: (T extends Function ? never : T) | ((prev: T) => T)) => T];
+}): [get: () => T, set: (v: (T extends Function ? never : T) | ((prev: T) => T)) => T];
 export declare function createComputed<T>(fn: (v?: T) => T, value?: T): void;
 export declare const createRenderEffect: typeof createComputed;
 export declare function createEffect<T>(fn: (v?: T) => T, value?: T): void;
 export declare function createReaction(fn: () => void): (fn: () => void) => void;
 export declare function createMemo<T>(fn: (v?: T) => T, value?: T): () => T;
 export declare function createDeferred<T>(source: () => T): () => T;
-export declare function createSelector<T>(
-  source: () => T,
-  fn?: (k: T, value: T) => boolean
-): (k: T) => boolean;
+export declare function createSelector<T>(source: () => T, fn?: (k: T, value: T) => boolean): (k: T) => boolean;
 export declare function batch<T>(fn: () => T): T;
 export declare const untrack: typeof batch;
-export declare function on<T, U>(
-  deps: Array<() => T> | (() => T),
-  fn: (value: Array<T> | T, prev?: Array<T> | T, prevResults?: U) => U,
-  options?: {
+export declare function on<T, U>(deps: Array<() => T> | (() => T), fn: (value: Array<T> | T, prev?: Array<T> | T, prevResults?: U) => U, options?: {
     defer?: boolean;
-  }
-): (prev?: U) => U | undefined;
+}): (prev?: U) => U | undefined;
 export declare function onMount(fn: () => void): void;
 export declare function onCleanup(fn: () => void): () => void;
 export declare function cleanNode(node: Owner): void;
 export declare function catchError<T>(fn: () => T, handler: (err: Error) => void): T | undefined;
 export declare function getListener(): null;
 export interface Context<T> {
-  id: symbol;
-  Provider: (props: { value: T; children: any }) => any;
-  defaultValue?: T;
+    id: symbol;
+    Provider: (props: {
+        value: T;
+        children: any;
+    }) => any;
+    defaultValue?: T;
 }
 export declare function createContext<T>(defaultValue?: T): Context<T>;
 export declare function useContext<T>(context: Context<T>): T;
 export declare function getOwner(): Owner | null;
 type ChildrenReturn = Accessor<any> & {
-  toArray: () => any[];
+    toArray: () => any[];
 };
 export declare function children(fn: () => any): ChildrenReturn;
 export declare function runWithOwner<T>(o: typeof Owner, fn: () => T): T | undefined;
 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;
-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[];
-export declare function indexArray<T, U>(
-  list: Accessor<readonly T[] | undefined | null | false>,
-  mapFn: (v: Accessor<T>, i: number) => U,
-  options?: {
+}): () => U[];
+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[];
-export type ObservableObserver<T> =
-  | ((v: T) => void)
-  | {
-      next: (v: T) => void;
-      error?: (v: any) => void;
-      complete?: (v: boolean) => void;
-    };
+}): () => U[];
+export type ObservableObserver<T> = ((v: T) => void) | {
+    next: (v: T) => void;
+    error?: (v: any) => void;
+    complete?: (v: boolean) => void;
+};
 export declare function observable<T>(input: Accessor<T>): {
-  subscribe(observer: ObservableObserver<T>): {
-    unsubscribe(): void;
-  };
-  [Symbol.observable](): any;
+    subscribe(observer: ObservableObserver<T>): {
+        unsubscribe(): void;
+    };
+    [Symbol.observable](): any;
 };
-export declare function from<T>(
-  producer:
-    | ((setter: Setter<T>) => () => void)
-    | {
-        subscribe: (fn: (v: T) => void) =>
-          | (() => void)
-          | {
-              unsubscribe: () => void;
-            };
-      }
-): Accessor<T>;
+export declare function from<T>(producer: ((setter: Setter<T>) => () => void) | {
+    subscribe: (fn: (v: T) => void) => (() => void) | {
+        unsubscribe: () => void;
+    };
+}): Accessor<T>;
 export declare function enableExternalSource(factory: any): void;
 /**
  * @deprecated since version 1.7.0 and will be removed in next major - use catchError instead