ci: apply automated fixes

Author: autofix-ci[bot]

scripts/extract-solid-ref.mjs

@@ -750,9 +750,7 @@ function getDocs(declarations) {
 function renderComment(comment) {
 	if (!comment) return "";
 	if (typeof comment === "string") return comment;
-	return comment
-		.map((part) => renderCommentPart(part))
-		.join("");
+	return comment.map((part) => renderCommentPart(part)).join("");
 }
 
 function renderCommentPart(part) {

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

@@ -104,25 +104,25 @@ createEffect(
 
 ```ts
 type ComputeFunction<Prev, Next extends Prev = Prev> = (
-  v: 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;
+	effect: EffectFunction<Prev, Next>;
+	error: (err: unknown, cleanup: () => void) => void;
 };
 ```
 
 ### `EffectFunction`
 
 ```ts
 type EffectFunction<Prev, Next extends Prev = Prev> = (
-  v: Next,
-  p?: Prev
+	v: Next,
+	p?: Prev
 ) => (() => void) | void;
 ```
 
@@ -132,17 +132,17 @@ Options for effect primitives that support deferring/scheduling their initial ru
 
 ```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;
-};
+	/** 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;
+}
 ```

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

@@ -27,8 +27,8 @@ import { createMemo } from "solid-js";
 
 ```ts
 function createMemo<T>(
-  compute: ComputeFunction<undefined | NoInfer<T>, T>,
-  options?: MemoOptions<T>
+	compute: ComputeFunction<undefined | NoInfer<T>, T>,
+	options?: MemoOptions<T>
 ): Accessor<T>;
 ```
 
@@ -56,8 +56,8 @@ 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();
+	const res = await fetch(`/users/${id()}`);
+	return res.json();
 });
 ```
 
@@ -77,31 +77,31 @@ Also used in combination with `SignalOptions` for writable memos
 
 ```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;
-};
+	/** 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`
@@ -110,18 +110,18 @@ Options for plain signals created with `createSignal(value)` or `createOptimisti
 
 ```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;
-};
+	/** 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-signal.mdx

@@ -33,10 +33,13 @@ import { createSignal } from "solid-js";
 
 ```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>
+	value: Exclude<T, Function>,
+	options?: SignalOptions<T>
+): Signal<T>;
+function createSignal<T>(
+	fn: ComputeFunction<T>,
+	options?: SignalOptions<T> & MemoOptions<T>
 ): Signal<T>;
 ```
 
@@ -59,9 +62,9 @@ optional object with a name for debugging purposes and equals, a comparator func
 ```ts
 const [count, setCount] = createSignal(0);
 
-count();              // 0
-setCount(1);          // explicit value
-setCount(c => c + 1); // updater
+count(); // 0
+setCount(1); // explicit value
+setCount((c) => c + 1); // updater
 ```
 
 ```ts
@@ -87,31 +90,31 @@ Also used in combination with `SignalOptions` for writable memos
 
 ```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;
-};
+	/** 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`
@@ -126,18 +129,18 @@ Options for plain signals created with `createSignal(value)` or `createOptimisti
 
 ```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;
-};
+	/** 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/(2)stores/create-projection.mdx

@@ -86,9 +86,9 @@ Options for derived/projected stores created with `createStore(fn)`, `createProj
 
 ```ts
 interface ProjectionOptions extends StoreOptions {
-  /** Key property name or function for reconciliation identity */
-  key?: string | ((item: NonNullable<any>) => any);
-};
+	/** Key property name or function for reconciliation identity */
+	key?: string | ((item: NonNullable<any>) => any);
+}
 ```
 
 ### `Refreshable`

src/routes/v2/reference/(2)stores/create-store.mdx

@@ -96,9 +96,9 @@ Options for derived/projected stores created with `createStore(fn)`, `createProj
 
 ```ts
 interface ProjectionOptions extends StoreOptions {
-  /** Key property name or function for reconciliation identity */
-  key?: string | ((item: NonNullable<any>) => any);
-};
+	/** Key property name or function for reconciliation identity */
+	key?: string | ((item: NonNullable<any>) => any);
+}
 ```
 
 ### `Refreshable`
@@ -120,9 +120,9 @@ Base options for store primitives.
 
 ```ts
 interface StoreOptions {
-  /** Debug name (dev mode only) */
-  name?: string;
-};
+	/** Debug name (dev mode only) */
+	name?: string;
+}
 ```
 
 ### `StoreSetter`

src/routes/v2/reference/(2)stores/omit.mdx

@@ -63,6 +63,6 @@ function Input(
 
 ```ts
 type Omit<T, K extends readonly (keyof T)[]> = {
-  [P in keyof T as Exclude<P, K[number]>]: T[P];
+	[P in keyof T as Exclude<P, K[number]>]: T[P];
 };
 ```

src/routes/v2/reference/(4)components-context/children.mdx

@@ -57,7 +57,9 @@ function List(props: { children: JSX.Element }) {
 ### `ChildrenReturn`
 
 ```ts
-type ChildrenReturn = Accessor<ResolvedChildren> & { toArray: () => ResolvedJSXElement[] };
+type ChildrenReturn = Accessor<ResolvedChildren> & {
+	toArray: () => ResolvedJSXElement[];
+};
 ```
 
 ### `ResolvedChildren`

src/routes/v2/reference/(4)components-context/use-context.mdx

@@ -63,12 +63,12 @@ function TodoList() {
 
 ```ts
 class ContextNotFoundError extends Error {
-  constructor() {
-    super(
-      __DEV__
-        ? "Context must either be created with a default value or a value must be provided before accessing it."
-        : ""
-    );
-  }
-};
+	constructor() {
+		super(
+			__DEV__
+				? "Context must either be created with a default value or a value must be provided before accessing it."
+				: ""
+		);
+	}
+}
 ```

src/routes/v2/reference/(5)components-jsx/dynamic.mdx

@@ -44,8 +44,8 @@ function Dynamic<T extends ValidComponent>(props: DynamicProps<T>): JSX.Element;
 
 ```ts
 type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
-  [K in keyof P]: P[K];
+	[K in keyof P]: P[K];
 } & {
-  component: T | null | undefined | false;
+	component: T | null | undefined | false;
 };
 ```