@tanstack/table-core 9.0.0-alpha.4 → 9.0.0-alpha.41

package/src/utils.ts

@@ -1,103 +1,48 @@
-import { TableOptionsResolved, TableState, Updater } from './types'
-
-export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
-export type RequiredKeys<T, K extends keyof T> = Omit<T, K> &
-  Required<Pick<T, K>>
-export type Overwrite<T, U extends { [TKey in keyof T]?: any }> = Omit<
-  T,
-  keyof U
-> &
-  U
-
-export type UnionToIntersection<T> = (
-  T extends any ? (x: T) => any : never
-) extends (x: infer R) => any
-  ? R
-  : never
-
-export type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N
-export type IsKnown<T, Y, N> = unknown extends T ? N : Y
-
-type ComputeRange<
-  N extends number,
-  Result extends Array<unknown> = [],
-> = Result['length'] extends N
-  ? Result
-  : ComputeRange<N, [...Result, Result['length']]>
-type Index40 = ComputeRange<40>[number]
-
-// Is this type a tuple?
-type IsTuple<T> = T extends readonly any[] & { length: infer Length }
-  ? Length extends Index40
-    ? T
-    : never
-  : never
-
-// If this type is a tuple, what indices are allowed?
-type AllowedIndexes<
-  Tuple extends ReadonlyArray<any>,
-  Keys extends number = never,
-> = Tuple extends readonly []
-  ? Keys
-  : Tuple extends readonly [infer _, ...infer Tail]
-    ? AllowedIndexes<Tail, Keys | Tail['length']>
-    : Keys
-
-export type DeepKeys<T, TDepth extends any[] = []> = TDepth['length'] extends 5
-  ? never
-  : unknown extends T
-    ? string
-    : T extends readonly any[] & IsTuple<T>
-      ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>, TDepth>
-      : T extends any[]
-        ? DeepKeys<T[number], [...TDepth, any]>
-        : T extends Date
-          ? never
-          : T extends object
-            ? (keyof T & string) | DeepKeysPrefix<T, keyof T, TDepth>
-            : never
-
-type DeepKeysPrefix<
-  T,
-  TPrefix,
-  TDepth extends any[],
-> = TPrefix extends keyof T & (number | string)
-  ? `${TPrefix}.${DeepKeys<T[TPrefix], [...TDepth, any]> & string}`
-  : never
-
-export type DeepValue<T, TProp> = T extends Record<string | number, any>
-  ? TProp extends `${infer TBranch}.${infer TDeepProp}`
-    ? DeepValue<T[TBranch], TDeepProp>
-    : T[TProp & string]
-  : never
-
-export type NoInfer<T> = [T][T extends any ? 0 : never]
-
-export type Getter<TValue> = <TTValue = TValue>() => NoInfer<TTValue>
-
-///
+import type { Table, Table_Internal } from './types/Table'
+import type { NoInfer, RowData, Updater } from './types/type-utils'
+import type { TableFeatures } from './types/TableFeatures'
+import type { TableState, TableState_All } from './types/TableState'
 
 export function functionalUpdate<T>(updater: Updater<T>, input: T): T {
   return typeof updater === 'function'
-    ? (updater as (input: T) => T)(input)
+    ? (updater as (i: T) => T)(input)
     : updater
 }
 
-export function noop() {
-  //
+export function cloneState<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return value.map(cloneState) as T
+  }
+
+  if (value && typeof value === 'object') {
+    const proto = Object.getPrototypeOf(value)
+
+    if (proto !== Object.prototype && proto !== null) {
+      return value
+    }
+
+    const copy: Record<string, unknown> = {}
+
+    for (const key of Object.keys(value)) {
+      copy[key] = cloneState((value as Record<string, unknown>)[key])
+    }
+
+    return copy as T
+  }
+
+  return value
 }
 
