reselect-kit 1.0.0 → 1.1.0

package/src/createAdaptedSelector.ts

@@ -1,5 +1,4 @@
-import { Selector } from '@veksa/reselect';
-import { CachedSelector, NamedParametricSelector } from './types';
+import { CachedSelector, NamedSelector } from './types';
 import { withDebugName } from './debug/withDebugName';
 import { getSelectorName } from './_helpers/getSelectorName';
 import { isCachedSelector } from './_helpers/isCachedSelector';
@@ -25,15 +24,20 @@ const generateMappingName = <P1 extends object, P2>(mapping: (props: P2) => P1)
 
 const innerCreateAdaptedSelector =
   <S, P1, P2, R>(
-    baseSelector: Selector<S, R, [P1]>,
+    baseSelector: (state: S, props: P1) => R,
     mapping: (props: P2) => P1,
-  ): NamedParametricSelector<S, P2, R> =>
+  ): NamedSelector<S, R, [P2]> =>
   (state: S, props: P2) => {
     return baseSelector(state, mapping(props));
   };
 
+/**
+ * Rewrites the props a selector reads. Only the props argument changes: the
+ * adapted selector takes `[P2]` where the base took `[P1]`, which is the same
+ * argument tuple every other creator in the library carries.
+ */
 export const createAdaptedSelector = <S, P1 extends object, P2, R>(
-  baseSelector: Selector<S, R, [P1]>,
+  baseSelector: (state: S, props: P1) => R,
   mapping: (props: P2) => P1,
 ) => {
   const adaptedSelector = innerCreateAdaptedSelector(baseSelector, mapping);

package/src/createBoundSelector.ts

@@ -1,5 +1,4 @@
-import { Selector } from '@veksa/reselect';
-import { CachedSelector, NamedParametricSelector, NamedSelector } from './types';
+import { CachedSelector, NamedSelector } from './types';
 import { isComposedKeySelector, KeySelectorComposer } from './keys/createKeySelectorComposer';
 import { isPropSelector } from './createPropSelector';
 import { excludeDefaultSelectors } from './keys/createKeySelectorCreator';
@@ -28,47 +27,119 @@ const generateBindingName = <P extends object>(binding: P) => {
 };
 
 /**
- * The special type to prevent binding of non optional props on optional values
+ * The bound selector: what the binding did not supply is what is left to pass.
+ * A binding covering every prop leaves an empty argument tuple, which is what a
+ * plain selector is in the unified model — so one type covers both cases.
+ *
+ * The outer condition is the guard against binding a prop the base selector
+ * declares as optional with a value that is not.
  */
 export type BoundSelector<S, P2, P1 extends Partial<P2>, R> =
   P2 extends Pick<P1, keyof P2>
-    ? Exclude<keyof P1, keyof P2> extends never
-      ? NamedSelector<S, R>
-      : NamedParametricSelector<S, Omit<P1, keyof P2>, R>
+    ? NamedSelector<S, R, Exclude<keyof P1, keyof P2> extends never ? [] : [Omit<P1, keyof P2>]>
     : never;
 
 export type BoundSelectorOptions<S, P2, P1 extends Partial<P2>, R> = {
   bindingStrategy?: (
-    baseSelector: Selector<S, R, [P1]>,
+    baseSelector: (state: S, props: P1) => R,
     binding: P2,
-  ) => Selector<S, R, [Omit<P1, keyof P2>]>;
+  ) => (state: S, props: Omit<P1, keyof P2>) => R;
   keySelectorComposer?: KeySelectorComposer;
 };
 
