@tidyjs/tidy 2.4.4 → 2.5.0

package/dist/tidy.d.ts

@@ -125,7 +125,7 @@ declare function summarizeAll<T extends object, F extends SummaryKeyFn<T>>(summa
 declare function summarizeIf<T extends object, F extends SummaryKeyFn<T>>(predicateFn: (vector: Vector<T>) => boolean, summaryFn: F): TidyFn<T, A.Compute<Record<keyof T, SummaryFnOutput<T, F>>>>;
 declare function summarizeAt<T extends object, Keys extends (keyof T)[], F extends SummaryKeyFn<T, Keys[number]>>(keys: Keys, summaryFn: F): TidyFn<T, A.Compute<Record<Keys[number], SummaryFnOutput<T, F>>>>;
 
-declare type MutateSpecValue<T, O = any> = ((item: T) => O) | NonFunctionValue;
+declare type MutateSpecValue<T, O = any> = ((item: T, index: number, array: Iterable<T>) => O) | NonFunctionValue;
 declare type MutateSpec<T> = Record<Key, MutateSpecValue<T>>;
 declare type ResolvedObj<Obj extends Record<Key, MutateSpecValue<any>>> = {
     [K in keyof Obj]: Obj[K] extends (...args: any) => any ? ReturnType<Obj[K]> extends any[] ? ReturnType<Obj[K]>[number] : ReturnType<Obj[K]> : Obj[K];
@@ -1269,19 +1269,25 @@ declare type Options = {
 declare function debug<T extends object>(label?: string | null | undefined, options?: Options | null | undefined): TidyFn<T>;
 
 declare type RateOptions<T> = {
-    predicate?: (d: T) => boolean;
+    predicate?: (d: T, index: number, array: Iterable<T>) => boolean;
     allowDivideByZero?: boolean;
 };
 /**
  * Returns a function that computes a rate (numerator / denominator), setting the value to
  * 0 if denominator = 0 and numerator = 0.
  */
-declare function rate<T extends object>(numerator: keyof T | ((d: T) => number), denominator: keyof T | ((d: T) => number), options?: RateOptions<T>): (d: T) => number | undefined;
+declare function rate<T extends object>(numerator: keyof T | ((d: T, index: number, array: Iterable<T>) => number), denominator: keyof T | ((d: T, index: number, array: Iterable<T>) => number), options?: RateOptions<T>): (d: T, index: number, array: Iterable<T>) => number | undefined;
 
-declare function cumsum<T extends object>(key: keyof T | ((d: T) => number | null | undefined)): (items: T[]) => Float64Array;
+declare function cumsum<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => number | null | undefined)): (items: T[]) => Float64Array;
 
 declare type RollOptions = {
     partial?: boolean;
+    /** which direction the window is aligned to (default: right, looking back)
+     * - right: current row is the last item [1,2,**3**]
+     * - left: current row is the first item [**1**,2,3]
+     * - center: current row is the center item [1,**2**,3]
+     */
+    align?: 'left' | 'center' | 'right';
 };
 /**
  * Returns a function that computes the a rolling value (e.g. moving average) by
@@ -1304,7 +1310,7 @@ declare type LagOptions = {
  * @param key The key or accessor to lag
  * @param options Options to configure roll. e.g. whether to run on partial windows.
  */
-declare function lag<T extends object>(key: keyof T | ((d: T) => any), options?: LagOptions | undefined | null): (items: any[]) => any[];
+declare function lag<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => any), options?: LagOptions | undefined | null): (items: T[]) => any[];
 
 declare type LeadOptions = {
     /** Number of positions to lead by (default: 1) */
@@ -1318,67 +1324,82 @@ declare type LeadOptions = {
  * @param key The key or accessor to lead
  * @param options Options to configure roll. e.g. whether to run on partial windows.
  */
-declare function lead<T extends object>(key: keyof T | ((d: T) => any), options?: LeadOptions | undefined | null): (items: any[]) => any[];
+declare function lead<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => any), options?: LeadOptions | undefined | null): (items: T[]) => any[];
 
