semiotic 2.0.3 → 3.0.0-beta.2

package/ai/dist/src/components/data/dataFunctions.js

@@ -0,0 +1,487 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDataExtent = void 0;
+exports.stringToFn = stringToFn;
+exports.stringToArrayFn = stringToArrayFn;
+const lineDrawing_1 = require("../geometry/lineDrawing");
+const coordinateNames_1 = require("../constants/coordinateNames");
+const lineDrawing_2 = require("../geometry/lineDrawing");
+const areaDrawing_1 = require("../geometry/areaDrawing");
+const unflowedFunctions_1 = require("./unflowedFunctions");
+const baseDefinedFunction = () => true;
+const whichPointsHashY = {
+    top: coordinateNames_1.projectedYTop,
+    bottom: coordinateNames_1.projectedYBottom,
+    orphan: coordinateNames_1.projectedY
+};
+const whichPointsHashX = {
+    top: coordinateNames_1.projectedXTop,
+    bottom: coordinateNames_1.projectedXBottom,
+    orphan: coordinateNames_1.projectedX
+};
+const builtInTransformations = {
+    stackedarea: lineDrawing_2.stackedArea,
+    "stackedarea-invert": lineDrawing_2.stackedArea,
+    stackedpercent: lineDrawing_2.stackedArea,
+    "stackedpercent-invert": lineDrawing_2.stackedArea,
+    linepercent: lineDrawing_2.stackedArea,
+    difference: lineDrawing_2.differenceLine,
+    bumparea: lineDrawing_2.bumpChart,
+    bumpline: lineDrawing_2.bumpChart,
+    "bumparea-invert": lineDrawing_2.bumpChart,
+    line: lineDrawing_2.lineChart,
+    area: lineDrawing_2.lineChart,
+    cumulative: lineDrawing_2.cumulativeLine,
+    "cumulative-reverse": lineDrawing_2.cumulativeLine
+};
+function stringToFn(accessor, defaultAccessor, raw) {
+    if (!accessor && defaultAccessor) {
+        return defaultAccessor;
+    }
+    else if (typeof accessor === "object") {
+        return () => accessor;
+    }
+    else if (accessor instanceof Function) {
+        return accessor;
+    }
+    else if (raw === true) {
+        const castAccessor = accessor;
+        return () => castAccessor;
+    }
+    else if (typeof accessor === "string") {
+        return (d) => (d ? d[accessor] : undefined);
+    }
+    return () => undefined;
+}
+function stringToArrayFn(accessor, defaultAccessor, raw) {
+    if (accessor === undefined) {
+        return [stringToFn(undefined, defaultAccessor, raw)];
+    }
+    let arrayOfAccessors = [];
+    if (Array.isArray(accessor)) {
+        arrayOfAccessors = accessor;
+    }
+    else {
+        arrayOfAccessors = [accessor];
+    }
+    return arrayOfAccessors.map((a) => stringToFn(a, defaultAccessor, raw));
+}
+function rebuildFullDatasetWithSummaries(fullDataset, projectedSummaries) {
+    const rebuilt = [];
+    for (const d of projectedSummaries) {
+        rebuilt.push({ ...d });
+    }
+    for (const d of fullDataset) {
+        if (!d.parentSummary) {
+            rebuilt.push(d);
+        }
+    }
+    return rebuilt;
+}
+const calculateDataExtent = ({ lineDataAccessor, xAccessor, yAccessor, summaries, points, lines, lineType, showLinePoints, showSummaryPoints, xExtent, yExtent, invertX, invertY, summaryDataAccessor, summaryType, adjustedSize: size, margin, summaryStyleFn, summaryClassFn, summaryRenderModeFn, chartSize, filterRenderedLines, filterRenderedSummaries, filterRenderedPoints, defined = baseDefinedFunction, annotations = [] }) => {
+    let fullDataset = [];
+    let initialProjectedLines = [];
+    let projectedPoints = [], projectedLines = [], projectedSummaries = [];
+    if (points) {
+        xAccessor.forEach((actualXAccessor, xIndex) => {
+            yAccessor.forEach((actualYAccessor, yIndex) => {
+                let i = 0;
+                for (const d of points) {
+                    const x = actualXAccessor(d, i);
+                    const y = actualYAccessor(d, i);
+                    const projectedPoint = { x, y, data: d, xIndex, yIndex };
+                    if (Array.isArray(y)) {
+                        projectedPoint[coordinateNames_1.projectedYBottom] = Math.min(...y);
+                        projectedPoint[coordinateNames_1.projectedYTop] = Math.max(...y);
+                        projectedPoint[coordinateNames_1.projectedYMiddle] =
+                            (projectedPoint[coordinateNames_1.projectedYBottom] +
+                                projectedPoint[coordinateNames_1.projectedYTop]) /
+                                2;
+                    }
+                    if (Array.isArray(x)) {
+                        projectedPoint[coordinateNames_1.projectedXBottom] = Math.min(...x);
+                        projectedPoint[coordinateNames_1.projectedXTop] = Math.max(...x);
+                        projectedPoint[coordinateNames_1.projectedXMiddle] =
+                            (projectedPoint[coordinateNames_1.projectedXBottom] +
+                                projectedPoint[coordinateNames_1.projectedXTop]) /
+                                2;
+                    }
+                    projectedPoints.push(projectedPoint);
+                    i++;
+                }
+            });
+        });
+        for (const d of projectedPoints) {
+            fullDataset.push({
+                ...d,
+                [coordinateNames_1.projectedX]: d[coordinateNames_1.projectedXTop] || d[coordinateNames_1.projectedXBottom] || d.x,
+                [coordinateNames_1.projectedY]: d[coordinateNames_1.projectedYTop] || d[coordinateNames_1.projectedYBottom] || d.y
+            });
+        }
+    }
+    if (lines) {
+        initialProjectedLines = (0, lineDrawing_1.projectLineData)({
+            data: lines,
+            lineDataAccessor,
+            xProp: coordinateNames_1.projectedX,
+            xPropTop: coordinateNames_1.projectedXTop,
+            xPropBottom: coordinateNames_1.projectedXBottom,
+            yProp: coordinateNames_1.projectedY,
+            yPropTop: coordinateNames_1.projectedYTop,
+            yPropBottom: coordinateNames_1.projectedYBottom,
+            xAccessor,
+            yAccessor
+        });
+        const optionsObject = {
+            xProp: coordinateNames_1.projectedX,
+            yProp: coordinateNames_1.projectedY,
+            yPropMiddle: coordinateNames_1.projectedYMiddle,
+            yPropTop: coordinateNames_1.projectedYTop,
+            yPropBottom: coordinateNames_1.projectedYBottom,
+            xPropMiddle: coordinateNames_1.projectedXMiddle,
+            xPropTop: coordinateNames_1.projectedXTop,
+            xPropBottom: coordinateNames_1.projectedXBottom
+        };
+        projectedLines = lineTransformation(lineType, optionsObject)(initialProjectedLines);
+        for (const d of projectedLines) {
+            for (let q = 0; q < d.data.length; q++) {
+                const p = d.data[q];
+                if (!defined(Object.assign({}, p.data, p), q))
+                    continue;
+                const mappedP = {
+                    parentLine: d,
+                    y: p.y,
+                    x: p.x,
+                    xTop: p.xTop,
+                    xMiddle: p.xMiddle,
+                    xBottom: p.xBottom,
+                    yTop: p.yTop,
+                    yMiddle: p.yMiddle,
+                    yBottom: p.yBottom,
+                    data: p.data
+                };
+                if (p.percent) {
+                    mappedP.percent = p.percent;
+                }
+                fullDataset.push(mappedP);
+            }
+        }
+        if (showLinePoints) {
+            const whichPointsX = showLinePoints === true
+                ? coordinateNames_1.projectedXMiddle
+                : whichPointsHashX[showLinePoints];
+            const whichPointsY = showLinePoints === true
+                ? coordinateNames_1.projectedYMiddle
+                : whichPointsHashY[showLinePoints];
+            projectedLines.forEach((d) => {
+                d.data
+                    .filter((p, q) => {
+                    const isDefined = defined(Object.assign({}, p.data, p));
+                    if (isDefined) {
+                        if (showLinePoints === "orphan") {
+                            const prePoint = d.data[q - 1];
+                            const postPoint = d.data[q + 1];
+                            if ((!prePoint ||
+                                !defined(Object.assign({}, prePoint.data, prePoint))) &&
+                                (!postPoint ||
+                                    !defined(Object.assign({}, postPoint.data, postPoint)))) {
+                                return true;
+                            }
+                            else {
+                                return false;
+                            }
+                        }
+                        else {
+                            return true;
+                        }
+                    }
+                    else {
+                        return false;
+                    }
+                })
+                    .forEach((p) => {
+                    projectedPoints.push({
+                        ...p,
+                        parentLine: d,
+                        [coordinateNames_1.projectedY]: p[whichPointsY] !== undefined
+                            ? p[whichPointsY]
+                            : p[coordinateNames_1.projectedYMiddle] !== undefined
+                                ? p[coordinateNames_1.projectedYMiddle]
+                                : p[coordinateNames_1.projectedYBottom] !== undefined
+                                    ? p[coordinateNames_1.projectedYBottom]
+                                    : p.y,
+                        [coordinateNames_1.projectedX]: p[whichPointsX] !== undefined
+                            ? p[whichPointsX]
+                            : p[coordinateNames_1.projectedXMiddle] !== undefined
+                                ? p[coordinateNames_1.projectedXMiddle]
+                                : p[coordinateNames_1.projectedXBottom] !== undefined
+                                    ? p[coordinateNames_1.projectedXBottom]
+                                    : p.y
+                    });
+                });
+            });
+        }
+    }
+    if (summaries) {
+        projectedSummaries = (0, lineDrawing_1.projectSummaryData)({
+            data: summaries,
+            summaryDataAccessor,
+            xAccessor,
+            yAccessor
+        });
+        projectedSummaries.forEach((d) => {
+            const baseData = d._baseData;
+            if (d._xyfCoordinates.length > 0 && d._xyfCoordinates[0][0][0]) {
+                d._xyfCoordinates[0].forEach((multi) => {
+                    if (Array.isArray(multi)) {
+                        multi
+                            .map((p, q) => Object.assign({ parentSummary: d }, baseData[q], {
+                            [coordinateNames_1.projectedX]: p[0],
+                            [coordinateNames_1.projectedY]: p[1]
+                        }))
+                            .forEach((e) => {
+                            if (showSummaryPoints) {
+                                projectedPoints.push({
+                                    x: 0,
+                                    ...e,
+                                    [coordinateNames_1.projectedY]: e[coordinateNames_1.projectedYTop] || e[coordinateNames_1.projectedYBottom] || e[coordinateNames_1.projectedY]
+                                });
+                            }
+                            fullDataset.push({ x: 0, y: 0, ...e });
+                        });
+                    }
+                });
+            }
+            else if (d._xyfCoordinates.length > 0) {
+                if (Array.isArray(d._xyfCoordinates)) {
+                    const coordArray = d._xyfCoordinates;
+                    coordArray
+                        .map((p, q) => ({
+                        parentSummary: d,
+                        ...baseData[q],
+                        [coordinateNames_1.projectedX]: p[0],
+                        [coordinateNames_1.projectedY]: p[1]
+                    }))
+                        .forEach((e) => {
+                        if (showSummaryPoints) {
+                            projectedPoints.push({
+                                x: 0,
+                                ...e,
+                                [coordinateNames_1.projectedY]: e[coordinateNames_1.projectedYTop] || e[coordinateNames_1.projectedYBottom] || e[coordinateNames_1.projectedY]
+                            });
+                        }
+                        fullDataset.push({ x: 0, y: 0, ...e });
+                    });
+                }
+            }
+        });
+    }
+    let suitableXAnnotations = [];
+    let suitableYAnnotations = [];
+    if (xExtent &&
+        !Array.isArray(xExtent) &&
+        xExtent.includeAnnotations === true) {
+        xAccessor.forEach((actualXAccessor) => {
+            annotations.forEach((annotation, annotationIndex) => {
+                const x = actualXAccessor(annotation, annotationIndex);
+                if (isFinite(x)) {
+                    suitableXAnnotations.push({
+                        [coordinateNames_1.projectedX]: x
+                    });
+                }
+            });
+        });
+    }
+    if (yExtent &&
+        !Array.isArray(yExtent) &&
+        yExtent.includeAnnotations === true) {
+        yAccessor.forEach((actualYAccessor) => {
+            annotations.forEach((annotation, annotationIndex) => {
+                const y = actualYAccessor(annotation, annotationIndex);
+                if (isFinite(y)) {
+                    suitableYAnnotations.push({
+                        [coordinateNames_1.projectedY]: y
+                    });
+                }
+            });
+        });
+    }
+    // Single-pass extent calculation over fullDataset + annotations
+    let xMinVal;
+    let xMaxVal;
+    let yMinVal;
+    let yMaxVal;
+    for (const d of fullDataset) {
+        const xLo = d[coordinateNames_1.projectedXBottom] === undefined
+            ? d[coordinateNames_1.projectedX]
+            : Math.min(d[coordinateNames_1.projectedXTop], d[coordinateNames_1.projectedXBottom]);
+        const xHi = d[coordinateNames_1.projectedXTop] === undefined
+            ? d[coordinateNames_1.projectedX]
+            : Math.max(d[coordinateNames_1.projectedXBottom], d[coordinateNames_1.projectedXTop]);
+        const yLo = d[coordinateNames_1.projectedYBottom] === undefined
+            ? d[coordinateNames_1.projectedY]
+            : Math.min(d[coordinateNames_1.projectedYTop], d[coordinateNames_1.projectedYBottom]);
+        const yHi = d[coordinateNames_1.projectedYTop] === undefined
+            ? d[coordinateNames_1.projectedY]
+            : Math.max(d[coordinateNames_1.projectedYBottom], d[coordinateNames_1.projectedYTop]);
+        if (xLo !== undefined && (xMinVal === undefined || xLo < xMinVal))
+            xMinVal = xLo;
+        if (xHi !== undefined && (xMaxVal === undefined || xHi > xMaxVal))
+            xMaxVal = xHi;
+        if (yLo !== undefined && (yMinVal === undefined || yLo < yMinVal))
+            yMinVal = yLo;
+        if (yHi !== undefined && (yMaxVal === undefined || yHi > yMaxVal))
+            yMaxVal = yHi;
+    }
+    for (const d of suitableXAnnotations) {
+        const v = d[coordinateNames_1.projectedX];
+        if (v !== undefined && (xMinVal === undefined || v < xMinVal))
+            xMinVal = v;
+        if (v !== undefined && (xMaxVal === undefined || v > xMaxVal))
+            xMaxVal = v;
+    }
+    for (const d of suitableYAnnotations) {
+        const v = d[coordinateNames_1.projectedY];
+        if (v !== undefined && (yMinVal === undefined || v < yMinVal))
+            yMinVal = v;
+        if (v !== undefined && (yMaxVal === undefined || v > yMaxVal))
+            yMaxVal = v;
+    }
+    const calculatedXExtent = [xMinVal, xMaxVal];
+    const calculatedYExtent = [yMinVal, yMaxVal];
+    const actualXExtent = (0, unflowedFunctions_1.extentValue)(xExtent);
+    const actualYExtent = (0, unflowedFunctions_1.extentValue)(yExtent);
+    const xMin = actualXExtent && actualXExtent[0] !== undefined
+        ? actualXExtent[0]
+        : calculatedXExtent[0];
+    const xMax = actualXExtent && actualXExtent[1] !== undefined
+        ? actualXExtent[1]
+        : calculatedXExtent[1];
+    const yMin = actualYExtent && actualYExtent[0] !== undefined
+        ? actualYExtent[0]
+        : calculatedYExtent[0];
+    const yMax = actualYExtent && actualYExtent[1] !== undefined
+        ? actualYExtent[1]
+        : calculatedYExtent[1];
+    let finalYExtent = [yMin, yMax];
+    let finalXExtent = [xMin, xMax];
+    if (invertX && !(actualXExtent && actualXExtent.length === 2)) {
+        finalXExtent = [finalXExtent[1], finalXExtent[0]];
+    }
+    if ((lineType.type === "bumpline" || invertY) &&
+        !(actualYExtent && actualYExtent.length === 2)) {
+        finalYExtent = [finalYExtent[1], finalYExtent[0]];
+    }
+    if (summaryType.type && summaryType.type === "contour") {
+        projectedSummaries = (0, areaDrawing_1.contouring)({
+            summaryType,
+            data: projectedSummaries,
+            finalXExtent,
+            finalYExtent
+        });
+    }
+    else if (summaryType.type && summaryType.type === "linebounds") {
+        projectedSummaries = (0, areaDrawing_1.lineBounding)({
+            summaryType,
+            data: projectedSummaries,
+            defined
+        });
+        // Expand y extent to include the bounds so they aren't clipped
+        if (!(actualYExtent && actualYExtent.length === 2)) {
+            for (const summary of projectedSummaries) {
+                for (const coord of summary._xyfCoordinates) {
+                    const yVal = coord[1];
+                    if (yVal !== undefined && isFinite(yVal)) {
+                        if (yVal < finalYExtent[0])
+                            finalYExtent[0] = yVal;
+                        if (yVal > finalYExtent[1])
+                            finalYExtent[1] = yVal;
+                    }
+                }
+            }
+        }
+    }
+    else if (summaryType.type && summaryType.type === "hexbin") {
+        projectedSummaries = (0, areaDrawing_1.hexbinning)({
+            summaryType,
+            data: projectedSummaries[0],
+            processedData: summaries && !!summaries[0].processedData,
+            preprocess: false,
+            finalXExtent,
+            finalYExtent,
+            size,
+            margin,
+            styleFn: summaryStyleFn,
+            classFn: summaryClassFn,
+            renderFn: summaryRenderModeFn,
+            chartSize
+        });
+        fullDataset = rebuildFullDatasetWithSummaries(fullDataset, projectedSummaries);
+    }
+    else if (summaryType.type && summaryType.type === "heatmap") {
+        projectedSummaries = (0, areaDrawing_1.heatmapping)({
+            summaryType,
+            data: projectedSummaries[0],
+            processedData: summaries && !!summaries[0].processedData,
+            preprocess: false,
+            finalXExtent,
+            finalYExtent,
+            size,
+            margin,
+            styleFn: summaryStyleFn,
+            classFn: summaryClassFn,
+            renderFn: summaryRenderModeFn,
+            chartSize
+        });
+        fullDataset = rebuildFullDatasetWithSummaries(fullDataset, projectedSummaries);
+    }
+    else if (summaryType.type && summaryType.type === "trendline") {
+        projectedSummaries = (0, areaDrawing_1.trendlining)({
+            summaryType,
+            data: projectedSummaries[0],
+            preprocess: summaries && !!summaries[0].processedData,
+            finalXExtent
+        });
+        fullDataset = rebuildFullDatasetWithSummaries(fullDataset, projectedSummaries);
+    }
+    if (filterRenderedLines) {
+        projectedLines = projectedLines.filter(filterRenderedLines);
+        fullDataset = fullDataset.filter((d, i) => {
+            return !d.parentLine || filterRenderedLines(d.parentLine, i, []);
+        });
+    }
+    if (filterRenderedPoints) {
+        fullDataset = fullDataset.filter(filterRenderedPoints);
+    }
+    if (filterRenderedSummaries) {
+        projectedSummaries = projectedSummaries.filter(filterRenderedSummaries);
+        fullDataset = fullDataset.filter((d, i) => {
+            return !d.parentSummary || filterRenderedSummaries(d.parentSummary, i, []);
+        });
+    }
+    return {
+        xExtent: finalXExtent,
+        yExtent: finalYExtent,
+        projectedLines,
+        projectedPoints,
+        projectedSummaries,
+        fullDataset,
+        calculatedXExtent,
+        calculatedYExtent
+    };
+};
+exports.calculateDataExtent = calculateDataExtent;
+const differenceCatch = (olineType, data) => {
+    if (!builtInTransformations[olineType] ||
+        (olineType === "difference" && data.length !== 2)) {
+        return "line";
+    }
+    return olineType;
+};
+function lineTransformation(lineType, options) {
+    return (data) => builtInTransformations[differenceCatch(lineType.type, data)]({
+        ...lineType,
+        ...options,
+        data
+    });
+}

