add more

Author: amirhhashemi

src/routes/reference/reactive-utilities/from.mdx

@@ -17,7 +17,7 @@ function from<T>(
 
 ```
 
-A helper to make it easier to interop with external producers like RxJS observables or with Svelte Stores. 
+A helper to make it easier to interop with external producers like RxJS observables or with Svelte Stores.
 This basically turns any subscribable (object with a subscribe method) into a Signal and manages subscription and disposal.
 
 ```tsx
@@ -36,8 +36,10 @@ const clock = from((set) => {
 })
 ```
 
-## Arguments
+## Parameters
 
-| Name     | Type                                                                                                                           | Description                                  |
-| :------- | :----------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------- |
-| producer | `((setter: (v: T) => T) => () => void) \| { subscribe: (fn: (v: T) => void) => (() => void) \| { unsubscribe: () => void }; }` | The producer function or subscribable object |
+### `producer`
+
+**Type**: `((setter: (v: T) => T) => () => void) | { subscribe: (fn: (v: T) => void) => (() => void) | { unsubscribe: () => void }; }`
+
+The producer function or subscribable object.

src/routes/reference/reactive-utilities/index-array.mdx

@@ -12,7 +12,7 @@ function indexArray<T, U>(
 
 ```
 
-Similar to `mapArray` except it maps by index. 
+Similar to `mapArray` except it maps by index.
 The item is a signal and the index is now the constant.
 
 Underlying helper for the `<Index>` control flow.
@@ -33,9 +33,16 @@ const mapped = indexArray(source, (model) => {
 });
 ```
 
-## Arguments
+## Parameters
 
-| Name  | Type                           | Description           |
-| :---- | :----------------------------- | :-------------------- |
-| list  | `() => readonly T[]`           | The list to map.      |
-| mapFn | `(v: () => T, i: number) => U` | The mapping function. |
+### `list`
+
+**Type**: `() => readonly T[]`
+
+The list to map.
+
+### `mapFn`
+
+**Type**: `(v: () => T, i: number) => U`
+
+The mapping function.

src/routes/reference/reactive-utilities/map-array.mdx

@@ -12,8 +12,8 @@ function mapArray<T, U>(
 
 ```
 
-Reactive map helper that caches each item by reference to reduce unnecessary mapping on updates. 
-It only runs the mapping function once per value and then moves or removes it as needed. 
+Reactive map helper that caches each item by reference to reduce unnecessary mapping on updates.
+It only runs the mapping function once per value and then moves or removes it as needed.
 The index argument is a signal. The map function itself is not tracking.
 
 Underlying helper for the `<For>` control flow.
@@ -37,9 +37,16 @@ const mapped = mapArray(source, (model) => {
 })
 ```
 
-## Arguments
+## Parameters
 
-| Name  | Type                           | Description              |
-| :---- | :----------------------------- | :----------------------- |
-| list  | `() => readonly T[]`           | The source array to map. |
-| mapFn | `(v: T, i: () => number) => U` | The mapping function.    |
+### `list`
+
+**Type**: `() => readonly T[]`
+
+The source array to map.
+
+### `mapFn`
+
+**Type**: `(v: T, i: () => number) => U`
+
+The mapping function.

src/routes/reference/reactive-utilities/on-util.mdx

@@ -61,10 +61,22 @@ createEffect(
 setState({ a: 4 }); // logs 4
 ```
 
-## Arguments and options
+## Parameters
 
-| Argument | Type                                           | Description                                       |
-| :------- | :--------------------------------------------- | :------------------------------------------------ |
-| deps     | `T`                                            | The dependencies to watch.                        |
-| fn       | `(input: T, prevInput: T, prevValue?: U) => U` | The function to run when the dependencies change. |
-| options  | `{ defer?: boolean }`                          | Options to configure the effect.                  |
+### `deps`
+
+**Type**: `T`
+
+The dependencies to watch.
+
+### `fn`
+
+**Type**: `(input: T, prevInput: T, prevValue?: U) => U`
+
+The function to run when the dependencies change.
+
+### `options`
+
+**Type**: `{ defer?: boolean }`
+
+Options to configure the effect.

src/routes/reference/secondary-primitives/create-computed.mdx

@@ -9,23 +9,30 @@ function createComputed<T>(fn: (v: T) => T, value?: T): void
 
 ```
 
-`createComputed` creates a new computation that immediately runs the given function in a tracking scope, thus automatically tracking its dependencies, and automatically reruns the function whenever the dependencies changes. 
-The function gets called with an argument equal to the value returned from the function's last execution, or on the first call, equal to the optional second argument to `createComputed`. 
+`createComputed` creates a new computation that immediately runs the given function in a tracking scope, thus automatically tracking its dependencies, and automatically reruns the function whenever the dependencies changes.
+The function gets called with an argument equal to the value returned from the function's last execution, or on the first call, equal to the optional second argument to `createComputed`.
 Note that the return value of the function is not otherwise exposed; in particular, createComputed has no return value.
 
-`createComputed` is the most immediate form of reactivity in Solid, and is most useful for building other reactive primitives. 
-For example, some other Solid primitives are built from `createComputed`. 
-However, it should be used with care, as `createComputed` can easily cause more unnecessary updates than other reactive primitives. 
+`createComputed` is the most immediate form of reactivity in Solid, and is most useful for building other reactive primitives.
+For example, some other Solid primitives are built from `createComputed`.
+However, it should be used with care, as `createComputed` can easily cause more unnecessary updates than other reactive primitives.
 Before using it, consider the closely related primitives [`createMemo`](/reference/basic-reactivity/create-memo) and [`createRenderEffect`](/reference/secondary-primitives/create-render-effect).
 
-Like `createMemo`, `createComputed` calls its function immediately on updates (unless you're in a [batch](/reference/reactive-utilities/batch), [effect](/reference/basic-reactivity/create-effect), or [transition](/reference/reactive-utilities/use-transition)). 
-However, while `createMemo` functions should be pure (not set any signals), `createComputed` functions can set signals. 
-Related, `createMemo` offers a readonly signal for the return value of the function, whereas to do the same with `createComputed` you would need to set a signal within the function. 
+Like `createMemo`, `createComputed` calls its function immediately on updates (unless you're in a [batch](/reference/reactive-utilities/batch), [effect](/reference/basic-reactivity/create-effect), or [transition](/reference/reactive-utilities/use-transition)).
+However, while `createMemo` functions should be pure (not set any signals), `createComputed` functions can set signals.
+Related, `createMemo` offers a readonly signal for the return value of the function, whereas to do the same with `createComputed` you would need to set a signal within the function.
 If it is possible to use pure functions and `createMemo`, this is likely more efficient, as Solid optimizes the execution order of memo updates, whereas updating a signal within `createComputed` will immediately trigger reactive updates some of which may turn out to be unnecessary.
 
-## Arguments
+## Parameters
 
-| Name    | Type          | Description                                |
-| :------ | :------------ | :----------------------------------------- |
-| `fn`    | `(v: T) => T` | The function to run in a tracking scope.   |
-| `value` | `T`           | The initial value to pass to the function. |
+### `fn`
+
+**Type**: `(v: T) => T`
+
+The function to run in a tracking scope.
+
+### `value`
+
+**Type**: `T`
+
+The initial value to pass to the function.

src/routes/reference/secondary-primitives/create-render-effect.mdx

@@ -9,13 +9,13 @@ function createRenderEffect<T>(fn: (v: T) => T, value?: T): void
 
 ```
 
-A render effect is a computation similar to a regular effect (as created by [`createEffect`](/reference/basic-reactivity/create-effect)), but differs in when Solid schedules the first execution of the effect function. 
-While `createEffect` waits for the current rendering phase to be complete, `createRenderEffect` immediately calls the function. 
-Thus the effect runs as DOM elements are being created and updated, but possibly before specific elements of interest have been created, and probably before those elements have been connected to the document. 
-In particular, **refs** will not be set before the initial effect call. 
+A render effect is a computation similar to a regular effect (as created by [`createEffect`](/reference/basic-reactivity/create-effect)), but differs in when Solid schedules the first execution of the effect function.
+While `createEffect` waits for the current rendering phase to be complete, `createRenderEffect` immediately calls the function.
+Thus the effect runs as DOM elements are being created and updated, but possibly before specific elements of interest have been created, and probably before those elements have been connected to the document.
+In particular, **refs** will not be set before the initial effect call.
 Indeed, Solid uses `createRenderEffect` to implement the rendering phase itself, including setting of **refs**.
 
-Reactive updates to render effects are identical to effects: they queue up in response to a reactive change (e.g., a single signal update, or a batch of changes, or collective changes during an entire render phase) and run in a single [`batch`](/reference/reactive-utilities/batch) afterward (together with effects). 
+Reactive updates to render effects are identical to effects: they queue up in response to a reactive change (e.g., a single signal update, or a batch of changes, or collective changes during an entire render phase) and run in a single [`batch`](/reference/reactive-utilities/batch) afterward (together with effects).
 In particular, all signal updates within a render effect are batched.
 
 Here is an example of the behavior. (Compare with the example in [`createEffect`](/reference/basic-reactivity/create-effect).)
@@ -49,9 +49,16 @@ queueMicrotask(() => {
 
 Just like `createEffect`, the effect function gets called with an argument equal to the value returned from the effect function's last execution, or on the first call, equal to the optional second argument of `createRenderEffect`.
 
-## Arguments
+## Parameters
 
-| Name    | Type          | Description                                            |
-| :------ | :------------ | :----------------------------------------------------- |
-| `fn`    | `(v: T) => T` | The effect function to be called.                      |
-| `value` | `T`           | The initial value to be passed to the effect function. |
+### `fn`
+
+**Type**: `(v: T) => T`
+
+The effect function to be called.
+
+### `value`
+
+**Type**: `T`
+
+The initial value to be passed to the effect function.

src/routes/reference/secondary-primitives/create-selector.mdx

@@ -39,7 +39,7 @@ const isSelected = createSelector(selectedId)
 In the code above, each `li` element receives an `active` class
 exactly when the corresponding `item.id` is equal to `selectedId()`.
 When the `selectedId` signal changes, the `li` element(s) that previously
-had previously matching `id` get the `active` class removed, and the 
+had previously matching `id` get the `active` class removed, and the
 `li` element(s) that now have a matching `id` get the `active` class added.
 All other `li` elements get skipped, so if `id`s are distinct,
 only 2 DOM operations get performed.
@@ -55,9 +55,18 @@ const [selectedId, setSelectedId] = createSignal()
 </For>
 ```
 
-## Arguments
+## Parameters
 
-| Name     | Type                      | Description                                  |
-| :------- | :------------------------ | :------------------------------------------- |
-| `source` | `() => T`                 | The source signal to get the value from and compare with keys. |
-| `fn`     | `(a: U, b: T) => boolean` | A function to compare the key and the value, returning whether they should be treated as equal. Default: `===` |
+### `source`
+
+**Type**: `() => T`
+
+The source signal to get the value from and compare with keys.
+
+### `fn`
+
+**Type**: `(a: U, b: T) => boolean`
+
+**Default**: `===`
+
+A function to compare the key and the value, returning whether they should be treated as equal.

src/routes/solid-router/reference/data-apis/cache.mdx

@@ -94,14 +94,21 @@ The return value is a `CachedFunction`, a function that has the same signature a
 This cached function stores the return value using the cache key.
 Under most circumstances, this temporarily prevents the passed function from running with the same arguments, even if the created function is called repeatedly.
 
-## Arguments
+## Parameters
 
-| argument | type                    | description                                                               |
-| -------- | ----------------------- | ------------------------------------------------------------------------- |
-| `fn`     | `(...args: any) => any` | A function whose return value you'd like to be cached.                    |
-| `name`\* | string                  | Any arbitrary string that you'd like to use as the rest of the cache key. |
+### `fn`
 
-\*Since the internal cache is shared by all the functions using `cache`, the string should be unique for each function passed to `cache`.
+**Type**: `(...args: any) => any`
+
+A function whose return value you'd like to be cached.
+
+### `name`
+
+**Type**: string
+
+Any arbitrary string that you'd like to use as the rest of the cache key.
+
+Since the internal cache is shared by all the functions using `cache`, the string should be unique for each function passed to `cache`.
 If the same key is used with multiple functions, one function might return the cached result of the other.
 
 ## Methods

src/routes/solid-router/reference/data-apis/create-async.mdx

@@ -48,8 +48,6 @@ This is used for debugging purposes.
 
 If true, Solid will wait for the resource to resolve before flushing the stream.
 
-| initialValue | `any`                   | `undefined`    | The initial value of the resource.                                                                                                                            |
-
 ### `initialValue`
 
 The initial value of the resource.

src/routes/solid-router/reference/data-apis/query.mdx

@@ -89,14 +89,21 @@ The return value is a `CachedFunction`, a function that has the same signature a
 This cached function stores the return value using the cache key.
 Under most circumstances, this temporarily prevents the passed function from running with the same arguments, even if the created function is called repeatedly.
 
-## Arguments
+## Parameters
 
-| argument | type                    | description                                                               |
-| -------- | ----------------------- | ------------------------------------------------------------------------- |
-| `fn`     | `(...args: any) => any` | A function whose return value you'd like to be cached.                    |
-| `name`\* | string                  | Any arbitrary string that you'd like to use as the rest of the cache key. |
+### `fn`
 
-\*Since the internal cache is shared by all the functions using `query`, the string should be unique for each function passed to `query`.
+**Type**: `(...args: any) => any`
+
+A function whose return value you'd like to be cached.
+
+### `name`
+
+**Type**: `string`
+
+Any arbitrary string that you'd like to use as the rest of the cache key.
+
+Since the internal cache is shared by all the functions using `query`, the string should be unique for each function passed to `query`.
 If the same key is used with multiple functions, one function might return the cached result of the other.
 
 ## Methods