+declare type RowNumberOptions = {
+    /** what to start row numbers at, default is 0 */
+    startAt?: number;
+};
+/**
+ * Returns a vector of row numbers, starting at 0
+ */
+declare function rowNumber<T>(options?: RowNumberOptions): (items: T[]) => number[];
+
+declare type SumOptions<T> = {
+    predicate?: (d: T, index: number, array: Iterable<T>) => boolean;
+};
 /**
  * Returns a function that computes the sum over an array of items
  * @param key A string key of the object or an accessor converting the object to a number
  */
-declare function sum<T extends object>(key: keyof T | ((d: T) => number)): (items: T[]) => number;
+declare function sum<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => number), options?: SumOptions<T>): (items: T[]) => number;
 
 /**
  * Returns a function that computes the min over an array of items
  * @param key A string key of the object or an accessor converting the object to a number
  */
-declare function min<T extends object>(key: keyof T | ((d: T) => number)): (items: T[]) => number | undefined;
+declare function min<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)): (items: T[]) => number | undefined;
 
 /**
  * Returns a function that computes the max over an array of items
  * @param key A string key of the object or an accessor converting the object to a number
  */
-declare function max<T extends object>(key: keyof T | ((d: T) => number)): (items: T[]) => number | undefined;
+declare function max<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)): (items: T[]) => number | undefined;
 
 /**
  * Returns a function that computes the mean over an array of items
  * @param key A string key of the object or an accessor converting the object to a number
  */
-declare function mean<T extends object>(key: keyof T | ((d: T) => number)): (items: T[]) => number | undefined;
+declare function mean<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)): (items: T[]) => number | undefined;
 
 /**
  * Returns a function that computes the mean of a rate over an array of items
  * @param numerator A string key of the object or an accessor converting the object to a number
  * @param denominator A string key of the object or an accessor converting the object to a number
  */
-declare function meanRate<T extends object>(numerator: keyof T | ((d: T) => number), denominator: keyof T | ((d: T) => number)): (items: T[]) => number | undefined;
+declare function meanRate<T extends object>(numerator: keyof T | ((d: T, index: number, array: Iterable<T>) => number), denominator: keyof T | ((d: T, index: number, array: Iterable<T>) => number)): (items: T[]) => number | undefined;
 
 /**
  * Returns a function that computes the median over an array of items
  * @param key A string key of the object or an accessor converting the object to a number
  */
-declare function median<T extends object>(key: keyof T | ((d: T) => number)): (items: T[]) => number | undefined;
+declare function median<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)): (items: T[]) => number | undefined;
 
 /**
  * Returns a function that computes the deviation over an array of items
  * @param key A string key of the object or an accessor converting the object to a number
  */
-declare function deviation<T extends object>(key: keyof T | ((d: T) => number)): (items: T[]) => number | undefined;
+declare function deviation<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)): (items: T[]) => number | undefined;
 
 /**
  * Returns a function that computes the variance over an array of items
  * @param key A string key of the object or an accessor converting the object to a number
  */
-declare function variance<T extends object>(key: keyof T | ((d: T) => number)): (items: T[]) => number | undefined;
+declare function variance<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)): (items: T[]) => number | undefined;
 
+declare type NOptions<T> = {
+    predicate?: (d: T, index: number, array: Iterable<T>) => boolean;
+};
 /**
  * Returns a function that computes the count over an array of items
  */
-declare function n(): (items: any[]) => number;
+declare function n<T>(options?: NOptions<T>): (items: T[]) => number;
 
 /**
  * Returns a function that computes the distinct count for a key
  * over an array of items. By default it counts nulls but not undefined
  */
