• AddcreateSelectorCreator function overload that allows passing in anoptions object to allow for more customization. Thememoize property is mandatory, the rest are optional.
• Addmemoize andargsMemoize to output selector fields.
• Allow passingmemoize,argsMemoize andargsMemoizeOptions tooptions argument insidecreateSelector. This solves the issue of having to callcreateSelectorCreator anytime we want to use an alternate memoize function.
• So now instead of doing this:

constcreateSelectorWeakMap=createSelectorCreator(weakMapMemoize)constselectTodoIds=createSelectorWeakMap([(state:State)=>state.todos],todos=>todos.map(todo=>todo.id))

• We can do this:

constselectTodoIds=createSelector([(state:State)=>state.todos],todos=>todos.map(todo=>todo.id),{memoize:weakMapMemoize})

Why addmemoize andargsMemoize to output selector fields?

It's simple, it allows us to swap out memoize functions, compose selectors from other selectors easier and it helps with debugging:

exportconstfindFastestSelector=<SextendsOutputSelector>(selector:S,  ...selectorArgs:Parameters<S>)=>{constmemoizeFuncs=[defaultMemoize,weakMapMemoize,autotrackMemoize]constresults=memoizeFuncs.map(memoizeFunc=>{constalternateSelector=createSelector(selector.dependenciesas[...SelectorArray],selector.resultFunc,{memoize:memoizeFunc})conststart=performance.now()//@ts-ignorealternateSelector(...selectorArgs)consttime=performance.now()-startreturn{name:memoizeFunc.name, time,selector:alternateSelector}})constfastest=results.reduce((minResult,currentResult)=>currentResult.time<minResult.time ?currentResult :minResult)constratios=results.filter(({ time})=>time!==fastest.time).map(({ time, name})=>`\x1b[33m \x1b[1m${time/fastest.time}\x1b[0m times faster than \x1b[34m${name}`)if(fastest.selector.memoize.name!==selector.memoize.name){console.warn(`The memoization method for \x1B[1;41m${selector.name}\x1B[0m is \x1B[31m${selector.memoize.name}\x1B[0m!\nChange it to \x1b[32m\x1b[1m${fastest.selector.memoize.name}\x1b[0m to be more efficient.\nYou should use \x1b[32m\x1b[1m${fastest.name}\x1b[0m because it is${ratios.join('\nand\n')}`)}return{ results, fastest}asconst}

So now we can find out which memoize function would be fastest:

constselectorAutotrack=createSelector([(state:State,id:number)=>id,(state:State)=>state.todos],(id,todos)=>todos.filter(todo=>todo.id===id),{memoize:autotrackMemoize})Object.defineProperty(selectorAutotrack,'name',{value:'selectorAutotrack'})//@ts-ignorefindFastestSelector(selectorAutotrack,state,1)

We get the following message in the console:

The memoization method for selectorAutotrack is autotrackMemoize!Change it to defaultMemoize to be more efficient.You should use defaultMemoize because it is 1.4709747668511033 timesfaster than weakMapMemoize and 9.652792674178125 times faster than autotrackMemoize

Or we can also do this:

exportfunctioncreateSelectorCreatorCurried(  ...args:Parameters<typeofcreateSelectorCreator>){constcreateSelector=createSelectorCreator(...args)return(...args:Parameters<ReturnType<typeofcreateSelectorCreator>>)=>{constselector=createSelector(...args)constcurriedSelector=selector.argsMemoize((...params)=>selector.argsMemoize((state:unknown)=>selector(state, ...params)))Object.assign(curriedSelector,selector)returncurriedSelector}}constcreateCurriedSelector=createSelectorCreatorCurried(defaultMemoize)constcurriedSelector=createCurriedSelector([(state:State,id:number)=>id,(state:State)=>state.todos],(id,todos)=>todos.filter(todo=>todo.id===id))curriedSelector(1)(state)// Returns [ { id: 1, completed: false } ]

• UnknownMemoizer is exactly what it sounds like. It's a function that takes another function as its first argument and returns it. It can also take anoptions rest parameter.

• This was mostly because the pattern of(...args: SelectorResultArray<Selectors>) => Result is seen too often in the codebase, so it made sense to shorten it by aliasing its type.

• This is mainly used to remove explicitanys from the return type of some memoizers. e.g:microMemoize

• It helps conditionally resolve the type ofmemoizeOptions based on whethermemoize is provided or not. Same applies toargsMemoize andargsMemoizeOptions.

• A simple type alias that helps extract the extra properties that are attached to the return value of a memoizer. e.g.:clearCache

• A simple type alias that helps extract the type ofmemoizeOptions from the parameters ofmemoize. Same applies toargsMemoize andargsMemoizeOptions.

• It helps derive the type ofmemoizeOptions based on whethermemoize itself was overridden inside theoptions argument ofcreateSelector. Same applies toargsMemoize andargsMemoizeOptions.

• It is used to help us detect whether a memoize function has been overridden inside theoptions argument ofcreateSelector. If nomemoize is passed in, it will fallback to whatevermemoize was originally passed intocreateSelectorCreator. Same applies toargsMemoize but sinceargsMemoize is optional insidecreateSelectorCreator, it will ultimately fallback todefaultMemoize.

• This might be the biggest type change so far, yet it still pretty much functions like before. It does not break anything which means it is backwards-compatible. Here is all that has changed:

  • It used to take 4 generic type parameters, now it takes 2. One of which was added due to the newcreateSelectorCreator signature overload.
  • First generic parameter isMemoizeFunction which is almost the same as the oldMemoizeFunction. The only difference is it now extendsUnknownMemoizer and the type of the function it memoizes can be inferred.
  • Second generic parameter isArgsMemoizeFunction which has been added due to the newoptions argument increateSelector and the new function overload forcreateSelectorCreator. It is the type ofargsMemoize which has a default oftypeof defaultMemoize.
  • The input selectors parameter and thecombiner parameter are still pretty much the same as before. Within the signature overloads provided byCreateSelectorFunction, the 2 parts that have changed are theoptions parameter and the return type specifically the output selector fields that are attached to the memoized selector e.g.:clearCache
  • Theoptions parameter can now takememoize,argsMemoize andargsMemoizeOptions in addition to the previously providedinputStabilityCheck andmemoizeOptions.
  • If we pass in a value formemoize, the type ofmemoizeOptions will dynamically change to the type of the second parameter ofmemoize. Ifmemoize is not provided, the type ofmemoizeOptions falls back to the second parameter of whatevermemoize was initially passed in tocreateSelectorCreator whether it was passed in as an object with the new signature overload or traditionally as a plain function.

• Here is an example:

  constcreateSelectorWeakMap=createSelectorCreator(weakMapMemoize)// This would result in a TS error.constselector1=createSelectorWeakMap([(state:State)=>state.todos],todos=>todos.map(todo=>todo.id),{memoizeOptions:{maxSize:2}}// This causes the TS error.)// This on the other hand is fine.constselector2=createSelectorWeakMap([(state:State)=>state.todos],todos=>todos.map(todo=>todo.id),{memoize:defaultMemoize,memoizeOptions:{maxSize:2}}// When `memoize` is changed to `defaultMemoize`, `memoizeOptions` can now be the same type as the options args in `defaultMemoize`.)

• The same relationship dynamic applies toargsMemoize andargsMemoizeOptions. The only difference is sinceargsMemoize is optional when passing in an object tocreateSelectorCreator, the type ofargsMemoize defaults totypeof defaultMemoize and the type ofargsMemoizeOptions is derived from the second parameter ofdefaultMemoize.

// This is fineconstcreateSelector1=createSelectorCreator({memoize:defaultMemoize,argsMemoizeOptions:{maxSize:2}})// This would result in a TS error.constcreateSelector2=createSelectorCreator({memoize:defaultMemoize,argsMemoize:weakMapMemoize,argsMemoizeOptions:{maxSize:2}// This causes the TS error.})

• Same rules apply inside theoptions argument ofcreateSelector:

// This would result in a TS error.constselector1=createSelector([(state:State)=>state.todos],todos=>todos.map(todo=>todo.id),{memoize:weakMapMemoize,memoizeOptions:{maxSize:2}// This causes the TS error.})// This on the other hand is fine.constselector2=createSelector([(state:State)=>state.todos],todos=>todos.map(todo=>todo.id),{memoize:defaultMemoize,memoizeOptions:{maxSize:2}}// When `memoize` is set to `defaultMemoize`, `memoizeOptions` can now be the same type as the options args in `defaultMemoize`.)// This would result in a TS error.constselector3=createSelector([(state:State)=>state.todos],todos=>todos.map(todo=>todo.id),{argsMemoize:weakMapMemoize,argsMemoizeOptions:{maxSize:2}// This causes the TS error.})// This on the other hand is fine.constselector4=createSelector([(state:State)=>state.todos],todos=>todos.map(todo=>todo.id),{argsMemoize:defaultMemoize,argsMemoizeOptions:{maxSize:2}}// When `argsMemoize` is set to `defaultMemoize`, `argsMemoizeOptions` can now be the same type as the options args in `defaultMemoize`.)

• Since this type originally was a duplicate ofTail, it made sense to change it from a type that drops the first item in an array to a type that drops the first parameter of a function.

• It now has 2 additional propertiesmemoize andargsMemoize. Instead of taking aCombiner and aKeys generic type parameter, it now takes 4 generic parameters:

  • Selectors: the input selectors. This enables us to get a strongly typeddependencies property as well.
  • Result: the return value ofresultFunc.
  • MemoizeFunction: type ofmemoize. It is used to infer the correct type formemoizedResultFunc and the newmemoize output selector field.
  • ArgsMemoizeFunction: the memoize function used for the newargsMemoize output selector field.

• It now takes the exact same generic type parameters asOutputSelectorFields which in turn simplifies the return type ofCreateSelectorFunction and should make it easier to maintain.

• Remove theCombiner andKeys generic type parameters as they are no longer needed. This is one of those types that I don't think is insanely popular or useful, so technically we could just remove it without it becoming too much of a problem. But I still rewrote it to match the new type definitions just in case.

• RenameUnknownFunction which used to be of type(...args: any[]) => any toAnyFunction. This was mostly due to the implied correlation between the wordAny and parameters of typeany[]. To avoid potential further confusion, I also addedUnknownFunction which is an alias for(...args: unknown[]) => unknown. This can be helpful for situations where you want to avoid usingany.

• Remove union withnever in theParams generic type parameter ofSelector since a union ofany[] andnever is justany[].
• SimplifySelector by localizing the conditional toParams.
• Add more explicit type assertions insidecreateSelectorCreator function body to increase readability.

• Add JSDocs tocreateSelectorCreator
• Remove "indent" rule from.eslintrc as it conflicts withprettier
• Add "@internal/" path totsconfig for type tests

• MoveStabilityCheck andCreateSelectorOptions intotypes.ts.
• MovecreateSelectorCreator into its own file.
• MovecreateStructuredSelector into its own file.
• Changeindex.ts to be a barrel file exporting everything.

Addutils.ts tosrc folder

It contains the following:

• assertIsFunction: Contains a small part of code insidecreateSelectorCreator extracted to make the function body smaller and easier to read, and to add a small layer of type safety and reusability at the same time. Since we were doing a runtime check for a type of something and throwing an error on upon failure, the pattern looked very much like an assertion function which can help us kill 2 birds with one stone.
• ensureIsArray: Another small part of code insidecreateSelectorCreator. But since it is a pattern that we repeat, it does not hurt to turn it into a function that we can reuse.
• getDependencies: Same function from before, the only difference is now upon failure, in order to be more explicit, it throws aTypeError instead of anError.
• collectInputSelectorResults: Another piece of logic extracted from the body ofcreateSelectorCreator. It only focuses on creating an array from the return values of input selectors.
• runStabilityCheck: The extracted logic of running stability checks insidecreateSelectorCreator made into its own standalone function.