package/ai/dist/src/components/data/multiAccessorUtils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFirstAccessorValue = void 0;
+const findFirstAccessorValue = (accessorArray, data) => {
+    for (let i = 0; i < accessorArray.length; i++) {
+        const valueCheck = accessorArray[i](data);
+        if (valueCheck !== undefined &&
+            !Number.isNaN(valueCheck) &&
+            valueCheck !== null)
+            return valueCheck;
+    }
+    return undefined;
+};
+exports.findFirstAccessorValue = findFirstAccessorValue;

package/ai/dist/src/components/data/transforms.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Data transform helpers for common data shapes.
+ * Import from "semiotic/data"
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bin = bin;
+exports.rollup = rollup;
+exports.groupBy = groupBy;
+exports.pivot = pivot;
+/**
+ * Bin continuous data into histogram-ready format.
+ * Returns array of { category, value } objects suitable for BarChart.
+ */
+function bin(data, options) {
+    const { field, bins = 10 } = options;
+    const values = data.map((d) => Number(d[field])).filter((v) => !isNaN(v));
+    if (values.length === 0)
+        return [];
+    const min = options.domain ? options.domain[0] : Math.min(...values);
+    const max = options.domain ? options.domain[1] : Math.max(...values);
+    if (min === max) {
+        return [{ category: `${min}-${max}`, value: values.length }];
+    }
+    const binWidth = (max - min) / bins;
+    const counts = new Array(bins).fill(0);
+    for (const v of values) {
+        let idx = Math.floor((v - min) / binWidth);
+        if (idx === bins)
+            idx = bins - 1;
+        if (idx >= 0 && idx < bins) {
+            counts[idx]++;
+        }
+    }
+    return counts.map((count, i) => {
+        const lo = min + i * binWidth;
+        const hi = lo + binWidth;
+        return {
+            category: `${formatNum(lo)}-${formatNum(hi)}`,
+            value: count
+        };
+    });
+}
+/**
+ * Group and aggregate data.
+ * Returns array of { [groupBy]: string, value: number } objects.
+ */
+function rollup(data, options) {
+    const { groupBy: groupField, value: valueField, agg = "sum" } = options;
+    const groups = new Map();
+    for (const d of data) {
+        const key = String(d[groupField]);
+        if (!groups.has(key)) {
+            groups.set(key, []);
+        }
+        groups.get(key).push(Number(d[valueField]));
+    }
+    const result = [];
+    for (const [key, vals] of groups) {
+        let aggregated;
+        switch (agg) {
+            case "count":
+                aggregated = vals.length;
+                break;
+            case "mean":
+                aggregated = vals.reduce((a, b) => a + b, 0) / vals.length;
+                break;
+            case "min":
+                aggregated = Math.min(...vals);
+                break;
+            case "max":
+                aggregated = Math.max(...vals);
+                break;
+            case "sum":
+            default:
+                aggregated = vals.reduce((a, b) => a + b, 0);
+                break;
+        }
+        result.push({ [groupField]: key, value: aggregated });
+    }
+    return result;
+}
+/**
+ * Group flat rows into line-chart-ready nested format.
+ * Returns array of { id, coordinates } objects for LineChart with lineBy.
+ */
+function groupBy(data, options) {
+    const { key, fields } = options;
+    const groups = new Map();
+    for (const d of data) {
+        const groupKey = String(d[key]);
+        if (!groups.has(groupKey)) {
+            groups.set(groupKey, []);
+        }
+        if (fields) {
+            const filtered = {};
+            for (const f of fields) {
+                if (f in d) {
+                    filtered[f] = d[f];
+                }
+            }
+            groups.get(groupKey).push(filtered);
+        }
+        else {
+            groups.get(groupKey).push({ ...d });
+        }
+    }
+    const result = [];
+    for (const [id, coordinates] of groups) {
+        result.push({ id, coordinates });
+    }
+    return result;
+}
+/**
+ * Pivot wide data to long format.
+ * Converts column-per-variable to row-per-variable.
+ */
+function pivot(data, options) {
+    const { columns, nameField = "name", valueField = "value" } = options;
+    const columnsSet = new Set(columns);
+    const result = [];
+    for (const row of data) {
+        const base = {};
+        for (const k of Object.keys(row)) {
+            if (!columnsSet.has(k)) {
+                base[k] = row[k];
+            }
+        }
+        for (const col of columns) {
+            result.push({
+                ...base,
+                [nameField]: col,
+                [valueField]: row[col]
+            });
+        }
+    }
+    return result;
+}
+/** Round to avoid long floating-point strings in bin labels. */
+function formatNum(n) {
+    const rounded = Math.round(n * 1000) / 1000;
+    return String(rounded);
+}

package/ai/dist/src/components/data/unflowedFunctions.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extentValue = void 0;
+const extentValue = extent => (extent && extent.extent) || (Array.isArray(extent) && extent) || [];
+exports.extentValue = extentValue;