@solidjs/signals 2.0.0-beta.32 → 2.0.0-beta.34

package/dist/types-cjs/signals.d.cts

@@ -111,6 +111,28 @@ export interface EffectOptions extends BaseEffectOptions {
      * stored as-is and never awaited.
      */
     sync?: boolean;
+    /**
+     * Advanced (integration tier). When true, the effect is invisible to the
+     * hydration id scheme: it inherits its parent's id instead of consuming a
+     * child slot, and during hydration its compute runs live instead of
+     * adopting the serialized server value (its first run is not frozen to
+     * the server's decision).
+     *
+     * For **client-only effects created while hydrating** — effects with no
+     * server-rendered counterpart (a router wiring link state, scroll
+     * restoration, etc.). An id-consuming node the server never created would
+     * shift every later sibling's hydration id, making serialized lookups and
+     * template claims after it miss. `transparent` is also the supported
+     * alternative to branching on hydration state
+     * (`if (hydrating) createEffect(...)`), which freezes whatever the first
+     * run decided: create the effect unconditionally and let it observe live
+     * state instead.
+     *
+     * SSR ignores this option (a server-side effect always allocates its id
+     * slot), so only mark effects the server does not create. Outside
+     * hydration it is a no-op.
+     */
+    transparent?: boolean;
 }
 /** Options for plain signals created with `createSignal(value)` or `createOptimistic(value)`. */
 export interface SignalOptions<T> {
@@ -138,7 +160,14 @@ export interface MemoOptions<T> {
     id?: string;
     /** Debug name (dev mode only) */
     name?: string;
-    /** When true, the owner is invisible to the ID scheme -- inherits parent ID and doesn't consume a childCount slot */
+    /**
+     * Advanced (integration tier). When true, the memo is invisible to the
+     * hydration id scheme: it inherits its parent's id instead of consuming a
+     * child slot, and during hydration it computes live instead of adopting
+     * the serialized server value. For client-only memos with no
+     * server-rendered counterpart — see {@link EffectOptions.transparent} for
+     * the full semantics. No-op outside hydration.
+     */
     transparent?: boolean;
     /**
      * Custom equality function, or `false` to always notify subscribers.
@@ -168,6 +197,30 @@ export interface MemoOptions<T> {
      * stored as-is and never awaited.
      */
     sync?: boolean;
+    /**
+     * Commit #0: a committed value the memo is born with, shown until the
+     * compute's first real answer lands. While that first answer is in flight
+     * the memo reads as a settled value everywhere — nothing suspends to a
+     * `<Loading>` boundary, no transition is held (first-flight work is
+     * loading-class, like a boundary fallback), and `isPending(memo)` stays
+     * **false**: commit #0 answers the question by declaration, so first-load
+     * affordances are driven from the value itself (a `null` placeholder, a
+     * `skeleton: true` field, etc.). Once the first answer lands, the loading
+     * value leaves the lineage forever: refetches use normal pending semantics
+     * (stale value shown, `isPending` true, boundaries/transitions coordinate)
+     * — the canonical guard is `data.skeleton || isPending(data)`, whose two
+     * terms cover the two disjoint states.
+     *
+     * Typed strictly as `T`: to use `null`/`undefined` as the placeholder,
+     * declare it in the memo's type (e.g. `createMemo<User | null>(...)`), so
+     * every consumer sees the nullable window honestly. If the placeholder is
+     * shaped data standing in for real data, encode its provenance in the data
+     * (e.g. a `skeleton: true` field) rather than letting it impersonate truth.
+     *
+     * The loading value is also the compute's first `prev`, so `prev`-based
+     * memos fold from it.
+     */
+    loadingValue?: T;
 }
 export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
 /**
@@ -216,7 +269,7 @@ export declare function createSignal<T>(fn: ComputeFunction<T>, options?: Signal
  * const value = createMemo<T>(compute, options?: MemoOptions<T>);
  * ```
  * @param compute a function that receives its previous value and returns a new value used to react on a computation
- * @param options `MemoOptions` -- id, name, equals, unobserved, lazy
+ * @param options `MemoOptions` -- id, name, equals, unobserved, lazy, transparent
  *
  * @example
  * ```ts
@@ -239,6 +292,9 @@ export declare function createSignal<T>(fn: ComputeFunction<T>, options?: Signal
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
  */
+export declare function createMemo<T>(compute: ComputeFunction<NoInfer<T>, T>, options: MemoOptions<T> & {
+    loadingValue: T;
+}): SourceAccessor<T>;
 export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: MemoOptions<T>): SourceAccessor<T>;
 /**
  * Creates a reactive effect with **separate compute and effect phases**.
@@ -280,7 +336,7 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * ```
  * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects (return a cleanup function), or an `EffectBundle` with `effect` and `error` handlers
- * @param options `EffectOptions` -- name, defer, schedule
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
  *
  * @example
  * ```ts
@@ -334,7 +390,7 @@ export declare function createEffect<T>(compute: ComputeFunction<undefined | NoI
  * ```
  * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects
- * @param options `EffectOptions` -- name, defer, schedule
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
  *
  * @example
  * ```ts

package/dist/types-cjs/store/store.d.cts

@@ -33,6 +33,20 @@ export interface ProjectionOptions extends StoreOptions {
     key?: string | ((item: NonNullable<any>) => any) | null;
     /** Single-layer store: root keys reactive, values raw records replaced by reference */
     shallow?: boolean;
+    /**
+     * Treat the seed as commit #0: the store is born committed with the seed's
+     * contents, shown until the derive's first real answer lands. While that
+     * first answer is in flight, reads serve the seed everywhere — nothing
+     * suspends to a `<Loading>` boundary, no transition is held, and
+     * `isPending` stays false (the seed answers by declaration; first-load
+     * affordances belong to the data, e.g. a `skeleton: true` field in the
+     * seed). Once the first answer lands (reconciled into the seed), refetches
+     * use normal pending semantics with `isPending` true.
+     *
+     * The store equivalent of `MemoOptions.loadingValue`; the seed already
+     * carries the placeholder shape, so this is just the opt-in.
+     */
+    seedLoadingValue?: boolean;
 }
 export type NoFn<T> = T extends Function ? never : T;
 type DataNode = Signal<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-beta.32",
+  "version": "2.0.0-beta.34",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",