reselect

const createSelector: CreateSelectorFunction<
    <Func extends AnyFunction>(
        func: Func,
        options?: WeakMapMemoizeOptions<ReturnType<Func>>
    ) => Func & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    },
    <Func extends AnyFunction>(
        func: Func,
        options?: WeakMapMemoizeOptions<ReturnType<Func>>
    ) => Func & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    },
    any
>;

const createStructuredSelector: StructuredSelectorCreator<any>;

const referenceEqualityCheck: EqualityFn<any>;

createSelectorCreator: {
    <
        MemoizeFunction extends UnknownMemoizer<UnknownFunction>,
        ArgsMemoizeFunction extends UnknownMemoizer<UnknownFunction> = <
            Func extends AnyFunction
        >(
            func: Func,
            options?: WeakMapMemoizeOptions<ReturnType<Func>>
        ) => Func & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        }
    >(
        options: Simplify<
            SetRequired<
                CreateSelectorOptions<
                    typeof weakMapMemoize,
                    typeof weakMapMemoize,
                    MemoizeFunction,
                    ArgsMemoizeFunction
                >,
                'memoize'
            >
        >
    ): CreateSelectorFunction<MemoizeFunction, ArgsMemoizeFunction>;
    <MemoizeFunction extends UnknownMemoizer<UnknownFunction>>(
        memoize: MemoizeFunction,
        ...memoizeOptionsFromArgs: DropFirstParameter<MemoizeFunction>
    ): CreateSelectorFunction<
        MemoizeFunction,
        <Func extends AnyFunction>(
            func: Func,
            options?: WeakMapMemoizeOptions<ReturnType<Func>>
        ) => Func & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        },
        any
    >;
};

lruMemoize: <Func extends AnyFunction>(
    func: Func,
    equalityCheckOrOptions?: EqualityFn | LruMemoizeOptions<ReturnType<Func>>
) => Func & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
};

setGlobalDevModeChecks: (devModeChecks: Partial<DevModeChecks>) => void;

unstable_autotrackMemoize: <Func extends AnyFunction>(
    func: Func
) => Func & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
};

weakMapMemoize: <Func extends AnyFunction>(
    func: Func,
    options?: WeakMapMemoizeOptions<ReturnType<Func>>
) => Func & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
};

type Combiner<InputSelectors extends SelectorArray, Result> = Distribute<
    /**
     * A function that takes input selectors' return values as arguments and returns a result. Otherwise known as `resultFunc`.
     *
     * @param resultFuncArgs - Return values of input selectors.
     * @returns The return value of {@linkcode OutputSelectorFields.resultFunc resultFunc}.
     */
    (...resultFuncArgs: SelectorResultArray<InputSelectors>) => Result
>;

type DefaultMemoizeFields = {
    /**
     * Clears the memoization cache associated with a memoized function.
     * This method is typically used to reset the state of the cache, allowing
     * for the garbage collection of previously memoized results and ensuring
     * that future calls to the function recompute the results.
     */
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
};

type DevModeCheckFrequency = 'always' | 'once' | 'never';

type DevModeChecksExecutionInfo = {
    [K in keyof DevModeChecks]: {
        /**
         * A boolean indicating whether the check should be executed.
         */
        shouldRun: boolean;
        /**
         * The function to execute for the check.
         */
        run: AnyFunction;
    };
};

type EqualityFn<T = any> = (a: T, b: T) => boolean;

type ExtractMemoizerFields<MemoizeFunction extends UnknownMemoizer> = Simplify<
    OmitIndexSignature<ReturnType<MemoizeFunction>>
>;

type GetParamsFromSelectors<Selectors extends SelectorArray> = ArrayTail<
    MergeParameters<Selectors>
>;

type GetStateFromSelectors<Selectors extends SelectorArray> =
    MergeParameters<Selectors>[0];

type MemoizeOptionsFromParameters<MemoizeFunction extends UnknownMemoizer> =
    | (
          | NonFunctionType<DropFirstParameter<MemoizeFunction>[0]>
          | FunctionType<DropFirstParameter<MemoizeFunction>[0]>
      )
    | (
          | NonFunctionType<DropFirstParameter<MemoizeFunction>[number]>
          | FunctionType<DropFirstParameter<MemoizeFunction>[number]>
      )[];

