map-transform-cjs/dist/transformers/sort.cjs.map

MapTransform with CJS support

{"version":3,"sources":["../../src/transformers/sort.ts","../../src/operations/getSet.ts","../../src/utils/stateHelpers.ts","../../src/utils/is.ts","../../src/utils/array.ts","../../src/operations/merge.ts","../../src/operations/lookup.ts"],"sourcesContent":["import { pathGetter } from '../operations/getSet.js'\nimport type {\n  Path,\n  State,\n  DataMapperWithState,\n  TransformerProps,\n  Transformer,\n} from '../types.js'\n\nexport interface Props extends TransformerProps {\n  asc?: boolean\n  path?: Path\n}\n\ntype SortValue = [unknown, unknown]\n\nconst compareNumbers = (a: number, b: number, direction: number) =>\n  (a - b) * direction\n\nconst compareStrings = (a: string, b: string, direction: number) =>\n  a === b ? 0 : a > b ? direction : -1 * direction\n\nconst compare = (direction: number) =>\n  function compare([a]: SortValue, [b]: SortValue) {\n    if (typeof a === 'number' && typeof b === 'number') {\n      return compareNumbers(a, b, direction)\n    } else if (a instanceof Date && b instanceof Date) {\n      return compareNumbers(a.getTime(), b.getTime(), direction)\n    } else if (a === undefined || a === null || b === undefined || b === null) {\n      return a === undefined || a === null ? 1 : -1\n    } else {\n      return compareStrings(String(a), String(b), direction)\n    }\n  }\n\nfunction fetchSortValue(getFn: DataMapperWithState, state: State) {\n  return function fetchSortValue(item: unknown): SortValue {\n    const sortBy = getFn(item, state)\n    return [sortBy, item]\n  }\n}\n\nconst transformer: Transformer<Props> = function sort(props) {\n  return () => {\n    const { path, asc } = props || {}\n    if (typeof path !== 'string' && path !== undefined) {\n      throw new TypeError(\n        \"The 'sort' transformer does not allow `path` to be a pipeline\",\n      )\n    }\n\n    const direction = asc === false ? -1 : 1\n    const getFn = path ? pathGetter(path) : (value: unknown) => value\n\n    return (data, state) => {\n      if (!Array.isArray(data) || data.length < 2) {\n        // We don't need to sort one or no item\n        return data\n      }\n\n      // We first fetch value to sort by for each item ...\n      const sortArray = data.map(fetchSortValue(getFn, state))\n      /// ... and then sort the array and returns the original items\n      return sortArray.sort(compare(direction)).map(([_, item]) => item)\n    }\n  }\n}\n\nexport default transformer\n","/* eslint-disable security/detect-object-injection */\nimport mapAny from 'map-any-cjs'\nimport modify from './modify.js'\nimport {\n  getStateValue,\n  setStateValue,\n  getTargetFromState,\n  setTargetOnState,\n  getLastContext,\n  getRootFromState,\n  isNonvalue,\n  revFromState,\n  clearUntouched,\n} from '../utils/stateHelpers.js'\nimport { isObject } from '../utils/is.js'\nimport { ensureArray, indexOfIfArray } from '../utils/array.js'\nimport type {\n  Path,\n  Operation,\n  State,\n  StateMapper,\n  DataMapperWithState,\n  Options,\n} from '../types.js'\n\nconst adjustIsSet = (isSet: boolean, state: State) => revFromState(state, isSet) // `isSet` will work as `flip` here\n\nfunction flatMapAny(fn: (value: unknown, target?: unknown) => unknown) {\n  return (value: unknown, target?: unknown) =>\n    Array.isArray(value)\n      ? value.flatMap((value) => fn(value, target))\n      : fn(value, target)\n}\n\nfunction handleArrayPath(path: string): [string | number, boolean, boolean] {\n  if (path.endsWith('][')) {\n    // This is an index notation\n    return [path.slice(0, path.length - 2), false, true /* isIndexProp */]\n  }\n  const pos = path.indexOf('[')\n  if (path[pos - 1] === '\\\\') {\n    // We have an escaped [, return the path with the backslash removed\n    return [path.replace('\\\\[', '['), false, false]\n  } else {\n    // This is an array notation if the next char is ]\n    const isArr = path[pos + 1] === ']'\n    return [path.slice(0, pos), isArr, false]\n  }\n}\n\n// Get rid of some special characters in the path and return the clean path and\n// some flags to indicate if we're dealing with an array or index notation\nfunction preparePath(\n  path: string | number,\n): [string | number, boolean, boolean] {\n  if (typeof path === 'string') {\n    if (path.includes('[')) {\n      // We have an array notation\n      return handleArrayPath(path)\n    } else if (path.startsWith('\\\\$')) {\n      // This is an escaped $, remove the backslash and return the path with $\n      return [path.slice(1), false, false]\n    }\n  }\n\n  // We have just a plain path\n  return [path, false, false]\n}\n\nfunction getSetProp(path: string) {\n  if (path === '') {\n    // We have an empty path, return the value as is\n    return (value: unknown) => value\n  }\n\n  const getFn = flatMapAny((value) =>\n    isObject(value) ? value[path] : undefined,\n  )\n  const setFn = (value: unknown, target?: unknown) =>\n    isObject(target) ? { ...target, [path]: value } : { [path]: value }\n\n  return (value: unknown, isSet: boolean, target?: unknown) => {\n    if (isSet) {\n      return setFn(value, target)\n    } else {\n      return getFn(value)\n    }\n  }\n}\n\nconst calculateIndex = (index: number, arr: unknown[]) =>\n  index >= 0 ? index : arr.length + index\n\nfunction getSetIndex(index: number) {\n  return (value: unknown, isSet: boolean, target?: unknown) => {\n    if (isSet) {\n      const arr = Array.isArray(target) ? [...target] : []\n      arr[calculateIndex(index, arr)] = value\n      return arr\n    } else {\n      return Array.isArray(value)\n        ? value[calculateIndex(index, value)]\n        : undefined\n    }\n  }\n}\n\nfunction getParent(state: State) {\n  const nextValue = getLastContext(state)\n  const nextContext = state.context.slice(0, -1)\n  return { ...state, context: nextContext, value: nextValue }\n}\n\nfunction getRoot(state: State) {\n  const nextValue = getRootFromState(state)\n  return { ...state, context: [], value: nextValue }\n}\n\nfunction getSetParentOrRoot(path: string, isSet: boolean): Operation {\n  const getFn = path[1] === '^' ? getRoot : getParent\n  return () => (next) => async (state) => {\n    const nextState = await next(state)\n    if (adjustIsSet(isSet, state)) {\n      // Simple return target instead of setting anything\n      return setStateValue(nextState, state.target)\n    } else {\n      // Get root or parent\n      return getFn(nextState)\n    }\n  }\n}\n\nconst modifyOnSet =\n  (isSet: boolean): Operation =>\n  (options) =>\n    function modifyOnSet(next) {\n      const modifyFn = modify('.')(options)(next)\n      return async (state) => {\n        return adjustIsSet(isSet, state)\n          ? await modifyFn(state) // Modify when we're setting\n          : setStateValue(await next(state), undefined) // Return undefined value when we're getting\n      }\n    }\n\nfunction doModifyGetValue(value: unknown, state: State, options: Options) {\n  const { modifyGetValue } = options\n  return typeof modifyGetValue === 'function'\n    ? modifyGetValue(value, state, options)\n    : value\n}\n\nfunction getSet(isSet = false) {\n  return (path: string | number): Operation => {\n    if (typeof path === 'string') {\n      if (path === '$modify') {\n        return modifyOnSet(isSet)\n      } else if (path[0] === '^') {\n        return getSetParentOrRoot(path, isSet)\n      }\n    }\n\n    const [basePath, isArr, isIndexProp] = preparePath(path)\n    const isIndex = typeof basePath === 'number'\n    const getSetFn = isIndex ? getSetIndex(basePath) : getSetProp(basePath)\n\n    return (options) => (next) =>\n      async function doGetSet(state) {\n        if (adjustIsSet(isSet, state)) {\n          // Set\n          // We'll go backwards first. Start by preparing target for the next set\n          const target = getTargetFromState(state)\n          const nextTarget = getSetFn(target, false)\n\n          // Invoke the \"previous\" path part with the right target, iterate if array\n          const nextState = await next(\n            setTargetOnState(\n              { ...state, iterate: state.iterate || isArr },\n              nextTarget,\n            ),\n          )\n\n          // Now it's our turn. Set the state value - and iterate if necessary\n          const setIt = (value: unknown, index?: number) =>\n            getSetFn(value, true, indexOfIfArray(target, index))\n\n          const nextValue = getStateValue(nextState)\n          if (state.noDefaults && isNonvalue(nextValue, options.nonvalues)) {\n            return setStateValue(state, target)\n          }\n          const value = isArr\n            ? ensureArray(nextValue, options.nonvalues)\n            : nextValue\n\n          const thisValue =\n            nextState.iterate && !isArr && !isIndexProp\n              ? mapAny(setIt, value)\n              : setIt(value)\n\n          // Return the value\n          return setStateValue(state, thisValue)\n        } else {\n          // Get\n          // Go backwards\n          const nextState = await next(state)\n          const thisValue = getSetFn(getStateValue(nextState), false)\n          const modifiedValue = doModifyGetValue(thisValue, nextState, options)\n\n          const value =\n            state.noDefaults && isNonvalue(modifiedValue, options.nonvalues)\n              ? undefined\n              : isArr\n              ? ensureArray(modifiedValue, options.nonvalues)\n              : modifiedValue\n\n          return setStateValue(\n            nextState,\n            value,\n            true, // Push to context\n          )\n        }\n      }\n  }\n}\n\nfunction resolveArrayNotation(path: string, pos: number) {\n  const index = Number.parseInt(path.slice(pos + 1), 10)\n  if (!Number.isNaN(index)) {\n    const basePath = path.slice(0, pos).trim()\n    return basePath ? [`${basePath}][`, index] : [index] // `][` is our crazy notation for an index prop\n  } else {\n    return path.trim()\n  }\n}\n\nfunction resolveParentNotation(path: string) {\n  if (path.startsWith('^^') && path.length > 2) {\n    return ['^^', path.slice(2).trim()]\n  } else if (path.length > 1 && path !== '^^') {\n    return ['^^', path.slice(1).trim()]\n  } else {\n    return path.trim()\n  }\n}\n\nfunction splitUpArrayAndParentNotation(path: string) {\n  const pos = path.indexOf('[')\n  if (pos > -1 && path[pos - 1] !== '\\\\') {\n    return resolveArrayNotation(path, pos)\n  } else if (path.startsWith('^')) {\n    return resolveParentNotation(path)\n  } else {\n    return path.trim()\n  }\n}\n\n// Prepare a get or set path, depending on isSet. It's essentially the same,\n// only with reversed order and setting or getting by default. When ran in\n// reverse mode, it will run the other way.\nfunction pathToNextOperations(path: Path, isSet = false): Operation[] {\n  if (!path || path === '.') {\n    return [\n      () => (next: StateMapper) => async (state: State) =>\n        clearUntouched(await next(state)), // We don't change the value, but we still need to clear untouched\n    ]\n  }\n\n  // Treat as a set if it starts with >\n  if (path[0] === '>') {\n    path = path.slice(1)\n    isSet = true\n  }\n\n  // Split the path into parts, and get the operations for each part\n  const parts = path.split('.').flatMap(splitUpArrayAndParentNotation)\n  const operations = parts.map(getSet(isSet))\n\n  // Reverse order when we're setting\n  if (isSet) {\n    operations.reverse()\n  }\n\n  return operations\n}\n\nconst getByPart =\n  (part: string | number, isArr: boolean) => (value: unknown) => {\n    if (typeof part === 'string') {\n      if (isObject(value)) {\n        const nextValue = value[part]\n        return isArr ? ensureArray(nextValue) : nextValue\n      }\n    } else if (typeof part === 'number' && Array.isArray(value)) {\n      return value[calculateIndex(part, value)]\n    }\n    return isArr ? [] : undefined\n  }\n\nfunction prepareGetFn([part, isArr]: [string | number, boolean, boolean]): (\n  value: unknown,\n  state: State,\n) => [unknown, State | undefined] {\n  if (typeof part === 'string' && part[0] === '^') {\n    // This part is a parent or a root, so we'll return the value and the next state\n    const isRoot = part[1] === '^'\n    return (_value, state) => {\n      const nextState = isRoot ? getRoot(state) : getParent(state)\n      return [nextState.value, nextState]\n    }\n  } else if (typeof part === 'number') {\n    // This is an index part\n    const fn = getByPart(part, isArr)\n    return (value) => [fn(value), undefined]\n  } else {\n    // This is a regular part\n    const fn = flatMapAny(getByPart(part, isArr))\n    return (value) => [fn(value), undefined]\n  }\n}\n\nconst setOnObject = (part: string) => (value: unknown) =>\n  part ? { [part]: value } : value\n\nconst setByPart =\n  (part: string | number, isArr: boolean, doIterate: boolean) =>\n  (value: unknown) => {\n    const data = isArr ? ensureArray(value) : value\n    if (typeof part === 'number') {\n      const arr = []\n      const index = part < 0 ? 0 : part // Negative index will always be 0\n      arr[index] = data\n      return arr\n    } else {\n      return doIterate\n        ? mapAny(setOnObject(part), data)\n        : setOnObject(part)(data)\n    }\n  }\n\nfunction getDoIterateFromLastPart(\n  parts: [string | number, boolean, boolean][],\n) {\n  if (parts.length === 0) {\n    return false\n  }\n\n  const lastPart = parts[parts.length - 1]\n  return lastPart[1] || lastPart[2]\n}\n\nconst setDoIterateOnParts = (\n  parts: [string | number, boolean, boolean][],\n  [part, isArr]: [string | number, boolean, boolean],\n): [string | number, boolean, boolean][] => [\n  ...parts,\n  [part, isArr, isArr ? false : getDoIterateFromLastPart(parts)],\n]\n\n/**\n * Get a value at the given path.\n */\nexport function pathGetter(\n  path?: string | null,\n  _options: Options = {},\n): DataMapperWithState {\n  if (!path || path === '.') {\n    return (value) => value\n  }\n\n  const parts = path\n    .split('.')\n    .flatMap(splitUpArrayAndParentNotation)\n    .map(preparePath)\n    .map(prepareGetFn)\n\n  return function getFromPath(value, startState) {\n    let data = value\n    let state = startState\n    for (const partOrGetFn of parts) {\n      ;[data, state = state] = partOrGetFn(data, state)\n    }\n    return data\n  }\n}\n\n/**\n * Set a value to the given path.\n */\nexport function pathSetter(\n  path?: string | null,\n  options: Options = {},\n): DataMapperWithState {\n  if (typeof path !== 'string' || path === '' || path === '.') {\n    return (value) => value // Just return the value\n  } else if (path[0] === '^') {\n    return () => undefined // We won't set on parent or root\n  }\n\n  const setFns = path\n    .split('.')\n    .flatMap(splitUpArrayAndParentNotation)\n    .map(preparePath)\n    .reduce(setDoIterateOnParts, [])\n    .map(([part, isArr, doIterate]) => setByPart(part, isArr, doIterate))\n\n  return function setToPath(value, state) {\n    if (state.noDefaults && isNonvalue(value, options.nonvalues)) {\n      // We should not set a nonvalue, and this is a nonvalue, so return `undefined`\n      return undefined\n    } else {\n      // Set on path by running the parts in reverse order (from the innermost to the outermost)\n      return setFns.reduceRight((value, setFn) => setFn(value), value)\n    }\n  }\n}\n\n/**\n * Run a get path.\n */\nexport const get = (path: Path) => pathToNextOperations(path, false)\n\n/**\n * Run a set path.\n */\nexport const set = (path: Path) => pathToNextOperations(path, true)\n","import xor from './xor.js'\nimport type { State, InitialState } from '../types.js'\n\n// Context\n\nexport const getLastContext = (state: State) =>\n  state.context[state.context.length - 1]\n\nexport const removeLastContext = (state: State) => ({\n  ...state,\n  context: state.context.slice(0, -1),\n})\n\nexport const pushContext = (state: State, value: unknown) => ({\n  ...state,\n  context: [...state.context, value],\n})\n\nexport const popContext = (state: State) => ({\n  ...state,\n  context: state.context.slice(0, -1),\n  value: state.context[state.context.length - 1],\n})\n\n// Root\n\nexport const getRootFromState = (state: State) =>\n  state.context.length === 0 ? state.value : state.context[0]\n\n// Target\n\nexport const getTargetFromState = (state: State) => state.target\n\nexport function setTargetOnState(state: State, target: unknown): State {\n  return {\n    ...state,\n    target,\n  }\n}\n\n// State value\n\nexport const setStateValue = (\n  { untouched, ...state }: State, // Clear untouched every time we set a value\n  value: unknown,\n  shouldPushContext = false,\n): State =>\n  shouldPushContext\n    ? {\n        ...pushContext(state, state.value),\n        value,\n      }\n    : { ...state, value }\n\nexport const getStateValue = (state: State): unknown => state.value\n\nexport const setValueFromState = (\n  state: State,\n  { value }: State,\n  shouldPushContext = false,\n): State => setStateValue(state, value, shouldPushContext)\n\nexport const isNonvalue = (\n  value: unknown,\n  nonvalues: unknown[] = [undefined],\n) => nonvalues.includes(value)\n\nexport const isNonvalueState = (\n  state: State,\n  nonvalues: unknown[] = [undefined],\n) => isNonvalue(state.value, nonvalues)\n\nexport const markAsUntouched = (state: State) => ({ ...state, untouched: true })\nexport const clearUntouched = ({ untouched, ...state }: State) => state\nexport const isUntouched = ({ untouched }: State) => !!untouched\n\n// State\n\nexport const populateState = (\n  data: unknown,\n  { rev = false, noDefaults = false, target = undefined }: InitialState,\n): State => ({\n  context: [],\n  value: data,\n  target,\n  rev,\n  noDefaults,\n})\n\nexport const goForward = (state: State) =>\n  state.rev || state.flip\n    ? {\n        ...state,\n        rev: false,\n        flip: false,\n      }\n    : state\n\nexport const flipState = (state: State, flip = true) => ({\n  ...state,\n  flip: xor(state.flip, flip),\n})\n\nexport const stopIteration = (state: State) => ({ ...state, iterate: false })\n\nexport const noopNext = async (state: State) => state\n\nexport const revFromState = (state: State, flip = false) =>\n  flip ? xor(state.rev, !state.flip) : xor(state.rev, state.flip)\n","import type { Path } from '../types.js'\n\nexport const isObject = (value: unknown): value is Record<string, unknown> =>\n  Object.prototype.toString.call(value) === '[object Object]'\n\nexport const isString = (value: unknown): value is string =>\n  typeof value === 'string'\n\nexport const isPath = (value: unknown): value is Path =>\n  typeof value === 'string'\n\nexport const isArrayPath = (value: unknown): value is Path =>\n  isPath(value) && value.endsWith('[]')\n\nexport const isNullOrUndefined = (value: unknown): value is null | undefined =>\n  value === null || value === undefined\n\nexport const isNotNullOrUndefined = <T>(value: T): value is NonNullable<T> =>\n  !isNullOrUndefined(value)\n\nexport const isNonEmptyArray = <T>(value: unknown): value is T[] =>\n  Array.isArray(value) && value.length > 0\n","import { isNonvalue } from '../utils/stateHelpers.js'\n\nexport const ensureArray = <T = unknown>(\n  value: T | T[],\n  nonvalues?: unknown[]\n): T[] =>\n  Array.isArray(value) ? value : isNonvalue(value, nonvalues) ? [] : [value]\n\nexport const cloneAsArray = (value: unknown) => ensureArray(value).slice()\n\nexport const indexOfIfArray = (arr: unknown, index?: number) =>\n  Array.isArray(arr) && typeof index === 'number' ? arr[index] : arr // eslint-disable-line security/detect-object-injection\n","import deepmerge from 'deepmerge'\nimport type { Operation, State, TransformDefinition } from '../types.js'\nimport {\n  getStateValue,\n  setStateValue,\n  isNonvalueState,\n} from '../utils/stateHelpers.js'\nimport { defToOperation } from '../utils/definitionHelpers.js'\nimport { isObject } from '../utils/is.js'\n\nexport function mergeExisting<T, U>(\n  target: T[],\n  source: U[],\n): U | (U | T | (U & T))[] {\n  if (Array.isArray(target)) {\n    const arr = source.slice()\n    target.forEach((value, index) => {\n      // eslint-disable-next-line security/detect-object-injection\n      arr[index] = deepmerge<U, T>(source[index], value, {\n        arrayMerge: mergeExisting,\n      })\n    })\n    return arr\n  }\n  return target\n}\n\nexport function mergeStates(state: State, thisState: State) {\n  const target = getStateValue(state)\n  const source = getStateValue(thisState)\n\n  const value = !isObject(source)\n    ? target\n    : !isObject(target)\n    ? source\n    : deepmerge(target, source, { arrayMerge: mergeExisting })\n\n  return setStateValue(state, value)\n}\n\nexport default function merge(...defs: TransformDefinition[]): Operation {\n  return (options) => (next) => {\n    if (defs.length === 0) {\n      return async (state) => setStateValue(await next(state), undefined)\n    }\n    const pipelines = defs.map((def) =>\n      defToOperation(def, options)(options)(next),\n    )\n\n    return async function (state) {\n      const nextState = await next(state)\n      if (isNonvalueState(nextState, options.nonvalues)) {\n        return setStateValue(nextState, undefined)\n      } else {\n        const states = []\n        for (const pipeline of pipelines) {\n          states.push(await pipeline(nextState))\n        }\n        return states.reduce(mergeStates)\n      }\n    }\n  }\n}\n","import mapAny from 'map-any-cjs/async.js'\nimport { pathGetter } from '../operations/getSet.js'\nimport type { Operation, State, Path, TransformerProps } from '../types.js'\nimport {\n  getStateValue,\n  setStateValue,\n  goForward,\n  revFromState,\n} from '../utils/stateHelpers.js'\nimport { defToOperation } from '../utils/definitionHelpers.js'\nimport { noopNext } from '../utils/stateHelpers.js'\nimport { isObject } from '../utils/is.js'\n\nexport interface Props extends TransformerProps {\n  arrayPath: Path\n  propPath: Path\n  matchSeveral?: boolean\n  flip?: boolean\n}\n\ninterface GetPropFn {\n  (val: unknown, state: State): unknown\n}\n\ninterface MatchFn {\n  (value: unknown, state: State, arr: unknown[], getProp: GetPropFn): unknown\n}\n\nconst FLATTEN_DEPTH = 1\n\nconst flattenIfArray = (data: unknown) =>\n  Array.isArray(data) ? data.flat(FLATTEN_DEPTH) : data\n\n// Find all matches in array. To support async, we first map over the\n// array and get the value to compare against, then filter against these\n// values.\nconst findAllMatches: MatchFn = (value, state, arr, getProp) =>\n  arr.filter((val) => getProp(val, state) === value)\n\n// Find first match in array. We use a for loop here, as we have to do it\n// asyncronously.\nconst findOneMatch: MatchFn = (value, state, arr, getProp) =>\n  arr.find((val) => getProp(val, state) === value)\n\n// Do the actual lookup. Will retrieve the array from the given state, and then\n// compare to the state value.\nconst matchInArray =\n  (getArray: Operation, match: MatchFn, getProp: GetPropFn) =>\n  (state: State) => {\n    const getFn = getArray({})(noopNext)\n    return async (value: unknown) => {\n      const { value: arr } = await getFn(goForward(state))\n      if (Array.isArray(arr)) {\n        return match(value, state, arr, getProp)\n      } else if (isObject(arr)) {\n        return match(value, state, [arr], getProp)\n      } else {\n        return undefined\n      }\n    }\n  }\n\n/**\n * Will use the value in the pipeline to lookup objects found in the `arrayPath`\n * array. Matching is done by comparing the the pipeline value to the value at\n * `propPath` in each object in the array. If `matchSeveral` is `true`, all\n * matches will be returned, otherwise only the first match will be returned.\n * The pipeline value will be replaced by the result of the lookup, or\n * `undefined`.\n *\n * In reverse, `propPath` will be used to extract a value from the object(s) on\n * the pipeline. This is considered to be the oposite behavior of the lookup,\n * leading to the match value from the lookup being put back in the pipeline.\n *\n * Note that `flip` will reverse this behavior, and the `flip` property and the\n * state `flip` will \"flip each others\".\n */\nexport function lookup({\n  arrayPath,\n  propPath,\n  matchSeveral = false,\n  flip = false,\n}: Props): Operation {\n  return (options) => {\n    if (typeof propPath !== 'string' && propPath !== undefined) {\n      throw new TypeError(\n        \"The 'lookup' operation does not allow `path` (the prop path) to be a pipeline\",\n      )\n    }\n\n    const getter = pathGetter(propPath)\n    const matchFn = matchInArray(\n      defToOperation(arrayPath, options),\n      matchSeveral ? findAllMatches : findOneMatch,\n      getter,\n    )\n    const extractProp = (state: State) => async (value: unknown) =>\n      getter(value, state)\n\n    return (next) =>\n      async function doLookup(state) {\n        const nextState = await next(state)\n        const value = getStateValue(nextState)\n        const rev = revFromState(state, flip)\n        const matcher = rev ? extractProp : matchFn\n        const matches = await mapAny(matcher(nextState), value)\n        return setStateValue(nextState, flattenIfArray(matches))\n      }\n  }\n}\n\n// `lookdown` is the exact oposite of `lookup`, and will lookup in reverse\n// and extract prop going forward. State `flip` will be flipped too.\nexport function lookdown(props: Props): Operation {\n  return lookup({ ...props, flip: !props.flip })\n}\n"],"mappings":"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","names":["value","compare","fetchSortValue","props"]}