@tanstack/table-core 8.0.0-alpha.10

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@tanstack/table-core",
+  "author": "Tanner Linsley",
+  "version": "8.0.0-alpha.10",
+  "description": "Hooks for building lightweight, fast and extendable datagrids for React",
+  "license": "MIT",
+  "homepage": "https://github.com/tanstack/react-table#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tanstack/react-table.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "react",
+    "table",
+    "table-core",
+    "datagrid"
+  ],
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "module": "build/esm/index.js",
+  "main": "build/cjs/index.js",
+  "browser": "build/umd/index.production.min.js",
+  "types": "build/types/index.d.ts",
+  "engines": {
+    "node": ">=12"
+  },
+  "files": [
+    "build",
+    "src"
+  ],
+  "peerDependencies": {
+    "react": ">=16",
+    "react-dom": ">=16"
+  }
+}

package/src/aggregationTypes.ts

@@ -0,0 +1,115 @@
+export const aggregationTypes = {
+  sum,
+  min,
+  max,
+  extent,
+  mean,
+  median,
+  unique,
+  uniqueCount,
+  count,
+}
+
+export type BuiltInAggregationType = keyof typeof aggregationTypes
+
+function sum(_leafValues: unknown[], childValues: unknown[]) {
+  // It's faster to just add the aggregations together instead of
+  // process leaf nodes individually
+  return childValues.reduce(
+    (sum: number, next: unknown) => sum + (typeof next === 'number' ? next : 0),
+    0
+  )
+}
+
+function min(_leafValues: unknown[], childValues: unknown[]) {
+  let min: number | undefined
+
+  for (const value of childValues as number[]) {
+    if (
+      value != null &&
+      (min! > value || (min === undefined && value >= value))
+    ) {
+      min = value
+    }
+  }
+
+  return min
+}
+
+function max(_leafValues: unknown[], childValues: unknown[]) {
+  let max: number | undefined
+
+  for (const value of childValues as number[]) {
+    if (
+      value != null &&
+      (max! < value || (max === undefined && value >= value))
+    ) {
+      max = value
+    }
+  }
+
+  return max
+}
+
+function extent(_leafValues: unknown[], childValues: unknown[]) {
+  let min: number | undefined
+  let max: number | undefined
+
+  for (const value of childValues as number[]) {
+    if (value != null) {
+      if (min === undefined) {
+        if (value >= value) min = max = value
+      } else {
+        if (min > value) min = value
+        if (max! < value) max = value
+      }
+    }
+  }
+
+  return [min, max]
+}
+
+function mean(leafValues: unknown[]) {
+  let count = 0
+  let sum = 0
+
+  for (let value of leafValues as number[]) {
+    if (value != null && (value = +value) >= value) {
+      ++count, (sum += value)
+    }
+  }
+
+  if (count) return sum / count
+
+  return
+}
+
+function median(values: unknown[]) {
+  if (!values.length) {
+    return
+  }
+
+  let min = 0
+  let max = 0
+
+  values.forEach(value => {
+    if (typeof value === 'number') {
+      min = Math.min(min, value)
+      max = Math.max(max, value)
+    }
+  })
+
+  return (min + max) / 2
+}
+
+function unique<T>(values: T[]) {
+  return Array.from(new Set(values).values())
+}
+
+function uniqueCount(values: unknown[]) {
+  return new Set(values).size
+}
+
+function count(values: unknown[]) {
+  return values.length
+}