solid-js 2.0.0-experimental.2 → 2.0.0-experimental.4

package/dist/solid.cjs

@@ -171,6 +171,7 @@ function Repeat(props) {
   const options = "fallback" in props ? {
     fallback: () => props.fallback
   } : {};
+  options.from = () => props.from;
   return signals.createMemo(signals.repeat(() => props.count, index => typeof props.children === "function" ? props.children(index) : props.children, options));
 }
 function Show(props) {

package/dist/solid.js

@@ -235,6 +235,7 @@ function Repeat(props) {
           fallback: () => props.fallback
         }
       : {};
+  options.from = () => props.from;
   return createMemo(
     repeat(
       () => props.count,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "solid-js",
   "description": "A declarative JavaScript library for building user interfaces.",
-  "version": "2.0.0-experimental.2",
+  "version": "2.0.0-experimental.4",
   "author": "Ryan Carniato",
   "license": "MIT",
   "homepage": "https://solidjs.com",
@@ -79,7 +79,7 @@
     "performance"
   ],
   "dependencies": {
-    "@solidjs/signals": "^0.2.1",
+    "@solidjs/signals": "^0.2.4",
     "csstype": "^3.1.0"
   },
   "scripts": {

package/types/client/flow.d.ts

@@ -32,6 +32,7 @@ export declare function For<T extends readonly any[], U extends JSX.Element>(pro
  */
 export declare function Repeat<T extends JSX.Element>(props: {
   count: number;
+  from?: number | undefined;
   fallback?: JSX.Element;
   children: ((index: number) => T) | T;
 }): JSX.Element;

package/types/jsx.d.ts

@@ -317,7 +317,7 @@ export namespace JSX {
   /** @type {GlobalEventHandlers} */
   interface CustomEventHandlersLowerCase<T> {
     /** @deprecated Use camelCase event handlers */
-    onabort?: EventHandlerUnion<T, UIEvent> | undefined;
+    onabort?: EventHandlerUnion<T, Event> | undefined;
     /** @deprecated Use camelCase event handlers */
     onanimationend?: EventHandlerUnion<T, AnimationEvent> | undefined;
     /** @deprecated Use camelCase event handlers */
@@ -1199,8 +1199,7 @@ export namespace JSX {
     value?: string | string[] | number | undefined;
   }
   interface DetailsHtmlAttributes<T> extends HTMLAttributes<T> {
-    name?: string | undefined;
-    open?: "true" | boolean | undefined;
+    open?: boolean | undefined;
     onToggle?: EventHandlerUnion<T, Event> | undefined;
 
     /** @deprecated Use camelCase event handlers */
@@ -1475,6 +1474,7 @@ export namespace JSX {
       | "time"
       | "url"
       | "week"
+      | (string & {})
       | undefined;
     value?: string | string[] | number | undefined;
     width?: number | string | undefined;
@@ -1574,7 +1574,13 @@ export namespace JSX {
   interface MediaHTMLAttributes<T> extends HTMLAttributes<T> {
     autoplay?: "true" | boolean | undefined;
     controls?: "true" | boolean | undefined;
-    controlslist?: string | undefined;
+    controlslist?:
+      | "nodownload"
+      | "nofullscreen"
+      | "noplaybackrate"
+      | "noremoteplayback"
+      | (string & {})
+      | undefined;
     crossorigin?: HTMLCrossorigin | undefined;
     disableremoteplayback?: "true" | boolean | undefined;
     loop?: "true" | boolean | undefined;
@@ -1968,7 +1974,6 @@ export namespace JSX {
     poster?: string | undefined;
     width?: number | string | undefined;
     disablepictureinpicture?: "true" | boolean | undefined;
-    disableremoteplayback?: boolean;
   }
 
   interface WebViewHTMLAttributes<T> extends HTMLAttributes<T> {

package/types/server/index.d.ts

@@ -1,58 +1,41 @@
+export { $PROXY, $TRACK, $RAW, catchError, flatten, isEqual, isWrappable } from "@solidjs/signals";
 export {
-  catchError,
-  createRoot,
-  createSignal,
-  createRenderEffect,
+  createAsync,
   createEffect,
-  createReaction,
-  createDeferred,
-  createSelector,
   createMemo,
-  getListener,
-  onMount,
-  onCleanup,
-  onError,
-  untrack,
-  batch,
-  on,
-  children,
-  createContext,
-  useContext,
+  createRenderEffect,
+  createRoot,
+  createSignal,
+  flushSync,
+  getObserver,
   getOwner,
-  runWithOwner,
-  equalFn,
-  requestCallback,
+  isPending,
+  latest,
   mapArray,
-  indexArray,
-  observable,
-  from,
-  $PROXY,
-  $DEVCOMP,
-  $TRACK,
-  DEV,
-  enableExternalSource
-} from "./reactive.js";
+  onCleanup,
+  repeat,
+  resolve,
+  runWithObserver,
+  runWithOwner,
+  untrack
+} from "./signals.js";
+export { observable, from, children, createContext, onMount, useContext } from "./reactive.js";
+export { createProjection, createStore, unwrap, reconcile, merge, omit } from "./store.js";
 export {
-  mergeProps,
-  splitProps,
   createComponent,
   For,
-  Index,
+  Repeat,
   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";
+export declare const $DEVCOMP: unique symbol;
+export declare const DEV: undefined;
+export type { Component } from "../index.js";
 export * from "./store.js";

package/types/server/reactive.d.ts

@@ -1,97 +1,10 @@
-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 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 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;
-}
-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?: {
-    equals?: false | ((prev: T, next: T) => boolean);
-    name?: string;
-  }
-): [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 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?: {
-    defer?: boolean;
-  }
-): (prev?: U) => U | undefined;
+import { type Accessor, type Setter } from "@solidjs/signals";
+import type { JSX } from "../jsx.js";
+import type { ChildrenReturn, Context } from "../index.js";
 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;
-}
-export declare function createContext<T>(defaultValue?: T): Context<T>;
+export declare function createContext<T>(defaultValue?: T): Context<T | undefined>;
 export declare function useContext<T>(context: Context<T>): T;
-export declare function getOwner(): Owner | null;
-type ChildrenReturn = Accessor<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;
-}
-export declare function requestCallback(
-  fn: () => void,
-  options?: {
-    timeout: number;
-  }
-): 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?: {
-    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?: {
-    fallback?: Accessor<any>;
-  }
-): () => U[];
+export declare function children(fn: Accessor<JSX.Element>): ChildrenReturn;
 export type ObservableObserver<T> =
   | ((v: T) => void)
   | {
@@ -121,9 +34,3 @@ export declare function from<T>(
             };
       }
 ): 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
- */
-export declare function onError(fn: (err: Error) => void): void;
-export {};

package/types/server/rendering.d.ts

@@ -1,25 +1,6 @@
-import { Accessor, Setter, Signal } from "./reactive.js";
+import type { Accessor } from "@solidjs/signals";
 import type { JSX } from "../jsx.js";
-export type Component<P = {}> = (props: P) => JSX.Element;
-export type VoidProps<P = {}> = P & {
-  children?: never;
-};
-export type VoidComponent<P = {}> = Component<VoidProps<P>>;
-export type ParentProps<P = {}> = P & {
-  children?: JSX.Element;
-};
-export type ParentComponent<P = {}> = Component<ParentProps<P>>;
-export type FlowProps<P = {}, C = JSX.Element> = P & {
-  children: C;
-};
-export type FlowComponent<P = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
-export type Ref<T> = T | ((val: T) => void);
-export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
-export type ComponentProps<T extends ValidComponent> = T extends Component<infer P>
-  ? P
-  : T extends keyof JSX.IntrinsicElements
-  ? JSX.IntrinsicElements[T]
-  : Record<string, unknown>;
+import type { Component } from "../index.js";
 type SharedConfig = {
   context?: HydrationContext;
   getContextId(): string;
@@ -28,69 +9,17 @@ type SharedConfig = {
 export declare const sharedConfig: SharedConfig;
 export declare function createUniqueId(): string;
 export declare function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
-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;
-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>];
-export declare function splitProps<
-  T extends object,
-  K1 extends keyof T,
-  K2 extends keyof T,
-  K3 extends keyof T,
-  K4 extends keyof T
->(
-  props: T,
-  ...keys: [K1[], K2[], K3[], K4[]]
-): [Pick<T, K1>, Pick<T, K2>, Pick<T, K3>, Pick<T, K4>, Omit<T, K1 | K2 | K3 | K4>];
-export declare function splitProps<
-  T extends object,
-  K1 extends keyof T,
-  K2 extends keyof T,
-  K3 extends keyof T,
-  K4 extends keyof T,
-  K5 extends keyof T
->(
-  props: T,
-  ...keys: [K1[], K2[], K3[], K4[], K5[]]
-): [
-  Pick<T, K1>,
-  Pick<T, K2>,
-  Pick<T, K3>,
-  Pick<T, K4>,
-  Pick<T, K5>,
-  Omit<T, K1 | K2 | K3 | K4 | K5>
-];
 export declare function For<T>(props: {
   each: T[];
   fallback?: string;
-  children: (item: T, index: () => number) => string;
-}): string | any[] | undefined;
-export declare function Index<T>(props: {
-  each: T[];
+  children: (item: Accessor<T>, index: Accessor<number>) => string;
+}): () => string[];
+export declare function Repeat(props: {
+  count: number;
+  from?: number | undefined;
   fallback?: string;
-  children: (item: () => T, index: number) => string;
-}): string | any[] | undefined;
+  children: (index: number) => string;
+}): () => string[];
 /**
  * Conditionally render its children or an optional fallback component
  * @description https://docs.solidjs.com/reference/components/show
@@ -111,23 +40,10 @@ type MatchProps<T> = {
   children: string | ((item: NonNullable<T> | Accessor<NonNullable<T>>) => string);
 };
 export declare function Match<T>(props: MatchProps<T>): MatchProps<T>;
-export declare function resetErrorBoundaries(): void;
 export declare function ErrorBoundary(props: {
   fallback: string | ((err: any, reset: () => void) => string);
   children: string;
-}):
-  | string
-  | ((err: any, reset: () => void) => string)
-  | {
-      t: string;
-    };
-export interface Resource<T> {
-  (): T | undefined;
-  state: "unresolved" | "pending" | "ready" | "refreshing" | "errored";
-  loading: boolean;
-  error: any;
-  latest: T | undefined;
-}
+}): void;
 type SuspenseContextType = {
   resources: Map<
     string,
@@ -138,52 +54,6 @@ type SuspenseContextType = {
   >;
   completed: () => void;
 };
-export type ResourceActions<T> = {
-  mutate: Setter<T>;
-  refetch: (info?: unknown) => void;
-};
-export type ResourceReturn<T> = [Resource<T>, ResourceActions<T>];
-export type ResourceSource<S> = S | false | null | undefined | (() => S | false | null | undefined);
-export type ResourceFetcher<S, T> = (k: S, info: ResourceFetcherInfo<T>) => T | Promise<T>;
-export type ResourceFetcherInfo<T> = {
-  value: T | undefined;
-  refetching?: unknown;
-};
-export type ResourceOptions<T> = undefined extends T
-  ? {
-      initialValue?: T;
-      name?: string;
-      deferStream?: boolean;
-      ssrLoadFrom?: "initial" | "server";
-      storage?: () => Signal<T | undefined>;
-      onHydrated?: <S, T>(k: S, info: ResourceFetcherInfo<T>) => void;
-    }
-  : {
-      initialValue: T;
-      name?: string;
-      deferStream?: boolean;
-      ssrLoadFrom?: "initial" | "server";
-      storage?: (v?: T) => Signal<T | undefined>;
-      onHydrated?: <S, T>(k: S, info: ResourceFetcherInfo<T>) => void;
-    };
-export declare function createResource<T, S = true>(
-  fetcher: ResourceFetcher<S, T>,
-  options?: ResourceOptions<undefined>
-): ResourceReturn<T | undefined>;
-export declare function createResource<T, S = true>(
-  fetcher: ResourceFetcher<S, T>,
-  options: ResourceOptions<T>
-): ResourceReturn<T>;
-export declare function createResource<T, S>(
-  source: ResourceSource<S>,
-  fetcher: ResourceFetcher<S, T>,
-  options?: ResourceOptions<undefined>
-): ResourceReturn<T | undefined>;
-export declare function createResource<T, S>(
-  source: ResourceSource<S>,
-  fetcher: ResourceFetcher<S, T>,
-  options: ResourceOptions<T>
-): ResourceReturn<T>;
 export declare function lazy<T extends Component<any>>(
   fn: () => Promise<{
     default: T;
@@ -193,10 +63,7 @@ export declare function lazy<T extends Component<any>>(
     default: T;
   }>;
 };
-export declare function enableScheduling(): void;
 export declare function enableHydration(): void;
-export declare function startTransition(fn: () => any): void;
-export declare function useTransition(): [() => boolean, (fn: () => any) => void];
 type HydrationContext = {
   id: string;
   count: number;
@@ -211,20 +78,5 @@ type HydrationContext = {
   async?: boolean;
   noHydrate: boolean;
 };
-export declare function SuspenseList(props: {
-  children: string;
-  revealOrder: "forwards" | "backwards" | "together";
-  tail?: "collapsed" | "hidden";
-}): string;
-export declare function Suspense(props: { fallback?: string; children: string }):
-  | string
-  | number
-  | boolean
-  | Node
-  | JSX.ArrayElement
-  | {
-      t: string;
-    }
-  | null
-  | undefined;
+export declare function Suspense(props: { fallback?: string; children: string }): void;
 export {};

package/types/server/signals.d.ts

@@ -0,0 +1,85 @@
+import type {
+  Accessor,
+  Computation,
+  ComputeFunction,
+  EffectFunction,
+  EffectOptions,
+  MemoOptions,
+  Signal,
+  SignalOptions
+} from "@solidjs/signals";
+export declare let Owner: Owner | null;
+interface Owner {
+  owner: Owner | null;
+  context: any | null;
+  owned: Owner[] | null;
+  cleanups: (() => void)[] | null;
+}
+export declare function createRoot<T>(fn: ((dispose: () => void) => T) | (() => T)): T;
+export declare function createSignal<T>(): Signal<T | undefined>;
+export declare function createSignal<T>(
+  value: Exclude<T, Function>,
+  options?: SignalOptions<T>
+): Signal<T>;
+export declare function createSignal<T>(
+  fn: ComputeFunction<T>,
+  initialValue?: T,
+  options?: SignalOptions<T>
+): Signal<T>;
+export declare function createMemo<Next extends Prev, Prev = Next>(
+  compute: ComputeFunction<undefined | NoInfer<Prev>, Next>
+): Accessor<Next>;
+export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(
+  compute: ComputeFunction<Init | Prev, Next>,
+  value: Init,
+  options?: MemoOptions<Next>
+): Accessor<Next>;
+export declare function createRenderEffect<Next>(
+  compute: ComputeFunction<undefined | NoInfer<Next>, Next>,
+  effect: EffectFunction<NoInfer<Next>, Next>
+): void;
+export declare function createRenderEffect<Next, Init = Next>(
+  compute: ComputeFunction<Init | Next, Next>,
+  effect: EffectFunction<Next, Next>,
+  value: Init,
+  options?: EffectOptions
+): void;
+export declare function createEffect<Next>(
+  compute: ComputeFunction<undefined | NoInfer<Next>, Next>,
+  effect: EffectFunction<NoInfer<Next>, Next>,
+  error?: (err: unknown) => void
+): void;
+export declare function createEffect<Next, Init = Next>(
+  compute: ComputeFunction<Init | Next, Next>,
+  effect: EffectFunction<Next, Next>,
+  error: ((err: unknown) => void) | undefined,
+  value: Init,
+  options?: EffectOptions
+): void;
+export declare function createAsync(): void;
+export declare function isPending(): void;
+export declare function latest(): void;
+export declare function resolve(): void;
+export declare function flushSync(): void;
+export declare function getObserver(): Computation<any> | null;
+export declare function getOwner(): Owner | null;
+export declare function runWithOwner<T>(o: typeof Owner, fn: () => T): T | undefined;
+export declare function runWithObserver<T>(o: Computation, fn: () => T): T | undefined;
+export declare function untrack<T>(fn: () => T): T;
+export declare function onCleanup(fn: () => void): () => void;
+export declare function mapArray<T, U>(
+  list: Accessor<readonly T[] | undefined | null | false>,
+  mapFn: (v: Accessor<T>, i: Accessor<number>) => U,
+  options?: {
+    fallback?: Accessor<any>;
+  }
+): () => U[];
+export declare function repeat<T>(
+  count: Accessor<number>,
+  mapFn: (i: number) => T,
+  options?: {
+    fallback?: Accessor<any>;
+    from?: Accessor<number | undefined>;
+  }
+): () => T[];
+export {};

package/types/server/store.d.ts

@@ -1,6 +1,15 @@
-import type { Store, StoreSetter } from "@solidjs/signals";
+import type { Merge, Store, StoreSetter, Omit } from "@solidjs/signals";
 export type { NotWrappable, SolidStore, Store, StoreNode, StoreSetter } from "@solidjs/signals";
 export declare function isWrappable(obj: any): boolean;
 export declare function unwrap<T>(item: T): T;
 export declare function createStore<T>(state: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createProjection<T extends Object>(
+  fn: (draft: T) => void,
+  initialValue?: T
+): Store<T>;
 export declare function reconcile<T extends U, U extends object>(value: T): (state: U) => T;
+export declare function merge<T extends unknown[]>(...sources: T): Merge<T>;
+export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(
+  props: T,
+  ...keys: K
+): Omit<T, K>;