@opendata-ai/openchart-engine 6.11.0 → 6.13.0

package/src/transforms/fold.ts

@@ -0,0 +1,49 @@
+/**
+ * Fold transform: unpivots wide-format data into long format.
+ *
+ * Follows Vega-Lite fold transform conventions.
+ * For each input row, creates N new rows (one per fold field),
+ * copying all non-fold fields and adding key/value columns.
+ */
+
+import type { DataRow, FoldTransform } from '@opendata-ai/openchart-core';
+
+/**
+ * Apply a fold transform to data rows.
+ *
+ * For each input row, creates one output row per fold field. Each output
+ * row contains all fields from the original row (except the fold fields),
+ * plus a key field (the fold field name) and a value field (the fold field value).
+ *
+ * @param data - Input rows.
+ * @param transform - Fold transform definition.
+ * @returns Folded rows (N rows per input row, where N = fold fields count).
+ */
+export function runFold(data: DataRow[], transform: FoldTransform): DataRow[] {
+  const { fold } = transform;
+  const [keyAs, valueAs] = transform.as ?? ['key', 'value'];
+  const foldSet = new Set(fold);
+
+  const result: DataRow[] = [];
+
+  for (const row of data) {
+    // Copy all non-fold fields
+    const base: DataRow = {};
+    for (const [k, v] of Object.entries(row)) {
+      if (!foldSet.has(k)) {
+        base[k] = v;
+      }
+    }
+
+    // Create one row per fold field
+    for (const field of fold) {
+      result.push({
+        ...base,
+        [keyAs]: field,
+        [valueAs]: row[field],
+      });
+    }
+  }
+
+  return result;
+}

package/src/transforms/index.ts

@@ -7,15 +7,19 @@
  */
 
 import type { DataRow, Transform } from '@opendata-ai/openchart-core';
+import { runAggregate } from './aggregate';
 import { runBin } from './bin';
 import { runCalculate } from './calculate';
 import { runFilter } from './filter';
+import { runFold } from './fold';
 import { runTimeUnit } from './timeunit';
 
+export { runAggregate } from './aggregate';
 export { runBin } from './bin';
 export { runCalculate } from './calculate';
 export { isConditionalValueDef, resolveConditionalValue } from './conditional';
 export { runFilter } from './filter';
+export { runFold } from './fold';
 export { evaluatePredicate } from './predicates';
 export { runTimeUnit } from './timeunit';
 
@@ -41,6 +45,10 @@ export function runTransforms(data: DataRow[], transforms: Transform[]): DataRow
       result = runCalculate(result, transform);
     } else if ('timeUnit' in transform) {
       result = runTimeUnit(result, transform);
+    } else if ('aggregate' in transform) {
+      result = runAggregate(result, transform);
+    } else if ('fold' in transform) {
+      result = runFold(result, transform);
     }
   }