solid-js 2.0.0-beta.6 → 2.0.0-beta.8

package/types/client/hydration.d.ts

@@ -1,8 +1,8 @@
-import { createErrorBoundary as coreErrorBoundary, createMemo as coreMemo, createSignal as coreSignal, createOptimistic as coreOptimistic, createRenderEffect as coreRenderEffect, createEffect as coreEffect, $REFRESH, type ProjectionOptions, type Store, type StoreSetter, type Context } from "@solidjs/signals";
+import { createErrorBoundary as coreErrorBoundary, createRenderEffect as coreRenderEffect, createEffect as coreEffect, $REFRESH, type Accessor, type ComputeFunction, type MemoOptions, type NoInfer, type ProjectionOptions, type Signal, type SignalOptions, type Store, type StoreSetter, type Context } from "@solidjs/signals";
 import { JSX } from "../jsx.js";
 type HydrationSsrFields = {
     deferStream?: boolean;
-    ssrSource?: "server" | "hybrid" | "initial" | "client";
+    ssrSource?: "server" | "hybrid" | "client";
 };
 declare module "@solidjs/signals" {
     interface MemoOptions<T> extends HydrationSsrFields {
@@ -13,7 +13,19 @@ declare module "@solidjs/signals" {
     }
 }
 export type HydrationProjectionOptions = ProjectionOptions & {
-    ssrSource?: "server" | "hybrid" | "initial" | "client";
+    ssrSource?: "server" | "hybrid" | "client";
+};
+type HydrationClientMemoOptions<T> = Omit<MemoOptions<T>, "ssrSource"> & {
+    ssrSource: "client";
+};
+type HydrationMemoOptions<T> = Omit<MemoOptions<T>, "ssrSource"> & {
+    ssrSource?: "server" | "hybrid";
+};
+type HydrationClientSignalOptions<T> = Omit<SignalOptions<T> & MemoOptions<T>, "ssrSource"> & {
+    ssrSource: "client";
+};
+type HydrationSignalOptions<T> = Omit<SignalOptions<T> & MemoOptions<T>, "ssrSource"> & {
+    ssrSource?: "server" | "hybrid";
 };
 export type HydrationContext = {};
 export declare const NoHydrateContext: Context<boolean>;
@@ -26,6 +38,7 @@ type SharedConfig = {
     has?: (id: string) => boolean;
     gather?: (key: string) => void;
     cleanupFragment?: (id: string) => void;
+    loadModuleAssets?: (mapping: Record<string, string>) => Promise<void> | undefined;
     registry?: Map<string, Element>;
     completed?: WeakSet<Element> | null;
     events?: any[] | null;
@@ -41,23 +54,36 @@ export declare const sharedConfig: SharedConfig;
  */
 export declare function onHydrationEnd(callback: () => void): void;
 export declare function enableHydration(): void;
-export declare const createMemo: typeof coreMemo;
-export declare const createSignal: typeof coreSignal;
+export declare const createMemo: {
+    <T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options: HydrationClientMemoOptions<T>): Accessor<T | undefined>;
+    <T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: HydrationMemoOptions<T>): Accessor<T>;
+};
+export declare const createSignal: {
+    <T>(): Signal<T | undefined>;
+    <T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+    <T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options: HydrationClientSignalOptions<T>): Signal<T | undefined>;
+    <T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: HydrationSignalOptions<T>): Signal<T>;
+};
 export declare const createErrorBoundary: typeof coreErrorBoundary;
-export declare const createOptimistic: typeof coreOptimistic;
-export declare const createProjection: <T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: HydrationProjectionOptions) => Store<T> & {
+export declare const createOptimistic: {
+    <T>(): Signal<T | undefined>;
+    <T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+    <T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options: HydrationClientSignalOptions<T>): Signal<T | undefined>;
+    <T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: HydrationSignalOptions<T>): Signal<T>;
+};
+export declare const createProjection: <T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue: T, options?: HydrationProjectionOptions) => Store<T> & {
     [$REFRESH]: any;
 };
 type NoFn<T> = T extends Function ? never : T;
 export declare const createStore: {
     <T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: HydrationProjectionOptions): [get: Store<T> & {
+    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: NoFn<T> | Store<NoFn<T>>, options?: HydrationProjectionOptions): [get: Store<T> & {
         [$REFRESH]: any;
     }, set: StoreSetter<T>];
 };
 export declare const createOptimisticStore: {
     <T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: HydrationProjectionOptions): [get: Store<T> & {
+    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: NoFn<T> | Store<NoFn<T>>, options?: HydrationProjectionOptions): [get: Store<T> & {
         [$REFRESH]: any;
     }, set: StoreSetter<T>];
 };