type OutputSelector<
    InputSelectors extends SelectorArray = SelectorArray,
    Result = unknown,
    MemoizeFunction extends UnknownMemoizer = typeof weakMapMemoize,
    ArgsMemoizeFunction extends UnknownMemoizer = typeof weakMapMemoize
> = Selector<
    GetStateFromSelectors<InputSelectors>,
    Result,
    GetParamsFromSelectors<InputSelectors>
> &
    ExtractMemoizerFields<ArgsMemoizeFunction> &
    OutputSelectorFields<
        InputSelectors,
        Result,
        MemoizeFunction,
        ArgsMemoizeFunction
    >;

type OutputSelectorFields<
    InputSelectors extends SelectorArray = SelectorArray,
    Result = unknown,
    MemoizeFunction extends UnknownMemoizer = typeof weakMapMemoize,
    ArgsMemoizeFunction extends UnknownMemoizer = typeof weakMapMemoize
> = {
    /**
     * The final function passed to `createSelector`. Otherwise known as the `combiner`.
     */
    resultFunc: Combiner<InputSelectors, Result>;
    /**
     * The memoized version of {@linkcode OutputSelectorFields.resultFunc resultFunc}.
     */
    memoizedResultFunc: Combiner<InputSelectors, Result> &
        ExtractMemoizerFields<MemoizeFunction>;
    /**
     * @Returns The last result calculated by {@linkcode OutputSelectorFields.memoizedResultFunc memoizedResultFunc}.
     */
    lastResult: () => Result;
    /**
     * The array of the input selectors used by `createSelector` to compose the
     * combiner ({@linkcode OutputSelectorFields.memoizedResultFunc memoizedResultFunc}).
     */
    dependencies: InputSelectors;
    /**
     * Counts the number of times {@linkcode OutputSelectorFields.memoizedResultFunc memoizedResultFunc} has been recalculated.
     */
    recomputations: () => number;
    /**
     * Resets the count of {@linkcode OutputSelectorFields.recomputations recomputations} count to 0.
     */
    resetRecomputations: () => void;
    /**
     * Counts the number of times the input selectors ({@linkcode OutputSelectorFields.dependencies dependencies})
     * have been recalculated. This is distinct from {@linkcode OutputSelectorFields.recomputations recomputations},
     * which tracks the recalculations of the result function.
     *
     * @since 5.0.0
     */
    dependencyRecomputations: () => number;
    /**
     * Resets the count {@linkcode OutputSelectorFields.dependencyRecomputations dependencyRecomputations}
     * for the input selectors ({@linkcode OutputSelectorFields.dependencies dependencies})
     * of a memoized selector.
     *
     * @since 5.0.0
     */
    resetDependencyRecomputations: () => void;
} & Simplify<
    Required<
        Pick<
            CreateSelectorOptions<MemoizeFunction, ArgsMemoizeFunction>,
            'argsMemoize' | 'memoize'
        >
    >
>;

type OverrideMemoizeOptions<
    MemoizeFunction extends UnknownMemoizer,
    OverrideMemoizeFunction extends UnknownMemoizer = never
> = IfNever<
    OverrideMemoizeFunction,
    Simplify<MemoizeOptionsFromParameters<MemoizeFunction>>,
    Simplify<MemoizeOptionsFromParameters<OverrideMemoizeFunction>>
>;

type RootStateSelectors<RootState = any> = {
    [Key in keyof RootState]: Selector<RootState, RootState[Key], []>;
};

type Selector<
    State = any,
    Result = unknown,
    Params extends readonly any[] = any[]
> = Distribute<
    /**
     * A function that takes a state and returns data that is based on that state.
     *
     * @param state - The first argument, often a Redux root state object.
     * @param params - All additional arguments passed into the selector.
     * @returns A derived value from the state.
     */
    (state: State, ...params: FallbackIfNever<Params, []>) => Result
>;

type SelectorArray<State = any> = readonly Selector<State>[];

type SelectorResultArray<Selectors extends SelectorArray> =
    ExtractReturnType<Selectors>;

type SelectorResultsMap<TObject extends SelectorsObject> = {
    [Key in keyof TObject]: ReturnType<TObject[Key]>;
};

type SelectorsObject<StateType = any> = Record<string, Selector<StateType>>;

