solid-js 1.4.8 → 1.5.0-beta.2

package/types/reactive/array.d.ts

@@ -1,4 +1,4 @@
-import { Accessor } from "./signal";
+import { Accessor } from "./signal.js";
 /**
  * reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
  *

package/types/reactive/observable.d.ts

@@ -1,4 +1,4 @@
-import { Accessor, Setter } from "./signal";
+import { Accessor, Setter } from "./signal.js";
 declare global {
     interface SymbolConstructor {
         readonly observable: symbol;

package/types/reactive/signal.d.ts

@@ -1,11 +1,10 @@
-import { requestCallback } from "./scheduler";
-import type { JSX } from "../jsx";
-import type { FlowComponent } from "../render";
+import { requestCallback } from "./scheduler.js";
+import type { JSX } from "../jsx.js";
+import type { FlowComponent } from "../render/index.js";
 export declare const equalFn: <T>(a: T, b: T) => boolean;
 export declare const $PROXY: unique symbol;
 export declare const $TRACK: unique symbol;
 export declare const $DEVCOMP: unique symbol;
-export declare const NOTPENDING: {};
 export declare var Owner: Owner | null;
 export declare let Transition: TransitionState | null;
 declare let ExternalSourceFactory: ExternalSourceFactory | null;
@@ -17,7 +16,6 @@ export interface SignalState<T> {
     value?: T;
     observers: Computation<any>[] | null;
     observerSlots: number[] | null;
-    pending: T | {};
     tValue?: T;
     comparator?: (prev: T, next: T) => boolean;
     name?: string;
@@ -198,50 +196,87 @@ export interface MemoOptions<T> extends EffectOptions {
  */
 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 interface Resource<T> extends Accessor<T> {
-    loading: boolean;
-    error: any;
+interface Unresolved {
+    state: "unresolved";
+    loading: false;
+    error: undefined;
+    latest: undefined;
+    (): undefined;
+}
+interface Pending {
+    state: "pending";
+    loading: true;
+    error: undefined;
+    latest: undefined;
+    (): undefined;
+}
+interface Ready<T> {
+    state: "ready";
+    loading: false;
+    error: undefined;
+    latest: T;
+    (): T;
+}
+interface Refreshing<T> {
+    state: "refreshing";
+    loading: true;
+    error: undefined;
     latest: T;
+    (): T;
 }
-export declare type ResourceActions<T> = {
-    mutate: Setter<T>;
-    refetch: (info?: unknown) => T | Promise<T> | undefined | null;
+interface Error {
+    state: "error";
+    loading: false;
+    error: any;
+    latest: never;
+    (): never;
+}
+export declare type Resource<T> = Unresolved | Pending | Ready<T> | Refreshing<T> | Error;
+export declare type InitializedResource<T> = Ready<T> | Refreshing<T> | Error;
+export declare type ResourceActions<T, R = unknown> = {
+    mutate: Setter<T | undefined>;
+    refetch: (info?: R) => T | Promise<T> | undefined | null;
 };
 export declare type ResourceSource<S> = S | false | null | undefined | (() => S | false | null | undefined);
-export declare type ResourceFetcher<S, T> = (k: S, info: ResourceFetcherInfo<T>) => T | Promise<T>;
-export declare type ResourceFetcherInfo<T> = {
+export declare type ResourceFetcher<S, T, R = unknown> = (k: S, info: ResourceFetcherInfo<T, R>) => T | Promise<T>;
+export declare type ResourceFetcherInfo<T, R = unknown> = {
     value: T | undefined;
-    refetching?: unknown;
+    refetching: R | boolean;
 };
-export declare type ResourceOptions<T> = undefined extends T ? {
+export declare type ResourceOptions<T, S = unknown> = {
     initialValue?: T;
     name?: string;
     deferStream?: boolean;
-    onHydrated?: <S, T>(k: S, info: ResourceFetcherInfo<T>) => void;
-} : {
+    store?: (init: T | undefined) => [Accessor<T | undefined>, Setter<T | undefined>];
+    onHydrated?: (k: S | undefined, info: {
+        value: T | undefined;
+    }) => void;
+};
+export declare type InitializedResourceOptions<T, S = unknown> = ResourceOptions<T, S> & {
     initialValue: T;
-    name?: string;
-    deferStream?: boolean;
-    onHydrated?: <S, T>(k: S, info: ResourceFetcherInfo<T>) => void;
 };
-export declare type ResourceReturn<T, O extends ResourceOptions<T | undefined> | undefined, K = T> = [
-    Resource<O extends undefined | null ? T | undefined : NonNullable<O>["initialValue"] extends undefined ? T | undefined : T>,
-    ResourceActions<K>
+export declare type ResourceReturn<T, R = unknown> = [Resource<T>, ResourceActions<T, R>];
+export declare type InitializedResourceReturn<T, R = unknown> = [
+    InitializedResource<T>,
+    ResourceActions<T, R>
 ];
 /**
  * Creates a resource that wraps a repeated promise in a reactive pattern:
  * ```typescript
+ * // Without source
+ * const [resource, { mutate, refetch }] = createResource(fetcher, options);
+ * // With source
  * const [resource, { mutate, refetch }] = createResource(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:
+ * @param source - reactive data function which has its non-nullish and non-false values passed to the fetcher, optional
+ * @param fetcher - function that receives the source (true if source not provided), the last or initial value, and whether the resource is being refetched, and returns a value or a Promise:
  * ```typescript
- * const fetcher: ResourceFetcher<S, T, > = (
- *   sourceOutput: ReturnValue<typeof source>,
- *   info: ResourceFetcherInfo<T>
+ * const fetcher: ResourceFetcher<S, T, R> = (
+ *   sourceOutput: S,
+ *   info: { value: T | undefined, refetching: R | boolean }
  * ) => T | Promise<T>;
  * ```
- * @param options - an optional object with the initialValue and the name (for debugging purposes)
+ * @param options - an optional object with the initialValue and the name (for debugging purposes); see {@link ResourceOptions}
  *
  * @returns ```typescript
  * [Resource<T>, { mutate: Setter<T>, refetch: () => void }]
@@ -249,14 +284,14 @@ export declare type ResourceReturn<T, O extends ResourceOptions<T | undefined> |
  *
  * * 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
+ * * `refetch` will re-run the fetcher without changing the source, and if called with a value, that value will be passed to the fetcher via the `refetching` property on the fetcher's second parameter
  *
  * @description https://www.solidjs.com/docs/latest/api#createresource
  */
-export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): ResourceReturn<T | undefined, typeof options>;
-export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): ResourceReturn<T, typeof options>;
-export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): ResourceReturn<T | undefined, typeof options>;
-export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): ResourceReturn<T, typeof options>;
+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;

package/types/render/Suspense.d.ts

@@ -1,4 +1,4 @@
-import type { JSX } from "../jsx";
+import type { JSX } from "../jsx.js";
 /**
  * **[experimental]** controls the order in which suspended content is rendered
  *

package/types/render/component.d.ts

@@ -1,4 +1,4 @@
-import type { JSX } from "../jsx";
+import type { JSX } from "../jsx.js";
 export declare function enableHydration(): void;
 /**
  * A general `Component` has no implicit `children` prop.  If desired, you can
@@ -51,6 +51,7 @@ export declare type FlowProps<P = {}, C = JSX.Element> = P & {
 export declare type FlowComponent<P = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
 /** @deprecated: use `ParentProps` instead */
 export declare type PropsWithChildren<P = {}> = ParentProps<P>;
+export declare type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
 /**
  * Takes the props of the passed component and returns its type
  *
@@ -58,7 +59,7 @@ export declare type PropsWithChildren<P = {}> = ParentProps<P>;
  * ComponentProps<typeof Portal> // { mount?: Node; useShadow?: boolean; children: JSX.Element }
  * ComponentProps<'div'> // JSX.HTMLAttributes<HTMLDivElement>
  */
-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 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.
  *
@@ -66,16 +67,30 @@ export declare type ComponentProps<T extends keyof JSX.IntrinsicElements | Compo
  */
 export declare type Ref<T> = T | ((val: T) => void);
 export declare function createComponent<T>(Comp: Component<T>, props: T): JSX.Element;
+declare type DistributeOverride<T, F> = T extends undefined ? F : T;
 declare type Override<T, U> = T extends any ? U extends any ? {
-    [K in keyof T]: K extends keyof U ? undefined extends U[K] ? Exclude<U[K], undefined> | T[K] : U[K] : T[K];
+    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
 } & {
-    [K in keyof U]: K extends keyof T ? undefined extends U[K] ? Exclude<U[K], undefined> | T[K] : U[K] : U[K];
+    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
 } : T & U : T & U;
-export declare type MergeProps<T extends unknown[], Curr = {}> = T extends [
+declare 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;
+declare type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
+declare type _MergeProps<T extends unknown[], Curr = {}> = T extends [
     infer Next | (() => infer Next),
     ...infer Rest
-] ? MergeProps<Rest, Override<Curr, Next>> : Curr;
-export declare function mergeProps<T extends [unknown, ...unknown[]]>(...sources: T): MergeProps<T>;
+] ? _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 declare type MergeProps<T extends unknown[]> = Simplify<_MergeProps<T>>;
+export declare function mergeProps<T extends unknown[]>(...sources: T): MergeProps<T>;
 export declare 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;

package/types/render/flow.d.ts

@@ -1,5 +1,5 @@
-import { Accessor } from "../reactive/signal";
-import type { JSX } from "../jsx";
+import { Accessor } from "../reactive/signal.js";
+import type { JSX } from "../jsx.js";
 /**
  * creates a list elements from a list
  *

package/types/render/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./component";
-export * from "./flow";
-export * from "./Suspense";
-export { sharedConfig } from "./hydration";
+export * from "./component.js";
+export * from "./flow.js";
+export * from "./Suspense.js";
+export { sharedConfig } from "./hydration.js";

package/types/server/index.d.ts

@@ -1,3 +1,3 @@
-export { createRoot, createSignal, createComputed, createRenderEffect, createEffect, createReaction, createDeferred, createSelector, createMemo, getListener, onMount, onCleanup, onError, untrack, batch, on, children, createContext, useContext, getOwner, runWithOwner, equalFn, requestCallback, mapArray, observable, from, $PROXY, $DEVCOMP, DEV, enableExternalSource } from "./reactive";
-export { mergeProps, splitProps, createComponent, For, Index, Show, Switch, Match, ErrorBoundary, Suspense, SuspenseList, createResource, resetErrorBoundaries, enableScheduling, enableHydration, startTransition, useTransition, createUniqueId, lazy, sharedConfig } from "./rendering";
-export type { Component, Resource } from "./rendering";
+export { createRoot, createSignal, createComputed, createRenderEffect, createEffect, createReaction, createDeferred, createSelector, createMemo, getListener, onMount, onCleanup, onError, untrack, batch, on, children, createContext, useContext, getOwner, runWithOwner, equalFn, requestCallback, mapArray, observable, from, $PROXY, $DEVCOMP, 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,6 +4,8 @@ export declare const $DEVCOMP: unique symbol;
 export declare const DEV: {};
 export declare type Accessor<T> = () => T;
 export declare 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 declare const BRANCH: unique symbol;
+export declare function castError(err: any): string | Error;
 export declare let Owner: Owner | null;
 interface Owner {
     owner: Owner | null;
@@ -27,7 +29,10 @@ export declare function on<T, U>(deps: Array<() => T> | (() => T), fn: (value: A
     defer?: boolean;
 }): (prev?: U) => U | undefined;
 export declare function onMount(fn: () => void): void;
-export declare function onCleanup(fn: () => void): void;
+export declare function onCleanup(fn: () => void): () => void;
+export declare function cleanNode(node: {
+    cleanups?: Function[] | null;
+}): void;
 export declare function onError(fn: (err: any) => void): void;
 export declare function getListener(): null;
 export interface Context<T> {
@@ -42,7 +47,7 @@ export declare function createContext<T>(defaultValue?: T): Context<T>;
 export declare function useContext<T>(context: Context<T>): T;
 export declare function getOwner(): Owner | null;
 export declare function children(fn: () => any): () => unknown;
-export declare function runWithOwner<T>(o: Owner, fn: () => T): T;
+export declare function runWithOwner<T>(o: Owner, fn: () => T): T | undefined;
 export declare function lookup(owner: Owner | null, key: symbol | string): any;
 export interface Task {
     id: number;
@@ -63,10 +68,10 @@ export declare type ObservableObserver<T> = ((v: T) => void) | {
     complete?: (v: boolean) => void;
 };
 export declare function observable<T>(input: Accessor<T>): {
-    [x: number]: () => 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) | {

package/types/server/rendering.d.ts

@@ -1,5 +1,5 @@
-import { Setter } from "./reactive";
-import type { JSX } from "../jsx";
+import { Setter } from "./reactive.js";
+import type { JSX } from "../jsx.js";
 export declare type Component<P = {}> = (props: P) => JSX.Element;
 export declare type VoidProps<P = {}> = P & {
     children?: never;
@@ -14,7 +14,8 @@ export declare type FlowProps<P = {}, C = JSX.Element> = P & {
 };
 export declare type FlowComponent<P = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
 export declare type Ref<T> = T | ((val: T) => void);
-export declare type ComponentProps<T extends keyof JSX.IntrinsicElements | Component> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : {};
+export declare type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
+export declare type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
 declare type SharedConfig = {
     context?: HydrationContext;
 };
@@ -64,9 +65,12 @@ export declare function resetErrorBoundaries(): void;
 export declare function ErrorBoundary(props: {
     fallback: string | ((err: any, reset: () => void) => string);
     children: string;
-}): any;
+}): string | ((err: any, reset: () => void) => string) | {
+    t: string;
+};
 export interface Resource<T> {
     (): T | undefined;
+    state: "unresolved" | "pending" | "ready" | "refreshing" | "error";
     loading: boolean;
     error: any;
     latest: T | undefined;
@@ -76,6 +80,7 @@ declare type SuspenseContextType = {
         loading: boolean;
         error: any;
     }>;
+    complete: boolean;
     completed: () => void;
 };
 export declare type ResourceActions<T> = {
@@ -118,12 +123,12 @@ export declare function useTransition(): [() => boolean, (fn: () => any) => void
 declare type HydrationContext = {
     id: string;
     count: number;
-    writeResource?: (id: string, v: Promise<any> | any, error?: boolean, deferStream?: boolean) => void;
+    writeResource: (id: string, v: Promise<any> | any, error?: boolean, deferStream?: boolean) => void;
+    replace: (id: string, replacement: () => any) => void;
     resources: Record<string, any>;
     suspense: Record<string, SuspenseContextType>;
     registerFragment: (v: string) => (v?: string, err?: any) => boolean;
     async?: boolean;
-    streaming?: boolean;
     noHydrate: boolean;
 };
 export declare function SuspenseList(props: {

package/universal/types/index.d.ts

@@ -1,2 +1,2 @@
-import type { RendererOptions, Renderer } from "./universal";
+import type { RendererOptions, Renderer } from "./universal.js";
 export declare function createRenderer<NodeType>(options: RendererOptions<NodeType>): Renderer<NodeType>;

package/web/dist/dev.cjs

@@ -519,12 +519,12 @@ function renderToStream(fn, options) {
   throwInBrowser(renderToStream);
 }
 function ssr(template, ...nodes) {}
-function resolveSSRNode(node) {}
+function ssrElement(name, props, children, needsId) {}
 function ssrClassList(value) {}
 function ssrStyle(value) {}
-function ssrSpread(accessor) {}
 function ssrAttribute(key, value) {}
 function ssrHydrationKey() {}
+function resolveSSRNode(node) {}
 function escape(html) {}
 function generateHydrationScript() {}
 
@@ -685,8 +685,8 @@ exports.spread = spread;
 exports.ssr = ssr;
 exports.ssrAttribute = ssrAttribute;
 exports.ssrClassList = ssrClassList;
+exports.ssrElement = ssrElement;
 exports.ssrHydrationKey = ssrHydrationKey;
-exports.ssrSpread = ssrSpread;
 exports.ssrStyle = ssrStyle;
 exports.style = style;
 exports.template = template;

package/web/dist/dev.js

@@ -516,12 +516,12 @@ function renderToStream(fn, options) {
   throwInBrowser(renderToStream);
 }
 function ssr(template, ...nodes) {}
-function resolveSSRNode(node) {}
+function ssrElement(name, props, children, needsId) {}
 function ssrClassList(value) {}
 function ssrStyle(value) {}
-function ssrSpread(accessor) {}
 function ssrAttribute(key, value) {}
 function ssrHydrationKey() {}
+function resolveSSRNode(node) {}
 function escape(html) {}
 function generateHydrationScript() {}
 
@@ -591,4 +591,4 @@ function Dynamic(props) {
   });
 }
 
-export { Aliases, Assets, ChildProperties, DOMElements, DelegatedEvents, Dynamic, Assets as HydrationScript, NoHydration, Portal, PropAliases, Properties, SVGElements, SVGNamespace, addEventListener, assign, classList, className, clearDelegatedEvents, delegateEvents, dynamicProperty, escape, generateHydrationScript, getHydrationKey, getNextElement, getNextMarker, getNextMatch, hydrate, innerHTML, insert, isServer, memo, render, renderToStream, renderToString, renderToStringAsync, resolveSSRNode, runHydrationEvents, setAttribute, setAttributeNS, spread, ssr, ssrAttribute, ssrClassList, ssrHydrationKey, ssrSpread, ssrStyle, style, template };
+export { Aliases, Assets, ChildProperties, DOMElements, DelegatedEvents, Dynamic, Assets as HydrationScript, NoHydration, Portal, PropAliases, Properties, SVGElements, SVGNamespace, addEventListener, assign, classList, className, clearDelegatedEvents, delegateEvents, dynamicProperty, escape, generateHydrationScript, getHydrationKey, getNextElement, getNextMarker, getNextMatch, hydrate, innerHTML, insert, isServer, memo, render, renderToStream, renderToString, renderToStringAsync, resolveSSRNode, runHydrationEvents, setAttribute, setAttributeNS, spread, ssr, ssrAttribute, ssrClassList, ssrElement, ssrHydrationKey, ssrStyle, style, template };