package/types/jsx-properties.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Shared type-level helpers used to derive `prop:*` attribute typings from
+ * DOM element interfaces (e.g. `HTMLInputElement`, `HTMLButtonElement`).
+ *
+ * The wrapping of each value (`FunctionMaybe<T>` in `jsx-h.d.ts` vs. the
+ * raw value in `jsx.d.ts`) is applied by each consumer when composing its
+ * own `Properties<T>` mapped type. That way this file stays identical in
+ * both reactive and non-reactive contexts and only needs to exist once.
+ *
+ * originally from
+ * @url https://github.com/potahtml/pota
+ */
+
+/** Base-class properties shared by all elements — skipped from `prop:*`. */
+export type SkipPropsFrom = HTMLUnknownElement & HTMLElement & Element & Node;
+
+/**
+ * Value types allowed on a `prop:*`. Primitives plus the writable
+ * non-primitive DOM-object props worth exposing:
+ *
+ * - `HTMLMediaElement.srcObject`
+ * - `HTMLButtonElement.popoverTargetElement` / `commandForElement` (and the same via
+ *   `PopoverTargetAttributes` mixin on `HTMLInputElement`)
+ */
+export type PropValue =
+  | string
+  | number
+  | boolean
+  | null
+  | MediaStream
+  | MediaSource
+  | Blob
+  | File
+  | Element;
+
+/**
+ * Ergonomics widening for emitted `prop:*` value types:
+ *
+ * - general `string` → `string | number` (HTML coerces numbers)
+ * - string literal unions (`'on' | 'off'`) stay exact, so users still get autocomplete /
+ *   narrowing
+ * - other types pass through unchanged
+ */
+type WidenString<V> = string extends V ? string | number : V;
+export type WidenPropValue<V> = [V] extends [string] ? WidenString<V> : V;
+
+/**
+ * Structurally identical → `Y`; distinct → `N`. Used by `IsReadonlyKey` to detect
+ * readonly keys by comparing `Pick<T, K>` with `Readonly<Pick<T, K>>`.
+ */
+export type IfEquals<A, B, Y = unknown, N = never> =
+  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? Y : N;
+
+/**
+ * True when `K` is readonly on `T`. Singleton-constant properties (e.g.
+ * `tagName: "INPUT"`, `nodeType: 1`) are always `readonly` in `lib.dom.d.ts`, so this
+ * single check covers both readonly and singleton-literal cases.
+ */
+export type IsReadonlyKey<T, K extends keyof T> = IfEquals<
+  Pick<T, K>,
+  Readonly<Pick<T, K>>,
+  true,
+  false
+>;
+
+/**
+ * Resolves to the `prop:K` string literal when `K` is a writable, element-specific
+ * property suitable for a `prop:*` attribute; otherwise resolves to `never` so the
+ * key is filtered out of the resulting mapped type.
+ *
+ * Filters out:
+ *
+ * - base-class keys (via `SkipPropsFrom`)
+ * - aria-* keys (already typed via `AriaAttributes`)
+ * - readonly keys
+ * - keys whose value types fall outside `PropValue`
+ * - the generic `string` index signature (e.g. `HTMLFormElement[name: string]: any`),
+ *   which would otherwise shadow every key with an `any`-typed `prop:*`
+ */
+export type PropKey<T, K extends keyof T> = K extends keyof SkipPropsFrom
+  ? never
+  : K extends string
+    ? string extends K
+      ? never
+      : K extends `aria${string}`
+        ? never
+        : T[K] extends PropValue
+          ? IsReadonlyKey<T, K> extends true
+            ? never
+            : `prop:${K}`
+          : never
+    : never;