@tidyjs/tidy 2.5.1 → 2.6.0

package/dist/es/addRows.js.map

@@ -1 +1 @@
-{"version":3,"file":"addRows.js","sources":["../../src/addRows.ts"],"sourcesContent":["import { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\nimport { TidyFn } from './types';\n\n/**\n * adds items to the end of the collection\n * @param itemsToAdd The rows/items to be appended to end of collection\n */\nexport function addRows<T extends object>(\n  itemsToAdd: SingleOrArray<T> | ((items: T[]) => SingleOrArray<T>)\n): TidyFn<T> {\n  const _addRows: TidyFn<T> = (items: T[]): T[] => {\n    // TODO: allow options for specifying where it is inserted?\n    if (typeof itemsToAdd === 'function') {\n      return [...items, ...singleOrArray((itemsToAdd as Function)(items))];\n    }\n\n    return [...items, ...singleOrArray(itemsToAdd)];\n  };\n\n  return _addRows;\n}\n"],"names":[],"mappings":";;iBAQE;AAEA,QAAM,WAAsB,CAAC;AAE3B,QAAI,OAAO,eAAe;AACxB,aAAO,CAAC,GAAG,OAAO,GAAG,cAAe,WAAwB;AAAA;AAG9D,WAAO,CAAC,GAAG,OAAO,GAAG,cAAc;AAAA;AAGrC,SAAO;AAAA;;;;"}
+{"version":3,"file":"addRows.js","sources":["../../src/addRows.ts"],"sourcesContent":["import { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\nimport { TidyFn } from './types';\n\n/**\n * adds items to the end of the collection\n * @param itemsToAdd The rows/items to be appended to end of collection\n */\nexport function addRows<T extends object>(\n  itemsToAdd: SingleOrArray<T> | ((items: T[]) => SingleOrArray<T>)\n): TidyFn<T> {\n  const _addRows: TidyFn<T> = (items: T[]): T[] => {\n    // TODO: allow options for specifying where it is inserted?\n    if (typeof itemsToAdd === 'function') {\n      return [...items, ...singleOrArray((itemsToAdd as Function)(items))];\n    }\n\n    return [...items, ...singleOrArray(itemsToAdd)];\n  };\n\n  return _addRows;\n}\n"],"names":[],"mappings":";;AAOO,SAAS,QACd,UACW,EAAA;AACX,EAAM,MAAA,QAAA,GAAsB,CAAC,KAAoB,KAAA;AAE/C,IAAI,IAAA,OAAO,eAAe,UAAY,EAAA;AACpC,MAAO,OAAA,CAAC,GAAG,KAAO,EAAA,GAAG,cAAe,UAAwB,CAAA,KAAK,CAAC,CAAC,CAAA,CAAA;AAAA,KACrE;AAEA,IAAA,OAAO,CAAC,GAAG,KAAA,EAAO,GAAG,aAAA,CAAc,UAAU,CAAC,CAAA,CAAA;AAAA,GAChD,CAAA;AAEA,EAAO,OAAA,QAAA,CAAA;AACT;;;;"}

package/dist/es/arrange.js

