@rokkit/data 1.0.0-next.148 → 1.0.0-next.150

package/dist/benchmark/fixtures.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Generate sales rows: { region, product, year, revenue, units, status }
+ */
+export function generateSalesData(n: any): {
+    region: string;
+    product: string;
+    year: number;
+    revenue: number;
+    units: number;
+    status: string;
+}[];
+/**
+ * Generate orders/customers pair for join benchmarks.
+ */
+export function generateJoinData(n: any): {
+    customers: {
+        id: number;
+        name: string;
+        tier: string;
+    }[];
+    orders: {
+        orderId: number;
+        customerId: number;
+        amount: number;
+        year: number;
+    }[];
+};
+export function generateAlignData(n: any): {
+    revenue: number;
+    region: string;
+    product: string;
+    year: number;
+}[];

package/dist/benchmark/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/benchmark/runner.d.ts

@@ -0,0 +1,10 @@
+export function runBenchmarks(phase?: string): {
+    phase: string;
+    timestamp: string;
+    environment: {
+        runtime: string;
+        platform: NodeJS.Platform;
+        arch: NodeJS.Architecture;
+    };
+    results: never[];
+};

package/dist/{constants.d.ts → src/constants.d.ts}

@@ -1,4 +1,4 @@
-export const pickAllowedConfig: <U extends Partial<Record<"children" | "actual_flag", any>>>(obj: "children" | "actual_flag" extends keyof U ? U : never) => "children" | "actual_flag" extends keyof U ? Pick<U, keyof U & ("children" | "actual_flag")> : never;
+export function pickAllowedConfig(obj: any): {};
 /** @type {import('./types').DataFrameConfig */
 export const defaultConfig: import("./types").DataFrameConfig;
 export namespace defaultPathOptions {
@@ -36,11 +36,10 @@ export const filterOperations: {
     '!~': (value: any, pattern: any) => boolean;
 };
 export namespace typeConverters {
-    export function string(value: any): string;
-    export function number(value: any): number;
-    export function boolean(value: any): boolean;
-    export function date(value: any): Date;
-    export { identity as mixed };
+    function string(value: any): string;
+    function number(value: any): number;
+    function boolean(value: any): boolean;
+    function date(value: any): Date;
+    function mixed(x: any): any;
 }
 export function includeAll(): boolean;
-import { identity } from 'ramda';

package/dist/{dataset.d.ts → src/dataset.d.ts}

@@ -1,12 +1,13 @@
 /**
- * Returns the default aggregator which rolls up the columns other than the group_by columns into a single object.
- *
- * @param {import('./types').Metadata} metadata - The metadata for the columns to be aggregated.
- * @param {Object} config                       - The configuration used to build the aggregator.
- *
- * @returns {Object} An object containing the default aggregator for the specified metadata and configuration.
+ * Returns the default aggregator which rolls up non-group_by columns into a children array.
  */
-export function defaultAggregator(config: Object): Object;
+export function defaultAggregator(config: any): {
+    mapper: (row: any) => {};
+    reducers: {
+        field: any;
+        formula: (x: any) => any;
+    }[];
+};
 export function dataset(data: any, options?: {}): DataSet;
 export class DataSet {
     constructor(data: any);
@@ -15,19 +16,36 @@ export class DataSet {
     set config(props: any);
     override(props: any): this;
     where(condition: any): this;
-    groupBy(...fields: any[]): this;
-    alignBy(...fields: any[]): this;
-    usingTemplate(template: any): this;
-    summarize(from: any, fields: any): this;
+    apply(callback: any): this;
+    sortBy(...fields: any[]): this;
     rename(how: any): this;
     drop(...fields: any[]): DataSet;
-    sortBy(...fields: any[]): this;
+    fillNA(value: any): this;
     remove(): this;
     update(value: any): this;
-    fillNA(value: any): this;
-    apply(callback: any): this;
+    groupBy(...fields: any[]): this;
+    alignBy(...fields: any[]): this;
+    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.
+     *
+     * Returns `{ name, type, scale, sortable, filterable, fields, formatter }` for each
+     * column, plus any user-supplied properties from `options.enhancements`.
+     *
+     * @param {Object} [options]
+     * @param {Array<Object>} [options.enhancements=[]] - Per-column overrides keyed by name.
+     * @param {string} [options.language='en-US'] - Locale for formatters.
+     * @param {string} [options.scanMode='fast'] - 'fast' or 'deep'.
+     * @returns {Array<Object>}
+     */
+    columnDefs(options?: {
+        enhancements?: Object[] | undefined;
+        language?: string | undefined;
+        scanMode?: string | undefined;
+    }): Array<Object>;
     union(other: any): DataSet;
     minus(other: any): DataSet;
     intersect(other: any): DataSet;

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

@@ -0,0 +1,79 @@
+/**
+ * Factory function for `ReactiveDataSet`.
+ *
+ * @param {any[]} [data=[]] - Initial source rows.
+ * @returns {ReactiveDataSet}
+ */
+export function reactiveDataset(data?: any[]): ReactiveDataSet;
+export class ReactiveDataSet {
+    /**
+     * @param {any[]} data - Initial source rows.
+     */
+    constructor(data?: any[]);
+    /**
+     * Reactive computed result of filter + transforms + sort.
+     * Bind to this in templates instead of calling `.select()`.
+     */
+    get rows(): any;
+    /**
+     * Reactive derived column definitions: name, type, scale (discrete|continuous),
+     * sortable, filterable, fields, formatter — merged with any `withColumns` overrides.
+     *
+     * Re-computes when source data or column enhancements change.
+     * Bind to this in templates for Table / TreeTable column specs.
+     */
+    get columns(): Object[];
+    /**
+     * Set the filter predicate. Replaces any previous filter.
+     * @param {Function|null} fn
+     */
+    where(fn: Function | null): this;
+    /**
+     * Append a row transform. Each call to `apply` adds a new stage.
+     * @param {Function} fn
+     */
+    apply(fn: Function): this;
+    /**
+     * Set sort fields. Replaces any previous sort.
+     * @param {...string} fields
+     */
+    sortBy(...fields: string[]): this;
+    /**
+     * Set per-column enhancements / overrides for the reactive `columns` property.
+     *
+     * Each entry is matched by `name` and merged into the auto-derived column def.
+     * Unknown names are appended as synthetic columns (useful for action columns).
+     *
+     * @param {Array<Object>} enhancements - e.g. [{ name: 'revenue', label: 'Revenue ($)', scale: 'continuous' }]
+     * @param {Object} [options] - Options forwarded to deriveColumnDefs (language, scanMode).
+     */
+    withColumns(enhancements: Array<Object>, options?: Object): this;
+    /** Clear the current filter. */
+    clearFilter(): this;
+    /** Clear all transforms. */
+    clearTransforms(): this;
+    /**
+     * Replace the entire source dataset.
+     * @param {any[]} rows
+     */
+    setData(rows: any[]): this;
+    /**
+     * Append a single row to the source.
+     * @param {any} row
+     */
+    push(row: any): this;
+    /**
+     * Remove rows matching the predicate from the source.
+     * @param {Function} predicate
+     */
+    remove(predicate: Function): this;
+    /**
+     * Update rows matching the predicate with patch (object or function).
+     * @param {Function} predicate
+     * @param {Object|Function} patch
+     */
+    update(predicate: Function, patch: Object | Function): this;
+    /** Return a plain snapshot of the current reactive result (non-reactive copy). */
+    snapshot(): any[];
+    #private;
+}

package/dist/{index.d.ts → src/index.d.ts}

@@ -6,5 +6,5 @@ export { dataset } from "./dataset";
 export { dataview } from "./view";
 export { parseFilters } from "./parser";
 export { innerJoin, leftJoin, rightJoin, fullJoin, crossJoin, antiJoin, semiJoin } from "./join";
-export { deriveColumns, deriveMetadata, deriveSortableColumn } from "./infer";
+export { deriveColumns, deriveMetadata, deriveSortableColumn, inferScale, addScales, deriveColumnDefs, mergeColumnEnhancements } from "./infer";
 export { filterData, filterObjectArray } from "./filter";

package/dist/{infer.d.ts → src/infer.d.ts}

@@ -78,3 +78,42 @@ 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>;
+export function inferScale(values: any): any;
+/**
+ * Adds a `scale` property to each column definition.
+ *
+ * @param {Array<Object>} columns - Column definitions (from deriveColumns / deriveMetadata).
+ * @param {any[]} data - Source rows.
+ * @returns {Array<Object>} Column definitions with `scale` added.
+ */
+export function addScales(columns: Array<Object>, data: any[]): Array<Object>;
+/**
+ * Merges user-provided enhancements into auto-derived column definitions.
+ * Enhancements are matched by `name` and merged (user values win).
+ * Enhancements for unknown column names are appended as synthetic columns.
+ *
+ * @param {Array<Object>} derived - Auto-derived column definitions.
+ * @param {Array<Object>} enhancements - User-provided overrides/additions.
+ * @returns {Array<Object>} Merged column definitions.
+ */
+export function mergeColumnEnhancements(derived: Array<Object>, enhancements: Array<Object>): Array<Object>;
+/**
+ * Full column definition pipeline: derive → format → scale → merge enhancements.
+ *
+ * Produces column descriptors suitable for use in Table, TreeTable, and chart
+ * components. Each column gets: name, type, scale, sortable, filterable, fields,
+ * formatter — plus any user-supplied properties from `enhancements`.
+ *
+ * @param {any[]} data - Source rows.
+ * @param {Object} [options] - Options forwarded to deriveColumns / addFormatters.
+ * @param {Array<Object>} [options.enhancements=[]] - Per-column overrides keyed by name.
+ *        Use to override scale, add a label, attach a custom formatter, etc.
+ * @param {string} [options.language='en-US'] - Locale for formatters.
+ * @param {string} [options.scanMode='fast'] - 'fast' (first row) or 'deep' (all rows).
+ * @returns {Array<Object>} Column definitions with scale and formatters.
+ */
+export function deriveColumnDefs(data: any[], options?: {
+    enhancements?: Object[] | undefined;
+    language?: string | undefined;
+    scanMode?: string | undefined;
+}): Array<Object>;

package/dist/{model.d.ts → src/model.d.ts}

@@ -9,7 +9,7 @@ export function model(): {
      * Renames the reference names using a renamer
      * @param {Function} rename - the renamer function
      */
-    renameUsing: (rename?: Function) => /*elided*/ any;
+    renameUsing: (rename: Function) => /*elided*/ any;
     /**
      * Analyzes the input data and derives a model from it
      *

package/dist/src/pipeline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sort an array in-place by one or more field specs.
+ * @param {any[]} data - Array to sort (mutated in place).
+ * @param {...string|Object|Array} fields - Sort field specs (same as DataSet.sortBy).
+ * @returns {any[]}
+ */
+export function sortDataByFields(data: any[], ...fields: (string | Object | any[])[]): any[];
+export function executeFused(data: any, ops: any): any;

package/dist/{rollup.d.ts → src/rollup.d.ts}

@@ -14,7 +14,7 @@ export function initialValues(summaries: any[]): Object;
  */
 export function addToSummaries(group: Object, row: Object, summaries: any[]): void;
 /**
- * Groups data by specified keys.
+ * Groups data by specified keys using a composite string key (Phase 3: replaces JSON.stringify).
  *
  * @param {Array} data - An array of data points.
  * @param {Array} groupByKeys - Keys to group the data by.
@@ -30,6 +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[];
+export function getAlignGenerator(data: any, config: any): (children: any) => any[];
 /**
  * Performs aggregation operations on grouped data.
  *
@@ -38,14 +39,3 @@ export function fillAlignedData(groupedData: Object, config: Object, fillRowsFun
  * @returns {Array} Aggregated data array with computed summary values.
  */
 export function aggregateData(dataArray: any[], summaries: any[]): any[];
-/**
- * Creates a generator that produces missing rows in a dataset based on specified columns.
- * The function determines all unique combinations of the specified columns in config.align_by
- * and returns a generator function to create the missing combinations, potentially with default
- * values for other 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;

package/package.json

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

package/src/constants.js

@@ -1,6 +1,11 @@
-import { identity, pick } from 'ramda'
-
-export const pickAllowedConfig = pick(['children', 'actual_flag'])
+const ALLOWED_CONFIG_KEYS = new Set(['children', 'actual_flag'])
+export const pickAllowedConfig = (obj) => {
+	const result = {}
+	for (const k of ALLOWED_CONFIG_KEYS) {
+		if (k in obj) result[k] = obj[k]
+	}
+	return result
+}
 
 /** @type {import('./types').DataFrameConfig */
 export const defaultConfig = {
@@ -63,7 +68,7 @@ export const typeConverters = {
 	number: (value) => Number(value),
 	boolean: (value) => value === 'true' || value === true,
 	date: (value) => new Date(value),
-	mixed: identity
+	mixed: (x) => x
 }
 
 /**