Файловый менеджер - Редактировать - /home/freeclou/app.optimyar.com/backend/node_modules/reselect/src/index.ts
Назад
import type { Selector, GetParamsFromSelectors, OutputSelector, EqualityFn, SelectorArray, SelectorResultArray } from './types' export type { Selector, GetParamsFromSelectors, OutputSelector, EqualityFn, SelectorArray, SelectorResultArray, ParametricSelector, OutputParametricSelector } from './types' import { defaultMemoize, defaultEqualityCheck, DefaultMemoizeOptions } from './defaultMemoize' export { defaultMemoize, defaultEqualityCheck } export type { DefaultMemoizeOptions } function getDependencies(funcs: unknown[]) { const dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs if (!dependencies.every(dep => typeof dep === 'function')) { const dependencyTypes = dependencies .map(dep => typeof dep === 'function' ? `function ${dep.name || 'unnamed'}()` : typeof dep ) .join(', ') throw new Error( `createSelector expects all input-selectors to be functions, but received the following types: [${dependencyTypes}]` ) } return dependencies as SelectorArray } type DropFirst<T extends unknown[]> = T extends [unknown, ...infer U] ? U : never export function createSelectorCreator< F extends (...args: unknown[]) => unknown, MemoizeFunction extends (func: F, ...options: any[]) => F, MemoizeOptions extends unknown[] = DropFirst<Parameters<MemoizeFunction>> >( memoize: MemoizeFunction, ...memoizeOptionsFromArgs: DropFirst<Parameters<MemoizeFunction>> ) { // (memoize: MemoizeFunction, ...memoizeOptions: MemoizerOptions) { const createSelector = (...funcs: Function[]) => { let recomputations = 0 let lastResult: unknown // Due to the intricacies of rest params, we can't do an optional arg after `...funcs`. // So, start by declaring the default value here. // (And yes, the words 'memoize' and 'options' appear too many times in this next sequence.) let directlyPassedOptions: CreateSelectorOptions<MemoizeOptions> = { memoizeOptions: undefined } // Normally, the result func or "output selector" is the last arg let resultFunc = funcs.pop() // If the result func is actually an _object_, assume it's our options object if (typeof resultFunc === 'object') { directlyPassedOptions = resultFunc as any // and pop the real result func off resultFunc = funcs.pop() } if (typeof resultFunc !== 'function') { throw new Error( `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]` ) } // Determine which set of options we're using. Prefer options passed directly, // but fall back to options given to createSelectorCreator. const { memoizeOptions = memoizeOptionsFromArgs } = directlyPassedOptions // Simplifying assumption: it's unlikely that the first options arg of the provided memoizer // is an array. In most libs I've looked at, it's an equality function or options object. // Based on that, if `memoizeOptions` _is_ an array, we assume it's a full // user-provided array of options. Otherwise, it must be just the _first_ arg, and so // we wrap it in an array so we can apply it. const finalMemoizeOptions = Array.isArray(memoizeOptions) ? memoizeOptions : ([memoizeOptions] as MemoizeOptions) const dependencies = getDependencies(funcs) const memoizedResultFunc = memoize( function () { recomputations++ // apply arguments instead of spreading for performance. return resultFunc!.apply(null, arguments) } as F, ...finalMemoizeOptions ) // If a selector is called with the exact same arguments we don't need to traverse our dependencies again. const selector = memoize(function () { const params = [] const length = dependencies.length for (let i = 0; i < length; i++) { // apply arguments instead of spreading and mutate a local list of params for performance. // @ts-ignore params.push(dependencies[i].apply(null, arguments)) } // apply arguments instead of spreading for performance. lastResult = memoizedResultFunc.apply(null, params) return lastResult } as F) Object.assign(selector, { resultFunc, memoizedResultFunc, dependencies, lastResult: () => lastResult, recomputations: () => recomputations, resetRecomputations: () => (recomputations = 0) }) return selector } // @ts-ignore return createSelector as CreateSelectorFunction< F, MemoizeFunction, MemoizeOptions > } interface CreateSelectorOptions<MemoizeOptions extends unknown[]> { memoizeOptions: MemoizeOptions[0] | MemoizeOptions } /** * An instance of createSelector, customized with a given memoize implementation */ interface CreateSelectorFunction< F extends (...args: unknown[]) => unknown, MemoizeFunction extends (func: F, ...options: any[]) => F, MemoizeOptions extends unknown[] = DropFirst<Parameters<MemoizeFunction>> > { /** Input selectors as separate inline arguments */ <Selectors extends SelectorArray, Result>( ...items: [ ...Selectors, (...args: SelectorResultArray<Selectors>) => Result ] ): OutputSelector< Selectors, Result, GetParamsFromSelectors<Selectors>, ((...args: SelectorResultArray<Selectors>) => Result) & ReturnType<MemoizeFunction> > /** Input selectors as separate inline arguments with memoizeOptions passed */ <Selectors extends SelectorArray, Result>( ...items: [ ...Selectors, (...args: SelectorResultArray<Selectors>) => Result, CreateSelectorOptions<MemoizeOptions> ] ): OutputSelector< Selectors, Result, GetParamsFromSelectors<Selectors>, ((...args: SelectorResultArray<Selectors>) => Result) & ReturnType<MemoizeFunction> > /** Input selectors as a separate array */ <Selectors extends SelectorArray, Result>( selectors: [...Selectors], combiner: (...args: SelectorResultArray<Selectors>) => Result, options?: CreateSelectorOptions<MemoizeOptions> ): OutputSelector< Selectors, Result, GetParamsFromSelectors<Selectors>, ((...args: SelectorResultArray<Selectors>) => Result) & ReturnType<MemoizeFunction> > } export const createSelector = /* #__PURE__ */ createSelectorCreator(defaultMemoize) type SelectorsObject = { [key: string]: (...args: any[]) => any } export interface StructuredSelectorCreator { <SelectorMap extends SelectorsObject>( selectorMap: SelectorMap, selectorCreator?: CreateSelectorFunction<any, any, any> ): ( state: SelectorMap[keyof SelectorMap] extends ( state: infer State ) => unknown ? State : never ) => { [Key in keyof SelectorMap]: ReturnType<SelectorMap[Key]> } <State, Result = State>( selectors: { [K in keyof Result]: Selector<State, Result[K], never> }, selectorCreator?: CreateSelectorFunction<any, any, any> ): Selector<State, Result, never> } // Manual definition of state and output arguments export const createStructuredSelector: StructuredSelectorCreator = ( selectors: SelectorsObject, selectorCreator = createSelector ) => { if (typeof selectors !== 'object') { throw new Error( 'createStructuredSelector expects first argument to be an object ' + `where each property is a selector, instead received a ${typeof selectors}` ) } const objectKeys = Object.keys(selectors) return selectorCreator( // @ts-ignore objectKeys.map(key => selectors[key]), (...values: any[]) => { return values.reduce((composition, value, index) => { composition[objectKeys[index]] = value return composition }, {}) } ) }
| ver. 1.4 |
Github
|
.
| PHP 8.1.33 | Генерация страницы: 0.01 |
proxy
|
phpinfo
|
Настройка