semiotic 3.0.0-beta.2 → 3.0.0-beta.4

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

@@ -1,487 +0,0 @@
-"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

@@ -1,14 +0,0 @@
-"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

@@ -1,143 +0,0 @@
-"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

@@ -1,5 +0,0 @@
-"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;