-declare function nDistinct<T extends object>(key: keyof T | ((d: T) => any), options?: {
+declare function nDistinct<T extends object>(key: keyof T | ((d: T, index: number, array: Iterable<T>) => any), options?: {
     includeNull?: boolean;
     includeUndefined?: boolean;
 }): (items: T[]) => number;
@@ -1387,13 +1408,13 @@ declare function nDistinct<T extends object>(key: keyof T | ((d: T) => any), opt
  * Returns a function that returns the first value for the specified key
  * @param key A string key of the object or an accessor converting the object to a number
  */
-declare function first<T extends object>(key: keyof T | ((d: T) => number)): (items: T[]) => number | undefined;
+declare function first<T extends object>(key: keyof T | ((d: T) => any)): (items: T[]) => any;
 
 /**
  * Returns a function that returns the last value for the specified key
  * @param key A string key of the object or an accessor converting the object to a number
  */
-declare function last<T extends object>(key: keyof T | ((d: T) => number)): (items: T[]) => number | undefined;
+declare function last<T extends object>(key: keyof T | ((d: T) => any)): (items: T[]) => any;
 
 /**
  * Returns all keys
@@ -1448,4 +1469,4 @@ declare namespace math {
   };
 }
 
-export { Comparator, Datum, Granularity, GroupKey, Grouped, Key, KeyOrFn, LevelSpec, NonFunctionValue, Primitive, SummarizeOptions, SummarizeSpec, math as TMath, TidyContext, TidyFn, TidyGroupExportFn, Vector, addRows as addItems, addRows, arrange, asc, complete, contains, count, cumsum, debug, desc, deviation, distinct, endsWith, everything, expand, fill, filter, first, fixedOrder, fullJoin, fullSeq, fullSeqDate, fullSeqDateISOString, groupBy, innerJoin, lag, last, lead, leftJoin, map, matches, max, mean, meanRate, median, min, mutate, mutateWithSummary, n, nDistinct, negate, numRange, select as pick, pivotLonger, pivotWider, rate, rename, replaceNully, roll, select, slice, sliceHead, sliceMax, sliceMin, sliceSample, sliceTail, arrange as sort, startsWith, sum, summarize, summarizeAll, summarizeAt, summarizeIf, tally, tidy, total, totalAll, totalAt, totalIf, transmute, variance, vectorSeq, vectorSeqDate, when };
+export { Comparator, Datum, Granularity, GroupKey, Grouped, Key, KeyOrFn, LevelSpec, NonFunctionValue, Primitive, SummarizeOptions, SummarizeSpec, math as TMath, TidyContext, TidyFn, TidyGroupExportFn, Vector, addRows as addItems, addRows, arrange, asc, complete, contains, count, cumsum, debug, desc, deviation, distinct, endsWith, everything, expand, fill, filter, first, fixedOrder, fullJoin, fullSeq, fullSeqDate, fullSeqDateISOString, groupBy, innerJoin, lag, last, lead, leftJoin, map, matches, max, mean, meanRate, median, min, mutate, mutateWithSummary, n, nDistinct, negate, numRange, select as pick, pivotLonger, pivotWider, rate, rename, replaceNully, roll, rowNumber, select, slice, sliceHead, sliceMax, sliceMin, sliceSample, sliceTail, arrange as sort, startsWith, sum, summarize, summarizeAll, summarizeAt, summarizeIf, tally, tidy, total, totalAll, totalAt, totalIf, transmute, variance, vectorSeq, vectorSeqDate, when };

package/dist/umd/tidy.js

@@ -217,15 +217,15 @@
 
   function mutate(mutateSpec) {
     const _mutate = (items) => {
-      const mutatedItems = [];
-      for (const item of items) {
-        const mutatedItem = {...item};
+      const mutatedItems = items.map((d) => ({...d}));
+      let i = 0;
+      for (const mutatedItem of mutatedItems) {
         for (const key in mutateSpec) {
           const mutateSpecValue = mutateSpec[key];
-          const mutatedResult = typeof mutateSpecValue === "function" ? mutateSpecValue(mutatedItem) : mutateSpecValue;
+          const mutatedResult = typeof mutateSpecValue === "function" ? mutateSpecValue(mutatedItem, i, mutatedItems) : mutateSpecValue;
           mutatedItem[key] = mutatedResult;
         }
-        mutatedItems.push(mutatedItem);
+        ++i;
       }
       return mutatedItems;
     };
@@ -301,6 +301,11 @@
 
   const identity = (d) => d;
 
+  function isObject(obj) {
+    const type = typeof obj;
+    return obj != null && (type === "object" || type === "function");
+  }
+
   function groupBy(groupKeys, fns, options) {
     if (typeof fns === "function") {
       fns = [fns];
@@ -368,7 +373,7 @@
       const keyCache = new Map();
       return (d) => {
         const keyValue = keyFn(d);
-        const keyValueOf = typeof keyValue === "object" ? keyValue.valueOf() : keyValue;
+        const keyValueOf = isObject(keyValue) ? keyValue.valueOf() : keyValue;
         if (keyCache.has(keyValueOf)) {
           return keyCache.get(keyValueOf);
         }
@@ -510,12 +515,21 @@
     return groupTraversal(grouped, initialOutputObject, [], addSubgroup, addLeaf);
   }
 
-  function n() {
+  function n(options) {
+    if (options == null ? void 0 : options.predicate) {
+      const predicate = options.predicate;
+      return (items) => items.reduce((n2, d, i) => predicate(d, i, items) ? n2 + 1 : n2, 0);
+    }
     return (items) => items.length;
   }
 
-  function sum(key) {
-    const keyFn = typeof key === "function" ? key : (d) => d[key];
+  function sum(key, options) {
+    let keyFn = typeof key === "function" ? key : (d) => d[key];
+    if (options == null ? void 0 : options.predicate) {
+      const originalKeyFn = keyFn;
+      const predicate = options.predicate;
+      keyFn = (d, index, array) => predicate(d, index, array) ? originalKeyFn(d, index, array) : 0;
+    }
     return (items) => d3Array.fsum(items, keyFn);
   }
 
@@ -1100,15 +1114,15 @@
     const numeratorFn = typeof numerator === "function" ? numerator : (d) => d[numerator];
     const denominatorFn = typeof denominator === "function" ? denominator : (d) => d[denominator];
     const {predicate, allowDivideByZero} = options != null ? options : {};
-    return predicate == null ? (d) => {
-      const denom = denominatorFn(d);
-      const numer = numeratorFn(d);
+    return predicate == null ? (d, index, array) => {
+      const denom = denominatorFn(d, index, array);
+      const numer = numeratorFn(d, index, array);
       return rate(numer, denom, allowDivideByZero);
-    } : (d) => {
-      if (!predicate(d))
+    } : (d, index, array) => {
+      if (!predicate(d, index, array))
         return void 0;
-      const denom = denominatorFn(d);
-      const numer = numeratorFn(d);
+      const denom = denominatorFn(d, index, array);
+      const numer = numeratorFn(d, index, array);
       return rate(numer, denom, allowDivideByZero);
     };
   }
@@ -1134,11 +1148,12 @@
   }
 
   function roll(width, rollFn, options) {
-    const {partial = false} = options != null ? options : {};
+    const {partial = false, align = "right"} = options != null ? options : {};
+    const halfWidth = Math.floor(width / 2);
     return (items) => {
       return items.map((_, i) => {
-        const endIndex = i;
-        if (!partial && endIndex - width + 1 < 0) {
+        const endIndex = align === "right" ? i : align === "center" ? i + halfWidth : i + width - 1;
+        if (!partial && (endIndex - width + 1 < 0 || endIndex >= items.length)) {
           return void 0;
         }
         const startIndex = Math.max(0, endIndex - width + 1);
@@ -1154,7 +1169,7 @@
     return (items) => {
       return items.map((_, i) => {
         const lagItem = items[i - n];
-        return lagItem == null ? defaultValue : keyFn(lagItem);
+        return lagItem == null ? defaultValue : keyFn(lagItem, i, items);
       });
     };
   }
@@ -1165,11 +1180,19 @@
     return (items) => {
       return items.map((_, i) => {
         const leadItem = items[i + n];
-        return leadItem == null ? defaultValue : keyFn(leadItem);
+        return leadItem == null ? defaultValue : keyFn(leadItem, i, items);
       });
     };
   }
 
+  function rowNumber(options) {
+    var _a;
+    const startAt = (_a = options == null ? void 0 : options.startAt) != null ? _a : 0;
+    return (items) => {
+      return items.map((_, i) => i + startAt);
+    };
+  }
+
   function min(key) {
     const keyFn = typeof key === "function" ? key : (d) => d[key];
     return (items) => d3Array.min(items, keyFn);
@@ -1215,8 +1238,9 @@
     return (items) => {
       const uniques = new Map();
       let count = 0;
+      let i = 0;
       for (const item of items) {
-        const value = keyFn(item);
+        const value = keyFn(item, i++, items);
         if (!uniques.has(value)) {
           if (!options.includeUndefined && value === void 0 || options.includeNull === false && value === null) {
             continue;
@@ -1350,6 +1374,7 @@
   exports.rename = rename;
   exports.replaceNully = replaceNully;
   exports.roll = roll;
+  exports.rowNumber = rowNumber;
   exports.select = select;
   exports.slice = slice;
   exports.sliceHead = sliceHead;