Refine Solid v2 reference generation

Author: LadyBluenotes

scripts/extract-solid-ref.mjs

@@ -97,3 +97,52 @@ createEffect(
 	}
 );
 ```
+
+## Related types
+
+### `ComputeFunction`
+
+```ts
+type ComputeFunction<Prev, Next extends Prev = Prev> = (
+  v: Prev
+) => PromiseLike<Next> | AsyncIterable<Next> | Next;
+```
+
+### `EffectBundle`
+
+```ts
+type EffectBundle<Prev, Next extends Prev = Prev> = {
+  effect: EffectFunction<Prev, Next>;
+  error: (err: unknown, cleanup: () => void) => void;
+};
+```
+
+### `EffectFunction`
+
+```ts
+type EffectFunction<Prev, Next extends Prev = Prev> = (
+  v: Next,
+  p?: Prev
+) => (() => void) | void;
+```
+
+### `EffectOptions`
+
+Options for effect primitives that support deferring/scheduling their initial run (`createEffect`, `createRenderEffect`, `createReaction`).
+
+```ts
+interface EffectOptions extends BaseEffectOptions {
+  /** When true, defers the initial effect execution until the next change */
+  defer?: boolean;
+  /**
+   * When true, enqueues the initial effect callback through the effect queue instead of running
+   * it synchronously at creation. Lets the initial run participate in transitions -- if any
+   * source throws `NotReadyError` during the compute phase, the callback is held until the
+   * transition settles.
+   *
+   * Primarily for render effects that need transition-aware initial mounts (e.g. the root
+   * `insert()` in `render()`).
+   */
+  schedule?: boolean;
+};
+```

…2/reference/reactivity/create-effect.mdx …eference/(1)reactivity/create-effect.mdxsrc/routes/v2/reference/reactivity/create-effect.mdx renamed to src/routes/v2/reference/(1)reactivity/create-effect.mdx src/routes/v2/reference/reactivity/create-effect.mdx renamed to src/routes/v2/reference/(1)reactivity/create-effect.mdx

@@ -0,0 +1,127 @@
+---
+title: "createMemo"
+category: "Reactivity"
+version: "2.0"
+description: "Creates a readonly derived reactive memoized signal."
+source_repo: "solidjs/solid"
+source_ref: "next"
+source_sha: "a93a216ef35bd053949493506942884fb24e7684"
+source_path: "packages/solid-signals/src/signals.ts"
+---
+
+{/* Generated by scripts/extract-solid-ref.mjs. Edit the source JSDoc or disposition map, then regenerate. */}
+
+Creates a readonly derived reactive memoized signal.
+
+```typescript
+const value = createMemo<T>(compute, options?: MemoOptions<T>);
+```
+
+## Import
+
+```ts
+import { createMemo } from "solid-js";
+```
+
+## Type signature
+
+```ts
+function createMemo<T>(
+  compute: ComputeFunction<undefined | NoInfer<T>, T>,
+  options?: MemoOptions<T>
+): Accessor<T>;
+```
+
+## Parameters
+
+### `compute`
+
+a function that receives its previous value and returns a new value used to react on a computation
+
+### `options`
+
+`MemoOptions` -- id, name, equals, unobserved, lazy
+
+## Examples
+
+```ts
+const [first, setFirst] = createSignal("Ada");
+const [last, setLast] = createSignal("Lovelace");
+
+const fullName = createMemo(() => `${first()} ${last()}`);
+
+fullName(); // "Ada Lovelace"
+```
+
+```ts
+// Async memo — reads surface as pending inside <Loading>
+const user = createMemo(async () => {
+  const res = await fetch(`/users/${id()}`);
+  return res.json();
+});
+```
+
+## Related types
+
+### `isEqual`
+
+```ts
+function isEqual<T>(a: T, b: T): boolean;
+```
+
+### `MemoOptions`
+
+Options for read-only memos created with `createMemo`.
+Also used in combination with `SignalOptions` for writable memos
+(`createSignal(fn)` / `createOptimistic(fn)`).
+
+```ts
+interface MemoOptions<T> {
+  /** Stable identifier for the owner hierarchy */
+  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 */
+  transparent?: boolean;
+  /**
+   * Custom equality function, or `false` to always notify subscribers.
+   * Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
+   * `(a, b) => a.id === b.id`) for value-based equality, or `false` to
+   * notify on every recompute regardless of equality.
+   */
+  equals?: false | ((prev: T, next: T) => boolean);
+  /** Callback invoked when the computed loses all subscribers */
+  unobserved?: () => void;
+  /**
+   * When true, defers the initial computation until the value is first read,
+   * **and** opts the memo into autodisposal — once it has no remaining
+   * subscribers it is torn down and recomputed from scratch on the next read.
+   * Use it for compute-on-demand values that should not retain state across
+   * idle periods. Non-lazy owned memos live for their owner's lifetime and
+   * never autodispose.
+   */
+  lazy?: boolean;
+};
+```
+
+### `SignalOptions`
+
+Options for plain signals created with `createSignal(value)` or `createOptimistic(value)`.
+
+```ts
+interface SignalOptions<T> {
+  /** Debug name (dev mode only) */
+  name?: string;
+  /**
+   * Custom equality function, or `false` to always notify subscribers.
+   * Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
+   * `(a, b) => a.id === b.id`) for value-based equality, or `false` to
+   * notify on every write regardless of equality.
+   */
+  equals?: false | ((prev: T, next: T) => boolean);
+  /** Suppress dev-mode warnings when writing inside an owned scope */
+  ownedWrite?: boolean;
+  /** Callback invoked when the signal loses all subscribers */
+  unobserved?: () => void;
+};
+```

src/routes/v2/reference/(1)reactivity/create-memo.mdx

@@ -0,0 +1,143 @@
+---
+title: "createSignal"
+category: "Reactivity"
+version: "2.0"
+description: "Creates a simple reactive state with a getter and setter."
+source_repo: "solidjs/solid"
+source_ref: "next"
+source_sha: "a93a216ef35bd053949493506942884fb24e7684"
+source_path: "packages/solid-signals/src/signals.ts"
+---
+
+{/* Generated by scripts/extract-solid-ref.mjs. Edit the source JSDoc or disposition map, then regenerate. */}
+
+Creates a simple reactive state with a getter and setter.
+
+When called with a plain value, creates a signal with `SignalOptions` (name, equals, ownedWrite, unobserved).
+When called with a function, creates a writable memo with `SignalOptions & MemoOptions` (adds id, lazy).
+
+```typescript
+// Plain signal
+const [state, setState] = createSignal<T>(value, options?: SignalOptions<T>);
+// Writable memo (function overload)
+const [state, setState] = createSignal<T>(fn, initialValue?, options?: SignalOptions<T> & MemoOptions<T>);
+```
+
+## Import
+
+```ts
+import { createSignal } from "solid-js";
+```
+
+## Type signature
+
+```ts
+function createSignal<T>(): Signal<T | undefined>;
+function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+function createSignal<T>(
+  fn: ComputeFunction<T>,
+  options?: SignalOptions<T> & MemoOptions<T>
+): Signal<T>;
+```
+
+## Parameters
+
+### `value`
+
+initial value of the state; if empty, the state's type will automatically extended with undefined
+
+### `options`
+
+optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
+
+## Return value
+
+`[state: Accessor<T>, setState: Setter<T>]`
+
+## Examples
+
+```ts
+const [count, setCount] = createSignal(0);
+
+count();              // 0
+setCount(1);          // explicit value
+setCount(c => c + 1); // updater
+```
+
+```ts
+// Writable memo: starts as `fn()`, can be locally overwritten by setter.
+const [user, setUser] = createSignal(() => fetchUser(userId()));
+
+setUser({ ...user(), name: "Alice" }); // optimistic local edit
+```
+
+## Related types
+
+### `isEqual`
+
+```ts
+function isEqual<T>(a: T, b: T): boolean;
+```
+
+### `MemoOptions`
+
+Options for read-only memos created with `createMemo`.
+Also used in combination with `SignalOptions` for writable memos
+(`createSignal(fn)` / `createOptimistic(fn)`).
+
+```ts
+interface MemoOptions<T> {
+  /** Stable identifier for the owner hierarchy */
+  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 */
+  transparent?: boolean;
+  /**
+   * Custom equality function, or `false` to always notify subscribers.
+   * Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
+   * `(a, b) => a.id === b.id`) for value-based equality, or `false` to
+   * notify on every recompute regardless of equality.
+   */
+  equals?: false | ((prev: T, next: T) => boolean);
+  /** Callback invoked when the computed loses all subscribers */
+  unobserved?: () => void;
+  /**
+   * When true, defers the initial computation until the value is first read,
+   * **and** opts the memo into autodisposal — once it has no remaining
+   * subscribers it is torn down and recomputed from scratch on the next read.
+   * Use it for compute-on-demand values that should not retain state across
+   * idle periods. Non-lazy owned memos live for their owner's lifetime and
+   * never autodispose.
+   */
+  lazy?: boolean;
+};
+```
+
+### `NoInfer`
+
+```ts
+type NoInfer<T extends any> = [T][T extends any ? 0 : never];
+```
+
+### `SignalOptions`
+
+Options for plain signals created with `createSignal(value)` or `createOptimistic(value)`.
+
+```ts
+interface SignalOptions<T> {
+  /** Debug name (dev mode only) */
+  name?: string;
+  /**
+   * Custom equality function, or `false` to always notify subscribers.
+   * Defaults to reference equality (`isEqual`). Pass a comparator (e.g.
+   * `(a, b) => a.id === b.id`) for value-based equality, or `false` to
+   * notify on every write regardless of equality.
+   */
+  equals?: false | ((prev: T, next: T) => boolean);
+  /** Suppress dev-mode warnings when writing inside an owned scope */
+  ownedWrite?: boolean;
+  /** Callback invoked when the signal loses all subscribers */
+  unobserved?: () => void;
+};
+```

…ference/reactivity/create-optimistic.mdx …ence/(1)reactivity/create-optimistic.mdxsrc/routes/v2/reference/reactivity/create-optimistic.mdx renamed to src/routes/v2/reference/(1)reactivity/create-optimistic.mdx src/routes/v2/reference/reactivity/create-optimistic.mdx renamed to src/routes/v2/reference/(1)reactivity/create-optimistic.mdx

@@ -74,3 +74,18 @@ const removeTodo = action(function* (id: string) {
 	yield api.removeTodo(id);
 });
 ```
+
+## Related types
+
+### `Refreshable`
+
+Brand applied to derived/projected stores indicating they participate in
+the `refresh()` re-run protocol. Use this alias instead of inlining
+`T & { [$REFRESH]: any }` so that user-defined hooks that wrap
+`createOptimisticStore` / `createProjection` / projection-form
+`createStore` can have their return types inferred without leaking the
+internal `$REFRESH` symbol into public type signatures (TS4058).
+
+```ts
+type Refreshable<T> = T & { readonly [$REFRESH]: any };
+```