@@ -3,12 +3,16 @@ import { singleOrArray } from './helpers/singleOrArray.js';
 
 function arrange(comparators) {
   const _arrange = (items) => {
-    const comparatorFns = singleOrArray(comparators).map((comp) => typeof comp === "function" ? comp.length === 1 ? asc(comp) : comp : asc(comp));
+    const comparatorFns = singleOrArray(comparators).map(
+      (comp) => typeof comp === "function" ? (
+        // length === 1 means it is an accessor (1 argument). convert to comparator via asc
+        comp.length === 1 ? asc(comp) : comp
+      ) : asc(comp)
+    );
     return items.slice().sort((a, b) => {
       for (const comparator of comparatorFns) {
         const result = comparator(a, b);
-        if (result)
-          return result;
+        if (result) return result;
       }
       return 0;
     });
@@ -28,9 +32,9 @@ function desc(key) {
   };
 }
 function fixedOrder(key, order, options) {
-  let {position = "start"} = options != null ? options : {};
+  let { position = "start" } = options != null ? options : {};
   const positionFactor = position === "end" ? -1 : 1;
-  const indexMap = new Map();
+  const indexMap = /* @__PURE__ */ new Map();
   for (let i = 0; i < order.length; ++i) {
     indexMap.set(order[i], i);
   }

package/dist/es/arrange.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrange.js","sources":["../../src/arrange.ts"],"sourcesContent":["import { ascending } from 'd3-array';\nimport { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\nimport { Comparator, Key, KeyOrFn, TidyFn } from './types';\n\n/**\n * Sorts items\n * @param comparators Given a, b return -1 if a comes before b, 0 if equal, 1 if after\n */\nexport function arrange<T extends object>(\n  // note: had to switch to returning `any` instead of using Comparator<T> (returns number)\n  // for #49 - otherwise typescript failed to do type inference on accessors\n  comparators: SingleOrArray<Key | ((a: T, b: T) => any)>\n): TidyFn<T> {\n  const _arrange: TidyFn<T> = (items: T[]): T[] => {\n    // expand strings `key` to `asc(key)`\n    const comparatorFns = singleOrArray(comparators).map((comp) =>\n      typeof comp === 'function'\n        ? // length === 1 means it is an accessor (1 argument). convert to comparator via asc\n          comp.length === 1\n          ? asc(comp as (d: T) => unknown)\n          : (comp as Comparator<T>)\n        : asc<T>(comp)\n    );\n\n    return items.slice().sort((a, b) => {\n      for (const comparator of comparatorFns) {\n        const result = comparator(a, b);\n        if (result) return result;\n      }\n\n      return 0;\n    });\n  };\n\n  return _arrange;\n}\n\n/**\n * Creates an ascending comparator based on a key\n * @param key property key of T\n */\nexport function asc<T>(key: Key | ((d: T) => any)): Comparator<T> {\n  const keyFn = typeof key === 'function' ? key : (d: any) => d[key];\n\n  return function _asc(a: T, b: T) {\n    return emptyAwareComparator(keyFn(a), keyFn(b), false);\n  };\n}\n\n/**\n * Creates a descending comparator based on a key\n * @param key property key of T\n */\nexport function desc<T>(key: Key | ((d: T) => any)): Comparator<T> {\n  const keyFn = typeof key === 'function' ? key : (d: any) => d[key];\n  return function _desc(a: T, b: T) {\n    return emptyAwareComparator(keyFn(a), keyFn(b), true);\n  };\n}\n\n/**\n * Creates a comparator that sorts values based on a key\n * and a supplied array of the desired order for the values.\n * Items not found in the array will be sorted last.\n * @param order array of desired sort order\n */\nexport function fixedOrder<T>(\n  key: KeyOrFn<T>,\n  order: Array<T[keyof T]>,\n  options?: { position?: 'start' | 'end' }\n): (a: T, b: T) => number {\n  let { position = 'start' } = options ?? {};\n  const positionFactor = position === 'end' ? -1 : 1;\n\n  const indexMap = new Map();\n  for (let i = 0; i < order.length; ++i) {\n    indexMap.set(order[i], i);\n  }\n\n  const keyFn =\n    typeof key === 'function'\n      ? key\n      : (d: T) => (d[key as keyof T] as unknown) as any;\n\n  return function _fixedOrder(a: T, b: T) {\n    const aIndex: number = indexMap.get(keyFn(a)) ?? -1;\n    const bIndex: number = indexMap.get(keyFn(b)) ?? -1;\n\n    if (aIndex >= 0 && bIndex >= 0) {\n      return aIndex - bIndex;\n    }\n\n    if (aIndex >= 0) {\n      return positionFactor * -1;\n    }\n\n    if (bIndex >= 0) {\n      return positionFactor * 1;\n    }\n\n    return 0;\n  };\n}\n\nfunction emptyAwareComparator(aInput: any, bInput: any, desc: boolean) {\n  // we swap order to get descending behavior\n  let a = desc ? bInput : aInput;\n  let b = desc ? aInput : bInput;\n\n  // NaN, null, undefined is the order for emptys\n  if (isEmpty(a) && isEmpty(b)) {\n    const rankA = a !== a ? 0 : a === null ? 1 : 2;\n    const rankB = b !== b ? 0 : b === null ? 1 : 2;\n    const order = rankA - rankB;\n    return desc ? -order : order;\n  }\n\n  // keep empty values at the bottom\n  if (isEmpty(a)) {\n    return desc ? -1 : 1;\n  }\n  if (isEmpty(b)) {\n    return desc ? 1 : -1;\n  }\n\n  // descending is handled by swapping the a and b args at the start\n  return ascending(a, b);\n}\n\nfunction isEmpty(value: any) {\n  return value == null || value !== value /* NaN check */;\n}\n"],"names":[],"mappings":";;;iBAWE;AAEA,QAAM,WAAsB,CAAC;AAE3B,UAAM,gBAAgB,cAAc,aAAa,IAAI,CAAC,SACpD,OAAO,SAAS,aAEZ,KAAK,WAAW,IACd,IAAI,QACH,OACH,IAAO;AAGb,WAAO,MAAM,QAAQ,KAAK,CAAC,GAAG;AAC5B,iBAAW,cAAc;AACvB,cAAM,SAAS,WAAW,GAAG;AAC7B,YAAI;AAAQ,iBAAO;AAAA;AAGrB,aAAO;AAAA;AAAA;AAIX,SAAO;AAAA;aAOc;AACrB,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAW,EAAE;AAE9D,SAAO,cAAc,GAAM;AACzB,WAAO,qBAAqB,MAAM,IAAI,MAAM,IAAI;AAAA;AAAA;cAQ5B;AACtB,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAW,EAAE;AAC9D,SAAO,eAAe,GAAM;AAC1B,WAAO,qBAAqB,MAAM,IAAI,MAAM,IAAI;AAAA;AAAA;oBAWlD,KACA,OACA;AAEA,MAAI,CAAE,WAAW,WAAY,4BAAW;AACxC,QAAM,iBAAiB,aAAa,QAAQ,KAAK;AAEjD,QAAM,WAAW,IAAI;AACrB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,EAAE;AAClC,aAAS,IAAI,MAAM,IAAI;AAAA;AAGzB,QAAM,QACJ,OAAO,QAAQ,aACX,MACA,CAAC,MAAU,EAAE;AAEnB,SAAO,qBAAqB,GAAM;AApFpC;AAqFI,UAAM,SAAiB,eAAS,IAAI,MAAM,QAAnB,YAA0B;AACjD,UAAM,SAAiB,eAAS,IAAI,MAAM,QAAnB,YAA0B;AAEjD,QAAI,UAAU,KAAK,UAAU;AAC3B,aAAO,SAAS;AAAA;AAGlB,QAAI,UAAU;AACZ,aAAO,iBAAiB;AAAA;AAG1B,QAAI,UAAU;AACZ,aAAO,iBAAiB;AAAA;AAG1B,WAAO;AAAA;AAAA;AAIX,8BAA8B,QAAa,QAAa;AAEtD,MAAI,IAAI,QAAO,SAAS;AACxB,MAAI,IAAI,QAAO,SAAS;AAGxB,MAAI,QAAQ,MAAM,QAAQ;AACxB,UAAM,QAAQ,MAAM,IAAI,IAAI,MAAM,OAAO,IAAI;AAC7C,UAAM,QAAQ,MAAM,IAAI,IAAI,MAAM,OAAO,IAAI;AAC7C,UAAM,QAAQ,QAAQ;AACtB,WAAO,QAAO,CAAC,QAAQ;AAAA;AAIzB,MAAI,QAAQ;AACV,WAAO,QAAO,KAAK;AAAA;AAErB,MAAI,QAAQ;AACV,WAAO,QAAO,IAAI;AAAA;AAIpB,SAAO,UAAU,GAAG;AAAA;AAGtB,iBAAiB;AACf,SAAO,SAAS,QAAQ,UAAU;AAAA;;;;"}
+{"version":3,"file":"arrange.js","sources":["../../src/arrange.ts"],"sourcesContent":["import { ascending } from 'd3-array';\nimport { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\nimport { Comparator, Key, KeyOrFn, TidyFn } from './types';\n\n/**\n * Sorts items\n * @param comparators Given a, b return -1 if a comes before b, 0 if equal, 1 if after\n */\nexport function arrange<T extends object>(\n  // note: had to switch to returning `any` instead of using Comparator<T> (returns number)\n  // for #49 - otherwise typescript failed to do type inference on accessors\n  comparators: SingleOrArray<Key | ((a: T, b: T) => any)>\n): TidyFn<T> {\n  const _arrange: TidyFn<T> = (items: T[]): T[] => {\n    // expand strings `key` to `asc(key)`\n    const comparatorFns = singleOrArray(comparators).map((comp) =>\n      typeof comp === 'function'\n        ? // length === 1 means it is an accessor (1 argument). convert to comparator via asc\n          comp.length === 1\n          ? asc(comp as (d: T) => unknown)\n          : (comp as Comparator<T>)\n        : asc<T>(comp)\n    );\n\n    return items.slice().sort((a, b) => {\n      for (const comparator of comparatorFns) {\n        const result = comparator(a, b);\n        if (result) return result;\n      }\n\n      return 0;\n    });\n  };\n\n  return _arrange;\n}\n\n/**\n * Creates an ascending comparator based on a key\n * @param key property key of T\n */\nexport function asc<T>(key: Key | ((d: T) => any)): Comparator<T> {\n  const keyFn = typeof key === 'function' ? key : (d: any) => d[key];\n\n  return function _asc(a: T, b: T) {\n    return emptyAwareComparator(keyFn(a), keyFn(b), false);\n  };\n}\n\n/**\n * Creates a descending comparator based on a key\n * @param key property key of T\n */\nexport function desc<T>(key: Key | ((d: T) => any)): Comparator<T> {\n  const keyFn = typeof key === 'function' ? key : (d: any) => d[key];\n  return function _desc(a: T, b: T) {\n    return emptyAwareComparator(keyFn(a), keyFn(b), true);\n  };\n}\n\n/**\n * Creates a comparator that sorts values based on a key\n * and a supplied array of the desired order for the values.\n * Items not found in the array will be sorted last.\n * @param order array of desired sort order\n */\nexport function fixedOrder<T>(\n  key: KeyOrFn<T>,\n  order: Array<T[keyof T]>,\n  options?: { position?: 'start' | 'end' }\n): (a: T, b: T) => number {\n  let { position = 'start' } = options ?? {};\n  const positionFactor = position === 'end' ? -1 : 1;\n\n  const indexMap = new Map();\n  for (let i = 0; i < order.length; ++i) {\n    indexMap.set(order[i], i);\n  }\n\n  const keyFn =\n    typeof key === 'function'\n      ? key\n      : (d: T) => d[key as keyof T] as unknown as any;\n\n  return function _fixedOrder(a: T, b: T) {\n    const aIndex: number = indexMap.get(keyFn(a)) ?? -1;\n    const bIndex: number = indexMap.get(keyFn(b)) ?? -1;\n\n    if (aIndex >= 0 && bIndex >= 0) {\n      return aIndex - bIndex;\n    }\n\n    if (aIndex >= 0) {\n      return positionFactor * -1;\n    }\n\n    if (bIndex >= 0) {\n      return positionFactor * 1;\n    }\n\n    return 0;\n  };\n}\n\nfunction emptyAwareComparator(aInput: any, bInput: any, desc: boolean) {\n  // we swap order to get descending behavior\n  let a = desc ? bInput : aInput;\n  let b = desc ? aInput : bInput;\n\n  // NaN, null, undefined is the order for emptys\n  if (isEmpty(a) && isEmpty(b)) {\n    const rankA = a !== a ? 0 : a === null ? 1 : 2;\n    const rankB = b !== b ? 0 : b === null ? 1 : 2;\n    const order = rankA - rankB;\n    return desc ? -order : order;\n  }\n\n  // keep empty values at the bottom\n  if (isEmpty(a)) {\n    return desc ? -1 : 1;\n  }\n  if (isEmpty(b)) {\n    return desc ? 1 : -1;\n  }\n\n  // descending is handled by swapping the a and b args at the start\n  return ascending(a, b);\n}\n\nfunction isEmpty(value: any) {\n  return value == null || value !== value /* NaN check */;\n}\n"],"names":["desc"],"mappings":"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"}

package/dist/es/complete.js.map

@@ -1 +1 @@
-{"version":3,"file":"complete.js","sources":["../../src/complete.ts"],"sourcesContent":["import { expand, KeyMap } from './expand';\nimport { leftJoin } from './leftJoin';\nimport { Key, TidyFn } from './types';\nimport { replaceNully } from './replaceNully';\nimport { SingleOrArray } from './helpers/singleOrArray';\n\n/**\n * Complete a collection with missing combinations of data\n * @param expandKeys The keys to expand to all combinations of\n * @param replaceNullySpec a map from key name to value of how to deal with undefined values\n */\nexport function complete<T extends object>(\n  expandKeys: SingleOrArray<Key> | KeyMap<T>,\n  replaceNullySpec?: Partial<T> | null | undefined\n): TidyFn<T> {\n  const _complete: TidyFn<T> = (items: T[]): T[] => {\n    const expanded = expand<T, any>(expandKeys)(items);\n    const joined = leftJoin(items)(expanded) as T[]; // actually may have some undefineds...\n    return replaceNullySpec\n      ? (replaceNully(replaceNullySpec)(joined) as T[])\n      : joined;\n  };\n\n  return _complete;\n}\n"],"names":[],"mappings":";;;;kBAYE,YACA;AAEA,QAAM,YAAuB,CAAC;AAC5B,UAAM,WAAW,OAAe,YAAY;AAC5C,UAAM,SAAS,SAAS,OAAO;AAC/B,WAAO,mBACF,aAAa,kBAAkB,UAChC;AAAA;AAGN,SAAO;AAAA;;;;"}
+{"version":3,"file":"complete.js","sources":["../../src/complete.ts"],"sourcesContent":["import { expand, KeyMap } from './expand';\nimport { leftJoin } from './leftJoin';\nimport { Key, TidyFn } from './types';\nimport { replaceNully } from './replaceNully';\nimport { SingleOrArray } from './helpers/singleOrArray';\n\n/**\n * Complete a collection with missing combinations of data\n * @param expandKeys The keys to expand to all combinations of\n * @param replaceNullySpec a map from key name to value of how to deal with undefined values\n */\nexport function complete<T extends object>(\n  expandKeys: SingleOrArray<Key> | KeyMap<T>,\n  replaceNullySpec?: Partial<T> | null | undefined\n): TidyFn<T> {\n  const _complete: TidyFn<T> = (items: T[]): T[] => {\n    const expanded = expand<T, any>(expandKeys)(items);\n    const joined = leftJoin(items)(expanded) as T[]; // actually may have some undefineds...\n    return replaceNullySpec\n      ? (replaceNully(replaceNullySpec)(joined) as T[])\n      : joined;\n  };\n\n  return _complete;\n}\n"],"names":[],"mappings":";;;;AAWgB,SAAA,QAAA,CACd,YACA,gBACW,EAAA;AACX,EAAM,MAAA,SAAA,GAAuB,CAAC,KAAoB,KAAA;AAChD,IAAA,MAAM,QAAW,GAAA,MAAA,CAAe,UAAU,CAAA,CAAE,KAAK,CAAA,CAAA;AACjD,IAAA,MAAM,MAAS,GAAA,QAAA,CAAS,KAAK,CAAA,CAAE,QAAQ,CAAA,CAAA;AACvC,IAAA,OAAO,gBACF,GAAA,YAAA,CAAa,gBAAgB,CAAA,CAAE,MAAM,CACtC,GAAA,MAAA,CAAA;AAAA,GACN,CAAA;AAEA,EAAO,OAAA,SAAA,CAAA;AACT;;;;"}

package/dist/es/count.js

@@ -7,8 +7,12 @@ import { tidy } from './tidy.js';
 function count(groupKeys, options) {
   const _count = (items) => {
     options = options != null ? options : {};
-    const {name = "n", sort} = options;
-    const results = tidy(items, groupBy(groupKeys, [tally(options)]), sort ? arrange(desc(name)) : identity);
+    const { name = "n", sort } = options;
+    const results = tidy(
+      items,
+      groupBy(groupKeys, [tally(options)]),
+      sort ? arrange(desc(name)) : identity
+    );
     return results;
   };
   return _count;

package/dist/es/count.js.map

@@ -1 +1 @@
-{"version":3,"file":"count.js","sources":["../../src/count.ts"],"sourcesContent":["import { arrange, desc } from './arrange';\nimport { groupBy } from './groupBy';\nimport { identity } from './helpers/identity';\nimport { SingleOrArray } from './helpers/singleOrArray';\nimport { tally } from './tally';\nimport { tidy } from './tidy';\nimport { KeyOrFn } from './types';\n\ntype CountOptions = {\n  name?: string;\n  sort?: boolean;\n  wt?: string;\n};\n\n/**\n * Tallies the number distinct values for the specified keys and adds\n * the count as a new key (default `n`). Optionally sorts by the count.\n */\nexport function count<T extends object, Keys extends SingleOrArray<KeyOrFn<T>>>(\n  groupKeys: Keys,\n  options?: CountOptions | null | undefined\n) {\n  const _count = (items: T[]) => {\n    options = options ?? {};\n    const { name = 'n', sort } = options;\n\n    const results = tidy(\n      items,\n      groupBy(groupKeys, [tally(options)]),\n      sort ? arrange(desc(name)) : identity\n    );\n\n    return results;\n  };\n\n  return _count;\n}\n"],"names":[],"mappings":";;;;;;eAmBE,WACA;AAEA,QAAM,SAAS,CAAC;AACd,cAAU,4BAAW;AACrB,UAAM,CAAE,OAAO,KAAK,QAAS;AAE7B,UAAM,UAAU,KACd,OACA,QAAQ,WAAW,CAAC,MAAM,YAC1B,OAAO,QAAQ,KAAK,SAAS;AAG/B,WAAO;AAAA;AAGT,SAAO;AAAA;;;;"}
+{"version":3,"file":"count.js","sources":["../../src/count.ts"],"sourcesContent":["import { arrange, desc } from './arrange';\nimport { groupBy } from './groupBy';\nimport { identity } from './helpers/identity';\nimport { SingleOrArray } from './helpers/singleOrArray';\nimport { tally } from './tally';\nimport { tidy } from './tidy';\nimport { KeyOrFn } from './types';\n\ntype CountOptions = {\n  name?: string;\n  sort?: boolean;\n  wt?: string;\n};\n\n/**\n * Tallies the number distinct values for the specified keys and adds\n * the count as a new key (default `n`). Optionally sorts by the count.\n */\nexport function count<T extends object, Keys extends SingleOrArray<KeyOrFn<T>>>(\n  groupKeys: Keys,\n  options?: CountOptions | null | undefined\n) {\n  const _count = (items: T[]) => {\n    options = options ?? {};\n    const { name = 'n', sort } = options;\n\n    const results = tidy(\n      items,\n      groupBy(groupKeys, [tally(options)]),\n      sort ? arrange(desc(name)) : identity\n    );\n\n    return results;\n  };\n\n  return _count;\n}\n"],"names":[],"mappings":";;;;;;AAkBgB,SAAA,KAAA,CACd,WACA,OACA,EAAA;AACA,EAAM,MAAA,MAAA,GAAS,CAAC,KAAe,KAAA;AAC7B,IAAA,OAAA,GAAU,4BAAW,EAAC,CAAA;AACtB,IAAA,MAAM,EAAE,IAAA,GAAO,GAAK,EAAA,IAAA,EAAS,GAAA,OAAA,CAAA;AAE7B,IAAA,MAAM,OAAU,GAAA,IAAA;AAAA,MACd,KAAA;AAAA,MACA,QAAQ,SAAW,EAAA,CAAC,KAAM,CAAA,OAAO,CAAC,CAAC,CAAA;AAAA,MACnC,IAAO,GAAA,OAAA,CAAQ,IAAK,CAAA,IAAI,CAAC,CAAI,GAAA,QAAA;AAAA,KAC/B,CAAA;AAEA,IAAO,OAAA,OAAA,CAAA;AAAA,GACT,CAAA;AAEA,EAAO,OAAA,MAAA,CAAA;AACT;;;;"}

package/dist/es/debug.js

@@ -10,13 +10,15 @@ function debug(label, options) {
       }
     }
     options = options != null ? options : {};
-    const {limit = 10, output = "table"} = options;
+    const { limit = 10, output = "table" } = options;
     const dashString = "--------------------------------------------------------------------------------";
     let numDashes = dashString.length;
     const prefixedLabel = prefix + "]" + (label == null ? "" : " " + label);
     numDashes = Math.max(0, numDashes - (prefixedLabel.length + 2));
     console.log(`${prefixedLabel} ${dashString.substring(0, numDashes)}`);
-    console[output](limit == null || limit >= items.length ? items : items.slice(0, limit));
+    console[output](
+      limit == null || limit >= items.length ? items : items.slice(0, limit)
+    );
     return items;
   };
   return _debug;

package/dist/es/debug.js.map

@@ -1 +1 @@
-{"version":3,"file":"debug.js","sources":["../../src/debug.ts"],"sourcesContent":["import { TidyContext, TidyFn } from './types';\n\ntype Options = {\n  limit?: number | null;\n  output?: 'log' | 'table';\n};\n\n/**\n * Debugs items\n */\nexport function debug<T extends object>(\n  label?: string | null | undefined,\n  options?: Options | null | undefined\n): TidyFn<T> {\n  const _debug: TidyFn<T> = (items: T[], context?: TidyContext): T[] => {\n    let prefix = '[tidy.debug';\n    if (context?.groupKeys?.length) {\n      const groupKeys = context.groupKeys;\n      const groupKeyStrings = groupKeys\n        .map((keyPair: any) => keyPair.join(': '))\n        .join(', ');\n      if (groupKeyStrings.length) {\n        prefix += '|' + groupKeyStrings;\n      }\n    }\n    options = options ?? {};\n    const { limit = 10, output = 'table' } = options;\n\n    // check for sneaky group keys as last arg\n    const dashString =\n      '--------------------------------------------------------------------------------';\n    let numDashes = dashString.length;\n    const prefixedLabel = prefix + ']' + (label == null ? '' : ' ' + label);\n    numDashes = Math.max(0, numDashes - (prefixedLabel.length + 2));\n\n    console.log(`${prefixedLabel} ${dashString.substring(0, numDashes)}`);\n    console[output](\n      limit == null || limit >= items.length ? items : items.slice(0, limit)\n    );\n    return items;\n  };\n\n  return _debug;\n}\n"],"names":[],"mappings":"eAWE,OACA;AAEA,QAAM,SAAoB,CAAC,OAAY;AAdzC;AAeI,QAAI,SAAS;AACb,QAAI,yCAAS,cAAT,mBAAoB;AACtB,YAAM,YAAY,QAAQ;AAC1B,YAAM,kBAAkB,UACrB,IAAI,CAAC,YAAiB,QAAQ,KAAK,OACnC,KAAK;AACR,UAAI,gBAAgB;AAClB,kBAAU,MAAM;AAAA;AAAA;AAGpB,cAAU,4BAAW;AACrB,UAAM,CAAE,QAAQ,IAAI,SAAS,WAAY;AAGzC,UAAM,aACJ;AACF,QAAI,YAAY,WAAW;AAC3B,UAAM,gBAAgB,SAAS,gBAAgB,OAAO,KAAK,MAAM;AACjE,gBAAY,KAAK,IAAI,GAAG,2BAA2B,SAAS;AAE5D,YAAQ,IAAI,GAAG,iBAAiB,WAAW,UAAU,GAAG;AACxD,YAAQ,QACN,SAAS,QAAQ,SAAS,MAAM,SAAS,QAAQ,MAAM,MAAM,GAAG;AAElE,WAAO;AAAA;AAGT,SAAO;AAAA;;;;"}
+{"version":3,"file":"debug.js","sources":["../../src/debug.ts"],"sourcesContent":["import { TidyContext, TidyFn } from './types';\n\ntype Options = {\n  limit?: number | null;\n  output?: 'log' | 'table';\n};\n\n/**\n * Debugs items\n */\nexport function debug<T extends object>(\n  label?: string | null | undefined,\n  options?: Options | null | undefined\n): TidyFn<T> {\n  const _debug: TidyFn<T> = (items: T[], context?: TidyContext): T[] => {\n    let prefix = '[tidy.debug';\n    if (context?.groupKeys?.length) {\n      const groupKeys = context.groupKeys;\n      const groupKeyStrings = groupKeys\n        .map((keyPair: any) => keyPair.join(': '))\n        .join(', ');\n      if (groupKeyStrings.length) {\n        prefix += '|' + groupKeyStrings;\n      }\n    }\n    options = options ?? {};\n    const { limit = 10, output = 'table' } = options;\n\n    // check for sneaky group keys as last arg\n    const dashString =\n      '--------------------------------------------------------------------------------';\n    let numDashes = dashString.length;\n    const prefixedLabel = prefix + ']' + (label == null ? '' : ' ' + label);\n    numDashes = Math.max(0, numDashes - (prefixedLabel.length + 2));\n\n    console.log(`${prefixedLabel} ${dashString.substring(0, numDashes)}`);\n    console[output](\n      limit == null || limit >= items.length ? items : items.slice(0, limit)\n    );\n    return items;\n  };\n\n  return _debug;\n}\n"],"names":[],"mappings":"AAUgB,SAAA,KAAA,CACd,OACA,OACW,EAAA;AACX,EAAM,MAAA,MAAA,GAAoB,CAAC,KAAA,EAAY,OAA+B,KAAA;AAdxE,IAAA,IAAA,EAAA,CAAA;AAeI,IAAA,IAAI,MAAS,GAAA,aAAA,CAAA;AACb,IAAI,IAAA,CAAA,EAAA,GAAA,OAAA,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,OAAA,CAAS,SAAT,KAAA,IAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAoB,MAAQ,EAAA;AAC9B,MAAA,MAAM,YAAY,OAAQ,CAAA,SAAA,CAAA;AAC1B,MAAM,MAAA,eAAA,GAAkB,SACrB,CAAA,GAAA,CAAI,CAAC,OAAA,KAAiB,OAAQ,CAAA,IAAA,CAAK,IAAI,CAAC,CACxC,CAAA,IAAA,CAAK,IAAI,CAAA,CAAA;AACZ,MAAA,IAAI,gBAAgB,MAAQ,EAAA;AAC1B,QAAA,MAAA,IAAU,GAAM,GAAA,eAAA,CAAA;AAAA,OAClB;AAAA,KACF;AACA,IAAA,OAAA,GAAU,4BAAW,EAAC,CAAA;AACtB,IAAA,MAAM,EAAE,KAAA,GAAQ,EAAI,EAAA,MAAA,GAAS,SAAY,GAAA,OAAA,CAAA;AAGzC,IAAA,MAAM,UACJ,GAAA,kFAAA,CAAA;AACF,IAAA,IAAI,YAAY,UAAW,CAAA,MAAA,CAAA;AAC3B,IAAA,MAAM,gBAAgB,MAAS,GAAA,GAAA,IAAO,KAAS,IAAA,IAAA,GAAO,KAAK,GAAM,GAAA,KAAA,CAAA,CAAA;AACjE,IAAA,SAAA,GAAY,KAAK,GAAI,CAAA,CAAA,EAAG,SAAa,IAAA,aAAA,CAAc,SAAS,CAAE,CAAA,CAAA,CAAA;AAE9D,IAAQ,OAAA,CAAA,GAAA,CAAI,GAAG,aAAa,CAAA,CAAA,EAAI,WAAW,SAAU,CAAA,CAAA,EAAG,SAAS,CAAC,CAAE,CAAA,CAAA,CAAA;AACpE,IAAA,OAAA,CAAQ,MAAM,CAAA;AAAA,MACZ,KAAA,IAAS,QAAQ,KAAS,IAAA,KAAA,CAAM,SAAS,KAAQ,GAAA,KAAA,CAAM,KAAM,CAAA,CAAA,EAAG,KAAK,CAAA;AAAA,KACvE,CAAA;AACA,IAAO,OAAA,KAAA,CAAA;AAAA,GACT,CAAA;AAEA,EAAO,OAAA,MAAA,CAAA;AACT;;;;"}

package/dist/es/distinct.js

@@ -4,13 +4,13 @@ function distinct(keys) {
   const _distinct = (items) => {
     keys = singleOrArray(keys);
     if (!keys.length) {
-      const set = new Set();
+      const set = /* @__PURE__ */ new Set();
       for (const item of items) {
         set.add(item);
       }
       return Array.from(set);
     }
-    const rootMap = new Map();
+    const rootMap = /* @__PURE__ */ new Map();
     const distinctItems = [];
     const lastKey = keys[keys.length - 1];
     for (const item of items) {
@@ -27,7 +27,7 @@ function distinct(keys) {
           break;
         }
         if (!map.has(mapItemKey)) {
-          map.set(mapItemKey, new Map());
+          map.set(mapItemKey, /* @__PURE__ */ new Map());
         }
         map = map.get(mapItemKey);
       }

package/dist/es/distinct.js.map

@@ -1 +1 @@
-{"version":3,"file":"distinct.js","sources":["../../src/distinct.ts"],"sourcesContent":["import { KeyOrFn, TidyFn } from './types';\nimport { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\n\n/**\n * Removes items with duplicate values for the specified keys.\n * If no keys provided, uses strict equality.\n *\n * @param keys Keys to compute distinct across\n */\nexport function distinct<T extends object>(\n  keys?: SingleOrArray<KeyOrFn<T>> | null | undefined\n): TidyFn<T> {\n  const _distinct: TidyFn<T> = (items: T[]): T[] => {\n    keys = singleOrArray(keys);\n\n    if (!keys.length) {\n      // https://jsperf.com/unique-array-by-strict-equality\n      const set = new Set<T>();\n      for (const item of items) {\n        set.add(item);\n      }\n      return Array.from(set);\n    }\n\n    // compare keys\n    // https://jsperf.com/distinct-by-key\n    // turns out nested Maps are faster than string keys. AND they support\n    // and arbitrary value.\n    const rootMap = new Map();\n    const distinctItems: T[] = [];\n    const lastKey = keys[keys.length - 1];\n    for (const item of items) {\n      let map = rootMap;\n      let hasItem = false;\n\n      // go through each key to find out if we have it\n      for (const key of keys) {\n        const mapItemKey =\n          typeof key === 'function' ? key(item) : item[key as keyof T];\n        // last key, check if we already added it\n        if (key === lastKey) {\n          hasItem = map.has(mapItemKey);\n          if (!hasItem) {\n            distinctItems.push(item);\n            map.set(mapItemKey, true);\n          }\n          break;\n        }\n\n        // create maps all the way down\n        if (!map.has(mapItemKey)) {\n          map.set(mapItemKey, new Map());\n        }\n\n        // move to next inner map\n        map = map.get(mapItemKey);\n      }\n    }\n\n    return distinctItems;\n  };\n\n  return _distinct;\n}\n"],"names":[],"mappings":";;kBAUE;AAEA,QAAM,YAAuB,CAAC;AAC5B,WAAO,cAAc;AAErB,QAAI,CAAC,KAAK;AAER,YAAM,MAAM,IAAI;AAChB,iBAAW,QAAQ;AACjB,YAAI,IAAI;AAAA;AAEV,aAAO,MAAM,KAAK;AAAA;AAOpB,UAAM,UAAU,IAAI;AACpB,UAAM,gBAAqB;AAC3B,UAAM,UAAU,KAAK,KAAK,SAAS;AACnC,eAAW,QAAQ;AACjB,UAAI,MAAM;AACV,UAAI,UAAU;AAGd,iBAAW,OAAO;AAChB,cAAM,aACJ,OAAO,QAAQ,aAAa,IAAI,QAAQ,KAAK;AAE/C,YAAI,QAAQ;AACV,oBAAU,IAAI,IAAI;AAClB,cAAI,CAAC;AACH,0BAAc,KAAK;AACnB,gBAAI,IAAI,YAAY;AAAA;AAEtB;AAAA;AAIF,YAAI,CAAC,IAAI,IAAI;AACX,cAAI,IAAI,YAAY,IAAI;AAAA;AAI1B,cAAM,IAAI,IAAI;AAAA;AAAA;AAIlB,WAAO;AAAA;AAGT,SAAO;AAAA;;;;"}
+{"version":3,"file":"distinct.js","sources":["../../src/distinct.ts"],"sourcesContent":["import { KeyOrFn, TidyFn } from './types';\nimport { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\n\n/**\n * Removes items with duplicate values for the specified keys.\n * If no keys provided, uses strict equality.\n *\n * @param keys Keys to compute distinct across\n */\nexport function distinct<T extends object>(\n  keys?: SingleOrArray<KeyOrFn<T>> | null | undefined\n): TidyFn<T> {\n  const _distinct: TidyFn<T> = (items: T[]): T[] => {\n    keys = singleOrArray(keys);\n\n    if (!keys.length) {\n      // https://jsperf.com/unique-array-by-strict-equality\n      const set = new Set<T>();\n      for (const item of items) {\n        set.add(item);\n      }\n      return Array.from(set);\n    }\n\n    // compare keys\n    // https://jsperf.com/distinct-by-key\n    // turns out nested Maps are faster than string keys. AND they support\n    // and arbitrary value.\n    const rootMap = new Map();\n    const distinctItems: T[] = [];\n    const lastKey = keys[keys.length - 1];\n    for (const item of items) {\n      let map = rootMap;\n      let hasItem = false;\n\n      // go through each key to find out if we have it\n      for (const key of keys) {\n        const mapItemKey =\n          typeof key === 'function' ? key(item) : item[key as keyof T];\n        // last key, check if we already added it\n        if (key === lastKey) {\n          hasItem = map.has(mapItemKey);\n          if (!hasItem) {\n            distinctItems.push(item);\n            map.set(mapItemKey, true);\n          }\n          break;\n        }\n\n        // create maps all the way down\n        if (!map.has(mapItemKey)) {\n          map.set(mapItemKey, new Map());\n        }\n\n        // move to next inner map\n        map = map.get(mapItemKey);\n      }\n    }\n\n    return distinctItems;\n  };\n\n  return _distinct;\n}\n"],"names":[],"mappings":";;AASO,SAAS,SACd,IACW,EAAA;AACX,EAAM,MAAA,SAAA,GAAuB,CAAC,KAAoB,KAAA;AAChD,IAAA,IAAA,GAAO,cAAc,IAAI,CAAA,CAAA;AAEzB,IAAI,IAAA,CAAC,KAAK,MAAQ,EAAA;AAEhB,MAAM,MAAA,GAAA,uBAAU,GAAO,EAAA,CAAA;AACvB,MAAA,KAAA,MAAW,QAAQ,KAAO,EAAA;AACxB,QAAA,GAAA,CAAI,IAAI,IAAI,CAAA,CAAA;AAAA,OACd;AACA,MAAO,OAAA,KAAA,CAAM,KAAK,GAAG,CAAA,CAAA;AAAA,KACvB;AAMA,IAAM,MAAA,OAAA,uBAAc,GAAI,EAAA,CAAA;AACxB,IAAA,MAAM,gBAAqB,EAAC,CAAA;AAC5B,IAAA,MAAM,OAAU,GAAA,IAAA,CAAK,IAAK,CAAA,MAAA,GAAS,CAAC,CAAA,CAAA;AACpC,IAAA,KAAA,MAAW,QAAQ,KAAO,EAAA;AACxB,MAAA,IAAI,GAAM,GAAA,OAAA,CAAA;AACV,MAAA,IAAI,OAAU,GAAA,KAAA,CAAA;AAGd,MAAA,KAAA,MAAW,OAAO,IAAM,EAAA;AACtB,QAAM,MAAA,UAAA,GACJ,OAAO,GAAQ,KAAA,UAAA,GAAa,IAAI,IAAI,CAAA,GAAI,KAAK,GAAc,CAAA,CAAA;AAE7D,QAAA,IAAI,QAAQ,OAAS,EAAA;AACnB,UAAU,OAAA,GAAA,GAAA,CAAI,IAAI,UAAU,CAAA,CAAA;AAC5B,UAAA,IAAI,CAAC,OAAS,EAAA;AACZ,YAAA,aAAA,CAAc,KAAK,IAAI,CAAA,CAAA;AACvB,YAAI,GAAA,CAAA,GAAA,CAAI,YAAY,IAAI,CAAA,CAAA;AAAA,WAC1B;AACA,UAAA,MAAA;AAAA,SACF;AAGA,QAAA,IAAI,CAAC,GAAA,CAAI,GAAI,CAAA,UAAU,CAAG,EAAA;AACxB,UAAA,GAAA,CAAI,GAAI,CAAA,UAAA,kBAAgB,IAAA,GAAA,EAAK,CAAA,CAAA;AAAA,SAC/B;AAGA,QAAM,GAAA,GAAA,GAAA,CAAI,IAAI,UAAU,CAAA,CAAA;AAAA,OAC1B;AAAA,KACF;AAEA,IAAO,OAAA,aAAA,CAAA;AAAA,GACT,CAAA;AAEA,EAAO,OAAA,SAAA,CAAA;AACT;;;;"}

package/dist/es/expand.js

@@ -12,26 +12,31 @@ function expand(expandKeys) {
       } else {
         values = Array.from(new Set(items.map((d) => d[key])));
       }
-      vectors.push(values.map((value) => ({[key]: value})));
+      vectors.push(values.map((value) => ({ [key]: value })));
     }
     return makeCombinations(vectors);
   };
   return _expand;
 }
+const EXPAND_WARN_THRESHOLD = 1e5;
 function makeCombinations(vectors) {
-  function combine(accum, baseObj, remainingVectors) {
-    if (!remainingVectors.length && baseObj != null) {
-      accum.push(baseObj);
-      return;
-    }
-    const vector = remainingVectors[0];
-    const newRemainingArrays = remainingVectors.slice(1);
-    for (const item of vector) {
-      combine(accum, {...baseObj, ...item}, newRemainingArrays);
+  if (!vectors.length) return [];
+  const totalSize = vectors.reduce((acc, v) => acc * v.length, 1);
+  if (totalSize > EXPAND_WARN_THRESHOLD) {
+    console.warn(
+      `tidy expand: generating ${totalSize.toLocaleString()} combinations. This may be slow or use excessive memory.`
+    );
+  }
+  let result = [null];
+  for (const vector of vectors) {
+    const next = [];
+    for (const baseObj of result) {
+      for (const item of vector) {
+        next.push(baseObj == null ? item : { ...baseObj, ...item });
+      }
     }
+    result = next;
   }
-  const result = [];
-  combine(result, null, vectors);
   return result;
 }
 function makeKeyMap(keys) {
@@ -44,7 +49,7 @@ function makeKeyMap(keys) {
   } else if (typeof keys === "object") {
     return keys;
   }
-  return {[keys]: keys};
+  return { [keys]: keys };
 }
 
 export { expand, makeKeyMap };

package/dist/es/expand.js.map

@@ -1 +1 @@
-{"version":3,"file":"expand.js","sources":["../../src/expand.ts"],"sourcesContent":["import { A, O } from 'ts-toolbelt';\nimport { SingleOrArray } from './helpers/singleOrArray';\nimport { Key, TidyFn } from './types';\n\n// helper types\nexport type KeyMap<T extends object = any> = Partial<\n  {\n    [key in keyof T]: keyof T | Array<T[key]> | ((items: T[]) => T[key][]);\n  }\n>;\n\n/**\n * Expands a set of items to include all combinations of the specified keys.\n */\n// prettier-ignore\nexport function expand<T extends object = any, K extends keyof T = keyof T>(expandKeys: K): TidyFn<T, A.Compute<Pick<T, K>>>;\n// prettier-ignore\nexport function expand<T extends object = any, K extends (keyof T)[] = (keyof T)[]>(expandKeys: K): TidyFn<T, A.Compute<Pick<T, K[number]>>>;\n// prettier-ignore\nexport function expand<T extends object = any, K extends KeyMap<T> = KeyMap<T>>(expandKeys: K): TidyFn<T, O.Pick<T, keyof K>>\n// prettier-ignore\nexport function expand<T extends object>(expandKeys: SingleOrArray<Key> | KeyMap<T>): TidyFn<T> {\n  const _expand: TidyFn<T> = (items: T[]) => {\n    const keyMap = makeKeyMap(expandKeys);\n\n    // for each key, get all distinct values or use the provided values\n    const vectors = [];\n    for (const key in keyMap) {\n      const keyValue = keyMap[key];\n      let values;\n      if (typeof keyValue === 'function') {\n        values = keyValue(items);\n      } else if (Array.isArray(keyValue)) {\n        values = keyValue;\n      } else {\n        // read distinct values from the key in the data\n        values = Array.from(new Set(items.map((d) => d[key as keyof T])));\n      }\n\n      vectors.push(values.map((value: any) => ({ [key]: value })));\n    }\n\n    // make all combinations of all value sets\n    return makeCombinations(vectors);\n  };\n\n  return _expand;\n}\n\n/*\n  Recursively compute key combinations\n*/\nfunction makeCombinations(vectors: any[][]): any[] {\n  function combine(accum: any[], baseObj: any, remainingVectors: any[][]) {\n    if (!remainingVectors.length && baseObj != null) {\n      accum.push(baseObj);\n      return;\n    }\n\n    const vector = remainingVectors[0];\n    const newRemainingArrays = remainingVectors.slice(1);\n    for (const item of vector) {\n      combine(accum, { ...baseObj, ...item }, newRemainingArrays);\n    }\n  }\n\n  const result: any[] = [];\n  combine(result, null, vectors);\n  return result;\n}\n\n// convert by option in to a map from T key to JoinT key\nexport function makeKeyMap(keys: SingleOrArray<Key> | KeyMap): KeyMap {\n  if (Array.isArray(keys)) {\n    const keyMap: KeyMap = {};\n    for (const key of keys) {\n      keyMap[key as any] = key;\n    }\n    return keyMap;\n  } else if (typeof keys === 'object') {\n    return keys;\n  }\n\n  return { [keys]: keys as any } as KeyMap;\n}\n"],"names":[],"mappings":"gBAqByC;AACvC,QAAM,UAAqB,CAAC;AAC1B,UAAM,SAAS,WAAW;AAG1B,UAAM,UAAU;AAChB,eAAW,OAAO;AAChB,YAAM,WAAW,OAAO;AACxB,UAAI;AACJ,UAAI,OAAO,aAAa;AACtB,iBAAS,SAAS;AAAA,iBACT,MAAM,QAAQ;AACvB,iBAAS;AAAA;AAGT,iBAAS,MAAM,KAAK,IAAI,IAAI,MAAM,IAAI,CAAC,MAAM,EAAE;AAAA;AAGjD,cAAQ,KAAK,OAAO,IAAI,CAAC,aAAmB,MAAM;AAAA;AAIpD,WAAO,iBAAiB;AAAA;AAG1B,SAAO;AAAA;AAMT,0BAA0B;AACxB,mBAAiB,OAAc,SAAc;AAC3C,QAAI,CAAC,iBAAiB,UAAU,WAAW;AACzC,YAAM,KAAK;AACX;AAAA;AAGF,UAAM,SAAS,iBAAiB;AAChC,UAAM,qBAAqB,iBAAiB,MAAM;AAClD,eAAW,QAAQ;AACjB,cAAQ,OAAO,IAAK,YAAY,OAAQ;AAAA;AAAA;AAI5C,QAAM,SAAgB;AACtB,UAAQ,QAAQ,MAAM;AACtB,SAAO;AAAA;oBAIkB;AACzB,MAAI,MAAM,QAAQ;AAChB,UAAM,SAAiB;AACvB,eAAW,OAAO;AAChB,aAAO,OAAc;AAAA;AAEvB,WAAO;AAAA,aACE,OAAO,SAAS;AACzB,WAAO;AAAA;AAGT,SAAO,EAAG,OAAO;AAAA;;;;"}
+{"version":3,"file":"expand.js","sources":["../../src/expand.ts"],"sourcesContent":["import { SingleOrArray } from './helpers/singleOrArray';\nimport { Key, TidyFn } from './types';\nimport { Prettify } from './type-utils';\n\n// helper types\nexport type KeyMap<T extends object = any> = Partial<{\n  [key in keyof T]: keyof T | Array<T[key]> | ((items: T[]) => T[key][]);\n}>;\n\n/**\n * Expands a set of items to include all combinations of the specified keys.\n */\n// prettier-ignore\nexport function expand<T extends object = any, K extends keyof T = keyof T>(expandKeys: K): TidyFn<T, Prettify<Pick<T, K>>>;\n// prettier-ignore\nexport function expand<T extends object = any, K extends (keyof T)[] = (keyof T)[]>(expandKeys: K): TidyFn<T, Prettify<Pick<T, K[number]>>>;\n// prettier-ignore\nexport function expand<T extends object = any, K extends KeyMap<T> = KeyMap<T>>(expandKeys: K): TidyFn<T, Pick<T, Extract<keyof K, keyof T>>>\n// prettier-ignore\nexport function expand<T extends object>(expandKeys: SingleOrArray<Key> | KeyMap<T>): TidyFn<T> {\n  const _expand: TidyFn<T> = (items: T[]) => {\n    const keyMap = makeKeyMap(expandKeys);\n\n    // for each key, get all distinct values or use the provided values\n    const vectors = [];\n    for (const key in keyMap) {\n      const keyValue = keyMap[key];\n      let values;\n      if (typeof keyValue === 'function') {\n        values = keyValue(items);\n      } else if (Array.isArray(keyValue)) {\n        values = keyValue;\n      } else {\n        // read distinct values from the key in the data\n        values = Array.from(new Set(items.map((d) => d[key as keyof T])));\n      }\n\n      vectors.push(values.map((value: any) => ({ [key]: value })));\n    }\n\n    // make all combinations of all value sets\n    return makeCombinations(vectors);\n  };\n\n  return _expand;\n}\n\n/*\n  Recursively compute key combinations\n*/\nconst EXPAND_WARN_THRESHOLD = 100_000;\n\n/*\n  Iteratively compute key combinations (avoids recursive array slicing)\n*/\nfunction makeCombinations(vectors: any[][]): any[] {\n  if (!vectors.length) return [];\n\n  // warn if Cartesian product will be very large\n  const totalSize = vectors.reduce((acc, v) => acc * v.length, 1);\n  if (totalSize > EXPAND_WARN_THRESHOLD) {\n    console.warn(\n      `tidy expand: generating ${totalSize.toLocaleString()} combinations. ` +\n        `This may be slow or use excessive memory.`\n    );\n  }\n\n  let result: any[] = [null];\n  for (const vector of vectors) {\n    const next: any[] = [];\n    for (const baseObj of result) {\n      for (const item of vector) {\n        next.push(baseObj == null ? item : { ...baseObj, ...item });\n      }\n    }\n    result = next;\n  }\n  return result;\n}\n\n// convert by option in to a map from T key to JoinT key\nexport function makeKeyMap(keys: SingleOrArray<Key> | KeyMap): KeyMap {\n  if (Array.isArray(keys)) {\n    const keyMap: KeyMap = {};\n    for (const key of keys) {\n      keyMap[key as any] = key;\n    }\n    return keyMap;\n  } else if (typeof keys === 'object') {\n    return keys;\n  }\n\n  return { [keys]: keys as any } as KeyMap;\n}\n"],"names":[],"mappings":"AAmBO,SAAS,OAAyB,UAAuD,EAAA;AAC9F,EAAM,MAAA,OAAA,GAAqB,CAAC,KAAe,KAAA;AACzC,IAAM,MAAA,MAAA,GAAS,WAAW,UAAU,CAAA,CAAA;AAGpC,IAAA,MAAM,UAAU,EAAC,CAAA;AACjB,IAAA,KAAA,MAAW,OAAO,MAAQ,EAAA;AACxB,MAAM,MAAA,QAAA,GAAW,OAAO,GAAG,CAAA,CAAA;AAC3B,MAAI,IAAA,MAAA,CAAA;AACJ,MAAI,IAAA,OAAO,aAAa,UAAY,EAAA;AAClC,QAAA,MAAA,GAAS,SAAS,KAAK,CAAA,CAAA;AAAA,OACd,MAAA,IAAA,KAAA,CAAM,OAAQ,CAAA,QAAQ,CAAG,EAAA;AAClC,QAAS,MAAA,GAAA,QAAA,CAAA;AAAA,OACJ,MAAA;AAEL,QAAA,MAAA,GAAS,KAAM,CAAA,IAAA,CAAK,IAAI,GAAA,CAAI,KAAM,CAAA,GAAA,CAAI,CAAC,CAAA,KAAM,CAAE,CAAA,GAAc,CAAC,CAAC,CAAC,CAAA,CAAA;AAAA,OAClE;AAEA,MAAQ,OAAA,CAAA,IAAA,CAAK,MAAO,CAAA,GAAA,CAAI,CAAC,KAAA,MAAgB,EAAE,CAAC,GAAG,GAAG,KAAM,EAAA,CAAE,CAAC,CAAA,CAAA;AAAA,KAC7D;AAGA,IAAA,OAAO,iBAAiB,OAAO,CAAA,CAAA;AAAA,GACjC,CAAA;AAEA,EAAO,OAAA,OAAA,CAAA;AACT,CAAA;AAKA,MAAM,qBAAwB,GAAA,GAAA,CAAA;AAK9B,SAAS,iBAAiB,OAAyB,EAAA;AACjD,EAAA,IAAI,CAAC,OAAA,CAAQ,MAAQ,EAAA,OAAO,EAAC,CAAA;AAG7B,EAAM,MAAA,SAAA,GAAY,QAAQ,MAAO,CAAA,CAAC,KAAK,CAAM,KAAA,GAAA,GAAM,CAAE,CAAA,MAAA,EAAQ,CAAC,CAAA,CAAA;AAC9D,EAAA,IAAI,YAAY,qBAAuB,EAAA;AACrC,IAAQ,OAAA,CAAA,IAAA;AAAA,MACN,CAAA,wBAAA,EAA2B,SAAU,CAAA,cAAA,EAAgB,CAAA,wDAAA,CAAA;AAAA,KAEvD,CAAA;AAAA,GACF;AAEA,EAAI,IAAA,MAAA,GAAgB,CAAC,IAAI,CAAA,CAAA;AACzB,EAAA,KAAA,MAAW,UAAU,OAAS,EAAA;AAC5B,IAAA,MAAM,OAAc,EAAC,CAAA;AACrB,IAAA,KAAA,MAAW,WAAW,MAAQ,EAAA;AAC5B,MAAA,KAAA,MAAW,QAAQ,MAAQ,EAAA;AACzB,QAAK,IAAA,CAAA,IAAA,CAAK,WAAW,IAAO,GAAA,IAAA,GAAO,EAAE,GAAG,OAAA,EAAS,GAAG,IAAA,EAAM,CAAA,CAAA;AAAA,OAC5D;AAAA,KACF;AACA,IAAS,MAAA,GAAA,IAAA,CAAA;AAAA,GACX;AACA,EAAO,OAAA,MAAA,CAAA;AACT,CAAA;AAGO,SAAS,WAAW,IAA2C,EAAA;AACpE,EAAI,IAAA,KAAA,CAAM,OAAQ,CAAA,IAAI,CAAG,EAAA;AACvB,IAAA,MAAM,SAAiB,EAAC,CAAA;AACxB,IAAA,KAAA,MAAW,OAAO,IAAM,EAAA;AACtB,MAAA,MAAA,CAAO,GAAU,CAAI,GAAA,GAAA,CAAA;AAAA,KACvB;AACA,IAAO,OAAA,MAAA,CAAA;AAAA,GACT,MAAA,IAAW,OAAO,IAAA,KAAS,QAAU,EAAA;AACnC,IAAO,OAAA,IAAA,CAAA;AAAA,GACT;AAEA,EAAA,OAAO,EAAE,CAAC,IAAI,GAAG,IAAY,EAAA,CAAA;AAC/B;;;;"}

package/dist/es/fill.js

@@ -5,11 +5,18 @@ function fill(keys) {
     const keysArray = singleOrArray(keys);
     const replaceMap = {};
     return items.map((d) => {
-      const obj = {...d};
+      let needsCopy = false;
       for (const key of keysArray) {
-        if (obj[key] != null) {
-          replaceMap[key] = obj[key];
+        if (d[key] != null) {
+          replaceMap[key] = d[key];
         } else if (replaceMap[key] != null) {
+          needsCopy = true;
+        }
+      }
+      if (!needsCopy) return d;
+      const obj = { ...d };
+      for (const key of keysArray) {
+        if (obj[key] == null && replaceMap[key] != null) {
           obj[key] = replaceMap[key];
         }
       }

package/dist/es/fill.js.map

@@ -1 +1 @@
-{"version":3,"file":"fill.js","sources":["../../src/fill.ts"],"sourcesContent":["import { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\nimport { Key, TidyFn } from './types';\n\n/**\n * Fills values for the specified keys to match the last seen value in the collection.\n */\nexport function fill<T extends object>(keys: SingleOrArray<Key>): TidyFn<T> {\n  const _fill: TidyFn<T> = (items: T[]): T[] => {\n    const keysArray = singleOrArray(keys);\n\n    const replaceMap: Partial<T> = {};\n\n    return items.map((d) => {\n      const obj = { ...d };\n      for (const key of keysArray) {\n        if (obj[key as keyof T] != null) {\n          replaceMap[key as keyof T] = obj[key as keyof T];\n        } else if (replaceMap[key as keyof T] != null) {\n          obj[key as keyof T] = replaceMap[key as keyof T] as any;\n        }\n      }\n      return obj;\n    });\n  };\n\n  return _fill;\n}\n"],"names":[],"mappings":";;cAMuC;AACrC,QAAM,QAAmB,CAAC;AACxB,UAAM,YAAY,cAAc;AAEhC,UAAM,aAAyB;AAE/B,WAAO,MAAM,IAAI,CAAC;AAChB,YAAM,MAAM,IAAK;AACjB,iBAAW,OAAO;AAChB,YAAI,IAAI,QAAmB;AACzB,qBAAW,OAAkB,IAAI;AAAA,mBACxB,WAAW,QAAmB;AACvC,cAAI,OAAkB,WAAW;AAAA;AAAA;AAGrC,aAAO;AAAA;AAAA;AAIX,SAAO;AAAA;;;;"}
+{"version":3,"file":"fill.js","sources":["../../src/fill.ts"],"sourcesContent":["import { SingleOrArray, singleOrArray } from './helpers/singleOrArray';\nimport { Key, TidyFn } from './types';\n\n/**\n * Fills values for the specified keys to match the last seen value in the collection.\n */\nexport function fill<T extends object>(keys: SingleOrArray<Key>): TidyFn<T> {\n  const _fill: TidyFn<T> = (items: T[]): T[] => {\n    const keysArray = singleOrArray(keys);\n\n    const replaceMap: Partial<T> = {};\n\n    return items.map((d) => {\n      let needsCopy = false;\n      for (const key of keysArray) {\n        if (d[key as keyof T] != null) {\n          replaceMap[key as keyof T] = d[key as keyof T];\n        } else if (replaceMap[key as keyof T] != null) {\n          needsCopy = true;\n        }\n      }\n      if (!needsCopy) return d;\n      const obj = { ...d };\n      for (const key of keysArray) {\n        if (obj[key as keyof T] == null && replaceMap[key as keyof T] != null) {\n          obj[key as keyof T] = replaceMap[key as keyof T] as any;\n        }\n      }\n      return obj;\n    });\n  };\n\n  return _fill;\n}\n"],"names":[],"mappings":";;AAMO,SAAS,KAAuB,IAAqC,EAAA;AAC1E,EAAM,MAAA,KAAA,GAAmB,CAAC,KAAoB,KAAA;AAC5C,IAAM,MAAA,SAAA,GAAY,cAAc,IAAI,CAAA,CAAA;AAEpC,IAAA,MAAM,aAAyB,EAAC,CAAA;AAEhC,IAAO,OAAA,KAAA,CAAM,GAAI,CAAA,CAAC,CAAM,KAAA;AACtB,MAAA,IAAI,SAAY,GAAA,KAAA,CAAA;AAChB,MAAA,KAAA,MAAW,OAAO,SAAW,EAAA;AAC3B,QAAI,IAAA,CAAA,CAAE,GAAc,CAAA,IAAK,IAAM,EAAA;AAC7B,UAAW,UAAA,CAAA,GAAc,CAAI,GAAA,CAAA,CAAE,GAAc,CAAA,CAAA;AAAA,SACpC,MAAA,IAAA,UAAA,CAAW,GAAc,CAAA,IAAK,IAAM,EAAA;AAC7C,UAAY,SAAA,GAAA,IAAA,CAAA;AAAA,SACd;AAAA,OACF;AACA,MAAI,IAAA,CAAC,WAAkB,OAAA,CAAA,CAAA;AACvB,MAAM,MAAA,GAAA,GAAM,EAAE,GAAG,CAAE,EAAA,CAAA;AACnB,MAAA,KAAA,MAAW,OAAO,SAAW,EAAA;AAC3B,QAAA,IAAI,IAAI,GAAc,CAAA,IAAK,QAAQ,UAAW,CAAA,GAAc,KAAK,IAAM,EAAA;AACrE,UAAI,GAAA,CAAA,GAAc,CAAI,GAAA,UAAA,CAAW,GAAc,CAAA,CAAA;AAAA,SACjD;AAAA,OACF;AACA,MAAO,OAAA,GAAA,CAAA;AAAA,KACR,CAAA,CAAA;AAAA,GACH,CAAA;AAEA,EAAO,OAAA,KAAA,CAAA;AACT;;;;"}

package/dist/es/filter.js.map

@@ -1 +1 @@
-{"version":3,"file":"filter.js","sources":["../../src/filter.ts"],"sourcesContent":["import { TidyFn } from './types';\n\n/**\n * Filters items\n * @param filterFn Returns true to keep the item, false to filter out\n */\nexport function filter<T extends object, O extends T>(\n  filterFn: (item: T, index: number, array: T[]) => item is O\n): TidyFn<T, O>;\nexport function filter<T extends object>(\n  filterFn: (item: T, index: number, array: T[]) => boolean\n): TidyFn<T>;\nexport function filter<T extends object>(\n  filterFn: (item: T, index: number, array: T[]) => boolean\n): TidyFn<T> {\n  const _filter: TidyFn<T> = (items: T[]): T[] => items.filter(filterFn);\n  return _filter;\n}\n"],"names":[],"mappings":"gBAaE;AAEA,QAAM,UAAqB,CAAC,UAAoB,MAAM,OAAO;AAC7D,SAAO;AAAA;;;;"}
+{"version":3,"file":"filter.js","sources":["../../src/filter.ts"],"sourcesContent":["import { TidyFn } from './types';\n\n/**\n * Filters items\n * @param filterFn Returns true to keep the item, false to filter out\n */\nexport function filter<T extends object, O extends T>(\n  filterFn: (item: T, index: number, array: T[]) => item is O\n): TidyFn<T, O>;\nexport function filter<T extends object>(\n  filterFn: (item: T, index: number, array: T[]) => boolean\n): TidyFn<T>;\nexport function filter<T extends object>(\n  filterFn: (item: T, index: number, array: T[]) => boolean\n): TidyFn<T> {\n  const _filter: TidyFn<T> = (items: T[]): T[] => items.filter(filterFn);\n  return _filter;\n}\n"],"names":[],"mappings":"AAYO,SAAS,OACd,QACW,EAAA;AACX,EAAA,MAAM,OAAqB,GAAA,CAAC,KAAoB,KAAA,KAAA,CAAM,OAAO,QAAQ,CAAA,CAAA;AACrE,EAAO,OAAA,OAAA,CAAA;AACT;;;;"}

package/dist/es/fullJoin.js

@@ -1,33 +1,36 @@
-import { autodetectByMap, makeByMap, isMatch } from './innerJoin.js';
+import { autodetectByMap, makeByMap, buildJoinIndex, computeKey } from './innerJoin.js';
 
 function fullJoin(itemsToJoin, options) {
   const _fullJoin = (items) => {
-    if (!itemsToJoin.length)
-      return items;
-    if (!items.length)
-      return itemsToJoin;
+    if (!itemsToJoin.length) return items;
+    if (!items.length) return itemsToJoin;
     const byMap = (options == null ? void 0 : options.by) == null ? autodetectByMap(items, itemsToJoin) : makeByMap(options.by);
-    const matchMap = new Map();
+    const joinKeys = Object.keys(byMap);
+    const itemKeys = joinKeys.map((jKey) => byMap[jKey]);
+    const index = buildJoinIndex(itemsToJoin, joinKeys);
+    const matchedItems = /* @__PURE__ */ new Set();
     const joinObjectKeys = Object.keys(itemsToJoin[0]);
     const joined = items.flatMap((d) => {
-      const matches = itemsToJoin.filter((j) => {
-        const matched = isMatch(d, j, byMap);
-        if (matched) {
-          matchMap.set(j, true);
+      const key = computeKey(d, itemKeys);
+      const matches = index.get(key);
+      if (matches !== void 0) {
+        for (const j of matches) {
+          matchedItems.add(j);
         }
-        return matched;
-      });
-      if (matches.length) {
-        return matches.map((j) => ({...d, ...j}));
+        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 };
     });
-    if (matchMap.size < itemsToJoin.length) {
-      const leftEmptyObject = Object.fromEntries(Object.keys(items[0]).map((key) => [key, void 0]));
+    if (matchedItems.size < itemsToJoin.length) {
+      const leftEmptyObject = Object.fromEntries(
+        Object.keys(items[0]).map((key) => [key, void 0])
+      );
       for (const item of itemsToJoin) {
-        if (!matchMap.has(item)) {
-          joined.push({...leftEmptyObject, ...item});
+        if (!matchedItems.has(item)) {
+          joined.push({ ...leftEmptyObject, ...item });
         }
       }
     }

package/dist/es/fullJoin.js.map

@@ -1 +1 @@
-{"version":3,"file":"fullJoin.js","sources":["../../src/fullJoin.ts"],"sourcesContent":["import { Datum, TidyFn } from './types';\nimport { isMatch, makeByMap, autodetectByMap, JoinOptions } from './innerJoin';\nimport { O } from 'ts-toolbelt';\n\n/**\n * Performs a full join on two collections\n * @param itemsToJoin The rows/items to be appended to end of collection\n */\nexport function fullJoin<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 _fullJoin: 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    if (!items.length) return itemsToJoin 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    // keep track of what has been matched\n    const matchMap = new Map();\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) => {\n        const matched = isMatch(d, j, byMap);\n        if (matched) {\n          matchMap.set(j, true);\n        }\n        return matched;\n      });\n\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    // add in the ones we missed\n    if (matchMap.size < itemsToJoin.length) {\n      const leftEmptyObject = Object.fromEntries(\n        Object.keys(items[0]).map((key) => [key, undefined])\n      );\n      for (const item of itemsToJoin) {\n        if (!matchMap.has(item)) {\n          joined.push({ ...leftEmptyObject, ...item });\n        }\n      }\n    }\n\n    return joined;\n  };\n  return _fullJoin;\n}\n"],"names":[],"mappings":";;kBASE,aACA;AAEA,QAAM,YAAmD,CACvD;AAEA,QAAI,CAAC,YAAY;AAAQ,aAAO;AAChC,QAAI,CAAC,MAAM;AAAQ,aAAO;AAG1B,UAAM,QACJ,oCAAS,OAAM,OACX,gBAAgB,OAAO,eACvB,UAAU,QAAQ;AAGxB,UAAM,WAAW,IAAI;AAIrB,UAAM,iBAAiB,OAAO,KAAK,YAAY;AAE/C,UAAM,SAAS,MAAM,QAAQ,CAAC;AAC5B,YAAM,UAAU,YAAY,OAAO,CAAC;AAClC,cAAM,UAAU,QAAQ,GAAG,GAAG;AAC9B,YAAI;AACF,mBAAS,IAAI,GAAG;AAAA;AAElB,eAAO;AAAA;AAGT,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;AAIpB,QAAI,SAAS,OAAO,YAAY;AAC9B,YAAM,kBAAkB,OAAO,YAC7B,OAAO,KAAK,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK;AAE3C,iBAAW,QAAQ;AACjB,YAAI,CAAC,SAAS,IAAI;AAChB,iBAAO,KAAK,IAAK,oBAAoB;AAAA;AAAA;AAAA;AAK3C,WAAO;AAAA;AAET,SAAO;AAAA;;;;"}
+{"version":3,"file":"fullJoin.js","sources":["../../src/fullJoin.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 full join on two collections\n * @param itemsToJoin The rows/items to be appended to end of collection\n */\nexport function fullJoin<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 _fullJoin: TidyFn<T, Merge<T, Partial<JoinT>>> = (\n    items: T[]\n  ): Merge<T, Partial<JoinT>>[] => {\n    if (!itemsToJoin.length) return items as any;\n    if (!items.length) return itemsToJoin 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    // keep track of matched join items by reference\n    const matchedItems = new Set<JoinT>();\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\n      if (matches !== undefined) {\n        for (const j of matches) {\n          matchedItems.add(j);\n        }\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    // add in the ones we missed\n    if (matchedItems.size < itemsToJoin.length) {\n      const leftEmptyObject = Object.fromEntries(\n        Object.keys(items[0]).map((key) => [key, undefined])\n      );\n      for (const item of itemsToJoin) {\n        if (!matchedItems.has(item)) {\n          joined.push({ ...leftEmptyObject, ...item });\n        }\n      }\n    }\n\n    return joined;\n  };\n  return _fullJoin;\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;AAChC,IAAI,IAAA,CAAC,KAAM,CAAA,MAAA,EAAe,OAAA,WAAA,CAAA;AAG1B,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;AAGlD,IAAM,MAAA,YAAA,uBAAmB,GAAW,EAAA,CAAA;AAIpC,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;AAE7B,MAAA,IAAI,YAAY,KAAW,CAAA,EAAA;AACzB,QAAA,KAAA,MAAW,KAAK,OAAS,EAAA;AACvB,UAAA,YAAA,CAAa,IAAI,CAAC,CAAA,CAAA;AAAA,SACpB;AACA,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;AAGD,IAAI,IAAA,YAAA,CAAa,IAAO,GAAA,WAAA,CAAY,MAAQ,EAAA;AAC1C,MAAA,MAAM,kBAAkB,MAAO,CAAA,WAAA;AAAA,QAC7B,MAAO,CAAA,IAAA,CAAK,KAAM,CAAA,CAAC,CAAC,CAAA,CAAE,GAAI,CAAA,CAAC,GAAQ,KAAA,CAAC,GAAK,EAAA,KAAA,CAAS,CAAC,CAAA;AAAA,OACrD,CAAA;AACA,MAAA,KAAA,MAAW,QAAQ,WAAa,EAAA;AAC9B,QAAA,IAAI,CAAC,YAAA,CAAa,GAAI,CAAA,IAAI,CAAG,EAAA;AAC3B,UAAA,MAAA,CAAO,KAAK,EAAE,GAAG,eAAiB,EAAA,GAAG,MAAM,CAAA,CAAA;AAAA,SAC7C;AAAA,OACF;AAAA,KACF;AAEA,IAAO,OAAA,MAAA,CAAA;AAAA,GACT,CAAA;AACA,EAAO,OAAA,SAAA,CAAA;AACT;;;;"}

package/dist/es/groupBy.js

@@ -12,9 +12,13 @@ function groupBy(groupKeys, fns, options) {
   } else if (arguments.length === 2 && fns != null && !Array.isArray(fns)) {
     options = fns;
   }
-  const _groupBy = (items) => {
+  const _groupBy = ((items) => {
     const grouped = makeGrouped(items, groupKeys);
-    const results = runFlow(grouped, fns, options == null ? void 0 : options.addGroupKeys);
+    const results = runFlow(
+      grouped,
+      fns,
+      options == null ? void 0 : options.addGroupKeys
+    );
     if (options == null ? void 0 : options.export) {
       switch (options.export) {
         case "grouped":
@@ -38,29 +42,33 @@ function groupBy(groupKeys, fns, options) {
     }
     const ungrouped = ungroup(results, options == null ? void 0 : options.addGroupKeys);
     return ungrouped;
-  };
+  });
   return _groupBy;
 }
-groupBy.grouped = (options) => ({...options, export: "grouped"});
-groupBy.entries = (options) => ({...options, export: "entries"});
-groupBy.entriesObject = (options) => ({...options, export: "entries-object"});
-groupBy.object = (options) => ({...options, export: "object"});
-groupBy.map = (options) => ({...options, export: "map"});
-groupBy.keys = (options) => ({...options, export: "keys"});
-groupBy.values = (options) => ({...options, export: "values"});
-groupBy.levels = (options) => ({...options, export: "levels"});
+groupBy.grouped = (options) => ({ ...options, export: "grouped" });
+groupBy.entries = (options) => ({ ...options, export: "entries" });
+groupBy.entriesObject = (options) => ({ ...options, export: "entries-object" });
+groupBy.object = (options) => ({ ...options, export: "object" });
+groupBy.map = (options) => ({ ...options, export: "map" });
+groupBy.keys = (options) => ({ ...options, export: "keys" });
+groupBy.values = (options) => ({ ...options, export: "values" });
+groupBy.levels = (options) => ({ ...options, export: "levels" });
 function runFlow(items, fns, addGroupKeys) {
   let result = items;
-  if (!(fns == null ? void 0 : fns.length))
-    return result;
+  if (!(fns == null ? void 0 : fns.length)) return result;
   for (const fn of fns) {
-    if (!fn)
-      continue;
+    if (!fn) continue;
     result = groupMap(result, (items2, keys) => {
-      const context = {groupKeys: keys};
+      const keysSnapshot = keys.slice();
+      const context = { groupKeys: keysSnapshot };
       let leafItemsMapped = fn(items2, context);
       if (addGroupKeys !== false) {
-        leafItemsMapped = leafItemsMapped.map((item) => assignGroupKeys(item, keys));
+        const filteredKeys = keysSnapshot.filter(
+          (key) => typeof key[0] !== "function" && key[0] != null
+        );
+        leafItemsMapped = leafItemsMapped.map(
+          (item) => assignGroupKeys(item, keysSnapshot, filteredKeys)
+        );
       }
       return leafItemsMapped;
     });
@@ -68,9 +76,9 @@ function runFlow(items, fns, addGroupKeys) {
   return result;
 }
 function makeGrouped(items, groupKeys) {
-  const groupKeyFns = singleOrArray(groupKeys).map((key, i) => {
+  const groupKeyFns = singleOrArray(groupKeys).map((key) => {
     const keyFn = typeof key === "function" ? key : (d) => d[key];
-    const keyCache = new Map();
+    const keyCache = /* @__PURE__ */ new Map();
     return (d) => {
       const keyValue = keyFn(d);
       const keyValueOf = isObject(keyValue) ? keyValue.valueOf() : keyValue;
@@ -90,7 +98,10 @@ function ungroup(grouped, addGroupKeys) {
   groupTraversal(grouped, items, [], identity, (root, keys, values) => {
     let valuesToAdd = values;
     if (addGroupKeys !== false) {
-      valuesToAdd = values.map((d) => assignGroupKeys(d, keys));
+      const filteredKeys = keys.filter(
+        (key) => typeof key[0] !== "function" && key[0] != null
+      );
+      valuesToAdd = values.map((d) => assignGroupKeys(d, keys, filteredKeys));
     }
     root.push(...valuesToAdd);
   });
@@ -111,23 +122,30 @@ function processFromGroupsOptions(options) {
     compositeKey = (_a = options.compositeKey) != null ? _a : defaultCompositeKey;
   }
   const groupFn = (values, keys) => {
-    return single ? mapLeaf(addGroupKeys === false ? values[0] : assignGroupKeys(values[0], keys)) : mapLeaves(values.map((d) => mapLeaf(addGroupKeys === false ? d : assignGroupKeys(d, keys))));
+    return single ? mapLeaf(
+      addGroupKeys === false ? values[0] : assignGroupKeys(values[0], keys)
+    ) : mapLeaves(
+      values.map(
+        (d) => mapLeaf(addGroupKeys === false ? d : assignGroupKeys(d, keys))
+      )
+    );
   };
   const keyFn = flat ? (keys) => compositeKey(keys.map((d) => d[1])) : (keys) => keys[keys.length - 1][1];
-  return {groupFn, keyFn};
+  return { groupFn, keyFn };
 }
 function exportLevels(grouped, options) {
-  const {groupFn, keyFn} = processFromGroupsOptions(options);
-  let {mapEntry = identity} = options;
-  const {levels = ["entries"]} = options;
+  const { groupFn, keyFn } = processFromGroupsOptions(options);
+  let { mapEntry = identity } = options;
+  const { levels = ["entries"] } = options;
   const levelSpecs = [];
   for (const levelOption of levels) {
     switch (levelOption) {
+      // entries / entries-object -----------------------------------------
       case "entries":
       case "entries-object":
       case "entries-obj":
       case "entriesObject": {
-        const levelMapEntry = (levelOption === "entries-object" || levelOption === "entries-obj" || levelOption === "entriesObject") && options.mapEntry == null ? ([key, values]) => ({key, values}) : mapEntry;
+        const levelMapEntry = (levelOption === "entries-object" || levelOption === "entries-obj" || levelOption === "entriesObject") && options.mapEntry == null ? ([key, values]) => ({ key, values }) : mapEntry;
         levelSpecs.push({
           id: "entries",
           createEmptySubgroup: () => [],
@@ -140,10 +158,11 @@ function exportLevels(grouped, options) {
         });
         break;
       }
+      // map -------------------------------------------------------------
       case "map":
         levelSpecs.push({
           id: "map",
-          createEmptySubgroup: () => new Map(),
+          createEmptySubgroup: () => /* @__PURE__ */ new Map(),
           addSubgroup: (parentGrouped, newSubgroup, key) => {
             parentGrouped.set(key, newSubgroup);
           },
@@ -152,6 +171,7 @@ function exportLevels(grouped, options) {
           }
         });
         break;
+      // object ----------------------------------------------------------
       case "object":
         levelSpecs.push({
           id: "object",
@@ -164,6 +184,7 @@ function exportLevels(grouped, options) {
           }
         });
         break;
+      // keys ------------------------------------------------------------
       case "keys":
         levelSpecs.push({
           id: "keys",
@@ -176,6 +197,7 @@ function exportLevels(grouped, options) {
           }
         });
         break;
+      // values ----------------------------------------------------------
       case "values":
         levelSpecs.push({
           id: "values",
@@ -188,6 +210,7 @@ function exportLevels(grouped, options) {
           }
         });
         break;
+      // custom ----------------------------------------------------------
       default: {
         if (typeof levelOption === "object") {
           levelSpecs.push(levelOption);
@@ -209,7 +232,12 @@ function exportLevels(grouped, options) {
   const addLeaf = (parentGrouped, keys, values, level) => {
     var _a;
     const levelSpec = (_a = levelSpecs[level]) != null ? _a : levelSpecs[levelSpecs.length - 1];
-    levelSpec.addLeaf(parentGrouped, keyFn(keys), groupFn(values, keys), level);
+    levelSpec.addLeaf(
+      parentGrouped,
+      keyFn(keys),
+      groupFn(values, keys),
+      level
+    );
   };
   const initialOutputObject = levelSpecs[0].createEmptySubgroup();
   return groupTraversal(grouped, initialOutputObject, [], addSubgroup, addLeaf);