@tidyjs/tidy 2.5.2 → 2.6.0

package/dist/es/groupBy.js.map

@@ -1 +1 @@
-{"version":3,"file":"groupBy.js","sources":["../../src/groupBy.ts"],"sourcesContent":["import { group } from 'd3-array';\nimport { A, O } from 'ts-toolbelt';\nimport { assignGroupKeys } from './helpers/assignGroupKeys';\nimport { groupMap } from './helpers/groupMap';\nimport { groupTraversal } from './helpers/groupTraversal';\nimport { identity } from './helpers/identity';\nimport { isObject } from './helpers/isObject';\nimport { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\nimport { Grouped, GroupKey, TidyGroupExportFn, Key, TidyFn } from './types';\n\n/** [key, values] where values could be more nested entries */\ntype EntriesOutput = [any, any][];\ntype EntriesObjectOutput = { key: Key; values: any }[];\n\n/** nested objects: { [key]: values } */\ntype ObjectOutput = Record<Key, any>;\n\n/** nested keys: e.g. [key, key, key, [key, key, [key]]] */\ntype KeysOutput = any[];\n\n/** nested values: e.g. [[value1_1, value1_2], [value2_1, value2_2]] */\ntype ValuesOutput = any[];\n\nexport type LevelSpec = {\n  id?: string;\n  createEmptySubgroup: () => any;\n  addSubgroup: (\n    parentGrouped: any,\n    newSubgroup: any,\n    key: any,\n    level: number\n  ) => void;\n  addLeaf: (parentGrouped: any, key: any, values: any[], level: number) => void;\n};\n\n/**\n * Options to affect export type\n */\ninterface GroupByOptions {\n  /** whether to merge group keys back into the objects */\n  readonly addGroupKeys?: boolean;\n\n  // -- export related -- //\n  /** export method */\n  readonly export?:\n    | 'grouped'\n    | 'entries'\n    | 'entries-object'\n    | 'object'\n    | 'map'\n    | 'keys'\n    | 'values'\n    | 'levels'\n    | 'ungrouped';\n  /** if all nested levels should be brought to a single top level */\n  readonly flat?: boolean;\n  /** when flat is true, how to flatten nested keys */\n  readonly compositeKey?: (keys: any[]) => string;\n  /** whether the leaf sets consist of just one item (typical after summarize).\n   *  if true, uses the first element in the leaf set instead of an array\n   */\n  readonly single?: boolean;\n  /** operation called on each leaf during export to map it to a different value\n   *  (default: identity)\n   */\n  readonly mapLeaf?: (value: any) => any;\n  /** operation called on each leaf set to map the array of values to a different value.\n   * Similar to `rollup` from d3-collection nest or d3-array\n   * (default: identity)\n   */\n  readonly mapLeaves?: (values: any[]) => any;\n  /** [entries only] operation called on entries to map from [key, values] to\n   * whatever the output of this is (e.g. `{ key, values }`)\n   * (default: identity)\n   */\n  readonly mapEntry?: (entry: [any, any], level: number) => any;\n\n  /** [required for levels] specifies the export operation for each level of the grouping */\n  readonly levels?: (\n    | 'entries'\n    | 'entries-object'\n    | 'object'\n    | 'map'\n    | 'keys'\n    | 'values'\n    | LevelSpec\n  )[];\n}\n\n// aliases to make overloads shorter\ntype GK<T extends object> = SingleOrArray<keyof T | ((d: T) => any)>;\ntype F<I extends object, O extends object> = TidyFn<I, O>;\n\n// merge back in group keys to output types\ntype MergeGroupKeys<\n  T extends object,\n  Out extends object,\n  Keys extends GK<T>\n> = Keys extends keyof T\n  ? O.Merge<Pick<T, Keys>, Out>\n  : Keys extends (keyof T)[]\n  ? O.Merge<Pick<T, Keys[number]>, Out>\n  : Out;\n\n// do not merge in group keys if explicitly said not to\ntype WithGroupKeys<\n  T extends object,\n  Out extends object,\n  Keys extends GK<T>,\n  Opts extends GroupByOptions\n> = NonNullable<Opts>['addGroupKeys'] extends false\n  ? Out\n  : MergeGroupKeys<T, Out, Keys>;\n\n/**\n * output varies based on export options\n */\ntype GroupByOutput<\n  T extends object,\n  O extends object,\n  Keys extends GK<T>,\n  Opts extends GroupByOptions\n> = A.Compute<\n  NonNullable<Opts>['export'] extends 'grouped'\n    ? Grouped<WithGroupKeys<T, O, Keys, Opts>>\n    : NonNullable<Opts>['export'] extends 'entries'\n    ? EntriesOutput\n    : NonNullable<Opts>['export'] extends 'entries-object'\n    ? EntriesObjectOutput\n    : NonNullable<Opts>['export'] extends 'object'\n    ? ObjectOutput\n    : NonNullable<Opts>['export'] extends 'map'\n    ? Map<any, any>\n    : NonNullable<Opts>['export'] extends 'keys'\n    ? KeysOutput\n    : NonNullable<Opts>['export'] extends 'values'\n    ? ValuesOutput\n    : NonNullable<Opts>['export'] extends 'levels'\n    ? any\n    : WithGroupKeys<T, O, Keys, Opts>[]\n>;\n\ntype GroupByFn<\n  T extends object,\n  O extends object,\n  Keys extends GK<T>,\n  Opts extends GroupByOptions\n> = Opts['export'] extends\n  | 'grouped'\n  | 'entries'\n  | 'entries-object'\n  | 'object'\n  | 'map'\n  | 'keys'\n  | 'values'\n  | 'levels'\n  ? TidyGroupExportFn<T, GroupByOutput<T, O, Keys, Opts>>\n  : // default is no export, ungrouped and back in simple form\n    TidyFn<T, WithGroupKeys<T, O, Keys, Opts>>;\n\n/**\n * Nests the data by the specified groupings\n */\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: F<T, T1>, options: Opts): GroupByFn<T, T1, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, Keys extends GK<T>>(groupKeys: Keys, fns: F<T, T1>): GroupByFn<T, T1, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, T6 extends object, T7 extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>, F<T5, T6>, F<T6, T7>], options: Opts): GroupByFn<T, T7, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, T6 extends object, T7 extends object, Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>, F<T5, T6>, F<T6, T7>]): GroupByFn<T, T7, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, T6 extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>, F<T5, T6>], options: Opts): GroupByFn<T, T6, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, T6 extends object, Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>, F<T5, T6>]): GroupByFn<T, T6, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>], options: Opts): GroupByFn<T, T5, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>]): GroupByFn<T, T5, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>], options: Opts): GroupByFn<T, T4, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>]): GroupByFn<T, T4, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>], options: Opts): GroupByFn<T, T3, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>]): GroupByFn<T, T3, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>], options: Opts): GroupByFn<T, T2, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>]): GroupByFn<T, T2, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>], options: Opts): GroupByFn<T, T1, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>]): GroupByFn<T, T1, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [], options: Opts): GroupByFn<T, T, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, Keys extends GK<T>>(groupKeys: Keys, fns: []): GroupByFn<T, T, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, options: Opts): GroupByFn<T, T, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, Keys extends GK<T>>(groupKeys: Keys): GroupByFn<T, T, Keys, GroupByOptions>;\nexport function groupBy<\n  T extends object,\n  O extends object,\n  Keys extends GK<T>,\n  Opts extends GroupByOptions\n>(\n  groupKeys: Keys,\n  fns?: TidyFn<any, any>[] | TidyFn<any, any>,\n  options?: Opts\n): GroupByFn<T, O, Keys, Opts> {\n  if (typeof fns === 'function') {\n    fns = [fns];\n  } else if (arguments.length === 2 && fns != null && !Array.isArray(fns)) {\n    options = fns as any;\n  }\n\n  const _groupBy: GroupByFn<T, O, Keys, Opts> = ((items: T[]) => {\n    // form into a nested map\n    const grouped = makeGrouped(items, groupKeys);\n\n    // run group functions\n    const results = runFlow(\n      grouped,\n      fns as TidyFn<any, any>[],\n      options?.addGroupKeys\n    );\n\n    // export\n    if (options?.export) {\n      switch (options.export) {\n        case 'grouped':\n          return results;\n        case 'levels':\n          return exportLevels(results, options);\n        case 'entries-obj' as any:\n        case 'entriesObject' as any:\n          return exportLevels(results, {\n            ...options,\n            export: 'levels',\n            levels: ['entries-object'],\n          });\n        default:\n          return exportLevels(results, {\n            ...options,\n            export: 'levels',\n            levels: [options.export],\n          });\n      }\n    }\n\n    // export === 'ungrouped' or nully:\n    const ungrouped = ungroup(results, options?.addGroupKeys);\n    return ungrouped as any;\n  }) as GroupByFn<T, O, Keys, Opts>;\n  // (_groupBy as any).tidyType = 'group-export';\n\n  return _groupBy;\n}\n// convenient export option configs\ngroupBy.grouped = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'grouped' } as const);\ngroupBy.entries = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'entries' } as const);\ngroupBy.entriesObject = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'entries-object' } as const);\ngroupBy.object = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'object' } as const);\ngroupBy.map = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'map' } as const);\ngroupBy.keys = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'keys' } as const);\ngroupBy.values = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'values' } as const);\ngroupBy.levels = (options?: Omit<GroupByOptions, 'export'>) =>\n  ({ ...options, export: 'levels' } as const);\n\nfunction runFlow<T extends object>(\n  items: Grouped<T>,\n  fns?: TidyFn<any, any>[],\n  addGroupKeys?: boolean\n) {\n  let result: any = items;\n  if (!fns?.length) return result;\n\n  for (const fn of fns) {\n    if (!fn) continue;\n\n    // otherwise break it up and call it on each leaf set\n    result = groupMap(result, (items, keys) => {\n      // ensure we kept the group keys in the object\n      // (necessary for e.g. summarize which may remove them)\n      const context = { groupKeys: keys };\n      let leafItemsMapped = fn(items, context);\n      if (addGroupKeys !== false) {\n        leafItemsMapped = leafItemsMapped.map((item: T) =>\n          assignGroupKeys(item, keys)\n        );\n      }\n\n      return leafItemsMapped;\n    });\n  }\n\n  return result;\n}\n\nfunction makeGrouped<T extends object>(\n  items: T[],\n  groupKeys: SingleOrArray<keyof T | ((d: T) => any)>\n): Grouped<T> {\n  // convert string based keys to functions and keep the key name with the key value in a tuple\n  const groupKeyFns = singleOrArray(groupKeys).map((key, i) => {\n    const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n    // use a cache so we don't generate new keys for the same tuple\n    const keyCache = new Map();\n    return (d: T) => {\n      const keyValue = keyFn(d);\n\n      const keyValueOf = isObject(keyValue) ? keyValue.valueOf() : keyValue;\n      // used cache tuple if available\n      if (keyCache.has(keyValueOf)) {\n        return keyCache.get(keyValueOf) as GroupKey;\n      }\n\n      const keyWithName = [key, keyValue];\n      keyCache.set(keyValueOf, keyWithName);\n\n      return keyWithName;\n    };\n  });\n\n  const grouped = group(items, ...groupKeyFns);\n  return grouped;\n}\n\n/**\n * flattens a grouped collection back to a simple array\n */\nfunction ungroup<T extends object>(\n  grouped: Grouped<T>,\n  addGroupKeys: boolean | undefined\n): T[] {\n  // flatten the groups\n  const items: T[] = [];\n\n  groupTraversal(grouped, items, [], identity, (root, keys, values) => {\n    // ensure we have group keys on items (in case runFlow didn't run)\n    let valuesToAdd = values;\n    if (addGroupKeys !== false) {\n      valuesToAdd = values.map((d) => assignGroupKeys(d, keys));\n    }\n    root.push(...valuesToAdd);\n  });\n\n  return items;\n}\n\n// -----------------------------------------------------------------------\n// --- EXPORTS -----------------------------------------------------------\n// -----------------------------------------------------------------------\nconst defaultCompositeKey = (keys: any[]) => keys.join('/');\n\nfunction processFromGroupsOptions<T extends object>(options: GroupByOptions) {\n  const {\n    flat,\n    single,\n    mapLeaf = identity,\n    mapLeaves = identity,\n    addGroupKeys,\n  } = options;\n  let compositeKey: (keys: any[]) => string;\n  if (options.flat) {\n    compositeKey = options.compositeKey! ?? defaultCompositeKey;\n  }\n\n  const groupFn = (values: T[], keys: any[]) => {\n    return single\n      ? mapLeaf(\n          addGroupKeys === false ? values[0] : assignGroupKeys(values[0], keys)\n        )\n      : mapLeaves(\n          values.map((d) =>\n            mapLeaf(addGroupKeys === false ? d : assignGroupKeys(d, keys))\n          )\n        );\n  };\n\n  const keyFn = flat\n    ? (keys: GroupKey[]) => compositeKey(keys.map((d) => d[1]))\n    : (keys: GroupKey[]) => keys[keys.length - 1][1];\n\n  return { groupFn, keyFn };\n}\n\n// -- Levels -------------------------------------------------------------\nfunction exportLevels<T extends object>(\n  grouped: Grouped<T>,\n  options: GroupByOptions\n): any {\n  type NestedEntries<T> = Array<[any, NestedEntries<T> | T[]]>;\n  type NestedObject<T> = { [key: string]: NestedObject<T> | T[] };\n\n  const { groupFn, keyFn } = processFromGroupsOptions(options);\n  let { mapEntry = identity } = options;\n  const { levels = ['entries'] } = options;\n\n  const levelSpecs: LevelSpec[] = [];\n  for (const levelOption of levels) {\n    switch (levelOption) {\n      // entries / entries-object -----------------------------------------\n      case 'entries':\n      case 'entries-object':\n      case 'entries-obj' as any:\n      case 'entriesObject' as any: {\n        const levelMapEntry =\n          (levelOption === 'entries-object' ||\n            levelOption === ('entries-obj' as any) ||\n            levelOption === ('entriesObject' as any)) &&\n          options.mapEntry == null\n            ? ([key, values]: any) => ({ key, values })\n            : mapEntry;\n\n        levelSpecs.push({\n          id: 'entries',\n          createEmptySubgroup: () => [],\n          addSubgroup: (\n            parentGrouped: NestedEntries<T>,\n            newSubgroup: any,\n            key: any,\n            level: number\n          ) => {\n            parentGrouped.push(levelMapEntry([key, newSubgroup], level));\n          },\n\n          addLeaf: (\n            parentGrouped: NestedEntries<T>,\n            key: any,\n            values: T[],\n            level: number\n          ) => {\n            parentGrouped.push(levelMapEntry([key, values], level));\n          },\n        });\n        break;\n      }\n      // map -------------------------------------------------------------\n      case 'map':\n        levelSpecs.push({\n          id: 'map',\n          createEmptySubgroup: () => new Map(),\n          addSubgroup: (\n            parentGrouped: Map<any, any>,\n            newSubgroup: any,\n            key: any\n          ) => {\n            parentGrouped.set(key, newSubgroup);\n          },\n\n          addLeaf: (parentGrouped: Map<any, any>, key: any, values: T[]) => {\n            parentGrouped.set(key, values);\n          },\n        });\n        break;\n\n      // object ----------------------------------------------------------\n      case 'object':\n        levelSpecs.push({\n          id: 'object',\n          createEmptySubgroup: () => ({}),\n          addSubgroup: (\n            parentGrouped: NestedObject<T>,\n            newSubgroup: any,\n            key: any\n          ) => {\n            parentGrouped[key] = newSubgroup;\n          },\n\n          addLeaf: (parentGrouped: NestedObject<T>, key: any, values: T[]) => {\n            parentGrouped[key] = values;\n          },\n        });\n        break;\n\n      // keys ------------------------------------------------------------\n      case 'keys':\n        levelSpecs.push({\n          id: 'keys',\n          createEmptySubgroup: () => [],\n          addSubgroup: (parentGrouped: any, newSubgroup: any, key: any) => {\n            parentGrouped.push([key, newSubgroup]);\n          },\n\n          addLeaf: (parentGrouped: any, key: any) => {\n            parentGrouped.push(key);\n          },\n        });\n        break;\n\n      // values ----------------------------------------------------------\n      case 'values':\n        levelSpecs.push({\n          id: 'values',\n          createEmptySubgroup: () => [],\n          addSubgroup: (parentGrouped: any, newSubgroup: any) => {\n            parentGrouped.push(newSubgroup);\n          },\n\n          addLeaf: (parentGrouped: any, key: any, values: T[]) => {\n            parentGrouped.push(values);\n          },\n        });\n        break;\n\n      // custom ----------------------------------------------------------\n      default: {\n        // LevelSpec obj already\n        if (typeof levelOption === 'object') {\n          levelSpecs.push(levelOption);\n        }\n      }\n    }\n  }\n\n  // add subgroup\n  const addSubgroup = (parentGrouped: any, keys: any[], level: number): any => {\n    if (options.flat) {\n      return parentGrouped;\n    }\n\n    const levelSpec = levelSpecs[level] ?? levelSpecs[levelSpecs.length - 1];\n    const nextLevelSpec = levelSpecs[level + 1] ?? levelSpec;\n    const newSubgroup = nextLevelSpec.createEmptySubgroup();\n    levelSpec!.addSubgroup(parentGrouped, newSubgroup, keyFn(keys), level);\n    return newSubgroup;\n  };\n\n  // add leaves\n  const addLeaf = (\n    parentGrouped: any,\n    keys: any[],\n    values: T[],\n    level: number\n  ) => {\n    const levelSpec = levelSpecs[level] ?? levelSpecs[levelSpecs.length - 1];\n    levelSpec!.addLeaf(\n      parentGrouped,\n      keyFn(keys),\n      groupFn(values, keys),\n      level\n    );\n  };\n\n  const initialOutputObject = levelSpecs[0]!.createEmptySubgroup();\n  return groupTraversal(grouped, initialOutputObject, [], addSubgroup, addLeaf);\n}\n"],"names":[],"mappings":";;;;;;;;iBAiNE,WACA,KACA;AAEA,MAAI,OAAO,QAAQ;AACjB,UAAM,CAAC;AAAA,aACE,UAAU,WAAW,KAAK,OAAO,QAAQ,CAAC,MAAM,QAAQ;AACjE,cAAU;AAAA;AAGZ,QAAM,WAAyC,CAAC;AAE9C,UAAM,UAAU,YAAY,OAAO;AAGnC,UAAM,UAAU,QACd,SACA,KACA,mCAAS;AAIX,QAAI,mCAAS;AACX,cAAQ,QAAQ;AAAA,aACT;AACH,iBAAO;AAAA,aACJ;AACH,iBAAO,aAAa,SAAS;AAAA,aAC1B;AAAA,aACA;AACH,iBAAO,aAAa,SAAS;AAAA,eACxB;AAAA,YACH,QAAQ;AAAA,YACR,QAAQ,CAAC;AAAA;AAAA;AAGX,iBAAO,aAAa,SAAS;AAAA,eACxB;AAAA,YACH,QAAQ;AAAA,YACR,QAAQ,CAAC,QAAQ;AAAA;AAAA;AAAA;AAMzB,UAAM,YAAY,QAAQ,SAAS,mCAAS;AAC5C,WAAO;AAAA;AAIT,SAAO;AAAA;AAGT,QAAQ,UAAU,CAAC,iBACX,SAAS,QAAQ;AACzB,QAAQ,UAAU,CAAC,iBACX,SAAS,QAAQ;AACzB,QAAQ,gBAAgB,CAAC,iBACjB,SAAS,QAAQ;AACzB,QAAQ,SAAS,CAAC,iBACV,SAAS,QAAQ;AACzB,QAAQ,MAAM,CAAC,iBACP,SAAS,QAAQ;AACzB,QAAQ,OAAO,CAAC,iBACR,SAAS,QAAQ;AACzB,QAAQ,SAAS,CAAC,iBACV,SAAS,QAAQ;AACzB,QAAQ,SAAS,CAAC,iBACV,SAAS,QAAQ;AAEzB,iBACE,OACA,KACA;AAEA,MAAI,SAAc;AAClB,MAAI,6BAAM;AAAQ,WAAO;AAEzB,aAAW,MAAM;AACf,QAAI,CAAC;AAAI;AAGT,aAAS,SAAS,QAAQ,CAAC,QAAO;AAGhC,YAAM,UAAU,CAAE,WAAW;AAC7B,UAAI,kBAAkB,GAAG,QAAO;AAChC,UAAI,iBAAiB;AACnB,0BAAkB,gBAAgB,IAAI,CAAC,SACrC,gBAAgB,MAAM;AAAA;AAI1B,aAAO;AAAA;AAAA;AAIX,SAAO;AAAA;AAGT,qBACE,OACA;AAGA,QAAM,cAAc,cAAc,WAAW,IAAI,CAAC,KAAK;AACrD,UAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAG5D,UAAM,WAAW,IAAI;AACrB,WAAO,CAAC;AACN,YAAM,WAAW,MAAM;AAEvB,YAAM,aAAa,SAAS,YAAY,SAAS,YAAY;AAE7D,UAAI,SAAS,IAAI;AACf,eAAO,SAAS,IAAI;AAAA;AAGtB,YAAM,cAAc,CAAC,KAAK;AAC1B,eAAS,IAAI,YAAY;AAEzB,aAAO;AAAA;AAAA;AAIX,QAAM,UAAU,MAAM,OAAO,GAAG;AAChC,SAAO;AAAA;AAMT,iBACE,SACA;AAGA,QAAM,QAAa;AAEnB,iBAAe,SAAS,OAAO,IAAI,UAAU,CAAC,MAAM,MAAM;AAExD,QAAI,cAAc;AAClB,QAAI,iBAAiB;AACnB,oBAAc,OAAO,IAAI,CAAC,MAAM,gBAAgB,GAAG;AAAA;AAErD,SAAK,KAAK,GAAG;AAAA;AAGf,SAAO;AAAA;AAMT,MAAM,sBAAsB,CAAC,SAAgB,KAAK,KAAK;AAEvD,kCAAoD;AA9WpD;AA+WE,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,UAAU;AAAA,IACV,YAAY;AAAA,IACZ;AAAA,MACE;AACJ,MAAI;AACJ,MAAI,QAAQ;AACV,mBAAe,cAAQ,iBAAR,YAAyB;AAAA;AAG1C,QAAM,UAAU,CAAC,QAAa;AAC5B,WAAO,SACH,QACE,iBAAiB,QAAQ,OAAO,KAAK,gBAAgB,OAAO,IAAI,SAElE,UACE,OAAO,IAAI,CAAC,MACV,QAAQ,iBAAiB,QAAQ,IAAI,gBAAgB,GAAG;AAAA;AAKlE,QAAM,QAAQ,OACV,CAAC,SAAqB,aAAa,KAAK,IAAI,CAAC,MAAM,EAAE,OACrD,CAAC,SAAqB,KAAK,KAAK,SAAS,GAAG;AAEhD,SAAO,CAAE,SAAS;AAAA;AAIpB,sBACE,SACA;AAKA,QAAM,CAAE,SAAS,SAAU,yBAAyB;AACpD,MAAI,CAAE,WAAW,YAAa;AAC9B,QAAM,CAAE,SAAS,CAAC,cAAe;AAEjC,QAAM,aAA0B;AAChC,aAAW,eAAe;AACxB,YAAQ;AAAA,WAED;AAAA,WACA;AAAA,WACA;AAAA,WACA;AACH,cAAM,gBACH,iBAAgB,oBACf,gBAAiB,iBACjB,gBAAiB,oBACnB,QAAQ,YAAY,OAChB,CAAC,CAAC,KAAK,cAAoB,KAAK,WAChC;AAEN,mBAAW,KAAK;AAAA,UACd,IAAI;AAAA,UACJ,qBAAqB,MAAM;AAAA,UAC3B,aAAa,CACX,eACA,aACA,KACA;AAEA,0BAAc,KAAK,cAAc,CAAC,KAAK,cAAc;AAAA;AAAA,UAGvD,SAAS,CACP,eACA,KACA,QACA;AAEA,0BAAc,KAAK,cAAc,CAAC,KAAK,SAAS;AAAA;AAAA;AAGpD;AAAA;AAAA,WAGG;AACH,mBAAW,KAAK;AAAA,UACd,IAAI;AAAA,UACJ,qBAAqB,MAAM,IAAI;AAAA,UAC/B,aAAa,CACX,eACA,aACA;AAEA,0BAAc,IAAI,KAAK;AAAA;AAAA,UAGzB,SAAS,CAAC,eAA8B,KAAU;AAChD,0BAAc,IAAI,KAAK;AAAA;AAAA;AAG3B;AAAA,WAGG;AACH,mBAAW,KAAK;AAAA,UACd,IAAI;AAAA,UACJ,qBAAqB;AAAO,UAC5B,aAAa,CACX,eACA,aACA;AAEA,0BAAc,OAAO;AAAA;AAAA,UAGvB,SAAS,CAAC,eAAgC,KAAU;AAClD,0BAAc,OAAO;AAAA;AAAA;AAGzB;AAAA,WAGG;AACH,mBAAW,KAAK;AAAA,UACd,IAAI;AAAA,UACJ,qBAAqB,MAAM;AAAA,UAC3B,aAAa,CAAC,eAAoB,aAAkB;AAClD,0BAAc,KAAK,CAAC,KAAK;AAAA;AAAA,UAG3B,SAAS,CAAC,eAAoB;AAC5B,0BAAc,KAAK;AAAA;AAAA;AAGvB;AAAA,WAGG;AACH,mBAAW,KAAK;AAAA,UACd,IAAI;AAAA,UACJ,qBAAqB,MAAM;AAAA,UAC3B,aAAa,CAAC,eAAoB;AAChC,0BAAc,KAAK;AAAA;AAAA,UAGrB,SAAS,CAAC,eAAoB,KAAU;AACtC,0BAAc,KAAK;AAAA;AAAA;AAGvB;AAAA;AAKA,YAAI,OAAO,gBAAgB;AACzB,qBAAW,KAAK;AAAA;AAAA;AAAA;AAAA;AAOxB,QAAM,cAAc,CAAC,eAAoB,MAAa;AAhhBxD;AAihBI,QAAI,QAAQ;AACV,aAAO;AAAA;AAGT,UAAM,YAAY,iBAAW,WAAX,YAAqB,WAAW,WAAW,SAAS;AACtE,UAAM,gBAAgB,iBAAW,QAAQ,OAAnB,YAAyB;AAC/C,UAAM,cAAc,cAAc;AAClC,cAAW,YAAY,eAAe,aAAa,MAAM,OAAO;AAChE,WAAO;AAAA;AAIT,QAAM,UAAU,CACd,eACA,MACA,QACA;AAjiBJ;AAmiBI,UAAM,YAAY,iBAAW,WAAX,YAAqB,WAAW,WAAW,SAAS;AACtE,cAAW,QACT,eACA,MAAM,OACN,QAAQ,QAAQ,OAChB;AAAA;AAIJ,QAAM,sBAAsB,WAAW,GAAI;AAC3C,SAAO,eAAe,SAAS,qBAAqB,IAAI,aAAa;AAAA;;;;"}
+{"version":3,"file":"groupBy.js","sources":["../../src/groupBy.ts"],"sourcesContent":["import { group } from 'd3-array';\nimport { Prettify, Merge } from './type-utils';\nimport { assignGroupKeys } from './helpers/assignGroupKeys';\nimport { groupMap } from './helpers/groupMap';\nimport { groupTraversal } from './helpers/groupTraversal';\nimport { identity } from './helpers/identity';\nimport { isObject } from './helpers/isObject';\nimport { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\nimport { Grouped, GroupKey, TidyGroupExportFn, Key, TidyFn } from './types';\n\n/** [key, values] where values could be more nested entries */\ntype EntriesOutput = [any, any][];\ntype EntriesObjectOutput = { key: Key; values: any }[];\n\n/** nested objects: { [key]: values } */\ntype ObjectOutput = Record<Key, any>;\n\n/** nested keys: e.g. [key, key, key, [key, key, [key]]] */\ntype KeysOutput = any[];\n\n/** nested values: e.g. [[value1_1, value1_2], [value2_1, value2_2]] */\ntype ValuesOutput = any[];\n\nexport type LevelSpec = {\n  id?: string;\n  createEmptySubgroup: () => any;\n  addSubgroup: (\n    parentGrouped: any,\n    newSubgroup: any,\n    key: any,\n    level: number\n  ) => void;\n  addLeaf: (parentGrouped: any, key: any, values: any[], level: number) => void;\n};\n\n/**\n * Options to affect export type\n */\ninterface GroupByOptions {\n  /** whether to merge group keys back into the objects */\n  readonly addGroupKeys?: boolean;\n\n  // -- export related -- //\n  /** export method */\n  readonly export?:\n    | 'grouped'\n    | 'entries'\n    | 'entries-object'\n    | 'object'\n    | 'map'\n    | 'keys'\n    | 'values'\n    | 'levels'\n    | 'ungrouped';\n  /** if all nested levels should be brought to a single top level */\n  readonly flat?: boolean;\n  /** when flat is true, how to flatten nested keys */\n  readonly compositeKey?: (keys: any[]) => string;\n  /** whether the leaf sets consist of just one item (typical after summarize).\n   *  if true, uses the first element in the leaf set instead of an array\n   */\n  readonly single?: boolean;\n  /** operation called on each leaf during export to map it to a different value\n   *  (default: identity)\n   */\n  readonly mapLeaf?: (value: any) => any;\n  /** operation called on each leaf set to map the array of values to a different value.\n   * Similar to `rollup` from d3-collection nest or d3-array\n   * (default: identity)\n   */\n  readonly mapLeaves?: (values: any[]) => any;\n  /** [entries only] operation called on entries to map from [key, values] to\n   * whatever the output of this is (e.g. `{ key, values }`)\n   * (default: identity)\n   */\n  readonly mapEntry?: (entry: [any, any], level: number) => any;\n\n  /** [required for levels] specifies the export operation for each level of the grouping */\n  readonly levels?: (\n    | 'entries'\n    | 'entries-object'\n    | 'object'\n    | 'map'\n    | 'keys'\n    | 'values'\n    | LevelSpec\n  )[];\n}\n\n// aliases to make overloads shorter\ntype GK<T extends object> = SingleOrArray<keyof T | ((d: T) => any)>;\ntype F<I extends object, O extends object> = TidyFn<I, O>;\n\n// merge back in group keys to output types\ntype MergeGroupKeys<\n  T extends object,\n  Out extends object,\n  Keys extends GK<T>\n> = Keys extends keyof T\n  ? Merge<Pick<T, Keys>, Out>\n  : Keys extends (keyof T)[]\n  ? Merge<Pick<T, Keys[number]>, Out>\n  : Out;\n\n// do not merge in group keys if explicitly said not to\ntype WithGroupKeys<\n  T extends object,\n  Out extends object,\n  Keys extends GK<T>,\n  Opts extends GroupByOptions\n> = NonNullable<Opts>['addGroupKeys'] extends false\n  ? Out\n  : MergeGroupKeys<T, Out, Keys>;\n\n/**\n * output varies based on export options\n */\ntype GroupByOutput<\n  T extends object,\n  O extends object,\n  Keys extends GK<T>,\n  Opts extends GroupByOptions\n> = Prettify<\n  NonNullable<Opts>['export'] extends 'grouped'\n    ? Grouped<WithGroupKeys<T, O, Keys, Opts>>\n    : NonNullable<Opts>['export'] extends 'entries'\n    ? EntriesOutput\n    : NonNullable<Opts>['export'] extends 'entries-object'\n    ? EntriesObjectOutput\n    : NonNullable<Opts>['export'] extends 'object'\n    ? ObjectOutput\n    : NonNullable<Opts>['export'] extends 'map'\n    ? Map<any, any>\n    : NonNullable<Opts>['export'] extends 'keys'\n    ? KeysOutput\n    : NonNullable<Opts>['export'] extends 'values'\n    ? ValuesOutput\n    : NonNullable<Opts>['export'] extends 'levels'\n    ? any\n    : WithGroupKeys<T, O, Keys, Opts>[]\n>;\n\ntype GroupByFn<\n  T extends object,\n  O extends object,\n  Keys extends GK<T>,\n  Opts extends GroupByOptions\n> = Opts['export'] extends\n  | 'grouped'\n  | 'entries'\n  | 'entries-object'\n  | 'object'\n  | 'map'\n  | 'keys'\n  | 'values'\n  | 'levels'\n  ? TidyGroupExportFn<T, GroupByOutput<T, O, Keys, Opts>>\n  : TidyFn<T, Prettify<WithGroupKeys<T, O, Keys, Opts>>>;\n\n/**\n * Nests the data by the specified groupings\n */\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: F<T, T1>, options: Opts): GroupByFn<T, T1, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, const Keys extends GK<T>>(groupKeys: Keys, fns: F<T, T1>): GroupByFn<T, T1, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, T6 extends object, T7 extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>, F<T5, T6>, F<T6, T7>], options: Opts): GroupByFn<T, T7, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, T6 extends object, T7 extends object, const Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>, F<T5, T6>, F<T6, T7>]): GroupByFn<T, T7, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, T6 extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>, F<T5, T6>], options: Opts): GroupByFn<T, T6, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, T6 extends object, const Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>, F<T5, T6>]): GroupByFn<T, T6, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>], options: Opts): GroupByFn<T, T5, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, T5 extends object, const Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>, F<T4, T5>]): GroupByFn<T, T5, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>], options: Opts): GroupByFn<T, T4, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, T4 extends object, const Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>, F<T3, T4>]): GroupByFn<T, T4, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>], options: Opts): GroupByFn<T, T3, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, T3 extends object, const Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>, F<T2, T3>]): GroupByFn<T, T3, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>], options: Opts): GroupByFn<T, T2, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, T2 extends object, const Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>, F<T1, T2>]): GroupByFn<T, T2, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [F<T, T1>], options: Opts): GroupByFn<T, T1, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, T1 extends object, const Keys extends GK<T>>(groupKeys: Keys, fns: [F<T, T1>]): GroupByFn<T, T1, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, fns: [], options: Opts): GroupByFn<T, T, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, const Keys extends GK<T>>(groupKeys: Keys, fns: []): GroupByFn<T, T, Keys, GroupByOptions>;\n// prettier-ignore\nexport function groupBy<T extends object, const Keys extends GK<T>, Opts extends GroupByOptions>(groupKeys: Keys, options: Opts): GroupByFn<T, T, Keys, Opts>;\n// prettier-ignore\nexport function groupBy<T extends object, const Keys extends GK<T>>(groupKeys: Keys): GroupByFn<T, T, Keys, GroupByOptions>;\nexport function groupBy<\n  T extends object,\n  O extends object,\n  const Keys extends GK<T>,\n  Opts extends GroupByOptions\n>(\n  groupKeys: Keys,\n  fns?: TidyFn<any, any>[] | TidyFn<any, any>,\n  options?: Opts\n): GroupByFn<T, O, Keys, Opts> {\n  if (typeof fns === 'function') {\n    fns = [fns];\n  } else if (arguments.length === 2 && fns != null && !Array.isArray(fns)) {\n    options = fns as any;\n  }\n\n  const _groupBy: GroupByFn<T, O, Keys, Opts> = ((items: T[]) => {\n    // form into a nested map\n    const grouped = makeGrouped(items, groupKeys);\n\n    // run group functions\n    const results = runFlow(\n      grouped,\n      fns as TidyFn<any, any>[],\n      options?.addGroupKeys\n    );\n\n    // export\n    if (options?.export) {\n      switch (options.export) {\n        case 'grouped':\n          return results;\n        case 'levels':\n          return exportLevels(results, options);\n        case 'entries-obj' as any:\n        case 'entriesObject' as any:\n          return exportLevels(results, {\n            ...options,\n            export: 'levels',\n            levels: ['entries-object'],\n          });\n        default:\n          return exportLevels(results, {\n            ...options,\n            export: 'levels',\n            levels: [options.export],\n          });\n      }\n    }\n\n    // export === 'ungrouped' or nully:\n    const ungrouped = ungroup(results, options?.addGroupKeys);\n    return ungrouped as any;\n  }) as GroupByFn<T, O, Keys, Opts>;\n  // (_groupBy as any).tidyType = 'group-export';\n\n  return _groupBy;\n}\n// convenient export option configs\ngroupBy.grouped = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'grouped' } as const);\ngroupBy.entries = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'entries' } as const);\ngroupBy.entriesObject = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'entries-object' } as const);\ngroupBy.object = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'object' } as const);\ngroupBy.map = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'map' } as const);\ngroupBy.keys = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'keys' } as const);\ngroupBy.values = (options?: Omit<GroupByOptions, 'export' | 'levels'>) =>\n  ({ ...options, export: 'values' } as const);\ngroupBy.levels = (options?: Omit<GroupByOptions, 'export'>) =>\n  ({ ...options, export: 'levels' } as const);\n\nfunction runFlow<T extends object>(\n  items: Grouped<T>,\n  fns?: TidyFn<any, any>[],\n  addGroupKeys?: boolean\n) {\n  let result: any = items;\n  if (!fns?.length) return result;\n\n  for (const fn of fns) {\n    if (!fn) continue;\n\n    // otherwise break it up and call it on each leaf set\n    result = groupMap(result, (items, keys) => {\n      // ensure we kept the group keys in the object\n      // (necessary for e.g. summarize which may remove them)\n      // snapshot keys since groupTraversal reuses the array\n      const keysSnapshot = keys.slice();\n      const context = { groupKeys: keysSnapshot };\n      let leafItemsMapped = fn(items, context);\n      if (addGroupKeys !== false) {\n        // pre-filter keys once per group instead of per item\n        const filteredKeys = keysSnapshot.filter(\n          (key: any) => typeof key[0] !== 'function' && key[0] != null\n        );\n        leafItemsMapped = leafItemsMapped.map((item: T) =>\n          assignGroupKeys(item, keysSnapshot, filteredKeys)\n        );\n      }\n\n      return leafItemsMapped;\n    });\n  }\n\n  return result;\n}\n\nfunction makeGrouped<T extends object>(\n  items: T[],\n  groupKeys: SingleOrArray<keyof T | ((d: T) => any)>\n): Grouped<T> {\n  // convert string based keys to functions and keep the key name with the key value in a tuple\n  const groupKeyFns = singleOrArray(groupKeys).map((key) => {\n    const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n    // use a cache so we don't generate new keys for the same tuple\n    const keyCache = new Map();\n    return (d: T) => {\n      const keyValue = keyFn(d);\n\n      const keyValueOf = isObject(keyValue) ? keyValue.valueOf() : keyValue;\n      // used cache tuple if available\n      if (keyCache.has(keyValueOf)) {\n        return keyCache.get(keyValueOf) as GroupKey;\n      }\n\n      const keyWithName = [key, keyValue];\n      keyCache.set(keyValueOf, keyWithName);\n\n      return keyWithName;\n    };\n  });\n\n  const grouped = group(items, ...groupKeyFns);\n  return grouped;\n}\n\n/**\n * flattens a grouped collection back to a simple array\n */\nfunction ungroup<T extends object>(\n  grouped: Grouped<T>,\n  addGroupKeys: boolean | undefined\n): T[] {\n  // flatten the groups\n  const items: T[] = [];\n\n  groupTraversal(grouped, items, [], identity, (root, keys, values) => {\n    // ensure we have group keys on items (in case runFlow didn't run)\n    let valuesToAdd = values;\n    if (addGroupKeys !== false) {\n      // pre-filter keys once per group instead of per item\n      const filteredKeys = keys.filter(\n        (key: any) => typeof key[0] !== 'function' && key[0] != null\n      );\n      valuesToAdd = values.map((d) => assignGroupKeys(d, keys, filteredKeys));\n    }\n    root.push(...valuesToAdd);\n  });\n\n  return items;\n}\n\n// -----------------------------------------------------------------------\n// --- EXPORTS -----------------------------------------------------------\n// -----------------------------------------------------------------------\nconst defaultCompositeKey = (keys: any[]) => keys.join('/');\n\nfunction processFromGroupsOptions<T extends object>(options: GroupByOptions) {\n  const {\n    flat,\n    single,\n    mapLeaf = identity,\n    mapLeaves = identity,\n    addGroupKeys,\n  } = options;\n  let compositeKey: (keys: any[]) => string;\n  if (options.flat) {\n    compositeKey = options.compositeKey! ?? defaultCompositeKey;\n  }\n\n  const groupFn = (values: T[], keys: any[]) => {\n    return single\n      ? mapLeaf(\n          addGroupKeys === false ? values[0] : assignGroupKeys(values[0], keys)\n        )\n      : mapLeaves(\n          values.map((d) =>\n            mapLeaf(addGroupKeys === false ? d : assignGroupKeys(d, keys))\n          )\n        );\n  };\n\n  const keyFn = flat\n    ? (keys: GroupKey[]) => compositeKey(keys.map((d) => d[1]))\n    : (keys: GroupKey[]) => keys[keys.length - 1][1];\n\n  return { groupFn, keyFn };\n}\n\n// -- Levels -------------------------------------------------------------\nfunction exportLevels<T extends object>(\n  grouped: Grouped<T>,\n  options: GroupByOptions\n): any {\n  type NestedEntries<T> = Array<[any, NestedEntries<T> | T[]]>;\n  type NestedObject<T> = { [key: string]: NestedObject<T> | T[] };\n\n  const { groupFn, keyFn } = processFromGroupsOptions(options);\n  let { mapEntry = identity } = options;\n  const { levels = ['entries'] } = options;\n\n  const levelSpecs: LevelSpec[] = [];\n  for (const levelOption of levels) {\n    switch (levelOption) {\n      // entries / entries-object -----------------------------------------\n      case 'entries':\n      case 'entries-object':\n      case 'entries-obj' as any:\n      case 'entriesObject' as any: {\n        const levelMapEntry =\n          (levelOption === 'entries-object' ||\n            levelOption === ('entries-obj' as any) ||\n            levelOption === ('entriesObject' as any)) &&\n          options.mapEntry == null\n            ? ([key, values]: any) => ({ key, values })\n            : mapEntry;\n\n        levelSpecs.push({\n          id: 'entries',\n          createEmptySubgroup: () => [],\n          addSubgroup: (\n            parentGrouped: NestedEntries<T>,\n            newSubgroup: any,\n            key: any,\n            level: number\n          ) => {\n            parentGrouped.push(levelMapEntry([key, newSubgroup], level));\n          },\n\n          addLeaf: (\n            parentGrouped: NestedEntries<T>,\n            key: any,\n            values: T[],\n            level: number\n          ) => {\n            parentGrouped.push(levelMapEntry([key, values], level));\n          },\n        });\n        break;\n      }\n      // map -------------------------------------------------------------\n      case 'map':\n        levelSpecs.push({\n          id: 'map',\n          createEmptySubgroup: () => new Map(),\n          addSubgroup: (\n            parentGrouped: Map<any, any>,\n            newSubgroup: any,\n            key: any\n          ) => {\n            parentGrouped.set(key, newSubgroup);\n          },\n\n          addLeaf: (parentGrouped: Map<any, any>, key: any, values: T[]) => {\n            parentGrouped.set(key, values);\n          },\n        });\n        break;\n\n      // object ----------------------------------------------------------\n      case 'object':\n        levelSpecs.push({\n          id: 'object',\n          createEmptySubgroup: () => ({}),\n          addSubgroup: (\n            parentGrouped: NestedObject<T>,\n            newSubgroup: any,\n            key: any\n          ) => {\n            parentGrouped[key] = newSubgroup;\n          },\n\n          addLeaf: (parentGrouped: NestedObject<T>, key: any, values: T[]) => {\n            parentGrouped[key] = values;\n          },\n        });\n        break;\n\n      // keys ------------------------------------------------------------\n      case 'keys':\n        levelSpecs.push({\n          id: 'keys',\n          createEmptySubgroup: () => [],\n          addSubgroup: (parentGrouped: any, newSubgroup: any, key: any) => {\n            parentGrouped.push([key, newSubgroup]);\n          },\n\n          addLeaf: (parentGrouped: any, key: any) => {\n            parentGrouped.push(key);\n          },\n        });\n        break;\n\n      // values ----------------------------------------------------------\n      case 'values':\n        levelSpecs.push({\n          id: 'values',\n          createEmptySubgroup: () => [],\n          addSubgroup: (parentGrouped: any, newSubgroup: any) => {\n            parentGrouped.push(newSubgroup);\n          },\n\n          addLeaf: (parentGrouped: any, key: any, values: T[]) => {\n            parentGrouped.push(values);\n          },\n        });\n        break;\n\n      // custom ----------------------------------------------------------\n      default: {\n        // LevelSpec obj already\n        if (typeof levelOption === 'object') {\n          levelSpecs.push(levelOption);\n        }\n      }\n    }\n  }\n\n  // add subgroup\n  const addSubgroup = (parentGrouped: any, keys: any[], level: number): any => {\n    if (options.flat) {\n      return parentGrouped;\n    }\n\n    const levelSpec = levelSpecs[level] ?? levelSpecs[levelSpecs.length - 1];\n    const nextLevelSpec = levelSpecs[level + 1] ?? levelSpec;\n    const newSubgroup = nextLevelSpec.createEmptySubgroup();\n    levelSpec!.addSubgroup(parentGrouped, newSubgroup, keyFn(keys), level);\n    return newSubgroup;\n  };\n\n  // add leaves\n  const addLeaf = (\n    parentGrouped: any,\n    keys: any[],\n    values: T[],\n    level: number\n  ) => {\n    const levelSpec = levelSpecs[level] ?? levelSpecs[levelSpecs.length - 1];\n    levelSpec!.addLeaf(\n      parentGrouped,\n      keyFn(keys),\n      groupFn(values, keys),\n      level\n    );\n  };\n\n  const initialOutputObject = levelSpecs[0]!.createEmptySubgroup();\n  return groupTraversal(grouped, initialOutputObject, [], addSubgroup, addLeaf);\n}\n"],"names":["items"],"mappings":"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"}

