@rokkit/data 1.0.0-next.149 → 1.0.0-next.151

package/dist/benchmark/fixtures.d.ts

@@ -25,13 +25,9 @@ export function generateJoinData(n: any): {
         year: number;
     }[];
 };
-/**
- * Pre-aggregated data for alignBy benchmarks:
- * one row per (region, product, year) — some combos intentionally missing.
- */
 export function generateAlignData(n: any): {
+    revenue: number;
     region: string;
     product: string;
     year: number;
-    revenue: number;
 }[];

package/dist/src/dataset.d.ts

@@ -28,7 +28,7 @@ export class DataSet {
     usingTemplate(template: any): this;
     summarize(from: any, fields: any): this;
     rollup(): DataSet;
-    select(...cols: any[]): any[];
+    select(...cols: any[]): any;
     /**
      * Derive column definitions from the current data.
      *

package/dist/src/dataset.svelte.d.ts

@@ -14,7 +14,7 @@ export class ReactiveDataSet {
      * Reactive computed result of filter + transforms + sort.
      * Bind to this in templates instead of calling `.select()`.
      */
-    get rows(): any[];
+    get rows(): any;
     /**
      * Reactive derived column definitions: name, type, scale (discrete|continuous),
      * sortable, filterable, fields, formatter — merged with any `withColumns` overrides.

package/dist/src/infer.d.ts

@@ -78,20 +78,7 @@ export function deriveActions(columns: Array<import("./types").ColumnMetadata>,
  * @returns {Array<import('./types').ColumnMetadata>} - The derived column metadata.
  */
 export function deriveMetadata(dataArray: any, options?: Object): Array<import("./types").ColumnMetadata>;
-/**
- * Infers whether a column's values are discrete (categorical) or continuous (quantitative).
- *
- * Rules:
- *  - string, boolean           → always discrete
- *  - date, number (float)      → always continuous
- *  - integer                   → discrete when ≤20 unique values OR unique ratio < 5 %,
- *                                continuous otherwise (e.g. large ID column)
- *  - anything else             → discrete (safe default for unknown types)
- *
- * @param {any[]} values - All values for the column (may include nulls).
- * @returns {'discrete'|'continuous'}
- */
-export function inferScale(values: any[]): "discrete" | "continuous";
+export function inferScale(values: any): any;
 /**
  * Adds a `scale` property to each column definition.
  *

package/dist/src/pipeline.d.ts

@@ -5,23 +5,4 @@
  * @returns {any[]}
  */
 export function sortDataByFields(data: any[], ...fields: (string | Object | any[])[]): any[];
-/**
- * Execute a list of pipeline ops in a single fused pass over `data`.
- *
- * Ops:
- *   { type: 'filter', fn }  — keep rows where fn(row) is truthy
- *   { type: 'map',    fn }  — transform row via fn(row)
- *   { type: 'sort', fields } — sort the result by fields
- *
- * Consecutive filter/map ops are merged into one loop.
- * Sort ops are applied after the linear pass.
- *
- * @param {any[]} data
- * @param {Array<{type:string, fn?:Function, fields?:string[]}>} ops
- * @returns {any[]}
- */
-export function executeFused(data: any[], ops: Array<{
-    type: string;
-    fn?: Function;
-    fields?: string[];
-}>): any[];
+export function executeFused(data: any, ops: any): any;

package/dist/src/rollup.d.ts

@@ -30,14 +30,7 @@ export function groupDataByKeys(data: any[], groupByKeys: any[], summaries: any[
  * @returns {Array} Aligned data array.
  */
 export function fillAlignedData(groupedData: Object, config: Object, fillRowsFunc: any): any[];
-/**
- * Creates a generator that produces missing rows in a dataset based on specified columns.
- *
- * @param {Array<Object>} data - The array of objects representing the dataset.
- * @param {Object} config - The configuration object.
- * @returns {Function} A generator function that when called, produces the missing rows.
- */
-export function getAlignGenerator(data: Array<Object>, config: Object): Function;
+export function getAlignGenerator(data: any, config: any): (children: any) => any[];
 /**
  * Performs aggregation operations on grouped data.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rokkit/data",
-  "version": "1.0.0-next.149",
+  "version": "1.0.0-next.151",
   "description": "Contains generic data manipulation functions that can be used in various components.",
   "repository": {
     "type": "git",

package/src/infer.js

@@ -289,21 +289,24 @@ export function deriveMetadata(dataArray, options = {}) {
  * @param {any[]} values - All values for the column (may include nulls).
  * @returns {'discrete'|'continuous'}
  */
+function inferIntegerScale(nonNull) {
+	const unique = new Set(nonNull).size
+	return unique <= 20 || unique / nonNull.length < 0.05 ? 'discrete' : 'continuous'
+}
+
+const SCALE_BY_TYPE = {
+	string: () => 'discrete',
+	boolean: () => 'discrete',
+	date: () => 'continuous',
+	number: () => 'continuous',
+	integer: (nonNull) => inferIntegerScale(nonNull)
+}
+
 export function inferScale(values) {
 	const nonNull = values.filter((v) => v !== null && v !== undefined)
 	if (nonNull.length === 0) return 'discrete'
-
 	const type = typeOf(nonNull[0])
-
-	if (type === 'string' || type === 'boolean') return 'discrete'
-	if (type === 'date' || type === 'number') return 'continuous'
-
-	if (type === 'integer') {
-		const unique = new Set(nonNull).size
-		return unique <= 20 || unique / nonNull.length < 0.05 ? 'discrete' : 'continuous'
-	}
-
-	return 'discrete'
+	return (SCALE_BY_TYPE[type] ?? (() => 'discrete'))(nonNull)
 }
 
 /**

package/src/pipeline.js

@@ -41,6 +41,39 @@ export function sortDataByFields(data, ...fields) {
  * @param {Array<{type:string, fn?:Function, fields?:string[]}>} ops
  * @returns {any[]}
  */
+function applyOpsToRow(row, linearOps) {
+	let cur = row
+	for (const op of linearOps) {
+		if (op.type === 'filter') {
+			if (!op.fn(cur)) return null
+		} else {
+			cur = op.fn(cur)
+		}
+	}
+	return cur
+}
+
+function applyLinearOps(data, linearOps) {
+	const out = []
+	for (const row of data) {
+		const result = applyOpsToRow(row, linearOps)
+		if (result !== null) out.push(result)
+	}
+	return out
+}
+
+function collectLinearOps(ops, i) {
+	const linearOps = []
+	while (i < ops.length && ops[i].type !== 'sort') linearOps.push(ops[i++])
+	return { linearOps, i }
+}
+
+function collectSortFields(ops, i) {
+	const sortFields = []
+	while (i < ops.length && ops[i].type === 'sort') sortFields.push(...ops[i++].fields)
+	return { sortFields, i }
+}
+
 export function executeFused(data, ops) {
 	if (ops.length === 0) return data
 
@@ -48,42 +81,15 @@ export function executeFused(data, ops) {
 	let i = 0
 
 	while (i < ops.length) {
-		// Collect a run of linear (filter/map) ops
-		const linearOps = []
-		while (i < ops.length && ops[i].type !== 'sort') {
-			linearOps.push(ops[i])
-			i++
-		}
+		const linear = collectLinearOps(ops, i)
+		i = linear.i
+		if (linear.linearOps.length > 0) result = applyLinearOps(result, linear.linearOps)
 
-		if (linearOps.length > 0) {
-			const out = []
-			for (const row of result) {
-				let cur = row
-				let keep = true
-				for (const op of linearOps) {
-					if (op.type === 'filter') {
-						if (!op.fn(cur)) {
-							keep = false
-							break
-						}
-					} else {
-						cur = op.fn(cur)
-					}
-				}
-				if (keep) out.push(cur)
-			}
-			result = out
-		}
-
-		// Collect a run of sort ops and apply them as a single sort
-		const sortFields = []
-		while (i < ops.length && ops[i].type === 'sort') {
-			sortFields.push(...ops[i].fields)
-			i++
-		}
-		if (sortFields.length > 0) {
+		const sorted = collectSortFields(ops, i)
+		i = sorted.i
+		if (sorted.sortFields.length > 0) {
 			result = [...result]
-			sortDataByFields(result, ...sortFields)
+			sortDataByFields(result, ...sorted.sortFields)
 		}
 	}
 

package/src/rollup.js

@@ -77,17 +77,17 @@ export function fillAlignedData(groupedData, config, fillRowsFunc) {
  * @param {Object} config - The configuration object.
  * @returns {Function} A generator function that when called, produces the missing rows.
  */
-export function getAlignGenerator(data, config) {
+function buildAlignTemplate(config) {
 	const { align_by, group_by, actual_flag } = config
-
-	// Build template: omit align_by and group_by keys, add actual_flag=0
 	const omitKeys = new Set([...align_by, ...group_by])
 	const template = { [actual_flag]: 0 }
 	for (const [k, v] of Object.entries(config.template)) {
 		if (!omitKeys.has(k)) template[k] = v
 	}
+	return template
+}
 
-	// Collect all unique combinations of align_by fields from full dataset
+function collectAllCombos(data, align_by) {
 	const seen = new Map()
 	for (const row of data) {
 		const key = align_by.map((k) => row[k]).join('\x00')
@@ -97,19 +97,19 @@ export function getAlignGenerator(data, config) {
 			seen.set(key, combo)
 		}
 	}
-	const allCombos = [...seen.values()]
+	return [...seen.values()]
+}
+
+export function getAlignGenerator(data, config) {
+	const { align_by } = config
+	const template = buildAlignTemplate(config)
+	const allCombos = collectAllCombos(data, align_by)
 
-	// Return a function that, given a group's children, yields the missing combos
 	return (children) => {
 		const childKeys = new Set(children.map((c) => align_by.map((k) => c[k]).join('\x00')))
-		const missing = []
-		for (const combo of allCombos) {
-			const key = align_by.map((k) => combo[k]).join('\x00')
-			if (!childKeys.has(key)) {
-				missing.push({ ...combo, ...template })
-			}
-		}
-		return missing
+		return allCombos
+			.filter((combo) => !childKeys.has(align_by.map((k) => combo[k]).join('\x00')))
+			.map((combo) => ({ ...combo, ...template }))
 	}
 }