-export function makeStateUpdater<K extends keyof TableState>(
-  key: K,
-  instance: unknown
-) {
-  return (updater: Updater<TableState[K]>) => {
-    ;(instance as any).setState(<TTableState>(old: TTableState) => {
-      return {
-        ...old,
-        [key]: functionalUpdate(updater, (old as any)[key]),
-      }
-    })
+export function noop() {}
+
+export function makeStateUpdater<
+  TFeatures extends TableFeatures,
+  K extends (string & {}) | keyof TableState_All | keyof TableState<TFeatures>,
+>(key: K, instance: Table<TFeatures, any>) {
+  return (updater: Updater<TableState<any>[K & keyof TableState<any>]>) => {
+    const externalAtom = (instance.options as any).atoms?.[key]
+    const targetAtom = externalAtom ?? (instance.baseAtoms as any)[key]
+    targetAtom.set((old: any) => functionalUpdate(updater, old))
   }
 }
 
@@ -107,21 +52,21 @@ export function isFunction<T extends AnyFunction>(d: any): d is T {
   return d instanceof Function
 }
 
-export function isNumberArray(d: any): d is number[] {
-  return Array.isArray(d) && d.every(val => typeof val === 'number')
+export function isNumberArray(d: any): d is Array<number> {
+  return Array.isArray(d) && d.every((val) => typeof val === 'number')
 }
 
 export function flattenBy<TNode>(
-  arr: TNode[],
-  getChildren: (item: TNode) => TNode[]
+  arr: Array<TNode>,
+  getChildren: (item: TNode) => Array<TNode>,
 ) {
-  const flat: TNode[] = []
+  const flat: Array<TNode> = []
 
-  const recurse = (subArr: TNode[]) => {
-    subArr.forEach(item => {
+  const recurse = (subArr: Array<TNode>) => {
+    subArr.forEach((item) => {
       flat.push(item)
       const children = getChildren(item)
-      if (children?.length) {
+      if (children.length) {
         recurse(children)
       }
     })
@@ -132,27 +77,53 @@ export function flattenBy<TNode>(
   return flat
 }
 
-export function memo<TDeps extends readonly any[], TDepArgs, TResult>(
-  getDeps: (depArgs?: TDepArgs) => [...TDeps],
-  fn: (...args: NoInfer<[...TDeps]>) => TResult,
-  opts: {
-    key: any
-    debug?: () => any
-    onChange?: (result: TResult) => void
-  }
-): (depArgs?: TDepArgs) => TResult {
-  let deps: any[] = []
-  let result: TResult | undefined
+export const $internalMemoFnMeta = Symbol('memoFnMeta')
+export type MemoFnMeta = { originalArgsLength?: number }
 
-  return depArgs => {
-    let depTime: number
-    if (opts.key && opts.debug) depTime = Date.now()
+/**
+ * @internal
+ */
+function setMemoFnMeta(fn: Function, meta: MemoFnMeta) {
+  Object.defineProperty(fn, $internalMemoFnMeta, { value: meta })
+}
 
-    const newDeps = getDeps(depArgs)
+/**
+ * @internal
+ */
+export function getMemoFnMeta(fn: any): MemoFnMeta | null {
+  return (typeof fn === 'function' && fn[$internalMemoFnMeta]) ?? null
+}
 
+interface MemoOptions<TDeps extends ReadonlyArray<any>, TDepArgs, TResult> {
+  fn: (...args: NoInfer<TDeps>) => TResult
+  memoDeps?: (depArgs?: TDepArgs) => [...TDeps] | undefined
+  onAfterCompare?: (depsChanged: boolean) => void
+  onAfterUpdate?: (result: TResult) => void
+  onBeforeCompare?: () => void
+  onBeforeUpdate?: () => void
+}
+
+export const memo = <TDeps extends ReadonlyArray<any>, TDepArgs, TResult>({
+  fn,
+  memoDeps,
+  onAfterCompare,
+  onAfterUpdate,
+  onBeforeCompare,
+  onBeforeUpdate,
+}: MemoOptions<TDeps, TDepArgs, TResult>): ((
+  depArgs?: TDepArgs,
+) => TResult) => {
+  let deps: Array<any> | undefined = []
+  let result: TResult | undefined
+
+  const memoizedFn = (depArgs?: TDepArgs): TResult => {
+    onBeforeCompare?.()
+    const newDeps = memoDeps?.(depArgs)
     const depsChanged =
-      newDeps.length !== deps.length ||
-      newDeps.some((dep: any, index: number) => deps[index] !== dep)
+      !newDeps ||
+      newDeps.length !== deps?.length ||
+      newDeps.some((dep: any, index: number) => deps?.[index] !== dep)
+    onAfterCompare?.(depsChanged)
 
     if (!depsChanged) {
       return result!
@@ -160,59 +131,288 @@ export function memo<TDeps extends readonly any[], TDepArgs, TResult>(
 
     deps = newDeps
 
-    let resultTime: number
-    if (opts.key && opts.debug) resultTime = Date.now()
+    onBeforeUpdate?.()
+    result = fn(...(newDeps ?? ([] as any)))
+    onAfterUpdate?.(result)
+
+    return result
+  }
+
+  setMemoFnMeta(memoizedFn, { originalArgsLength: fn.length })
 
-    result = fn(...newDeps)
-    opts?.onChange?.(result)
+  return memoizedFn
+}
 
-    if (opts.key && opts.debug) {
-      if (opts?.debug()) {
-        const depEndTime = Math.round((Date.now() - depTime!) * 100) / 100
-        const resultEndTime = Math.round((Date.now() - resultTime!) * 100) / 100
-        const resultFpsPercentage = resultEndTime / 16
+interface TableMemoOptions<
+  TFeatures extends TableFeatures,
+  TDeps extends ReadonlyArray<any>,
+  TDepArgs,
+  TResult,
+> extends MemoOptions<TDeps, TDepArgs, TResult> {
+  feature?: keyof TFeatures & string
+  fnName: string
+  objectId?: string
+  onAfterUpdate?: () => void
+  table: Table_Internal<TFeatures, any>
+}
 
-        const pad = (str: number | string, num: number) => {
-          str = String(str)
-          while (str.length < num) {
-            str = ' ' + str
-          }
-          return str
+const pad = (str: number | string, num: number) => {
+  str = String(str)
+  while (str.length < num) {
+    str = ' ' + str
+  }
+  return str
+}
+
+export function tableMemo<
+  TFeatures extends TableFeatures,
+  TDeps extends ReadonlyArray<any>,
+  TDepArgs,
+  TResult,
+>({
+  feature,
+  fnName,
+  objectId,
+  onAfterUpdate,
+  table,
+  ...memoOptions
+}: TableMemoOptions<TFeatures, TDeps, TDepArgs, TResult>) {
+  let beforeCompareTime: number
+  let afterCompareTime: number
+  let startCalcTime: number
+  let endCalcTime: number
+  let runCount = 0
+  let debug: boolean | undefined
+  let debugCache: boolean | undefined
+
+  if (process.env.NODE_ENV === 'development') {
+    const { debugCache: _debugCache, debugAll } = table.options
+    debugCache = _debugCache
+    const { parentName } = getFunctionNameInfo(fnName, '.')
+
+    const debugByParent =
+      // @ts-expect-error
+      table.options[
+        `debug${(parentName != 'table' ? parentName + 's' : parentName).replace(
+          parentName,
+          parentName.charAt(0).toUpperCase() + parentName.slice(1),
+        )}`
+      ]
+    const debugByFeature = feature
+      ? // @ts-expect-error
+        table.options[
+          `debug${feature.charAt(0).toUpperCase() + feature.slice(1)}`
+        ]
+      : false
+
+    debug = debugAll || debugByParent || debugByFeature
+  }
+
+  function logTime(time: number, depsChanged: boolean) {
+    const runType =
+      runCount === 0
+        ? '(1st run)'
+        : depsChanged
+          ? '(rerun #' + runCount + ')'
+          : '(cache)'
+    runCount++
+
+    console.groupCollapsed(
+      `%c⏱ ${pad(`${time.toFixed(1)} ms`, 12)} %c${runType}%c ${fnName}%c ${objectId ? `(${fnName.split('.')[0]}Id: ${objectId})` : ''}`,
+      `font-size: .6rem; font-weight: bold; ${
+        depsChanged
+          ? `color: hsl(
+        ${Math.max(0, Math.min(120 - Math.log10(time) * 60, 120))}deg 100% 31%);`
+          : ''
+      } `,
+      `color: ${runCount < 2 ? '#FF00FF' : '#FF1493'}`,
+      'color: #666',
+      'color: #87CEEB',
+    )
+    console.info({
+      feature,
+      state: table.store.state,
+      deps: memoOptions.memoDeps?.toString(),
+    })
+    console.trace()
+    console.groupEnd()
+  }
+
+  const debugOptions =
+    process.env.NODE_ENV === 'development'
+      ? {
+          onBeforeCompare: () => {
+            if (debugCache) {
+              beforeCompareTime = performance.now()
+            }
+          },
+          onAfterCompare: (depsChanged: boolean) => {
+            if (debugCache) {
+              afterCompareTime = performance.now()
+              const compareTime =
+                Math.round((afterCompareTime - beforeCompareTime) * 100) / 100
+              if (!depsChanged) {
+                logTime(compareTime, depsChanged)
+              }
+            }
+          },
+          onBeforeUpdate: () => {
+            if (debug) {
+              startCalcTime = performance.now()
+            }
+          },
+          onAfterUpdate: () => {
+            if (debug) {
+              endCalcTime = performance.now()
+              const executionTime =
+                Math.round((endCalcTime - startCalcTime) * 100) / 100
+              logTime(executionTime, true)
+            }
+            queueMicrotask(() => onAfterUpdate?.())
+          },
+        }
+      : {
+          onAfterUpdate: () => {
+            queueMicrotask(() => onAfterUpdate?.())
+          },
         }
 
-        console.info(
-          `%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`,
-          `
-            font-size: .6rem;
-            font-weight: bold;
-            color: hsl(${Math.max(
-              0,
-              Math.min(120 - 120 * resultFpsPercentage, 120)
-            )}deg 100% 31%);`,
-          opts?.key
-        )
+  return memo({
+    ...memoOptions,
+    ...debugOptions,
+  })
+}
+
+export interface API<TDeps extends ReadonlyArray<any>, TDepArgs> {
+  fn: (...args: any) => any
+  memoDeps?: (depArgs?: any) => [...any] | undefined
+}
+
+export type APIObject<TDeps extends ReadonlyArray<any>, TDepArgs> = Record<
+  string,
+  API<TDeps, TDepArgs>
+>
+
+/**
+ * Assumes that a function name is in the format of `parentName_fnKey` and returns the `fnKey` and `fnName` in the format of `parentName.fnKey`.
+ */
+export function getFunctionNameInfo(
+  staticFnName: string,
+  splitBy: '_' | '.' = '_',
+) {
+  const [parentName, fnKey] = staticFnName.split(splitBy)
+  const fnName = `${parentName}.${fnKey}`
+  return { fnKey, fnName, parentName } as {
+    fnKey: string
+    fnName: string
+    parentName: string
+  }
+}
+
+/**
+ * Assigns Table API methods directly to the table instance.
+ * Unlike row/cell/column/header, the table is a singleton so methods are assigned directly.
+ */
+export function assignTableAPIs<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TDeps extends ReadonlyArray<any>,
+  TDepArgs,
+>(
+  feature: keyof TFeatures & string,
+  table: Table_Internal<TFeatures, TData>,
+  apis: APIObject<TDeps, NoInfer<TDepArgs>>,
+): void {
+  for (const [staticFnName, { fn, memoDeps }] of Object.entries(apis)) {
+    const { fnKey, fnName } = getFunctionNameInfo(staticFnName)
+
+    ;(table as Record<string, any>)[fnKey] = memoDeps
+      ? tableMemo({
+          memoDeps,
+          fn,
+          fnName,
+          table,
+          feature,
+        })
+      : fn
+  }
+}
+
+export interface PrototypeAPI<TDeps extends ReadonlyArray<any>, TDepArgs> {
+  fn: (self: any, ...args: any) => any
+  memoDeps?: (self: any, depArgs?: any) => [...any] | undefined
+}
+
+export type PrototypeAPIObject<
+  TDeps extends ReadonlyArray<any>,
+  TDepArgs,
+> = Record<string, PrototypeAPI<TDeps, TDepArgs>>
+
+/**
+ * Assigns API methods to a prototype object for memory-efficient method sharing.
+ * All instances created with this prototype will share the same method references.
+ *
+ * For memoized methods, the memo state is lazily created and stored on each instance.
+ * This provides the best of both worlds: shared method code + per-instance caching.
+ */
+export function assignPrototypeAPIs<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TDeps extends ReadonlyArray<any>,
+  TDepArgs,
+>(
+  feature: keyof TFeatures & string,
+  prototype: Record<string, any>,
+  table: Table_Internal<TFeatures, TData>,
+  apis: PrototypeAPIObject<TDeps, NoInfer<TDepArgs>>,
+): void {
+  for (const [staticFnName, { fn, memoDeps }] of Object.entries(apis)) {
+    const { fnKey, fnName } = getFunctionNameInfo(staticFnName)
+
+    if (memoDeps) {
+      // For memoized methods, create a function that lazily initializes
+      // the memo on first access and stores it on the instance
+      const memoKey = `_memo_${fnKey}`
+
+      prototype[fnKey] = function (this: any, ...args: Array<any>) {
+        // Lazily create memo on first access for this instance
+        if (!this[memoKey]) {
+          const self = this
+          this[memoKey] = tableMemo({
+            memoDeps: (depArgs) => memoDeps(self, depArgs),
+            fn: (...deps) => fn(self, ...deps),
+            fnName,
+            objectId: self.id,
+            table,
+            feature,
+          })
+        }
+        return this[memoKey](...args)
+      }
+    } else {
+      // Non-memoized methods just call the static function with `this`
+      prototype[fnKey] = function (this: any, ...args: Array<any>) {
+        return fn(this, ...args)
       }
     }
 
-    return result!
+    setMemoFnMeta(prototype[fnKey], { originalArgsLength: fn.length })
   }
 }
 
-export function getMemoOptions(
-  tableOptions: Partial<TableOptionsResolved<any>>,
-  debugLevel:
-    | 'debugAll'
-    | 'debugCells'
-    | 'debugTable'
-    | 'debugColumns'
-    | 'debugRows'
-    | 'debugHeaders',
-  key: string,
-  onChange?: (result: any) => void
-) {
-  return {
-    debug: () => tableOptions?.debugAll ?? tableOptions[debugLevel],
-    key: process.env.NODE_ENV === 'development' && key,
-    onChange,
-  }
+/**
+ * Looks to run the memoized function with the builder pattern on the object if it exists, otherwise fallback to the static method passed in.
+ */
+export function callMemoOrStaticFn<
+  TObject extends Record<string, any>,
+  TStaticFn extends AnyFunction,
+>(
+  obj: TObject,
+  fnKey: string,
+  staticFn: TStaticFn,
+  ...args: Parameters<TStaticFn> extends [any, ...infer Rest] ? Rest : never
+): ReturnType<TStaticFn> {
+  return (
+    (obj[fnKey] as Function | undefined)?.(...args) ?? staticFn(obj, ...args)
+  )
 }

package/dist/cjs/aggregationFns.cjs

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const utils = require("./utils.cjs");
-const sum = (columnId, _leafRows, childRows) => {
-  return childRows.reduce((sum2, next) => {
-    const nextValue = next.getValue(columnId);
-    return sum2 + (typeof nextValue === "number" ? nextValue : 0);
-  }, 0);
-};
-const min = (columnId, _leafRows, childRows) => {
-  let min2;
-  childRows.forEach((row) => {
-    const value = row.getValue(columnId);
-    if (value != null && (min2 > value || min2 === void 0 && value >= value)) {
-      min2 = value;
-    }
-  });
-  return min2;
-};
-const max = (columnId, _leafRows, childRows) => {
-  let max2;
-  childRows.forEach((row) => {
-    const value = row.getValue(columnId);
-    if (value != null && (max2 < value || max2 === void 0 && value >= value)) {
-      max2 = value;
-    }
-  });
-  return max2;
-};
-const extent = (columnId, _leafRows, childRows) => {
-  let min2;
-  let max2;
-  childRows.forEach((row) => {
-    const value = row.getValue(columnId);
-    if (value != null) {
-      if (min2 === void 0) {
-        if (value >= value)
-          min2 = max2 = value;
-      } else {
-        if (min2 > value)
-          min2 = value;
-        if (max2 < value)
-          max2 = value;
-      }
-    }
-  });
-  return [min2, max2];
-};
-const mean = (columnId, leafRows) => {
-  let count2 = 0;
-  let sum2 = 0;
-  leafRows.forEach((row) => {
-    let value = row.getValue(columnId);
-    if (value != null && (value = +value) >= value) {
-      ++count2, sum2 += value;
-    }
-  });
-  if (count2)
-    return sum2 / count2;
-  return;
-};
-const median = (columnId, leafRows) => {
-  if (!leafRows.length) {
-    return;
-  }
-  const values = leafRows.map((row) => row.getValue(columnId));
-  if (!utils.isNumberArray(values)) {
-    return;
-  }
-  if (values.length === 1) {
-    return values[0];
-  }
-  const mid = Math.floor(values.length / 2);
-  const nums = values.sort((a, b) => a - b);
-  return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
-};
-const unique = (columnId, leafRows) => {
-  return Array.from(new Set(leafRows.map((d) => d.getValue(columnId))).values());
-};
-const uniqueCount = (columnId, leafRows) => {
-  return new Set(leafRows.map((d) => d.getValue(columnId))).size;
-};
-const count = (_columnId, leafRows) => {
-  return leafRows.length;
-};
-const aggregationFns = {
-  sum,
-  min,
-  max,
-  extent,
-  mean,
-  median,
-  unique,
-  uniqueCount,
-  count
-};
-exports.aggregationFns = aggregationFns;
-//# sourceMappingURL=aggregationFns.cjs.map

package/dist/cjs/aggregationFns.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"aggregationFns.cjs","sources":["../../src/aggregationFns.ts"],"sourcesContent":["import { AggregationFn } from './features/ColumnGrouping'\nimport { isNumberArray } from './utils'\n\nconst sum: AggregationFn<any> = (columnId, _leafRows, childRows) => {\n  // It's faster to just add the aggregations together instead of\n  // process leaf nodes individually\n  return childRows.reduce((sum, next) => {\n    const nextValue = next.getValue(columnId)\n    return sum + (typeof nextValue === 'number' ? nextValue : 0)\n  }, 0)\n}\n\nconst min: AggregationFn<any> = (columnId, _leafRows, childRows) => {\n  let min: number | undefined\n\n  childRows.forEach(row => {\n    const value = row.getValue<number>(columnId)\n\n    if (\n      value != null &&\n      (min! > value || (min === undefined && value >= value))\n    ) {\n      min = value\n    }\n  })\n\n  return min\n}\n\nconst max: AggregationFn<any> = (columnId, _leafRows, childRows) => {\n  let max: number | undefined\n\n  childRows.forEach(row => {\n    const value = row.getValue<number>(columnId)\n    if (\n      value != null &&\n      (max! < value || (max === undefined && value >= value))\n    ) {\n      max = value\n    }\n  })\n\n  return max\n}\n\nconst extent: AggregationFn<any> = (columnId, _leafRows, childRows) => {\n  let min: number | undefined\n  let max: number | undefined\n\n  childRows.forEach(row => {\n    const value = row.getValue<number>(columnId)\n    if (value != null) {\n      if (min === undefined) {\n        if (value >= value) min = max = value\n      } else {\n        if (min > value) min = value\n        if (max! < value) max = value\n      }\n    }\n  })\n\n  return [min, max]\n}\n\nconst mean: AggregationFn<any> = (columnId, leafRows) => {\n  let count = 0\n  let sum = 0\n\n  leafRows.forEach(row => {\n    let value = row.getValue<number>(columnId)\n    if (value != null && (value = +value) >= value) {\n      ++count, (sum += value)\n    }\n  })\n\n  if (count) return sum / count\n\n  return\n}\n\nconst median: AggregationFn<any> = (columnId, leafRows) => {\n  if (!leafRows.length) {\n    return\n  }\n\n  const values = leafRows.map(row => row.getValue(columnId))\n  if (!isNumberArray(values)) {\n    return\n  }\n  if (values.length === 1) {\n    return values[0]\n  }\n\n  const mid = Math.floor(values.length / 2)\n  const nums = values.sort((a, b) => a - b)\n  return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1]! + nums[mid]!) / 2\n}\n\nconst unique: AggregationFn<any> = (columnId, leafRows) => {\n  return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values())\n}\n\nconst uniqueCount: AggregationFn<any> = (columnId, leafRows) => {\n  return new Set(leafRows.map(d => d.getValue(columnId))).size\n}\n\nconst count: AggregationFn<any> = (_columnId, leafRows) => {\n  return leafRows.length\n}\n\nexport const aggregationFns = {\n  sum,\n  min,\n  max,\n  extent,\n  mean,\n  median,\n  unique,\n  uniqueCount,\n  count,\n}\n\nexport type BuiltInAggregationFn = keyof typeof aggregationFns\n"],"names":["sum","min","max","count","isNumberArray"],"mappings":";;;AAGA,MAAM,MAA0B,CAAC,UAAU,WAAW,cAAc;AAGlE,SAAO,UAAU,OAAO,CAACA,MAAK,SAAS;AAC/B,UAAA,YAAY,KAAK,SAAS,QAAQ;AACxC,WAAOA,QAAO,OAAO,cAAc,WAAW,YAAY;AAAA,KACzD,CAAC;AACN;AAEA,MAAM,MAA0B,CAAC,UAAU,WAAW,cAAc;AAC9DC,MAAAA;AAEJ,YAAU,QAAQ,CAAO,QAAA;AACjB,UAAA,QAAQ,IAAI,SAAiB,QAAQ;AAE3C,QACE,SAAS,SACRA,OAAO,SAAUA,SAAQ,UAAa,SAAS,QAChD;AACAA,aAAM;AAAA,IACR;AAAA,EAAA,CACD;AAEMA,SAAAA;AACT;AAEA,MAAM,MAA0B,CAAC,UAAU,WAAW,cAAc;AAC9DC,MAAAA;AAEJ,YAAU,QAAQ,CAAO,QAAA;AACjB,UAAA,QAAQ,IAAI,SAAiB,QAAQ;AAC3C,QACE,SAAS,SACRA,OAAO,SAAUA,SAAQ,UAAa,SAAS,QAChD;AACAA,aAAM;AAAA,IACR;AAAA,EAAA,CACD;AAEMA,SAAAA;AACT;AAEA,MAAM,SAA6B,CAAC,UAAU,WAAW,cAAc;AACjED,MAAAA;AACAC,MAAAA;AAEJ,YAAU,QAAQ,CAAO,QAAA;AACjB,UAAA,QAAQ,IAAI,SAAiB,QAAQ;AAC3C,QAAI,SAAS,MAAM;AACjB,UAAID,SAAQ,QAAW;AACrB,YAAI,SAAS;AAAOA,iBAAMC,OAAM;AAAA,MAAA,OAC3B;AACL,YAAID,OAAM;AAAOA,iBAAM;AACvB,YAAIC,OAAO;AAAOA,iBAAM;AAAA,MAC1B;AAAA,IACF;AAAA,EAAA,CACD;AAEM,SAAA,CAACD,MAAKC,IAAG;AAClB;AAEA,MAAM,OAA2B,CAAC,UAAU,aAAa;AACvD,MAAIC,SAAQ;AACZ,MAAIH,OAAM;AAEV,WAAS,QAAQ,CAAO,QAAA;AAClB,QAAA,QAAQ,IAAI,SAAiB,QAAQ;AACzC,QAAI,SAAS,SAAS,QAAQ,CAAC,UAAU,OAAO;AAC9C,QAAEG,QAAQH,QAAO;AAAA,IACnB;AAAA,EAAA,CACD;AAEGG,MAAAA;AAAO,WAAOH,OAAMG;AAExB;AACF;AAEA,MAAM,SAA6B,CAAC,UAAU,aAAa;AACrD,MAAA,CAAC,SAAS,QAAQ;AACpB;AAAA,EACF;AAEA,QAAM,SAAS,SAAS,IAAI,SAAO,IAAI,SAAS,QAAQ,CAAC;AACrD,MAAA,CAACC,MAAAA,cAAc,MAAM,GAAG;AAC1B;AAAA,EACF;AACI,MAAA,OAAO,WAAW,GAAG;AACvB,WAAO,OAAO,CAAC;AAAA,EACjB;AAEA,QAAM,MAAM,KAAK,MAAM,OAAO,SAAS,CAAC;AACxC,QAAM,OAAO,OAAO,KAAK,CAAC,GAAG,MAAM,IAAI,CAAC;AACxC,SAAO,OAAO,SAAS,MAAM,IAAI,KAAK,GAAG,KAAK,KAAK,MAAM,CAAC,IAAK,KAAK,GAAG,KAAM;AAC/E;AAEA,MAAM,SAA6B,CAAC,UAAU,aAAa;AACzD,SAAO,MAAM,KAAK,IAAI,IAAI,SAAS,IAAI,CAAA,MAAK,EAAE,SAAS,QAAQ,CAAC,CAAC,EAAE,OAAQ,CAAA;AAC7E;AAEA,MAAM,cAAkC,CAAC,UAAU,aAAa;AACvD,SAAA,IAAI,IAAI,SAAS,IAAI,CAAA,MAAK,EAAE,SAAS,QAAQ,CAAC,CAAC,EAAE;AAC1D;AAEA,MAAM,QAA4B,CAAC,WAAW,aAAa;AACzD,SAAO,SAAS;AAClB;AAEO,MAAM,iBAAiB;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;;"}