package/dist/es/helpers/assignGroupKeys.js

@@ -1,7 +1,7 @@
-function assignGroupKeys(d, keys) {
-  if (d == null || typeof d !== "object" || Array.isArray(d))
-    return d;
-  const keysObj = Object.fromEntries(keys.filter((key) => typeof key[0] !== "function" && key[0] != null));
+function assignGroupKeys(d, keys, filteredKeys) {
+  if (d == null || typeof d !== "object" || Array.isArray(d)) return d;
+  const validKeys = filteredKeys != null ? filteredKeys : keys.filter((key) => typeof key[0] !== "function" && key[0] != null);
+  const keysObj = Object.fromEntries(validKeys);
   return Object.assign(keysObj, d);
 }
 

package/dist/es/helpers/assignGroupKeys.js.map

@@ -1 +1 @@
-{"version":3,"file":"assignGroupKeys.js","sources":["../../../src/helpers/assignGroupKeys.ts"],"sourcesContent":["import { GroupKey } from '../types';\n\n/**\n * Given an object and a set of group keys [[keyName, keyValue], ...]\n * set the keys as properties within the object: { [keyName]: keyValue, ... }\n * (creates a new object with these properties added)\n */\nexport function assignGroupKeys<T extends object>(d: T, keys: GroupKey[]) {\n  // abort if atypical input\n  if (d == null || typeof d !== 'object' || Array.isArray(d)) return d;\n\n  // transform to { groupKey1: value, ... } excluding function group keys\n  const keysObj = Object.fromEntries(\n    keys.filter((key) => typeof key[0] !== 'function' && key[0] != null)\n  );\n\n  return Object.assign(keysObj, d);\n}\n"],"names":[],"mappings":"yBAOkD,GAAM;AAEtD,MAAI,KAAK,QAAQ,OAAO,MAAM,YAAY,MAAM,QAAQ;AAAI,WAAO;AAGnE,QAAM,UAAU,OAAO,YACrB,KAAK,OAAO,CAAC,QAAQ,OAAO,IAAI,OAAO,cAAc,IAAI,MAAM;AAGjE,SAAO,OAAO,OAAO,SAAS;AAAA;;;;"}
+{"version":3,"file":"assignGroupKeys.js","sources":["../../../src/helpers/assignGroupKeys.ts"],"sourcesContent":["import { GroupKey } from '../types';\n\n/**\n * Given an object and a set of group keys [[keyName, keyValue], ...]\n * set the keys as properties within the object: { [keyName]: keyValue, ... }\n * (creates a new object with these properties added)\n */\nexport function assignGroupKeys<T extends object>(\n  d: T,\n  keys: GroupKey[],\n  filteredKeys?: GroupKey[]\n) {\n  // abort if atypical input\n  if (d == null || typeof d !== 'object' || Array.isArray(d)) return d;\n\n  // use pre-filtered keys if provided, otherwise filter here\n  const validKeys =\n    filteredKeys ??\n    keys.filter((key) => typeof key[0] !== 'function' && key[0] != null);\n\n  // transform to { groupKey1: value, ... } excluding function group keys\n  const keysObj = Object.fromEntries(validKeys);\n\n  return Object.assign(keysObj, d);\n}\n"],"names":[],"mappings":"AAOgB,SAAA,eAAA,CACd,CACA,EAAA,IAAA,EACA,YACA,EAAA;AAEA,EAAI,IAAA,CAAA,IAAK,QAAQ,OAAO,CAAA,KAAM,YAAY,KAAM,CAAA,OAAA,CAAQ,CAAC,CAAA,EAAU,OAAA,CAAA,CAAA;AAGnE,EAAA,MAAM,SACJ,GAAA,YAAA,IAAA,IAAA,GAAA,YAAA,GACA,IAAK,CAAA,MAAA,CAAO,CAAC,GAAQ,KAAA,OAAO,GAAI,CAAA,CAAC,CAAM,KAAA,UAAA,IAAc,GAAI,CAAA,CAAC,KAAK,IAAI,CAAA,CAAA;AAGrE,EAAM,MAAA,OAAA,GAAU,MAAO,CAAA,WAAA,CAAY,SAAS,CAAA,CAAA;AAE5C,EAAO,OAAA,MAAA,CAAO,MAAO,CAAA,OAAA,EAAS,CAAC,CAAA,CAAA;AACjC;;;;"}

package/dist/es/helpers/groupMap.js

@@ -2,14 +2,14 @@ import { groupTraversal } from './groupTraversal.js';
 
 function groupMap(grouped, groupFn, keyFn = (keys) => keys[keys.length - 1]) {
   function addSubgroup(parentGrouped, keys) {
-    const subgroup = new Map();
+    const subgroup = /* @__PURE__ */ new Map();
     parentGrouped.set(keyFn(keys), subgroup);
     return subgroup;
   }
   function addLeaves(parentGrouped, keys, values) {
     parentGrouped.set(keyFn(keys), groupFn(values, keys));
   }
-  const outputGrouped = new Map();
+  const outputGrouped = /* @__PURE__ */ new Map();
   groupTraversal(grouped, outputGrouped, [], addSubgroup, addLeaves);
   return outputGrouped;
 }

package/dist/es/helpers/groupMap.js.map

@@ -1 +1 @@
-{"version":3,"file":"groupMap.js","sources":["../../../src/helpers/groupMap.ts"],"sourcesContent":["import { Grouped } from '../types';\nimport { groupTraversal } from './groupTraversal';\n\nexport function groupMap<T extends object, OutputT extends object = T>(\n  grouped: Grouped<T>,\n  groupFn: (items: T[], keys: any[]) => OutputT[],\n  keyFn: (keys: any[]) => any = (keys) =>\n    keys[\n      keys.length - 1\n    ] /* optional func to transform key based on all keys in map so far */\n): Grouped<OutputT> {\n  function addSubgroup(parentGrouped: Grouped<OutputT>, keys: any[]) {\n    const subgroup = new Map();\n    parentGrouped.set(keyFn(keys), subgroup);\n    return subgroup;\n  }\n\n  function addLeaves(\n    parentGrouped: Grouped<OutputT>,\n    keys: any[],\n    values: T[]\n  ) {\n    parentGrouped.set(keyFn(keys), groupFn(values, keys));\n  }\n\n  const outputGrouped: Grouped<OutputT> = new Map();\n\n  groupTraversal(grouped, outputGrouped, [], addSubgroup, addLeaves);\n\n  return outputGrouped;\n}\n"],"names":[],"mappings":";;kBAIE,SACA,SACA,QAA8B,CAAC,SAC7B,KACE,KAAK,SAAS;AAGlB,uBAAqB,eAAiC;AACpD,UAAM,WAAW,IAAI;AACrB,kBAAc,IAAI,MAAM,OAAO;AAC/B,WAAO;AAAA;AAGT,qBACE,eACA,MACA;AAEA,kBAAc,IAAI,MAAM,OAAO,QAAQ,QAAQ;AAAA;AAGjD,QAAM,gBAAkC,IAAI;AAE5C,iBAAe,SAAS,eAAe,IAAI,aAAa;AAExD,SAAO;AAAA;;;;"}
+{"version":3,"file":"groupMap.js","sources":["../../../src/helpers/groupMap.ts"],"sourcesContent":["import { Grouped } from '../types';\nimport { groupTraversal } from './groupTraversal';\n\nexport function groupMap<T extends object, OutputT extends object = T>(\n  grouped: Grouped<T>,\n  groupFn: (items: T[], keys: any[]) => OutputT[],\n  keyFn: (keys: any[]) => any = (keys) =>\n    keys[\n      keys.length - 1\n    ] /* optional func to transform key based on all keys in map so far */\n): Grouped<OutputT> {\n  function addSubgroup(parentGrouped: Grouped<OutputT>, keys: any[]) {\n    const subgroup = new Map();\n    parentGrouped.set(keyFn(keys), subgroup);\n    return subgroup;\n  }\n\n  function addLeaves(\n    parentGrouped: Grouped<OutputT>,\n    keys: any[],\n    values: T[]\n  ) {\n    parentGrouped.set(keyFn(keys), groupFn(values, keys));\n  }\n\n  const outputGrouped: Grouped<OutputT> = new Map();\n\n  groupTraversal(grouped, outputGrouped, [], addSubgroup, addLeaves);\n\n  return outputGrouped;\n}\n"],"names":[],"mappings":";;AAGgB,SAAA,QAAA,CACd,OACA,EAAA,OAAA,EACA,KAA8B,GAAA,CAAC,SAC7B,IACE,CAAA,IAAA,CAAK,MAAS,GAAA,CAChB,CACgB,EAAA;AAClB,EAAS,SAAA,WAAA,CAAY,eAAiC,IAAa,EAAA;AACjE,IAAM,MAAA,QAAA,uBAAe,GAAI,EAAA,CAAA;AACzB,IAAA,aAAA,CAAc,GAAI,CAAA,KAAA,CAAM,IAAI,CAAA,EAAG,QAAQ,CAAA,CAAA;AACvC,IAAO,OAAA,QAAA,CAAA;AAAA,GACT;AAEA,EAAS,SAAA,SAAA,CACP,aACA,EAAA,IAAA,EACA,MACA,EAAA;AACA,IAAA,aAAA,CAAc,IAAI,KAAM,CAAA,IAAI,GAAG,OAAQ,CAAA,MAAA,EAAQ,IAAI,CAAC,CAAA,CAAA;AAAA,GACtD;AAEA,EAAM,MAAA,aAAA,uBAAsC,GAAI,EAAA,CAAA;AAEhD,EAAA,cAAA,CAAe,OAAS,EAAA,aAAA,EAAe,EAAC,EAAG,aAAa,SAAS,CAAA,CAAA;AAEjE,EAAO,OAAA,aAAA,CAAA;AACT;;;;"}

package/dist/es/helpers/groupTraversal.js

@@ -1,12 +1,13 @@
 function groupTraversal(grouped, outputGrouped, keys, addSubgroup, addLeaves, level = 0) {
   for (const [key, value] of grouped.entries()) {
-    const keysHere = [...keys, key];
+    keys.push(key);
     if (value instanceof Map) {
-      const subgroup = addSubgroup(outputGrouped, keysHere, level);
-      groupTraversal(value, subgroup, keysHere, addSubgroup, addLeaves, level + 1);
+      const subgroup = addSubgroup(outputGrouped, keys, level);
+      groupTraversal(value, subgroup, keys, addSubgroup, addLeaves, level + 1);
     } else {
-      addLeaves(outputGrouped, keysHere, value, level);
+      addLeaves(outputGrouped, keys, value, level);
     }
+    keys.pop();
   }
   return outputGrouped;
 }

package/dist/es/helpers/groupTraversal.js.map

@@ -1 +1 @@
-{"version":3,"file":"groupTraversal.js","sources":["../../../src/helpers/groupTraversal.ts"],"sourcesContent":["import { Grouped, Datum } from '../types';\n\n/**\n * Traverse the leaves of the grouped items and and run the\n * groupFn on them. Basically an in-order traversal. Can you\n * believe this is real and not part of a coding interview??\n */\nexport function groupTraversal<\n  T extends object,\n  T2 extends Datum = T,\n  OutputType = Grouped<T2>\n>(\n  grouped: Grouped<T>,\n  outputGrouped: OutputType,\n  keys: any[],\n  addSubgroup: (root: OutputType, keys: any[], level: number) => OutputType,\n  addLeaves: (root: OutputType, keys: any[], items: T[], level: number) => void,\n  level: number = 0\n) {\n  for (const [key, value] of grouped.entries()) {\n    const keysHere = [...keys, key];\n\n    // internal node\n    if (value instanceof Map) {\n      const subgroup = addSubgroup(outputGrouped, keysHere, level);\n\n      // recurse\n      groupTraversal(\n        value,\n        subgroup,\n        keysHere,\n        addSubgroup,\n        addLeaves,\n        level + 1\n      );\n    } else {\n      // leaf\n      addLeaves(outputGrouped, keysHere, value, level);\n    }\n  }\n\n  return outputGrouped;\n}\n"],"names":[],"mappings":"wBAYE,SACA,eACA,MACA,aACA,WACA,QAAgB;AAEhB,aAAW,CAAC,KAAK,UAAU,QAAQ;AACjC,UAAM,WAAW,CAAC,GAAG,MAAM;AAG3B,QAAI,iBAAiB;AACnB,YAAM,WAAW,YAAY,eAAe,UAAU;AAGtD,qBACE,OACA,UACA,UACA,aACA,WACA,QAAQ;AAAA;AAIV,gBAAU,eAAe,UAAU,OAAO;AAAA;AAAA;AAI9C,SAAO;AAAA;;;;"}
+{"version":3,"file":"groupTraversal.js","sources":["../../../src/helpers/groupTraversal.ts"],"sourcesContent":["import { Grouped, Datum } from '../types';\n\n/**\n * Traverse the leaves of the grouped items and and run the\n * groupFn on them. Basically an in-order traversal. Can you\n * believe this is real and not part of a coding interview??\n */\nexport function groupTraversal<\n  T extends object,\n  T2 extends Datum = T,\n  OutputType = Grouped<T2>\n>(\n  grouped: Grouped<T>,\n  outputGrouped: OutputType,\n  keys: any[],\n  addSubgroup: (root: OutputType, keys: any[], level: number) => OutputType,\n  addLeaves: (root: OutputType, keys: any[], items: T[], level: number) => void,\n  level: number = 0\n) {\n  for (const [key, value] of grouped.entries()) {\n    keys.push(key);\n\n    // internal node\n    if (value instanceof Map) {\n      const subgroup = addSubgroup(outputGrouped, keys, level);\n\n      // recurse\n      groupTraversal(value, subgroup, keys, addSubgroup, addLeaves, level + 1);\n    } else {\n      // leaf\n      addLeaves(outputGrouped, keys, value, level);\n    }\n\n    keys.pop();\n  }\n\n  return outputGrouped;\n}\n"],"names":[],"mappings":"AAOO,SAAS,eAKd,OACA,EAAA,aAAA,EACA,MACA,WACA,EAAA,SAAA,EACA,QAAgB,CAChB,EAAA;AACA,EAAA,KAAA,MAAW,CAAC,GAAK,EAAA,KAAK,CAAK,IAAA,OAAA,CAAQ,SAAW,EAAA;AAC5C,IAAA,IAAA,CAAK,KAAK,GAAG,CAAA,CAAA;AAGb,IAAA,IAAI,iBAAiB,GAAK,EAAA;AACxB,MAAA,MAAM,QAAW,GAAA,WAAA,CAAY,aAAe,EAAA,IAAA,EAAM,KAAK,CAAA,CAAA;AAGvD,MAAA,cAAA,CAAe,OAAO,QAAU,EAAA,IAAA,EAAM,WAAa,EAAA,SAAA,EAAW,QAAQ,CAAC,CAAA,CAAA;AAAA,KAClE,MAAA;AAEL,MAAU,SAAA,CAAA,aAAA,EAAe,IAAM,EAAA,KAAA,EAAO,KAAK,CAAA,CAAA;AAAA,KAC7C;AAEA,IAAA,IAAA,CAAK,GAAI,EAAA,CAAA;AAAA,GACX;AAEA,EAAO,OAAA,aAAA,CAAA;AACT;;;;"}

package/dist/es/helpers/identity.js.map

@@ -1 +1 @@
-{"version":3,"file":"identity.js","sources":["../../../src/helpers/identity.ts"],"sourcesContent":["export const identity = <T>(d: T): T => d;\n"],"names":[],"mappings":"MAAa,WAAW,CAAI,MAAY;;;;"}
+{"version":3,"file":"identity.js","sources":["../../../src/helpers/identity.ts"],"sourcesContent":["export const identity = <T>(d: T): T => d;\n"],"names":[],"mappings":"AAAa,MAAA,QAAA,GAAW,CAAI,CAAY,KAAA;;;;"}

package/dist/es/helpers/isObject.js.map

@@ -1 +1 @@
-{"version":3,"file":"isObject.js","sources":["../../../src/helpers/isObject.ts"],"sourcesContent":["/**\n * Returns true if input is an object\n */\nexport function isObject(obj: any) {\n  const type = typeof obj;\n  return obj != null && (type === 'object' || type === 'function');\n}\n"],"names":[],"mappings":"kBAGyB;AACvB,QAAM,OAAO,OAAO;AACpB,SAAO,OAAO,kBAAkB,YAAY,SAAS;AAAA;;;;"}
+{"version":3,"file":"isObject.js","sources":["../../../src/helpers/isObject.ts"],"sourcesContent":["/**\n * Returns true if input is an object\n */\nexport function isObject(obj: any) {\n  const type = typeof obj;\n  return obj != null && (type === 'object' || type === 'function');\n}\n"],"names":[],"mappings":"AAGO,SAAS,SAAS,GAAU,EAAA;AACjC,EAAA,MAAM,OAAO,OAAO,GAAA,CAAA;AACpB,EAAA,OAAO,GAAO,IAAA,IAAA,KAAS,IAAS,KAAA,QAAA,IAAY,IAAS,KAAA,UAAA,CAAA,CAAA;AACvD;;;;"}

package/dist/es/helpers/keysFromItems.js

@@ -1,6 +1,5 @@
 function keysFromItems(items) {
-  if (items.length < 1)
-    return [];
+  if (items.length < 1) return [];
   const keys = Object.keys(items[0]);
   return keys;
 }

package/dist/es/helpers/keysFromItems.js.map

@@ -1 +1 @@
-{"version":3,"file":"keysFromItems.js","sources":["../../../src/helpers/keysFromItems.ts"],"sourcesContent":["/**\n * Helper to get keys from a collection of items.\n * For now, it naively just looks at the first item, but a more complete\n * solution involves looking at all of them (in case keys are omitted).\n * This isn't very efficient though, so perhaps there's a future where\n * the keys are stored sneakily on the object somewhere and that set\n * is updated after each tidy fn is called (if we can do it efficiently)\n *\n * Or perhaps this function can be memoized in a smart way where we don't\n * call it more than necessary?\n */\nexport function keysFromItems<T extends object>(items: T[]): (keyof T)[] {\n  if (items.length < 1) return [];\n  const keys = Object.keys(items[0]) as (keyof T)[];\n  return keys;\n}\n"],"names":[],"mappings":"uBAWgD;AAC9C,MAAI,MAAM,SAAS;AAAG,WAAO;AAC7B,QAAM,OAAO,OAAO,KAAK,MAAM;AAC/B,SAAO;AAAA;;;;"}
+{"version":3,"file":"keysFromItems.js","sources":["../../../src/helpers/keysFromItems.ts"],"sourcesContent":["/**\n * Helper to get keys from a collection of items.\n * For now, it naively just looks at the first item, but a more complete\n * solution involves looking at all of them (in case keys are omitted).\n * This isn't very efficient though, so perhaps there's a future where\n * the keys are stored sneakily on the object somewhere and that set\n * is updated after each tidy fn is called (if we can do it efficiently)\n *\n * Or perhaps this function can be memoized in a smart way where we don't\n * call it more than necessary?\n */\nexport function keysFromItems<T extends object>(items: T[]): (keyof T)[] {\n  if (items.length < 1) return [];\n  const keys = Object.keys(items[0]) as (keyof T)[];\n  return keys;\n}\n"],"names":[],"mappings":"AAWO,SAAS,cAAgC,KAAyB,EAAA;AACvE,EAAA,IAAI,KAAM,CAAA,MAAA,GAAS,CAAG,EAAA,OAAO,EAAC,CAAA;AAC9B,EAAA,MAAM,IAAO,GAAA,MAAA,CAAO,IAAK,CAAA,KAAA,CAAM,CAAC,CAAC,CAAA,CAAA;AACjC,EAAO,OAAA,IAAA,CAAA;AACT;;;;"}

package/dist/es/helpers/singleOrArray.js.map

@@ -1 +1 @@
-{"version":3,"file":"singleOrArray.js","sources":["../../../src/helpers/singleOrArray.ts"],"sourcesContent":["export type SingleOrArray<T> = T | T[];\n\n/**\n * Given an arg that may or may not be an array, make it an array if it isn't one.\n */\nexport function singleOrArray<T>(d: SingleOrArray<T> | null | undefined): T[] {\n  return d == null ? [] : Array.isArray(d) ? d : [d];\n}\n"],"names":[],"mappings":"uBAKiC;AAC/B,SAAO,KAAK,OAAO,KAAK,MAAM,QAAQ,KAAK,IAAI,CAAC;AAAA;;;;"}
+{"version":3,"file":"singleOrArray.js","sources":["../../../src/helpers/singleOrArray.ts"],"sourcesContent":["export type SingleOrArray<T> = T | T[];\n\n/**\n * Given an arg that may or may not be an array, make it an array if it isn't one.\n */\nexport function singleOrArray<T>(d: SingleOrArray<T> | null | undefined): T[] {\n  return d == null ? [] : Array.isArray(d) ? d : [d];\n}\n"],"names":[],"mappings":"AAKO,SAAS,cAAiB,CAA6C,EAAA;AAC5E,EAAO,OAAA,CAAA,IAAK,IAAO,GAAA,EAAK,GAAA,KAAA,CAAM,QAAQ,CAAC,CAAA,GAAI,CAAI,GAAA,CAAC,CAAC,CAAA,CAAA;AACnD;;;;"}

package/dist/es/helpers/summation.js

@@ -1,18 +1,26 @@
-import { Adder, fsum } from 'd3-array';
+import { Adder } from 'd3-array';
 
 function fcumsum(items, accessor) {
   let sum = new Adder(), i = 0;
-  return Float64Array.from(items, (value) => sum.add(+(accessor(value, i++, items) || 0)));
+  return Float64Array.from(
+    items,
+    // we do not actually need to coerce the Adder to number,
+    // as @Fil demonstrated here: https://github.com/pbeshai/tidy/pull/5
+    // so we can just tell typescript to be quiet.
+    (value) => sum.add(+(accessor(value, i++, items) || 0))
+  );
 }
 function mean(items, accessor) {
   let n = 0;
+  const sum = new Adder();
   for (let i = 0; i < items.length; ++i) {
     const value = accessor(items[i], i, items);
     if (+value === value) {
+      sum.add(+value);
       n += 1;
     }
   }
-  return n ? fsum(items, accessor) / n : void 0;
+  return n ? +sum / n : void 0;
 }
 
 export { fcumsum, mean };

package/dist/es/helpers/summation.js.map

@@ -1 +1 @@
-{"version":3,"file":"summation.js","sources":["../../../src/helpers/summation.ts"],"sourcesContent":["import { fsum, Adder } from 'd3-array';\n\n// See also https://observablehq.com/@fil/fcumsum\nexport function fcumsum<T>(\n  items: T[],\n  accessor: (element: T, i: number, array: Iterable<T>) => any\n): Float64Array {\n  let sum = new Adder(),\n    i = 0;\n\n  return Float64Array.from(\n    items,\n    // we do not actually need to coerce the Adder to number,\n    // as @Fil demonstrated here: https://github.com/pbeshai/tidy/pull/5\n    // so we can just tell typescript to be quiet.\n    (value: T): number =>\n      (sum.add(+(accessor(value, i++, items) || 0)) as unknown) as number\n  );\n}\n\nexport function mean<T>(\n  items: T[],\n  accessor: (element: T, i: number, array: Iterable<T>) => any\n): number | undefined {\n  let n = 0;\n  for (let i = 0; i < items.length; ++i) {\n    const value = accessor(items[i], i, items);\n    // count it if we have a valid number\n    if (+value === value) {\n      n += 1;\n    }\n  }\n\n  return n ? fsum(items, accessor) / n : undefined;\n}\n"],"names":[],"mappings":";;iBAIE,OACA;AAEA,MAAI,MAAM,IAAI,SACZ,IAAI;AAEN,SAAO,aAAa,KAClB,OAIA,CAAC,UACE,IAAI,IAAI,WAAW,OAAO,KAAK,UAAU;AAAA;cAK9C,OACA;AAEA,MAAI,IAAI;AACR,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,EAAE;AAClC,UAAM,QAAQ,SAAS,MAAM,IAAI,GAAG;AAEpC,QAAI,CAAC,UAAU;AACb,WAAK;AAAA;AAAA;AAIT,SAAO,IAAI,KAAK,OAAO,YAAY,IAAI;AAAA;;;;"}
+{"version":3,"file":"summation.js","sources":["../../../src/helpers/summation.ts"],"sourcesContent":["import { Adder } from 'd3-array';\n\n// See also https://observablehq.com/@fil/fcumsum\nexport function fcumsum<T>(\n  items: T[],\n  accessor: (element: T, i: number, array: Iterable<T>) => any\n): Float64Array {\n  let sum = new Adder(),\n    i = 0;\n\n  return Float64Array.from(\n    items,\n    // we do not actually need to coerce the Adder to number,\n    // as @Fil demonstrated here: https://github.com/pbeshai/tidy/pull/5\n    // so we can just tell typescript to be quiet.\n    (value: T): number =>\n      sum.add(+(accessor(value, i++, items) || 0)) as unknown as number\n  );\n}\n\nexport function mean<T>(\n  items: T[],\n  accessor: (element: T, i: number, array: Iterable<T>) => any\n): number | undefined {\n  let n = 0;\n  const sum = new Adder();\n  for (let i = 0; i < items.length; ++i) {\n    const value = accessor(items[i], i, items);\n    // count it if we have a valid number\n    if (+value === value) {\n      sum.add(+value);\n      n += 1;\n    }\n  }\n\n  return n ? +sum / n : undefined;\n}\n"],"names":[],"mappings":";;AAGgB,SAAA,OAAA,CACd,OACA,QACc,EAAA;AACd,EAAA,IAAI,GAAM,GAAA,IAAI,KAAM,EAAA,EAClB,CAAI,GAAA,CAAA,CAAA;AAEN,EAAA,OAAO,YAAa,CAAA,IAAA;AAAA,IAClB,KAAA;AAAA;AAAA;AAAA;AAAA,IAIA,CAAC,KACC,KAAA,GAAA,CAAI,GAAI,CAAA,EAAE,SAAS,KAAO,EAAA,CAAA,EAAA,EAAK,KAAK,CAAA,IAAK,CAAE,CAAA,CAAA;AAAA,GAC/C,CAAA;AACF,CAAA;AAEgB,SAAA,IAAA,CACd,OACA,QACoB,EAAA;AACpB,EAAA,IAAI,CAAI,GAAA,CAAA,CAAA;AACR,EAAM,MAAA,GAAA,GAAM,IAAI,KAAM,EAAA,CAAA;AACtB,EAAA,KAAA,IAAS,IAAI,CAAG,EAAA,CAAA,GAAI,KAAM,CAAA,MAAA,EAAQ,EAAE,CAAG,EAAA;AACrC,IAAA,MAAM,QAAQ,QAAS,CAAA,KAAA,CAAM,CAAC,CAAA,EAAG,GAAG,KAAK,CAAA,CAAA;AAEzC,IAAI,IAAA,CAAC,UAAU,KAAO,EAAA;AACpB,MAAI,GAAA,CAAA,GAAA,CAAI,CAAC,KAAK,CAAA,CAAA;AACd,MAAK,CAAA,IAAA,CAAA,CAAA;AAAA,KACP;AAAA,GACF;AAEA,EAAO,OAAA,CAAA,GAAI,CAAC,GAAA,GAAM,CAAI,GAAA,KAAA,CAAA,CAAA;AACxB;;;;"}

package/dist/es/innerJoin.js

@@ -1,6 +1,5 @@
 function autodetectByMap(itemsA, itemsB) {
-  if (itemsA.length === 0 || itemsB.length === 0)
-    return {};
+  if (itemsA.length === 0 || itemsB.length === 0) return {};
   const keysA = Object.keys(itemsA[0]);
   const keysB = Object.keys(itemsB[0]);
   const byMap = {};
@@ -21,28 +20,54 @@ function makeByMap(by) {
   } else if (typeof by === "object") {
     return by;
   }
-  return {[by]: by};
+  return { [by]: by };
 }
-function isMatch(d, j, byMap) {
-  for (const jKey in byMap) {
-    const dKey = byMap[jKey];
-    if (d[dKey] !== j[jKey]) {
-      return false;
+const KEY_DELIMITER = "\0";
+const NULL_SENTINEL = "
N";
+const UNDEF_SENTINEL = "
U";
+function serializeValue(v) {
+  if (v === null) return NULL_SENTINEL;
+  if (v === void 0) return UNDEF_SENTINEL;
+  return String(v);
+}
+function computeKey(row, keys) {
+  if (keys.length === 1) return serializeValue(row[keys[0]]);
+  let key = "";
+  for (let i = 0; i < keys.length; i++) {
+    if (i > 0) key += KEY_DELIMITER;
+    key += serializeValue(row[keys[i]]);
+  }
+  return key;
+}
+function buildJoinIndex(itemsToJoin, joinKeys) {
+  const index = /* @__PURE__ */ new Map();
+  for (const j of itemsToJoin) {
+    const key = computeKey(j, joinKeys);
+    let bucket = index.get(key);
+    if (bucket === void 0) {
+      bucket = [];
+      index.set(key, bucket);
     }
+    bucket.push(j);
   }
-  return true;
+  return index;
 }
 function innerJoin(itemsToJoin, options) {
   const _innerJoin = (items) => {
     const byMap = (options == null ? void 0 : options.by) == null ? autodetectByMap(items, itemsToJoin) : makeByMap(options.by);
+    const joinKeys = Object.keys(byMap);
+    const itemKeys = joinKeys.map((jKey) => byMap[jKey]);
+    const index = buildJoinIndex(itemsToJoin, joinKeys);
     const joined = items.flatMap((d) => {
-      const matches = itemsToJoin.filter((j) => isMatch(d, j, byMap));
-      return matches.map((j) => ({...d, ...j}));
+      const key = computeKey(d, itemKeys);
+      const matches = index.get(key);
+      if (matches === void 0) return [];
+      return matches.map((j) => ({ ...d, ...j }));
     });
     return joined;
   };
   return _innerJoin;
 }
 
-export { autodetectByMap, innerJoin, isMatch, makeByMap };
+export { autodetectByMap, buildJoinIndex, computeKey, innerJoin, makeByMap };
 //# sourceMappingURL=innerJoin.js.map

package/dist/es/innerJoin.js.map

@@ -1 +1 @@
-{"version":3,"file":"innerJoin.js","sources":["../../src/innerJoin.ts"],"sourcesContent":["import { O } from 'ts-toolbelt';\nimport { TidyFn, Datum } from './types';\n\ntype ByMap<JoinT extends Datum, T extends Datum> = Partial<\n  Record<keyof JoinT, keyof T>\n>;\n\nexport type JoinOptions<JoinT extends Datum, T extends Datum> = {\n  by?: keyof T | (keyof T)[] | ByMap<JoinT, T>;\n};\n\n/**\n * Compares first two sets of items to find overlapping keys\n * Naively looks at first element... could cause problems if first\n * elements don't have all keys, but scanning each entire set seems\n * unnecessarily slow for most cases.\n */\nexport function autodetectByMap<A, B>(itemsA: A[], itemsB: B[]) {\n  if (itemsA.length === 0 || itemsB.length === 0) return {};\n\n  // intersection of shared keys\n  const keysA = Object.keys(itemsA[0]);\n  const keysB = Object.keys(itemsB[0]);\n\n  // naive linear intersection, but we don't expect objects to have tons of keys\n  // so it's probably fine.\n  const byMap: any = {};\n  for (const key of keysA) {\n    if (keysB.includes(key)) {\n      byMap[key] = key;\n    }\n  }\n\n  return byMap;\n}\n\n// convert by option in to a map from JoinT to T key\nexport function makeByMap<T extends Datum, JoinT extends Datum>(\n  by: JoinOptions<JoinT, T>['by']\n): ByMap<JoinT, T> {\n  // convert by option in to a map from JoinT to T key\n  if (Array.isArray(by)) {\n    const byMap: ByMap<JoinT, T> = {};\n    for (const key of by) {\n      byMap[key as any] = key;\n    }\n    return byMap;\n  } else if (typeof by === 'object') {\n    return by;\n  }\n  return { [by as keyof JoinT]: by as keyof T } as ByMap<JoinT, T>;\n}\n\nexport function isMatch<T extends object, JoinT extends object>(\n  d: T,\n  j: JoinT,\n  byMap: ByMap<JoinT, T>\n) {\n  for (const jKey in byMap) {\n    const dKey = byMap[jKey];\n    if ((d[dKey as keyof T] as any) !== j[jKey as keyof JoinT]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Performs an inner join on two collections\n * @param itemsToJoin The rows/items to be appended to end of collection\n */\nexport function innerJoin<T extends object, JoinT extends object>(\n  itemsToJoin: JoinT[],\n  options?: JoinOptions<JoinT, T> | null | undefined\n): TidyFn<T, O.Merge<T, JoinT>> {\n  const _innerJoin: TidyFn<T, O.Merge<T, JoinT>> = (\n    items: T[]\n  ): O.Merge<T, JoinT>[] => {\n    // convert by option in to a map from JoinT to T key\n    const byMap =\n      options?.by == null\n        ? autodetectByMap(items, itemsToJoin)\n        : makeByMap(options.by);\n\n    const joined = items.flatMap((d: T) => {\n      const matches = itemsToJoin.filter((j: JoinT) => isMatch(d, j, byMap));\n      return matches.map((j: JoinT) => ({ ...d, ...j }));\n    });\n\n    return joined as O.Merge<T, JoinT>[];\n  };\n  return _innerJoin;\n}\n"],"names":[],"mappings":"yBAiBsC,QAAa;AACjD,MAAI,OAAO,WAAW,KAAK,OAAO,WAAW;AAAG,WAAO;AAGvD,QAAM,QAAQ,OAAO,KAAK,OAAO;AACjC,QAAM,QAAQ,OAAO,KAAK,OAAO;AAIjC,QAAM,QAAa;AACnB,aAAW,OAAO;AAChB,QAAI,MAAM,SAAS;AACjB,YAAM,OAAO;AAAA;AAAA;AAIjB,SAAO;AAAA;mBAKP;AAGA,MAAI,MAAM,QAAQ;AAChB,UAAM,QAAyB;AAC/B,eAAW,OAAO;AAChB,YAAM,OAAc;AAAA;AAEtB,WAAO;AAAA,aACE,OAAO,OAAO;AACvB,WAAO;AAAA;AAET,SAAO,EAAG,KAAoB;AAAA;iBAI9B,GACA,GACA;AAEA,aAAW,QAAQ;AACjB,UAAM,OAAO,MAAM;AACnB,QAAK,EAAE,UAA6B,EAAE;AACpC,aAAO;AAAA;AAAA;AAGX,SAAO;AAAA;mBAQP,aACA;AAEA,QAAM,aAA2C,CAC/C;AAGA,UAAM,QACJ,oCAAS,OAAM,OACX,gBAAgB,OAAO,eACvB,UAAU,QAAQ;AAExB,UAAM,SAAS,MAAM,QAAQ,CAAC;AAC5B,YAAM,UAAU,YAAY,OAAO,CAAC,MAAa,QAAQ,GAAG,GAAG;AAC/D,aAAO,QAAQ,IAAI,CAAC,WAAmB,MAAM;AAAA;AAG/C,WAAO;AAAA;AAET,SAAO;AAAA;;;;"}
+{"version":3,"file":"innerJoin.js","sources":["../../src/innerJoin.ts"],"sourcesContent":["import { TidyFn, Datum } from './types';\nimport { Merge } from './type-utils';\n\ntype ByMap<JoinT extends Datum, T extends Datum> = Partial<\n  Record<keyof JoinT, keyof T>\n>;\n\nexport type JoinOptions<JoinT extends Datum, T extends Datum> = {\n  by?: keyof T | (keyof T)[] | ByMap<JoinT, T>;\n};\n\n/**\n * Compares first two sets of items to find overlapping keys\n * Naively looks at first element... could cause problems if first\n * elements don't have all keys, but scanning each entire set seems\n * unnecessarily slow for most cases.\n */\nexport function autodetectByMap<A extends object, B extends object>(\n  itemsA: A[],\n  itemsB: B[]\n) {\n  if (itemsA.length === 0 || itemsB.length === 0) return {};\n\n  // intersection of shared keys\n  const keysA = Object.keys(itemsA[0]);\n  const keysB = Object.keys(itemsB[0]);\n\n  // naive linear intersection, but we don't expect objects to have tons of keys\n  // so it's probably fine.\n  const byMap: any = {};\n  for (const key of keysA) {\n    if (keysB.includes(key)) {\n      byMap[key] = key;\n    }\n  }\n\n  return byMap;\n}\n\n// convert by option in to a map from JoinT to T key\nexport function makeByMap<T extends Datum, JoinT extends Datum>(\n  by: JoinOptions<JoinT, T>['by']\n): ByMap<JoinT, T> {\n  // convert by option in to a map from JoinT to T key\n  if (Array.isArray(by)) {\n    const byMap: ByMap<JoinT, T> = {};\n    for (const key of by) {\n      byMap[key as any] = key;\n    }\n    return byMap;\n  } else if (typeof by === 'object') {\n    return by;\n  }\n  return { [by as keyof JoinT]: by as keyof T } as ByMap<JoinT, T>;\n}\n\nexport function isMatch<T extends object, JoinT extends object>(\n  d: T,\n  j: JoinT,\n  byMap: ByMap<JoinT, T>\n) {\n  for (const jKey in byMap) {\n    const dKey = byMap[jKey];\n    if ((d[dKey as keyof T] as any) !== j[jKey as keyof JoinT]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nconst KEY_DELIMITER = '\\x00';\nconst NULL_SENTINEL = '\\x01N';\nconst UNDEF_SENTINEL = '\\x01U';\n\nfunction serializeValue(v: any): string {\n  if (v === null) return NULL_SENTINEL;\n  if (v === undefined) return UNDEF_SENTINEL;\n  return String(v);\n}\n\nexport function computeKey(row: any, keys: string[]): string {\n  if (keys.length === 1) return serializeValue(row[keys[0]]);\n  let key = '';\n  for (let i = 0; i < keys.length; i++) {\n    if (i > 0) key += KEY_DELIMITER;\n    key += serializeValue(row[keys[i]]);\n  }\n  return key;\n}\n\nexport function buildJoinIndex<JoinT extends object>(\n  itemsToJoin: JoinT[],\n  joinKeys: string[]\n): Map<string, JoinT[]> {\n  const index = new Map<string, JoinT[]>();\n  for (const j of itemsToJoin) {\n    const key = computeKey(j, joinKeys);\n    let bucket = index.get(key);\n    if (bucket === undefined) {\n      bucket = [];\n      index.set(key, bucket);\n    }\n    bucket.push(j);\n  }\n  return index;\n}\n\n/**\n * Performs an inner join on two collections\n * @param itemsToJoin The rows/items to be appended to end of collection\n */\nexport function innerJoin<T extends object, JoinT extends object>(\n  itemsToJoin: JoinT[],\n  options?: JoinOptions<JoinT, T> | null | undefined\n): TidyFn<T, Merge<T, JoinT>> {\n  const _innerJoin: TidyFn<T, Merge<T, JoinT>> = (\n    items: T[]\n  ): Merge<T, JoinT>[] => {\n    // convert by option in to a map from JoinT to T key\n    const byMap =\n      options?.by == null\n        ? autodetectByMap(items, itemsToJoin)\n        : makeByMap(options.by);\n\n    const joinKeys = Object.keys(byMap);\n    const itemKeys = joinKeys.map((jKey) => byMap[jKey] as string);\n    const index = buildJoinIndex(itemsToJoin, joinKeys);\n\n    const joined = items.flatMap((d: T) => {\n      const key = computeKey(d, itemKeys);\n      const matches = index.get(key);\n      if (matches === undefined) return [];\n      return matches.map((j: JoinT) => ({ ...d, ...j }));\n    });\n\n    return joined as Merge<T, JoinT>[];\n  };\n  return _innerJoin;\n}\n"],"names":[],"mappings":"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"}

package/dist/es/item/rate.js

@@ -3,14 +3,13 @@ import { rate as rate$1 } from '../math/math.js';
 function rate(numerator, denominator, options) {
   const numeratorFn = typeof numerator === "function" ? numerator : (d) => d[numerator];
   const denominatorFn = typeof denominator === "function" ? denominator : (d) => d[denominator];
-  const {predicate, allowDivideByZero} = options != null ? options : {};
+  const { predicate, allowDivideByZero } = options != null ? options : {};
   return predicate == null ? (d, index, array) => {
     const denom = denominatorFn(d, index, array);
     const numer = numeratorFn(d, index, array);
     return rate$1(numer, denom, allowDivideByZero);
   } : (d, index, array) => {
-    if (!predicate(d, index, array))
-      return void 0;
+    if (!predicate(d, index, array)) return void 0;
     const denom = denominatorFn(d, index, array);
     const numer = numeratorFn(d, index, array);
     return rate$1(numer, denom, allowDivideByZero);

package/dist/es/item/rate.js.map

@@ -1 +1 @@
-{"version":3,"file":"rate.js","sources":["../../../src/item/rate.ts"],"sourcesContent":["import { rate as mathRate } from '../math/math';\n\ntype RateOptions<T> = {\n  predicate?: (d: T, index: number, array: Iterable<T>) => boolean;\n  allowDivideByZero?: boolean;\n};\n\n/**\n * Returns a function that computes a rate (numerator / denominator), setting the value to\n * 0 if denominator = 0 and numerator = 0.\n */\nexport function rate<T extends object>(\n  numerator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  denominator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  options?: RateOptions<T>\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => (d[numerator] as unknown) as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => (d[denominator] as unknown) as number;\n\n  const { predicate, allowDivideByZero } = options ?? {};\n  return predicate == null\n    ? (d: T, index: number, array: Iterable<T>) => {\n        const denom = denominatorFn(d, index, array);\n        const numer = numeratorFn(d, index, array);\n        return mathRate(numer, denom, allowDivideByZero);\n      }\n    : (d: T, index: number, array: Iterable<T>) => {\n        if (!predicate(d, index, array)) return undefined;\n\n        const denom = denominatorFn(d, index, array);\n        const numer = numeratorFn(d, index, array);\n        return mathRate(numer, denom, allowDivideByZero);\n      };\n}\n"],"names":["mathRate"],"mappings":";;cAYE,WACA,aACA;AAEA,QAAM,cACJ,OAAO,cAAc,aACjB,YACA,CAAC,MAAU,EAAE;AACnB,QAAM,gBACJ,OAAO,gBAAgB,aACnB,cACA,CAAC,MAAU,EAAE;AAEnB,QAAM,CAAE,WAAW,qBAAsB,4BAAW;AACpD,SAAO,aAAa,OAChB,CAAC,GAAM,OAAe;AACpB,UAAM,QAAQ,cAAc,GAAG,OAAO;AACtC,UAAM,QAAQ,YAAY,GAAG,OAAO;AACpC,WAAOA,OAAS,OAAO,OAAO;AAAA,MAEhC,CAAC,GAAM,OAAe;AACpB,QAAI,CAAC,UAAU,GAAG,OAAO;AAAQ,aAAO;AAExC,UAAM,QAAQ,cAAc,GAAG,OAAO;AACtC,UAAM,QAAQ,YAAY,GAAG,OAAO;AACpC,WAAOA,OAAS,OAAO,OAAO;AAAA;AAAA;;;;"}
+{"version":3,"file":"rate.js","sources":["../../../src/item/rate.ts"],"sourcesContent":["import { rate as mathRate } from '../math/math';\n\ntype RateOptions<T> = {\n  predicate?: (d: T, index: number, array: Iterable<T>) => boolean;\n  allowDivideByZero?: boolean;\n};\n\n/**\n * Returns a function that computes a rate (numerator / denominator), setting the value to\n * 0 if denominator = 0 and numerator = 0.\n */\nexport function rate<T extends object>(\n  numerator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  denominator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  options?: RateOptions<T>\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => d[numerator] as unknown as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => d[denominator] as unknown as number;\n\n  const { predicate, allowDivideByZero } = options ?? {};\n  return predicate == null\n    ? (d: T, index: number, array: Iterable<T>) => {\n        const denom = denominatorFn(d, index, array);\n        const numer = numeratorFn(d, index, array);\n        return mathRate(numer, denom, allowDivideByZero);\n      }\n    : (d: T, index: number, array: Iterable<T>) => {\n        if (!predicate(d, index, array)) return undefined;\n\n        const denom = denominatorFn(d, index, array);\n        const numer = numeratorFn(d, index, array);\n        return mathRate(numer, denom, allowDivideByZero);\n      };\n}\n"],"names":["mathRate"],"mappings":";;AAWgB,SAAA,IAAA,CACd,SACA,EAAA,WAAA,EACA,OACA,EAAA;AACA,EAAM,MAAA,WAAA,GACJ,OAAO,SAAc,KAAA,UAAA,GACjB,YACA,CAAC,CAAA,KAAS,EAAE,SAAS,CAAA,CAAA;AAC3B,EAAM,MAAA,aAAA,GACJ,OAAO,WAAgB,KAAA,UAAA,GACnB,cACA,CAAC,CAAA,KAAS,EAAE,WAAW,CAAA,CAAA;AAE7B,EAAA,MAAM,EAAE,SAAA,EAAW,iBAAkB,EAAA,GAAI,4BAAW,EAAC,CAAA;AACrD,EAAA,OAAO,SAAa,IAAA,IAAA,GAChB,CAAC,CAAA,EAAM,OAAe,KAAuB,KAAA;AAC3C,IAAA,MAAM,KAAQ,GAAA,aAAA,CAAc,CAAG,EAAA,KAAA,EAAO,KAAK,CAAA,CAAA;AAC3C,IAAA,MAAM,KAAQ,GAAA,WAAA,CAAY,CAAG,EAAA,KAAA,EAAO,KAAK,CAAA,CAAA;AACzC,IAAO,OAAAA,MAAA,CAAS,KAAO,EAAA,KAAA,EAAO,iBAAiB,CAAA,CAAA;AAAA,GAEjD,GAAA,CAAC,CAAM,EAAA,KAAA,EAAe,KAAuB,KAAA;AAC3C,IAAA,IAAI,CAAC,SAAU,CAAA,CAAA,EAAG,KAAO,EAAA,KAAK,GAAU,OAAA,KAAA,CAAA,CAAA;AAExC,IAAA,MAAM,KAAQ,GAAA,aAAA,CAAc,CAAG,EAAA,KAAA,EAAO,KAAK,CAAA,CAAA;AAC3C,IAAA,MAAM,KAAQ,GAAA,WAAA,CAAY,CAAG,EAAA,KAAA,EAAO,KAAK,CAAA,CAAA;AACzC,IAAO,OAAAA,MAAA,CAAS,KAAO,EAAA,KAAA,EAAO,iBAAiB,CAAA,CAAA;AAAA,GACjD,CAAA;AACN;;;;"}

package/dist/es/leftJoin.js

@@ -1,18 +1,23 @@
-import { autodetectByMap, makeByMap, isMatch } from './innerJoin.js';
+import { autodetectByMap, makeByMap, buildJoinIndex, computeKey } from './innerJoin.js';
 
 function leftJoin(itemsToJoin, options) {
   const _leftJoin = (items) => {
-    if (!itemsToJoin.length)
-      return items;
+    if (!itemsToJoin.length) return items;
     const byMap = (options == null ? void 0 : options.by) == null ? autodetectByMap(items, itemsToJoin) : makeByMap(options.by);
+    const joinKeys = Object.keys(byMap);
+    const itemKeys = joinKeys.map((jKey) => byMap[jKey]);
+    const index = buildJoinIndex(itemsToJoin, joinKeys);
     const joinObjectKeys = Object.keys(itemsToJoin[0]);
     const joined = items.flatMap((d) => {
-      const matches = itemsToJoin.filter((j) => isMatch(d, j, byMap));
-      if (matches.length) {
-        return matches.map((j) => ({...d, ...j}));
+      const key = computeKey(d, itemKeys);
+      const matches = index.get(key);
+      if (matches !== void 0) {
+        return matches.map((j) => ({ ...d, ...j }));
       }
-      const undefinedFill = Object.fromEntries(joinObjectKeys.filter((key) => d[key] == null).map((key) => [key, void 0]));
-      return {...d, ...undefinedFill};
+      const undefinedFill = Object.fromEntries(
+        joinObjectKeys.filter((key2) => d[key2] == null).map((key2) => [key2, void 0])
+      );
+      return { ...d, ...undefinedFill };
     });
     return joined;
   };

package/dist/es/leftJoin.js.map

@@ -1 +1 @@
-{"version":3,"file":"leftJoin.js","sources":["../../src/leftJoin.ts"],"sourcesContent":["import { Datum, TidyFn } from './types';\nimport { isMatch, makeByMap, autodetectByMap, JoinOptions } from './innerJoin';\nimport { O } from 'ts-toolbelt';\n\n/**\n * Performs a left join on two collections\n * @param itemsToJoin The rows/items to be appended to end of collection\n */\nexport function leftJoin<T extends Datum, JoinT extends Datum>(\n  itemsToJoin: JoinT[],\n  options?: JoinOptions<JoinT, T> | null | undefined\n): TidyFn<T, O.Merge<T, Partial<JoinT>>> {\n  const _leftJoin: TidyFn<T, O.Merge<T, Partial<JoinT>>> = (\n    items: T[]\n  ): O.Merge<T, Partial<JoinT>>[] => {\n    if (!itemsToJoin.length) return items as any;\n\n    // convert by option in to a map from T key to JoinT key\n    const byMap =\n      options?.by == null\n        ? autodetectByMap(items, itemsToJoin)\n        : makeByMap(options.by);\n\n    // when we miss a join, we want to explicitly add in undefined\n    // so our rows all have the same keys. get those keys here.\n    const joinObjectKeys = Object.keys(itemsToJoin[0]);\n\n    const joined = items.flatMap((d: T) => {\n      const matches = itemsToJoin.filter((j: JoinT) => isMatch(d, j, byMap));\n      if (matches.length) {\n        return matches.map((j: JoinT) => ({ ...d, ...j }));\n      }\n\n      // add in missing keys explicitly as undefined without\n      // overriding existing values and while maintaining order\n      // of keys\n      const undefinedFill = Object.fromEntries(\n        joinObjectKeys\n          .filter((key) => d[key] == null)\n          .map((key) => [key, undefined])\n      );\n\n      return { ...d, ...undefinedFill };\n    });\n\n    return joined;\n  };\n  return _leftJoin;\n}\n"],"names":[],"mappings":";;kBASE,aACA;AAEA,QAAM,YAAmD,CACvD;AAEA,QAAI,CAAC,YAAY;AAAQ,aAAO;AAGhC,UAAM,QACJ,oCAAS,OAAM,OACX,gBAAgB,OAAO,eACvB,UAAU,QAAQ;AAIxB,UAAM,iBAAiB,OAAO,KAAK,YAAY;AAE/C,UAAM,SAAS,MAAM,QAAQ,CAAC;AAC5B,YAAM,UAAU,YAAY,OAAO,CAAC,MAAa,QAAQ,GAAG,GAAG;AAC/D,UAAI,QAAQ;AACV,eAAO,QAAQ,IAAI,CAAC,WAAmB,MAAM;AAAA;AAM/C,YAAM,gBAAgB,OAAO,YAC3B,eACG,OAAO,CAAC,QAAQ,EAAE,QAAQ,MAC1B,IAAI,CAAC,QAAQ,CAAC,KAAK;AAGxB,aAAO,IAAK,MAAM;AAAA;AAGpB,WAAO;AAAA;AAET,SAAO;AAAA;;;;"}
+{"version":3,"file":"leftJoin.js","sources":["../../src/leftJoin.ts"],"sourcesContent":["import { Datum, TidyFn } from './types';\nimport {\n  makeByMap,\n  autodetectByMap,\n  JoinOptions,\n  buildJoinIndex,\n  computeKey,\n} from './innerJoin';\nimport { Merge } from './type-utils';\n\n/**\n * Performs a left join on two collections\n * @param itemsToJoin The rows/items to be appended to end of collection\n */\nexport function leftJoin<T extends Datum, JoinT extends Datum>(\n  itemsToJoin: JoinT[],\n  options?: JoinOptions<JoinT, T> | null | undefined\n): TidyFn<T, Merge<T, Partial<JoinT>>> {\n  const _leftJoin: TidyFn<T, Merge<T, Partial<JoinT>>> = (\n    items: T[]\n  ): Merge<T, Partial<JoinT>>[] => {\n    if (!itemsToJoin.length) return items as any;\n\n    // convert by option in to a map from T key to JoinT key\n    const byMap =\n      options?.by == null\n        ? autodetectByMap(items, itemsToJoin)\n        : makeByMap(options.by);\n\n    const joinKeys = Object.keys(byMap);\n    const itemKeys = joinKeys.map((jKey) => byMap[jKey] as string);\n    const index = buildJoinIndex(itemsToJoin, joinKeys);\n\n    // when we miss a join, we want to explicitly add in undefined\n    // so our rows all have the same keys. get those keys here.\n    const joinObjectKeys = Object.keys(itemsToJoin[0]);\n\n    const joined = items.flatMap((d: T) => {\n      const key = computeKey(d, itemKeys);\n      const matches = index.get(key);\n      if (matches !== undefined) {\n        return matches.map((j: JoinT) => ({ ...d, ...j }));\n      }\n\n      // add in missing keys explicitly as undefined without\n      // overriding existing values and while maintaining order\n      // of keys\n      const undefinedFill = Object.fromEntries(\n        joinObjectKeys\n          .filter((key) => d[key] == null)\n          .map((key) => [key, undefined])\n      );\n\n      return { ...d, ...undefinedFill };\n    });\n\n    return joined;\n  };\n  return _leftJoin;\n}\n"],"names":["key"],"mappings":";;AAcgB,SAAA,QAAA,CACd,aACA,OACqC,EAAA;AACrC,EAAM,MAAA,SAAA,GAAiD,CACrD,KAC+B,KAAA;AAC/B,IAAI,IAAA,CAAC,WAAY,CAAA,MAAA,EAAe,OAAA,KAAA,CAAA;AAGhC,IAAM,MAAA,KAAA,GAAA,CACJ,OAAS,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,OAAA,CAAA,EAAA,KAAM,IACX,GAAA,eAAA,CAAgB,OAAO,WAAW,CAAA,GAClC,SAAU,CAAA,OAAA,CAAQ,EAAE,CAAA,CAAA;AAE1B,IAAM,MAAA,QAAA,GAAW,MAAO,CAAA,IAAA,CAAK,KAAK,CAAA,CAAA;AAClC,IAAA,MAAM,WAAW,QAAS,CAAA,GAAA,CAAI,CAAC,IAAS,KAAA,KAAA,CAAM,IAAI,CAAW,CAAA,CAAA;AAC7D,IAAM,MAAA,KAAA,GAAQ,cAAe,CAAA,WAAA,EAAa,QAAQ,CAAA,CAAA;AAIlD,IAAA,MAAM,cAAiB,GAAA,MAAA,CAAO,IAAK,CAAA,WAAA,CAAY,CAAC,CAAC,CAAA,CAAA;AAEjD,IAAA,MAAM,MAAS,GAAA,KAAA,CAAM,OAAQ,CAAA,CAAC,CAAS,KAAA;AACrC,MAAM,MAAA,GAAA,GAAM,UAAW,CAAA,CAAA,EAAG,QAAQ,CAAA,CAAA;AAClC,MAAM,MAAA,OAAA,GAAU,KAAM,CAAA,GAAA,CAAI,GAAG,CAAA,CAAA;AAC7B,MAAA,IAAI,YAAY,KAAW,CAAA,EAAA;AACzB,QAAO,OAAA,OAAA,CAAQ,IAAI,CAAC,CAAA,MAAc,EAAE,GAAG,CAAA,EAAG,GAAG,CAAA,EAAI,CAAA,CAAA,CAAA;AAAA,OACnD;AAKA,MAAA,MAAM,gBAAgB,MAAO,CAAA,WAAA;AAAA,QAC3B,cACG,CAAA,MAAA,CAAO,CAACA,IAAAA,KAAQ,EAAEA,IAAG,CAAA,IAAK,IAAI,CAAA,CAC9B,IAAI,CAACA,IAAAA,KAAQ,CAACA,IAAAA,EAAK,MAAS,CAAC,CAAA;AAAA,OAClC,CAAA;AAEA,MAAA,OAAO,EAAE,GAAG,CAAG,EAAA,GAAG,aAAc,EAAA,CAAA;AAAA,KACjC,CAAA,CAAA;AAED,IAAO,OAAA,MAAA,CAAA;AAAA,GACT,CAAA;AACA,EAAO,OAAA,SAAA,CAAA;AACT;;;;"}

package/dist/es/map.js.map

@@ -1 +1 @@
-{"version":3,"file":"map.js","sources":["../../src/map.ts"],"sourcesContent":["import { TidyFn } from './types';\n\n/**\n * Maps items\n * @param mapFn Maps items from one form to another\n */\nexport function map<T extends object, OutputT>(\n  mapFn: (item: T, index: number, array: T[]) => OutputT\n): TidyFn<T, OutputT> {\n  const _map: TidyFn<T, OutputT> = (items: T[]) => items.map(mapFn);\n  return _map;\n}\n"],"names":[],"mappings":"aAOE;AAEA,QAAM,OAA2B,CAAC,UAAe,MAAM,IAAI;AAC3D,SAAO;AAAA;;;;"}
+{"version":3,"file":"map.js","sources":["../../src/map.ts"],"sourcesContent":["import { TidyFn } from './types';\n\n/**\n * Maps items\n * @param mapFn Maps items from one form to another\n */\nexport function map<T extends object, OutputT>(\n  mapFn: (item: T, index: number, array: T[]) => OutputT\n): TidyFn<T, OutputT> {\n  const _map: TidyFn<T, OutputT> = (items: T[]) => items.map(mapFn);\n  return _map;\n}\n"],"names":[],"mappings":"AAMO,SAAS,IACd,KACoB,EAAA;AACpB,EAAA,MAAM,IAA2B,GAAA,CAAC,KAAe,KAAA,KAAA,CAAM,IAAI,KAAK,CAAA,CAAA;AAChE,EAAO,OAAA,IAAA,CAAA;AACT;;;;"}

package/dist/es/math/math.js.map

@@ -1 +1 @@
-{"version":3,"file":"math.js","sources":["../../../src/math/math.ts"],"sourcesContent":["/** Tidy math helpers */\n\n/** Compute a fraction while handling common edge cases */\nexport function rate(\n  numerator: number | null | undefined,\n  denominator: number | null | undefined,\n  allowDivideByZero?: boolean\n): number | undefined {\n  return numerator == null || denominator == null\n    ? undefined\n    : denominator === 0 && numerator === 0\n    ? 0\n    : !allowDivideByZero && denominator === 0\n    ? undefined\n    : numerator / denominator;\n}\n\nexport function subtract(\n  a: number | null | undefined,\n  b: number | null | undefined,\n  nullyZero?: boolean\n) {\n  return a == null || b == null\n    ? nullyZero\n      ? (a ?? 0) - (b ?? 0)\n      : undefined\n    : a - b;\n}\n\nexport function add(\n  a: number | null | undefined,\n  b: number | null | undefined,\n  nullyZero?: boolean\n) {\n  return a == null || b == null\n    ? nullyZero\n      ? (a ?? 0) + (b ?? 0)\n      : undefined\n    : a + b;\n}\n"],"names":[],"mappings":"cAIE,WACA,aACA;AAEA,SAAO,aAAa,QAAQ,eAAe,OACvC,SACA,gBAAgB,KAAK,cAAc,IACnC,IACA,CAAC,qBAAqB,gBAAgB,IACtC,SACA,YAAY;AAAA;kBAIhB,GACA,GACA;AAEA,SAAO,KAAK,QAAQ,KAAK,OACrB,YACG,iBAAK,sBAAW,KACjB,SACF,IAAI;AAAA;aAIR,GACA,GACA;AAEA,SAAO,KAAK,QAAQ,KAAK,OACrB,YACG,iBAAK,sBAAW,KACjB,SACF,IAAI;AAAA;;;;"}
+{"version":3,"file":"math.js","sources":["../../../src/math/math.ts"],"sourcesContent":["/** Tidy math helpers */\n\n/** Compute a fraction while handling common edge cases */\nexport function rate(\n  numerator: number | null | undefined,\n  denominator: number | null | undefined,\n  allowDivideByZero?: boolean\n): number | undefined {\n  return numerator == null || denominator == null\n    ? undefined\n    : denominator === 0 && numerator === 0\n    ? 0\n    : !allowDivideByZero && denominator === 0\n    ? undefined\n    : numerator / denominator;\n}\n\nexport function subtract(\n  a: number | null | undefined,\n  b: number | null | undefined,\n  nullyZero?: boolean\n) {\n  return a == null || b == null\n    ? nullyZero\n      ? (a ?? 0) - (b ?? 0)\n      : undefined\n    : a - b;\n}\n\nexport function add(\n  a: number | null | undefined,\n  b: number | null | undefined,\n  nullyZero?: boolean\n) {\n  return a == null || b == null\n    ? nullyZero\n      ? (a ?? 0) + (b ?? 0)\n      : undefined\n    : a + b;\n}\n"],"names":[],"mappings":"AAGgB,SAAA,IAAA,CACd,SACA,EAAA,WAAA,EACA,iBACoB,EAAA;AACpB,EAAA,OAAO,SAAa,IAAA,IAAA,IAAQ,WAAe,IAAA,IAAA,GACvC,SACA,WAAgB,KAAA,CAAA,IAAK,SAAc,KAAA,CAAA,GACnC,IACA,CAAC,iBAAA,IAAqB,WAAgB,KAAA,CAAA,GACtC,SACA,SAAY,GAAA,WAAA,CAAA;AAClB,CAAA;AAEgB,SAAA,QAAA,CACd,CACA,EAAA,CAAA,EACA,SACA,EAAA;AACA,EAAO,OAAA,CAAA,IAAK,IAAQ,IAAA,CAAA,IAAK,IACrB,GAAA,SAAA,GAAA,CACG,gBAAK,CAAM,KAAA,CAAA,IAAA,IAAA,GAAA,CAAA,GAAK,CACjB,CAAA,GAAA,KAAA,CAAA,GACF,CAAI,GAAA,CAAA,CAAA;AACV,CAAA;AAEgB,SAAA,GAAA,CACd,CACA,EAAA,CAAA,EACA,SACA,EAAA;AACA,EAAO,OAAA,CAAA,IAAK,IAAQ,IAAA,CAAA,IAAK,IACrB,GAAA,SAAA,GAAA,CACG,gBAAK,CAAM,KAAA,CAAA,IAAA,IAAA,GAAA,CAAA,GAAK,CACjB,CAAA,GAAA,KAAA,CAAA,GACF,CAAI,GAAA,CAAA,CAAA;AACV;;;;"}

package/dist/es/mutate.js

@@ -1,6 +1,6 @@
 function mutate(mutateSpec) {
   const _mutate = (items) => {
-    const mutatedItems = items.map((d) => ({...d}));
+    const mutatedItems = items.map((d) => ({ ...d }));
     let i = 0;
     for (const mutatedItem of mutatedItems) {
       for (const key in mutateSpec) {

package/dist/es/mutate.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutate.js","sources":["../../src/mutate.ts"],"sourcesContent":["import { TidyFn, NonFunctionValue, Key } from './types';\nimport { A, O } from 'ts-toolbelt';\n\ntype MutateSpecValue<T, O = any> =\n  | ((item: T, index: number, array: Iterable<T>) => O)\n  | NonFunctionValue;\nexport type MutateSpec<T> = Record<Key, MutateSpecValue<T>>;\nexport type ResolvedObj<Obj extends Record<Key, MutateSpecValue<any>>> = {\n  [K in keyof Obj]: Obj[K] extends (...args: any) => any\n    ? ReturnType<Obj[K]> extends any[]\n      ? ReturnType<Obj[K]>[number]\n      : ReturnType<Obj[K]>\n    : Obj[K];\n};\n\ntype Mutated<T extends object, MSpec extends MutateSpec<T>> = O.Merge<\n  ResolvedObj<MSpec>,\n  T\n>;\n\ntype Compute<T> = A.Compute<T>;\n\n/**\n * Mutates items, one item at a time. For mutating across multiple items,\n * use mutateWithSummary.\n * @param mutateSpec\n */\nexport function mutate<T extends object, MSpec extends MutateSpec<T>>(\n  mutateSpec: MSpec\n): TidyFn<T, Compute<Mutated<T, MSpec>>> {\n  type MutatedT = Mutated<T, MSpec>;\n  // use Compute for better intellisense (reveals all keys in obj)\n  const _mutate: TidyFn<T, Compute<MutatedT>> = (\n    items: T[]\n  ): Compute<MutatedT>[] => {\n    // create the base items to merge mutated values into\n    // note we start with the original array so when we pass it as the third argument\n    // to a mutate function, you get the values that have been changed so far\n    const mutatedItems: MutatedT[] = items.map((d) => ({ ...d })) as MutatedT[];\n\n    // we can update each item completely one at a time, since mutate doesn't\n    // support looking across items. Use mutateWithSummary for that.\n    let i = 0;\n    for (const mutatedItem of mutatedItems) {\n      for (const key in mutateSpec) {\n        // get the mutated value for this item (either run the fn or use the constant)\n        const mutateSpecValue = mutateSpec[key];\n        const mutatedResult =\n          typeof mutateSpecValue === 'function'\n            ? mutateSpecValue(mutatedItem as T, i, mutatedItems as T[])\n            : mutateSpecValue;\n\n        mutatedItem[key as any] = mutatedResult;\n      }\n\n      ++i;\n    }\n\n    return mutatedItems as Compute<MutatedT>[];\n  };\n\n  return _mutate;\n}\n"],"names":[],"mappings":"gBA4BE;AAIA,QAAM,UAAwC,CAC5C;AAKA,UAAM,eAA2B,MAAM,IAAI,CAAC,WAAY;AAIxD,QAAI,IAAI;AACR,eAAW,eAAe;AACxB,iBAAW,OAAO;AAEhB,cAAM,kBAAkB,WAAW;AACnC,cAAM,gBACJ,OAAO,oBAAoB,aACvB,gBAAgB,aAAkB,GAAG,gBACrC;AAEN,oBAAY,OAAc;AAAA;AAG5B,QAAE;AAAA;AAGJ,WAAO;AAAA;AAGT,SAAO;AAAA;;;;"}
+{"version":3,"file":"mutate.js","sources":["../../src/mutate.ts"],"sourcesContent":["import { TidyFn, NonFunctionValue, Key } from './types';\nimport { Prettify, Merge } from './type-utils';\n\ntype MutateSpecValue<T, O = any> =\n  | ((item: T, index: number, array: Iterable<T>) => O)\n  | NonFunctionValue;\nexport type MutateSpec<T> = Record<Key, MutateSpecValue<T>>;\nexport type ResolvedObj<Obj extends Record<Key, MutateSpecValue<any>>> = {\n  [K in keyof Obj]: Obj[K] extends (...args: any) => any\n    ? ReturnType<Obj[K]> extends any[]\n      ? ReturnType<Obj[K]>[number]\n      : ReturnType<Obj[K]>\n    : Obj[K];\n};\n\ntype Mutated<T extends object, MSpec extends MutateSpec<T>> = Merge<\n  ResolvedObj<MSpec>,\n  T\n>;\n\ntype Compute<T> = Prettify<T>;\n\n/**\n * Mutates items, one item at a time. For mutating across multiple items,\n * use mutateWithSummary.\n * @param mutateSpec\n */\nexport function mutate<T extends object, MSpec extends MutateSpec<T>>(\n  mutateSpec: MSpec\n): TidyFn<T, Compute<Mutated<T, MSpec>>> {\n  type MutatedT = Mutated<T, MSpec>;\n  // use Compute for better intellisense (reveals all keys in obj)\n  const _mutate: TidyFn<T, Compute<MutatedT>> = (\n    items: T[]\n  ): Compute<MutatedT>[] => {\n    // create the base items to merge mutated values into\n    // note we start with the original array so when we pass it as the third argument\n    // to a mutate function, you get the values that have been changed so far\n    const mutatedItems: MutatedT[] = items.map((d) => ({ ...d })) as MutatedT[];\n\n    // we can update each item completely one at a time, since mutate doesn't\n    // support looking across items. Use mutateWithSummary for that.\n    let i = 0;\n    for (const mutatedItem of mutatedItems) {\n      for (const key in mutateSpec) {\n        // get the mutated value for this item (either run the fn or use the constant)\n        const mutateSpecValue = mutateSpec[key];\n        const mutatedResult =\n          typeof mutateSpecValue === 'function'\n            ? mutateSpecValue(mutatedItem as T, i, mutatedItems as T[])\n            : mutateSpecValue;\n\n        mutatedItem[key as any] = mutatedResult;\n      }\n\n      ++i;\n    }\n\n    return mutatedItems as Compute<MutatedT>[];\n  };\n\n  return _mutate;\n}\n"],"names":[],"mappings":"AA2BO,SAAS,OACd,UACuC,EAAA;AAGvC,EAAM,MAAA,OAAA,GAAwC,CAC5C,KACwB,KAAA;AAIxB,IAAM,MAAA,YAAA,GAA2B,MAAM,GAAI,CAAA,CAAC,OAAO,EAAE,GAAG,GAAI,CAAA,CAAA,CAAA;AAI5D,IAAA,IAAI,CAAI,GAAA,CAAA,CAAA;AACR,IAAA,KAAA,MAAW,eAAe,YAAc,EAAA;AACtC,MAAA,KAAA,MAAW,OAAO,UAAY,EAAA;AAE5B,QAAM,MAAA,eAAA,GAAkB,WAAW,GAAG,CAAA,CAAA;AACtC,QAAM,MAAA,aAAA,GACJ,OAAO,eAAoB,KAAA,UAAA,GACvB,gBAAgB,WAAkB,EAAA,CAAA,EAAG,YAAmB,CACxD,GAAA,eAAA,CAAA;AAEN,QAAA,WAAA,CAAY,GAAU,CAAI,GAAA,aAAA,CAAA;AAAA,OAC5B;AAEA,MAAE,EAAA,CAAA,CAAA;AAAA,KACJ;AAEA,IAAO,OAAA,YAAA,CAAA;AAAA,GACT,CAAA;AAEA,EAAO,OAAA,OAAA,CAAA;AACT;;;;"}

package/dist/es/mutateWithSummary.js

@@ -1,6 +1,6 @@
 function mutateWithSummary(mutateSpec) {
   const _mutate = (items) => {
-    const mutatedItems = items.map((d) => ({...d}));
+    const mutatedItems = items.map((d) => ({ ...d }));
     for (const key in mutateSpec) {
       const mutateSpecValue = mutateSpec[key];
       const mutatedResult = typeof mutateSpecValue === "function" ? mutateSpecValue(mutatedItems) : mutateSpecValue;

package/dist/es/mutateWithSummary.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutateWithSummary.js","sources":["../../src/mutateWithSummary.ts"],"sourcesContent":["import { TidyFn, NonFunctionValue, Key } from './types';\nimport { A } from 'ts-toolbelt';\n\ntype MutateSpecValue<T, O = any> = ((items: T[]) => O[] | O) | NonFunctionValue;\nexport type MutateSummarySpec<T> = Record<Key, MutateSpecValue<T>>;\nexport type ResolvedObj<Obj extends Record<Key, MutateSpecValue<any>>> = {\n  [K in keyof Obj]: Obj[K] extends (...args: any) => any\n    ? ReturnType<Obj[K]> extends any[]\n      ? ReturnType<Obj[K]>[number]\n      : ReturnType<Obj[K]> extends Float64Array\n      ? number\n      : ReturnType<Obj[K]>\n    : Obj[K];\n};\n\ntype Mutated<T, MSpec extends MutateSummarySpec<T>> = T & ResolvedObj<MSpec>;\n\ntype Compute<T> = A.Compute<T>;\n\n/**\n * Mutates items, looking at multiple items at a time to enable summarization.\n * For simpler, item by item mutations, use mutate.\n * @param mutateSpec\n */\nexport function mutateWithSummary<\n  T extends object,\n  MSpec extends MutateSummarySpec<T>\n>(mutateSpec: MSpec): TidyFn<T, Compute<Mutated<T, MSpec>>> {\n  type MutatedT = Mutated<T, MSpec>;\n  // use Compute for better intellisense (reveals all keys in obj)\n  const _mutate: TidyFn<T, Compute<MutatedT>> = (\n    items: T[]\n  ): Compute<MutatedT>[] => {\n    // create the base items to merge mutated values into\n    const mutatedItems: MutatedT[] = items.map((d) => ({ ...d })) as MutatedT[];\n\n    // create vectors for each mutated value\n    for (const key in mutateSpec) {\n      // convert individual values to a vector of the same value\n      // this allows mutate functions to return single numbers and still work\n      const mutateSpecValue = mutateSpec[key];\n      const mutatedResult =\n        typeof mutateSpecValue === 'function'\n          ? mutateSpecValue(mutatedItems)\n          : mutateSpecValue;\n      const mutatedVector =\n        mutatedResult?.[Symbol.iterator] && typeof mutatedResult !== 'string'\n          ? mutatedResult\n          : items.map(() => mutatedResult);\n\n      // merge the mutated vector into the mutated items\n      let i = -1;\n      for (const mutatedItem of mutatedItems) {\n        mutatedItem[key as keyof MutatedT] = mutatedVector[++i];\n      }\n    }\n\n    return mutatedItems as Compute<MutatedT>[];\n  };\n\n  return _mutate;\n}\n"],"names":[],"mappings":"2BA2BE;AAGA,QAAM,UAAwC,CAC5C;AAGA,UAAM,eAA2B,MAAM,IAAI,CAAC,WAAY;AAGxD,eAAW,OAAO;AAGhB,YAAM,kBAAkB,WAAW;AACnC,YAAM,gBACJ,OAAO,oBAAoB,aACvB,gBAAgB,gBAChB;AACN,YAAM,gBACJ,gDAAgB,OAAO,cAAa,OAAO,kBAAkB,WACzD,gBACA,MAAM,IAAI,MAAM;AAGtB,UAAI,IAAI;AACR,iBAAW,eAAe;AACxB,oBAAY,OAAyB,cAAc,EAAE;AAAA;AAAA;AAIzD,WAAO;AAAA;AAGT,SAAO;AAAA;;;;"}
+{"version":3,"file":"mutateWithSummary.js","sources":["../../src/mutateWithSummary.ts"],"sourcesContent":["import { TidyFn, NonFunctionValue, Key } from './types';\nimport { Prettify } from './type-utils';\n\ntype MutateSpecValue<T, O = any> = ((items: T[]) => O[] | O) | NonFunctionValue;\nexport type MutateSummarySpec<T> = Record<Key, MutateSpecValue<T>>;\nexport type ResolvedObj<Obj extends Record<Key, MutateSpecValue<any>>> = {\n  [K in keyof Obj]: Obj[K] extends (...args: any) => any\n    ? ReturnType<Obj[K]> extends any[]\n      ? ReturnType<Obj[K]>[number]\n      : ReturnType<Obj[K]> extends Float64Array\n      ? number\n      : ReturnType<Obj[K]>\n    : Obj[K];\n};\n\ntype Mutated<T, MSpec extends MutateSummarySpec<T>> = T & ResolvedObj<MSpec>;\n\ntype Compute<T> = Prettify<T>;\n\n/**\n * Mutates items, looking at multiple items at a time to enable summarization.\n * For simpler, item by item mutations, use mutate.\n * @param mutateSpec\n */\nexport function mutateWithSummary<\n  T extends object,\n  MSpec extends MutateSummarySpec<T>\n>(mutateSpec: MSpec): TidyFn<T, Compute<Mutated<T, MSpec>>> {\n  type MutatedT = Mutated<T, MSpec>;\n  // use Compute for better intellisense (reveals all keys in obj)\n  const _mutate: TidyFn<T, Compute<MutatedT>> = (\n    items: T[]\n  ): Compute<MutatedT>[] => {\n    // create the base items to merge mutated values into\n    const mutatedItems: MutatedT[] = items.map((d) => ({ ...d })) as MutatedT[];\n\n    // create vectors for each mutated value\n    for (const key in mutateSpec) {\n      // convert individual values to a vector of the same value\n      // this allows mutate functions to return single numbers and still work\n      const mutateSpecValue = mutateSpec[key];\n      const mutatedResult =\n        typeof mutateSpecValue === 'function'\n          ? mutateSpecValue(mutatedItems)\n          : mutateSpecValue;\n      const mutatedVector =\n        mutatedResult?.[Symbol.iterator] && typeof mutatedResult !== 'string'\n          ? mutatedResult\n          : items.map(() => mutatedResult);\n\n      // merge the mutated vector into the mutated items\n      let i = -1;\n      for (const mutatedItem of mutatedItems) {\n        mutatedItem[key as keyof MutatedT] = mutatedVector[++i];\n      }\n    }\n\n    return mutatedItems as Compute<MutatedT>[];\n  };\n\n  return _mutate;\n}\n"],"names":[],"mappings":"AAwBO,SAAS,kBAGd,UAA0D,EAAA;AAG1D,EAAM,MAAA,OAAA,GAAwC,CAC5C,KACwB,KAAA;AAExB,IAAM,MAAA,YAAA,GAA2B,MAAM,GAAI,CAAA,CAAC,OAAO,EAAE,GAAG,GAAI,CAAA,CAAA,CAAA;AAG5D,IAAA,KAAA,MAAW,OAAO,UAAY,EAAA;AAG5B,MAAM,MAAA,eAAA,GAAkB,WAAW,GAAG,CAAA,CAAA;AACtC,MAAA,MAAM,gBACJ,OAAO,eAAA,KAAoB,UACvB,GAAA,eAAA,CAAgB,YAAY,CAC5B,GAAA,eAAA,CAAA;AACN,MAAM,MAAA,aAAA,GAAA,CACJ,aAAgB,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,aAAA,CAAA,MAAA,CAAO,QAAa,CAAA,KAAA,OAAO,aAAkB,KAAA,QAAA,GACzD,aACA,GAAA,KAAA,CAAM,GAAI,CAAA,MAAM,aAAa,CAAA,CAAA;AAGnC,MAAA,IAAI,CAAI,GAAA,CAAA,CAAA,CAAA;AACR,MAAA,KAAA,MAAW,eAAe,YAAc,EAAA;AACtC,QAAA,WAAA,CAAY,GAAqB,CAAA,GAAI,aAAc,CAAA,EAAE,CAAC,CAAA,CAAA;AAAA,OACxD;AAAA,KACF;AAEA,IAAO,OAAA,YAAA,CAAA;AAAA,GACT,CAAA;AAEA,EAAO,OAAA,OAAA,CAAA;AACT;;;;"}