docs(toolkit): resolve minor JSDoc issues (#5227)

* docs(toolkit): resolve minor JSDoc issues

* docs(toolkit): resolve minor JSDoc issues

* docs(toolkit): resolve minor JSDoc issues

Author: aryaemami59

errors.json

@@ -43,4 +43,4 @@
   "41": "getPreviousPageParam for endpoint '' must be a function if maxPages is used",
   "42": "Duplicate middleware references found when creating the store. Ensure that each middleware is only included once.",
   "43": "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`"
-}
+}

packages/toolkit/src/actionCreatorInvariantMiddleware.ts

@@ -14,7 +14,7 @@ export function getMessage(type?: unknown) {
   const actionName = splitType[splitType.length - 1] || 'actionCreator'
   return `Detected an action creator with type "${
     type || 'unknown'
-  }" being dispatched. 
+  }" being dispatched.
 Make sure you're calling the action creator before dispatching, i.e. \`dispatch(${actionName}())\` instead of \`dispatch(${actionName})\`. This is necessary even if the action has no payload.`
 }
 

packages/toolkit/src/createReducer.ts

@@ -100,46 +100,42 @@ export type ReducerWithInitialState<S extends NotFunction<any>> = Reducer<S> & {
  * @param builderCallback - `(builder: Builder) => void` A callback that receives a *builder* object to define
  *   case reducers via calls to `builder.addCase(actionCreatorOrType, reducer)`.
  * @example
-```ts
-import {
-  createAction,
-  createReducer,
-  UnknownAction,
-  PayloadAction,
-} from "@reduxjs/toolkit";
-
-const increment = createAction<number>("increment");
-const decrement = createAction<number>("decrement");
-
-function isActionWithNumberPayload(
-  action: UnknownAction
-): action is PayloadAction<number> {
-  return typeof action.payload === "number";
-}
-
-const reducer = createReducer(
-  {
-    counter: 0,
-    sumOfNumberPayloads: 0,
-    unhandledActions: 0,
-  },
-  (builder) => {
-    builder
-      .addCase(increment, (state, action) => {
-        // action is inferred correctly here
-        state.counter += action.payload;
-      })
-      // You can chain calls, or have separate `builder.addCase()` lines each time
-      .addCase(decrement, (state, action) => {
-        state.counter -= action.payload;
-      })
-      // You can apply a "matcher function" to incoming actions
-      .addMatcher(isActionWithNumberPayload, (state, action) => {})
-      // and provide a default case if no other handlers matched
-      .addDefaultCase((state, action) => {});
-  }
-);
-```
+ * ```ts
+ * import type { PayloadAction, UnknownAction } from '@reduxjs/toolkit';
+ * import { createAction, createReducer } from '@reduxjs/toolkit';
+ *
+ * const increment = createAction<number>('increment');
+ * const decrement = createAction<number>('decrement');
+ *
+ * function isActionWithNumberPayload(
+ *   action: UnknownAction,
+ * ): action is PayloadAction<number> {
+ *   return typeof action.payload === 'number';
+ * }
+ *
+ * const reducer = createReducer(
+ *   {
+ *     counter: 0,
+ *     sumOfNumberPayloads: 0,
+ *     unhandledActions: 0,
+ *   },
+ *   (builder) => {
+ *     builder
+ *       .addCase(increment, (state, action) => {
+ *         // action is inferred correctly here
+ *         state.counter += action.payload;
+ *       })
+ *       // You can chain calls, or have separate `builder.addCase()` lines each time
+ *       .addCase(decrement, (state, action) => {
+ *         state.counter -= action.payload;
+ *       })
+ *       // You can apply a "matcher function" to incoming actions
+ *       .addMatcher(isActionWithNumberPayload, (state, action) => {})
+ *       // and provide a default case if no other handlers matched
+ *       .addDefaultCase((state, action) => {});
+ *   },
+ * );
+ * ```
  * @public
  */
 export function createReducer<S extends NotFunction<any>>(

packages/toolkit/src/createSlice.ts

@@ -224,41 +224,43 @@ export interface CreateSliceOptions<
    *
    *
    * @example
-```ts
-import { createAction, createSlice, Action } from '@reduxjs/toolkit'
-const incrementBy = createAction<number>('incrementBy')
-const decrement = createAction('decrement')
-
-interface RejectedAction extends Action {
-  error: Error
-}
-
-function isRejectedAction(action: Action): action is RejectedAction {
-  return action.type.endsWith('rejected')
-}
-
-createSlice({
-  name: 'counter',
-  initialState: 0,
-  reducers: {},
-  extraReducers: builder => {
-    builder
-      .addCase(incrementBy, (state, action) => {
-        // action is inferred correctly here if using TS
-      })
-      // You can chain calls, or have separate `builder.addCase()` lines each time
-      .addCase(decrement, (state, action) => {})
-      // You can match a range of action types
-      .addMatcher(
-        isRejectedAction,
-        // `action` will be inferred as a RejectedAction due to isRejectedAction being defined as a type guard
-        (state, action) => {}
-      )
-      // and provide a default case if no other handlers matched
-      .addDefaultCase((state, action) => {})
-    }
-})
-```
+   * ```ts
+   * import type { Action } from '@reduxjs/toolkit';
+   * import { createAction, createSlice } from '@reduxjs/toolkit';
+   *
+   * const incrementBy = createAction<number>('incrementBy');
+   * const decrement = createAction('decrement');
+   *
+   * interface RejectedAction extends Action {
+   *   error: Error;
+   * }
+   *
+   * function isRejectedAction(action: Action): action is RejectedAction {
+   *   return action.type.endsWith('rejected');
+   * }
+   *
+   * createSlice({
+   *   name: 'counter',
+   *   initialState: 0,
+   *   reducers: {},
+   *   extraReducers: (builder) => {
+   *     builder
+   *       .addCase(incrementBy, (state, action) => {
+   *         // action is inferred correctly here if using TS
+   *       })
+   *       // You can chain calls, or have separate `builder.addCase()` lines each time
+   *       .addCase(decrement, (state, action) => {})
+   *       // You can match a range of action types
+   *       .addMatcher(
+   *         isRejectedAction,
+   *         // `action` will be inferred as a RejectedAction due to isRejectedAction being defined as a type guard
+   *         (state, action) => {},
+   *       )
+   *       // and provide a default case if no other handlers matched
+   *       .addDefaultCase((state, action) => {});
+   *   },
+   * });
+   * ```
    */
   extraReducers?: (builder: ActionReducerMapBuilder<State>) => void
 
@@ -905,11 +907,13 @@ interface ReducerHandlingContextMethods<State> {
    * @param name The key to be exposed as.
    * @param actionCreator The action to expose.
    * @example
-   * context.exposeAction("addPost", createAction<Post>("addPost"));
+   * ```ts
+   * context.exposeAction('addPost', createAction<Post>('addPost'));
    *
-   * export const { addPost } = slice.actions
+   * export const { addPost } = slice.actions;
    *
-   * dispatch(addPost(post))
+   * dispatch(addPost(post));
+   * ```
    */
   exposeAction(
     name: string,
@@ -920,11 +924,13 @@ interface ReducerHandlingContextMethods<State> {
    * @param name The key to be exposed as.
    * @param reducer The reducer to expose.
    * @example
-   * context.exposeCaseReducer("addPost", (state, action: PayloadAction<Post>) => {
-   *   state.push(action.payload)
-   * })
+   * ```ts
+   * context.exposeCaseReducer('addPost', (state, action: PayloadAction<Post>) => {
+   *   state.push(action.payload);
+   * });
    *
-   * slice.caseReducers.addPost([], addPost(post))
+   * slice.caseReducers.addPost([], addPost(post));
+   * ```
    */
   exposeCaseReducer(
     name: string,

packages/toolkit/src/listenerMiddleware/types.ts

@@ -110,11 +110,11 @@ export interface ForkedTask<T> {
    *
    * ### Example
    * ```ts
-   * const result = await fork(async (forkApi) => Promise.resolve(4)).result
+   * const result = await fork(async (forkApi) => Promise.resolve(4)).result;
    *
-   * if(result.status === 'ok') {
-   *   console.log(result.value) // logs 4
-   * }}
+   * if (result.status === 'ok') {
+   *   console.log(result.value); // logs 4
+   * }
    * ```
    */
   result: Promise<TaskResult<T>>
@@ -151,17 +151,17 @@ export interface ListenerEffectAPI<
    *
    * ```ts
    * middleware.startListening({
-   *  predicate: () => true,
-   *  async effect(_, { getOriginalState }) {
-   *    getOriginalState(); // sync: OK!
+   *   predicate: () => true,
+   *   async effect(_, { getOriginalState }) {
+   *     getOriginalState(); // sync: OK!
    *
-   *    setTimeout(getOriginalState, 0); // async: throws Error
+   *     setTimeout(getOriginalState, 0); // async: throws Error
    *
-   *    await Promise().resolve();
+   *     await Promise().resolve();
    *
-   *    getOriginalState() // async: throws Error
-   *  }
-   * })
+   *     getOriginalState(); // async: throws Error
+   *   },
+   * });
    * ```
    */
   getOriginalState: () => State
@@ -184,17 +184,19 @@ export interface ListenerEffectAPI<
    * ### Example
    *
    * ```ts
+   * import { createAction } from '@reduxjs/toolkit';
+   *
    * const updateBy = createAction<number>('counter/updateBy');
    *
    * middleware.startListening({
-   *  actionCreator: updateBy,
-   *  async effect(_, { condition }) {
-   *    // wait at most 3s for `updateBy` actions.
-   *    if(await condition(updateBy.match, 3_000)) {
-   *      // `updateBy` has been dispatched twice in less than 3s.
-   *    }
-   *  }
-   * })
+   *   actionCreator: updateBy,
+   *   async effect(_, { condition }) {
+   *     // wait at most 3s for `updateBy` actions.
+   *     if (await condition(updateBy.match, 3_000)) {
+   *       // `updateBy` has been dispatched twice in less than 3s.
+   *     }
+   *   },
+   * });
    * ```
    */
   condition: ConditionFunction<State>
@@ -273,8 +275,8 @@ export type ListenerEffect<
 ) => void | Promise<void>
 
 /**
- * @public
  * Additional infos regarding the error raised.
+ * @public
  */
 export interface ListenerErrorInfo {
   /**
@@ -284,10 +286,10 @@ export interface ListenerErrorInfo {
 }
 
 /**
- * @public
  * Gets notified with synchronous and asynchronous errors raised by `listeners` or `predicates`.
  * @param error The thrown error.
  * @param errorInfo Additional information regarding the thrown error.
+ * @public
  */
 export interface ListenerErrorHandler {
   (error: unknown, errorInfo: ListenerErrorInfo): void
@@ -396,8 +398,11 @@ export type UnsubscribeListener = (
 ) => void
 
 /**
+ * The possible overloads and options for defining a listener.
+ * The return type of each function is specified as a generic arg,
+ * so the overloads can be reused for multiple different functions.
+ *
  * @public
- * The possible overloads and options for defining a listener. The return type of each function is specified as a generic arg, so the overloads can be reused for multiple different functions
  */
 export type AddListenerOverloads<
   Return,
@@ -555,9 +560,13 @@ export type TypedAddListener<
      *
      * @example
      * ```ts
-     * import { addListener } from '@reduxjs/toolkit'
+     * import { addListener } from '@reduxjs/toolkit';
      *
-     * export const addAppListener = addListener.withTypes<RootState, AppDispatch, ExtraArguments>()
+     * export const addAppListener = addListener.withTypes<
+     *   RootState,
+     *   AppDispatch,
+     *   ExtraArguments
+     * >();
      * ```
      *
      * @template OverrideStateType - The specific type of state the middleware listener operates on.
@@ -667,12 +676,13 @@ export type TypedStartListening<
 > & {
   /**
    * Creates a "pre-typed" version of
-   * {@linkcode ListenerMiddlewareInstance.startListening startListening}
+   * {@linkcode ListenerMiddlewareInstance.startListening | startListening}
    * where the `state`, `dispatch` and `extra` types are predefined.
    *
    * This allows you to set the `state`, `dispatch` and `extra` types once,
    * eliminating the need to specify them with every
-   * {@linkcode ListenerMiddlewareInstance.startListening startListening} call.
+   * {@linkcode ListenerMiddlewareInstance.startListening | startListening}
+   * call.
    *
    * @returns A pre-typed `startListening` with the state, dispatch and extra types already defined.
    *
@@ -726,12 +736,12 @@ export type TypedStopListening<
 > = RemoveListenerOverloads<StateType, DispatchType, ExtraArgument> & {
   /**
    * Creates a "pre-typed" version of
-   * {@linkcode ListenerMiddlewareInstance.stopListening stopListening}
+   * {@linkcode ListenerMiddlewareInstance.stopListening | stopListening}
    * where the `state`, `dispatch` and `extra` types are predefined.
    *
    * This allows you to set the `state`, `dispatch` and `extra` types once,
    * eliminating the need to specify them with every
-   * {@linkcode ListenerMiddlewareInstance.stopListening stopListening} call.
+   * {@linkcode ListenerMiddlewareInstance.stopListening | stopListening} call.
    *
    * @returns A pre-typed `stopListening` with the state, dispatch and extra types already defined.
    *
@@ -834,7 +844,11 @@ export type TypedCreateListenerEntry<
  * Internal Types
  */
 
-/** @internal An single listener entry */
+/**
+ * An single listener entry
+ *
+ * @internal
+ */
 export type ListenerEntry<
   State = unknown,
   DispatchType extends Dispatch = Dispatch,
@@ -848,8 +862,8 @@ export type ListenerEntry<
 }
 
 /**
- * @internal
  * A shorthand form of the accepted args, solely so that `createListenerEntry` has validly-typed conditional logic when checking the options contents
+ * @internal
  */
 export type FallbackAddListenerOptions = {
   actionCreator?: TypedActionCreatorWithMatchFunction<string>