type TypedStructuredSelectorCreator<RootState = any> =
    /**
     * A convenience function that simplifies returning an object
     * made up of selector results.
     *
     * @param inputSelectorsObject - A key value pair consisting of input selectors.
     * @param selectorCreator - A custom selector creator function. It defaults to `createSelector`.
     * @returns A memoized structured selector.
     *
     * @example
     * <caption>Modern Use Case</caption>
     * ```ts
     * import { createSelector, createStructuredSelector } from 'reselect'
     *
     * interface RootState {
     *   todos: {
     *     id: number
     *     completed: boolean
     *     title: string
     *     description: string
     *   }[]
     *   alerts: { id: number; read: boolean }[]
     * }
     *
     * // This:
     * const structuredSelector = createStructuredSelector(
     *   {
     *     todos: (state: RootState) => state.todos,
     *     alerts: (state: RootState) => state.alerts,
     *     todoById: (state: RootState, id: number) => state.todos[id]
     *   },
     *   createSelector
     * )
     *
     * // Is essentially the same as this:
     * const selector = createSelector(
     *   [
     *     (state: RootState) => state.todos,
     *     (state: RootState) => state.alerts,
     *     (state: RootState, id: number) => state.todos[id]
     *   ],
     *   (todos, alerts, todoById) => {
     *     return {
     *       todos,
     *       alerts,
     *       todoById
     *     }
     *   }
     * )
     * ```
     *
     * @example
     * <caption>In your component:</caption>
     * ```tsx
     * import type { RootState } from 'createStructuredSelector/modernUseCase'
     * import { structuredSelector } from 'createStructuredSelector/modernUseCase'
     * import type { FC } from 'react'
     * import { useSelector } from 'react-redux'
     *
     * interface Props {
     *   id: number
     * }
     *
     * const MyComponent: FC<Props> = ({ id }) => {
     *   const { todos, alerts, todoById } = useSelector((state: RootState) =>
     *     structuredSelector(state, id)
     *   )
     *
     *   return (
     *     <div>
     *       Next to do is:
     *       <h2>{todoById.title}</h2>
     *       <p>Description: {todoById.description}</p>
     *       <ul>
     *         <h3>All other to dos:</h3>
     *         {todos.map(todo => (
     *           <li key={todo.id}>{todo.title}</li>
     *         ))}
     *       </ul>
     *     </div>
     *   )
     * }
     * ```
     *
     * @example
     * <caption>Simple Use Case</caption>
     * ```ts
     * const selectA = state => state.a
     * const selectB = state => state.b
     *
     * // The result function in the following selector
     * // is simply building an object from the input selectors
     * const structuredSelector = createSelector(selectA, selectB, (a, b) => ({
     *   a,
     *   b
     * }))
     *
     * const result = structuredSelector({ a: 1, b: 2 }) // will produce { x: 1, y: 2 }
     * ```
     *
     * @template InputSelectorsObject - The shape of the input selectors object.
     * @template MemoizeFunction - The type of the memoize function that is used to create the structured selector. It defaults to `weakMapMemoize`.
     * @template ArgsMemoizeFunction - The type of the of the memoize function that is used to memoize the arguments passed into the generated structured selector. It defaults to `weakMapMemoize`.
     *
     * @see {@link https://reselect.js.org/api/createStructuredSelector `createStructuredSelector`}
     */
    <
        InputSelectorsObject extends RootStateSelectors<RootState> = RootStateSelectors<RootState>,
        MemoizeFunction extends UnknownMemoizer = typeof weakMapMemoize,
        ArgsMemoizeFunction extends UnknownMemoizer = typeof weakMapMemoize
    >(
        inputSelectorsObject: InputSelectorsObject,
        selectorCreator?: CreateSelectorFunction<
            MemoizeFunction,
            ArgsMemoizeFunction
        >
    ) => OutputSelector<
        ObjectValuesToTuple<InputSelectorsObject>,
        Simplify<SelectorResultsMap<InputSelectorsObject>>,
        MemoizeFunction,
        ArgsMemoizeFunction
    > &
        InterruptRecursion;

type UnknownMemoizer<FunctionType extends UnknownFunction = UnknownFunction> = (
    func: FunctionType,
    ...options: any[]
) => FunctionType;