What's the correct way of conditionally returning an input?

[shepmaster]

I have a selector that conditionally returns one of its inputs:

const selectNeatThing = createSelector(
  selectAlpha,
  selectBeta,
  (a, b) => b ? 42 : a,
);

In reselect 5, this now generates a warning:

The result function returned its own inputs without modification

The selector seems fine to me as it has the transformation logic in the result function, so I must be missing some detail to fix the root problem.

I have not yet seen a way to silence the warning for a specific selector, so I'm guessing this warning does not produce false positives.

Reproduction Steps

Paste this into your shell to generate a small project that reproduces the situation:

mkdir repro
cd repro
pnpm init
pnpm add reselect

cat > index.mjs <<EOF
import { createSelector } from 'reselect';

const state = {
  alpha: 1,
  beta: false,
};

const selectAlpha = (state) => state.alpha;
const selectBeta = (state) => state.beta;

const selectNeatThing = createSelector(
  selectAlpha,
  selectBeta,
  (a, b) => b ? 42 : a,
);

const neat = selectNeatThing(state);
console.log(neat);
EOF

node index.mjs

This produces the output:

The result function returned its own inputs without modification. e.g
`createSelector([state => state.todos], todos => todos)`
This could lead to inefficient memoization and unnecessary re-renders.
Ensure transformation logic is in the result function, and extraction logic is in the input selectors. {
  stack: 'Error\n' +
    '    at Object.runIdentityFunctionCheck [as run] (file:///private/tmp/repro/node_modules/.pnpm/reselect@5.0.1/node_modules/reselect/dist/reselect.mjs:13:13)\n' +
    '    at dependenciesChecker (file:///private/tmp/repro/node_modules/.pnpm/reselect@5.0.1/node_modules/reselect/dist/reselect.mjs:660:33)\n' +
    '    at memoized (file:///private/tmp/repro/node_modules/.pnpm/reselect@5.0.1/node_modules/reselect/dist/reselect.mjs:582:21)\n' +
    '    at file:///private/tmp/repro/index.mjs:17:14\n' +
    '    at ModuleJob.run (node:internal/modules/esm/module_job:218:25)\n' +
    '    at async ModuleLoader.import (node:internal/modules/esm/loader:329:24)\n' +
    '    at async loadESM (node:internal/process/esm_loader:28:7)\n' +

[markerikson]

Yeah, we have that there because returning the original value is usually an error. If you do actually need to silence the warning, pass:

createSelector(
  input1, 
  input2, 
  resultFn, 
  {
    devModeChecks: {identityFunctionCheck: 'never'}
  }
)

See https://reselect.js.org/api/development-only-stability-checks#2-per-selector-by-passing-an-identityfunctioncheck-option-directly-to-

[EskiMojo14]

this also seems like it would be fixed by #660, if that's something we're considering

[shepmaster]

If you do actually need to silence the warning

That's kind of what my original question is intended to be — is my selector bad / wrong / inefficient? The warning says it is, but is the warning overzealous?

[EskiMojo14]

depends - is the other branch of your if condition doing something that actually needs memoization?
it can be valid to have a function that sometimes works as an identity function and sometimes doesn't

[shepmaster]

is the other branch of your if condition doing something that actually needs memoization

Here's a sample of some of my result functions that trigger the warning:

  (primaryAction, autoPrimaryAction) => (
    primaryAction === PrimaryActionAuto.Auto ? autoPrimaryAction : primaryAction
  )

  (orientation, widthIsSmall) => {
    if (orientation == Orientation.Automatic) {
      if (widthIsSmall) { return Orientation.Horizontal } else { return Orientation.Vertical }
    } else {
      return orientation;
    }
  }

  (crateType, primaryAction) => {
    if (crateType) {
      return crateType;
    } else if (primaryAction === PrimaryActionCore.Execute) {
      return 'bin';
    } else {
      return 'lib';
    }
  }

I suppose none of them really do any particularly heavy work.

From a usage point of view, I like to consistently use createSelector so I don't have to think too deeply about each and every selector. Perhaps that's the wrong thing to do. I do see https://reselect.js.org/FAQ#what-if-i-want-to-use--without-memoization, which perhaps is what I should be using a lot more frequently, but the "rare cases" in that entry make me again think that I'm doing the wrong thing.