-const innerCreateBoundSelector = <S, P2, P1 extends Partial<P2>, R>(
-  baseSelector: Selector<S, R, [P1]>,
+/**
+ * The default binding strategy: applies the binding to the props the caller
+ * passed, hands them to the base selector, and puts them back as they were.
+ *
+ * Almost every binding is a single key — `bound(selector, { positionId })` —
+ * and specialising it removes the two allocations the generic path costs per
+ * call: the `{ result, rollback }` object and the `rollback` closure. On a
+ * graph with a bound selector per row those are the calls that dominate.
+ *
+ * The `delete` in the restore stays deliberately. Leaving the key behind as
+ * `undefined` would be cheaper — it avoids putting the caller's props object
+ * into dictionary mode — but it also changes the object's shape, and
+ * `useSelector` memoizes props shallowly: a props object that has grown an
+ * extra key never again compares equal to a freshly built one, so the
+ * memoization the binding exists to protect would be defeated.
+ */
+const applyBinding = <S, P2, P1 extends Partial<P2>, R>(
+  baseSelector: (state: S, props: P1) => R,
   binding: P2,
 ) => {
-  const boundSelector = (state: S, props: Omit<P1, keyof P2> | void) =>
-    baseSelector(state, {
-      ...props,
-      ...binding,
-    } as unknown as P1);
+  const source = binding as unknown as Record<string, unknown>;
+  const keys = Object.keys(source);
+
+  if (keys.length === 1) {
+    const key = keys[0];
+    const value = source[key];
+
+    return (state: S, props: Omit<P1, keyof P2> | void) => {
+      const target = props as unknown as Record<string, unknown>;
+
+      // Nothing to merge into when the selector is read without props, which is
+      // what a fully bound selector is called like.
+      if (typeof target !== 'object' || target === null) {
+        return baseSelector(state, source as unknown as P1);
+      }
+
+      const previous = target[key];
+
+      // A re-entrant call that finds the binding already applied has nothing to
+      // save and nothing to restore.
+      if (previous === value) {
+        return baseSelector(state, props as unknown as P1);
+      }
 
-  return boundSelector as BoundSelector<S, P2, P1, R>;
+      const had = Object.prototype.hasOwnProperty.call(target, key);
+      target[key] = value;
+
+      try {
+        return baseSelector(state, props as unknown as P1);
+      } finally {
+        if (had) {
+          target[key] = previous;
+        } else {
+          delete target[key];
+        }
+      }
+    };
+  }
+
+  return (state: S, props: Omit<P1, keyof P2> | void) => {
+    // `temporaryAssign` falls back to the binding itself when there are no props
+    // to merge into, which is the read of a fully bound selector.
+    const { result: nextProps, rollback } = temporaryAssign(
+      props as unknown as Record<string, unknown>,
+      source,
+    );
+
+    // Restored through `finally` for the same reason the single-key path does
+    // it: the props object belongs to the caller, and a selector that throws
+    // must not leave the binding written into it.
+    try {
+      return baseSelector(state, nextProps as unknown as P1);
+    } finally {
+      rollback();
+    }
+  };
 };
 
-const createBoundInnerSelector = <S, P2 extends object, P1 extends Partial<P2>, R, OR extends R>(
-  baseSelector: Selector<S, R, [P1]>,
+export const createBoundSelector = <S, P2 extends object, P1 extends Partial<P2>, R, OR extends R>(
+  baseSelector: (state: S, props: P1) => R,
   binding: P2,
   options: BoundSelectorOptions<S, P2, P1, OR> = {},
 ): BoundSelector<S, P2, P1, R> => {
-  const bindingStrategy =
-    (options.bindingStrategy as typeof innerCreateBoundSelector) ?? innerCreateBoundSelector;
+  const bindingStrategy = (options.bindingStrategy as typeof applyBinding) ?? applyBinding;
 
   const keySelectorComposer = options.keySelectorComposer ?? stringComposeKeySelectors;
 
-  const boundSelector = bindingStrategy(baseSelector, binding);
+  const boundSelector = bindingStrategy(baseSelector, binding) as unknown as BoundSelector<
+    S,
+    P2,
+    P1,
+    R
+  >;
 
   Object.assign(boundSelector, baseSelector);
   boundSelector.dependencies = [baseSelector];
@@ -132,66 +203,3 @@ const createBoundInnerSelector = <S, P2 extends object, P1 extends Partial<P2>,
 
   return boundSelector;
 };
-
-export const createBoundSelector: typeof createBoundInnerSelector = (baseSelector, binding) => {
-  return createBoundInnerSelector(baseSelector, binding, {
-    bindingStrategy: (selector, bindingProps) => {
-      const source = bindingProps as unknown as Record<string, unknown>;
-      const keys = Object.keys(source);
-
-      /**
-       * Almost every binding is a single key — `bound(selector, { positionId })` —
-       * and specialising it removes the two allocations the generic path costs per
-       * call: the `{ result, rollback }` object and the `rollback` closure. On a
-       * graph with a bound selector per row those are the calls that dominate.
-       *
-       * The `delete` in the restore stays deliberately. Leaving the key behind as
-       * `undefined` would be cheaper — it avoids putting the caller's props object
-       * into dictionary mode — but it also changes the object's shape, and
-       * `useSelector` memoizes props shallowly: a props object that has grown an
-       * extra key never again compares equal to a freshly built one, so the
-       * memoization the binding exists to protect would be defeated.
-       */
-      if (keys.length === 1) {
-        const key = keys[0];
-        const value = source[key];
-
-        return (state, props) => {
-          const target = props as unknown as Record<string, unknown>;
-
-          if (typeof target !== 'object' || target === null) {
-            return selector(state, source as Parameters<typeof baseSelector>[1]);
-          }
-
-          const previous = target[key];
-
-          // A re-entrant call that finds the binding already applied has nothing to
-          // save and nothing to restore.
-          if (previous === value) {
-            return selector(state, props as Parameters<typeof baseSelector>[1]);
-          }
-
-          const had = Object.prototype.hasOwnProperty.call(target, key);
-          target[key] = value;
-
-          try {
-            return selector(state, props as Parameters<typeof baseSelector>[1]);
-          } finally {
-            if (had) {
-              target[key] = previous;
-            } else {
-              delete target[key];
-            }
-          }
-        };
-      }
-
-      return (state, props) => {
-        const { result: nextProps, rollback } = temporaryAssign(props, source);
-        const result = selector(state, nextProps as Parameters<typeof baseSelector>[1]);
-        rollback();
-        return result;
-      };
-    },
-  });
-};

package/src/createCachedSequenceSelector.ts

@@ -1,14 +1,18 @@
-import { createSelector, Selector } from '@veksa/reselect';
+import { createSelector, Selector, SelectorResultArray } from '@veksa/reselect';
 import { createCachedSelector, PolymorphicCachedOptions } from '@veksa/re-reselect';
 import { createSequenceSelector } from './createSequenceSelector';
+import { AnySelector, MergedParams, MergedState } from './types';
 
-export function createCachedSequenceSelector<S, R>(
-  selectors: Selector<S, R>[],
-): (options: PolymorphicCachedOptions<Selector<S, R>[], R[]>) => Selector<S, R[]>;
-
-export function createCachedSequenceSelector<S, P, R>(
-  selectors: Selector<S, R, [P]>[],
-): (options: PolymorphicCachedOptions<Selector<S, R, [P]>[], R[]>) => Selector<S, R[], [P]>;
+/**
+ * The cached counterpart of {@link createSequenceSelector}. The inferred tuple
+ * reaches `PolymorphicCachedOptions` as-is, so re-reselect types the caller's
+ * `keySelector` with the exact arguments of the group.
+ */
+export function createCachedSequenceSelector<Selectors extends readonly AnySelector[]>(
+  selectors: [...Selectors],
+): (
+  options: PolymorphicCachedOptions<Selectors, SelectorResultArray<Selectors>>,
+) => Selector<MergedState<Selectors>, SelectorResultArray<Selectors>, MergedParams<Selectors>>;
 
 export function createCachedSequenceSelector(selectors: any): any {
   return createSequenceSelector(

package/src/createCachedStructuredSelector.ts

@@ -1,28 +1,19 @@
 import { createSelector, Selector, SelectorResultsMap, SelectorsObject } from '@veksa/reselect';
 import { createCachedSelector, PolymorphicCachedOptions } from '@veksa/re-reselect';
 import { createStructuredSelector } from './createStructuredSelector';
-import { UnionToIntersection } from './types';
+import { MergedParams, MergedState } from './types';
 
-/** Intersection of the `state` argument of every selector in the object. */
-type StructuredState<M extends SelectorsObject> = UnionToIntersection<
-  { [K in keyof M]: Parameters<M[K]>[0] }[keyof M]
->;
-
-/** Union of the `props` argument (position 1) of every parametric selector. */
-type StructuredPropsUnion<M extends SelectorsObject> = {
-  [K in keyof M]: Parameters<M[K]> extends [any, infer Props, ...any[]] ? Props : never;
-}[keyof M];
-
-/** The extra-arguments tuple: `[Props]` when any selector is parametric, else `[]`. */
-type StructuredParams<M extends SelectorsObject> = [StructuredPropsUnion<M>] extends [never]
-  ? []
-  : [UnionToIntersection<StructuredPropsUnion<M>>];
-
-/** The input selectors as reselect sees them, used to type the cached options. */
+/**
+ * The input selectors as re-reselect reads them when typing the caller's
+ * `keySelector`: it takes `state` and the extra arguments off the group, and
+ * both are already merged here. Putting the selectors back in key order would
+ * type the arguments no more precisely and would cost a type instantiation per
+ * key, capping the batch at roughly fifty fields.
+ */
 type StructuredInputs<M extends SelectorsObject> = Selector<
-  StructuredState<M>,
+  MergedState<M>,
   unknown,
-  StructuredParams<M>
+  MergedParams<M>
 >[];
 
 /**
@@ -34,7 +25,7 @@ export function createCachedStructuredSelector<M extends SelectorsObject>(
   selectors: M,
 ): (
   options: PolymorphicCachedOptions<StructuredInputs<M>, SelectorResultsMap<M>>,
-) => Selector<StructuredState<M>, SelectorResultsMap<M>, StructuredParams<M>>;
+) => Selector<MergedState<M>, SelectorResultsMap<M>, MergedParams<M>>;
 
 export function createCachedStructuredSelector(selectors: any): any {
   return createStructuredSelector(

package/src/createChainSelector.ts

@@ -1,30 +1,31 @@
-import { createSelectorCreator, Selector } from '@veksa/reselect';
+import { createSelector, createSelectorCreator, Selector } from '@veksa/reselect';
 import { createCachedSelector, ICacheObject, KeySelector } from '@veksa/re-reselect';
 import { KeySelectorComposer } from './keys/createKeySelectorComposer';
 import { isCachedSelector } from './_helpers/isCachedSelector';
 import { defaultKeySelector } from './keys/defaultKeySelector';
 import { stringComposeKeySelectors } from './keys/stringComposeKeySelectors';
 import { createKeySelectorCreator } from './keys/createKeySelectorCreator';
+import { MergeParams } from './types';
 import { runInDebug, withDebugName } from './debug/withDebugName';
 import { defineDynamicSelectorName } from './_helpers/defineDynamicSelectorName';
 import { getSelectorName } from './_helpers/getSelectorName';
 import { generateSelectorKey } from './_helpers/generateSelectorKey';
 import { stringifyFunction } from './_helpers/stringifyFunction';
 
-export type SelectorChain<R1, S1, R2> = (result: R1) => Selector<S1, R2>;
-
-export type ParametricSelectorChain<R1, S1, P1, R2> = (result: R1) => Selector<S1, R2, [P1]>;
+/**
+ * A chain step: given the previous level's result, it returns the selector the
+ * next level reads. `Params` is empty for a step that only needs `state`, so a
+ * single type covers what used to be a plain and a parametric variant.
+ */
+export type SelectorChain<R1, S1, R2, Params extends readonly any[] = []> = (
+  result: R1,
+) => Selector<S1, R2, Params>;
 
 export type SelectorChainHierarchy<
-  C extends SelectorChain<any, any, any>,
+  C extends SelectorChain<any, any, any, any>,
   H extends SelectorChainHierarchy<any, any>,
 > = C & { parentChain?: H };
 
-export type ParametricSelectorChainHierarchy<
-  C extends ParametricSelectorChain<any, any, any, any>,
-  H extends ParametricSelectorChainHierarchy<any, any>,
-> = C & { parentChain?: H };
-
 export type CreateSelectorOptions<SelectorCreator extends typeof createSelectorCreator> = {
   selectorCreator: ReturnType<SelectorCreator>;
   cacheObject: ICacheObject;
@@ -37,52 +38,46 @@ export type ChainSelectorOptions<
   keySelectorComposer?: KeySelectorComposer;
 };
 
-interface ChainSelectorResult<S1, R1> {
-  chain: <S2, R2 = any>(
-    fn: SelectorChain<R1, S2, R2>,
+/**
+ * Every level of the chain carries the arguments its selector needs. A level
+ * that only reads `state` leaves `Params` empty, and one that reads props adds
+ * them — so a step introducing props makes them required for the whole built
+ * selector, whether or not the base selector had any.
+ *
+ * `Params` defaults to empty on the entry point, so that
+ * `createChainSelector<State, Result>(selector)` keeps working for callers that
+ * spell the type arguments out.
+ */
+interface ChainSelectorResult<S1, R1, Params extends readonly any[]> {
+  chain: <S2, R2, Params2 extends readonly any[]>(
+    fn: (result: R1) => (state: S2, ...params: Params2) => R2,
     chainOptions?: ChainSelectorOptions,
-  ) => ChainSelectorResult<S1 & S2, R2>;
+  ) => ChainSelectorResult<S1 & S2, R2, MergeParams<Params, Params2>>;
   map: <R2>(
     fn: (result: R1) => R2,
     mapOptions?: ChainSelectorOptions,
-  ) => ChainSelectorResult<S1, R2>;
-  build: () => Selector<S1, R1, []> & {
+  ) => ChainSelectorResult<S1, R2, Params>;
+  build: () => Selector<S1, R1, Params> & {
     chainHierarchy: SelectorChainHierarchy<any, any> | undefined;
   };
 }
 
-interface ParametricChainSelectorResult<S1, P1, R1> {
-  chain: <S2, P2 = unknown, R2 = any>(
-    fn: ParametricSelectorChain<R1, S2, P2, R2>,
-    chainOptions?: ChainSelectorOptions,
-  ) => ParametricChainSelectorResult<S1 & S2, P1 & P2, R2>;
-  map: <R2>(
-    fn: (result: R1) => R2,
-    mapOptions?: ChainSelectorOptions,
-  ) => ParametricChainSelectorResult<S1, P1, R2>;
-  build: () => Selector<S1, R1, [P1]> & {
-    chainHierarchy: ParametricSelectorChainHierarchy<any, any> | undefined;
-  };
-}
-
-export function createChainSelector<S1, R1>(
-  selector: Selector<S1, R1>,
+export function createChainSelector<S1, R1, Params extends readonly any[] = []>(
+  selector: (state: S1, ...params: Params) => R1,
   options?: ChainSelectorOptions,
   prevChain?: SelectorChainHierarchy<any, any>,
-): ChainSelectorResult<S1, R1>;
+): ChainSelectorResult<S1, R1, Params>;
 
-export function createChainSelector<S1, P1, R1>(
-  selector: Selector<S1, R1, [P1]>,
-  options?: ChainSelectorOptions,
-  prevChain?: ParametricSelectorChainHierarchy<any, any>,
-): ParametricChainSelectorResult<S1, P1, R1>;
-
-export function createChainSelector<S1, P1, R1>(
+export function createChainSelector(
   selector: any,
   options?: ChainSelectorOptions,
   prevChain?: any,
 ): any {
-  const chain = <S2, P2, R2>(fn: any, chainOptions?: ChainSelectorOptions) => {
+  const createLevel = (
+    fn: any,
+    chainOptions: ChainSelectorOptions | undefined,
+    isDerivedKeyless: boolean,
+  ) => {
     const combinedOptions = {
       ...options,
       ...chainOptions,
@@ -95,13 +90,29 @@ export function createChainSelector<S1, P1, R1>(
 
     const keySelectorCreator = createKeySelectorCreator(keySelectorComposer);
 
-    const higherOrderSelector = createCachedSelector(
-      [selector],
-      fn,
-    )({
-      ...createSelectorOptions(),
-      keySelector,
-    });
+    /**
+     * Nothing below this level is keyed, so the cache would hold a single entry
+     * for the lifetime of the chain and every call would still pay for the key
+     * computation and the lookup that guard it. A plain memoized selector is the
+     * same mapping — re-reselect under a constant key is one `createSelector`
+     * instance — without the layer.
+     */
+    const isKeyless = keySelector === defaultKeySelector;
+
+    const selectorOptions = createSelectorOptions() as Partial<CreateSelectorOptions<any>>;
+
+    const higherOrderSelector = isKeyless
+      ? ((selectorOptions.selectorCreator ?? createSelector) as typeof createSelector)(
+          [selector],
+          fn,
+        )
+      : createCachedSelector(
+          [selector],
+          fn,
+        )({
+          ...selectorOptions,
+          keySelector,
+        });
 
     withDebugName(higherOrderSelector, () => {
       const baseName = getSelectorName(selector);
@@ -109,13 +120,13 @@ export function createChainSelector<S1, P1, R1>(
       return `higher order for ${baseName} (${stringifyFunction(fn)})`;
     });
 
-    type CombineSelector = Selector<S1 & S2, R1 & R2, [P1 & P2]> & {
+    type CombineSelector = Selector<any, any, [any]> & {
       dependencies: any;
-      cache: ICacheObject;
-      keySelector?: KeySelector<S1 & S2>;
+      cache?: ICacheObject;
+      keySelector?: KeySelector<any>;
     };
 
-    const combinedSelector: CombineSelector = (state: S1 & S2, props: P1 & P2): R1 & R2 => {
+    const combinedSelector: CombineSelector = (state: any, props: any): any => {
       const derivedSelector: any = (higherOrderSelector as any)(state, props);
 
       runInDebug(() => {
@@ -147,40 +158,74 @@ export function createChainSelector<S1, P1, R1>(
     };
 
     combinedSelector.dependencies = [higherOrderSelector];
-    combinedSelector.cache = higherOrderSelector.cache;
+
+    if (!isKeyless) {
+      combinedSelector.cache = (higherOrderSelector as unknown as { cache: ICacheObject }).cache;
+    }
 
     /**
-     * The derived selector's key selector, memoized on the derived selector itself.
-     *
-     * This used to be a second `createCachedSelector` over `[higherOrderSelector]`,
-     * which meant every key computation paid a whole extra cached-selector layer —
-     * its own key computation, its own cache lookup, and its own evaluation of
-     * `higherOrderSelector` — to produce a value that depends on nothing but the
-     * derived selector. A `WeakMap` keyed on that selector is the same mapping with
-     * none of the layer, and it shares across cache keys rather than per key.
-     *
-     * Note what is deliberately *not* memoized: the `(state, props)` pair. `props`
-     * is mutated in place by `createBoundSelector`, so two calls can pass the same
-     * object reference with different contents, and a reference-keyed cache would
-     * hand back a stale selector.
+     * Assigned through a local and written to the selector once. Assigning the
+     * property in both branches instead reads as two expando declarations of
+     * `keySelector` to TypeScript before 7, which rejects it as a duplicate
+     * identifier.
      */
-    const derivedKeySelectors = new WeakMap<object, KeySelector<S1 & S2>>();
-
-    combinedSelector.keySelector = (state: S1 & S2, props: P1 & P2) => {
-      const derivedSelector: any = (higherOrderSelector as any)(state, props);
-
-      let derivedKeySelector = derivedKeySelectors.get(derivedSelector);
-
-      if (derivedKeySelector === undefined) {
-        derivedKeySelector = keySelectorCreator({
-          inputSelectors: [higherOrderSelector, derivedSelector],
-        }) as KeySelector<S1 & S2>;
+    let levelKeySelector: KeySelector<any>;
+
+    if (isDerivedKeyless) {
+      /**
+       * A `map` level derives a plain `() => output`, never a cached selector, so
+       * it contributes nothing to the composed key and the whole composition is
+       * known at build time. It is the same call the wrapper below makes, minus
+       * the derived selector — so the key is composed exactly as before, once,
+       * instead of on every key computation of every level above.
+       */
+      levelKeySelector = keySelectorCreator({
+        inputSelectors: [higherOrderSelector],
+      }) as KeySelector<any>;
+    } else {
+      /**
+       * The derived selector's key selector, memoized on the derived selector itself.
+       *
+       * This used to be a second `createCachedSelector` over `[higherOrderSelector]`,
+       * which meant every key computation paid a whole extra cached-selector layer —
+       * its own key computation, its own cache lookup, and its own evaluation of
+       * `higherOrderSelector` — to produce a value that depends on nothing but the
+       * derived selector. A `WeakMap` keyed on that selector is the same mapping with
+       * none of the layer, and it shares across cache keys rather than per key.
+       *
+       * Note what is deliberately *not* memoized: the `(state, props)` pair. `props`
+       * is mutated in place by `createBoundSelector`, so two calls can pass the same
+       * object reference with different contents, and a reference-keyed cache would
+       * hand back a stale selector.
+       */
+      const derivedKeySelectors = new WeakMap<object, KeySelector<any>>();
+
+      levelKeySelector = (state: any, props: any) => {
+        const derivedSelector: any = (higherOrderSelector as any)(state, props);
+
+        let derivedKeySelector = derivedKeySelectors.get(derivedSelector);
+
+        if (derivedKeySelector === undefined) {
+          derivedKeySelector = keySelectorCreator({
+            inputSelectors: [higherOrderSelector, derivedSelector],
+          }) as KeySelector<any>;
+
+          derivedKeySelectors.set(derivedSelector, derivedKeySelector);
+        }
 
-        derivedKeySelectors.set(derivedSelector, derivedKeySelector);
-      }
+        return (derivedKeySelector as any)(state, props);
+      };
+    }
 
-      return (derivedKeySelector as any)(state, props);
-    };
+    /**
+     * When nothing keyed is left the composition yields the default key, and
+     * leaving the property off is what lets the next level skip its cache too.
+     * The wrapper above is a fresh closure, so only a `map` level can land here
+     * with the default.
+     */
+    if (levelKeySelector !== defaultKeySelector) {
+      combinedSelector.keySelector = levelKeySelector;
+    }
 
     withDebugName(combinedSelector, () => {
       const baseName = getSelectorName(selector);
@@ -192,15 +237,15 @@ export function createChainSelector<S1, P1, R1>(
       parentChain: prevChain,
     });
 
-    return createChainSelector<S1 & S2, P1 & P2, R1 & R2>(
-      combinedSelector,
-      combinedOptions,
-      nextPrevChain,
-    );
+    return createChainSelector(combinedSelector, combinedOptions, nextPrevChain);
+  };
+
+  const chain = (fn: any, chainOptions?: ChainSelectorOptions) => {
+    return createLevel(fn, chainOptions, false);
   };
 
-  const map = <R2>(fn: (result: R1) => R2, mapOptions?: ChainSelectorOptions) => {
-    const mapSelector = (result: R1) => {
+  const map = (fn: (result: any) => any, mapOptions?: ChainSelectorOptions) => {
+    const mapSelector = (result: any) => {
       const output = fn(result);
       const mapSelector = () => output;
 
@@ -213,7 +258,7 @@ export function createChainSelector<S1, P1, R1>(
       return mapSelector;
     };
 
-    return chain(mapSelector, mapOptions);
+    return createLevel(mapSelector, mapOptions, true);
   };
 
   const build = () => {