semiotic 2.0.2 → 3.0.0-beta.1

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

@@ -0,0 +1,473 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDataExtent = void 0;
+exports.stringToFn = stringToFn;
+exports.stringToArrayFn = stringToArrayFn;
+const lineDrawing_1 = require("../svg/lineDrawing");
+const coordinateNames_1 = require("../constants/coordinateNames");
+const lineDrawing_2 = require("../svg/lineDrawing");
+const areaDrawing_1 = require("../svg/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
+        });
+    }
+    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/networkPipelineCache.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNetworkPipelineCache = createNetworkPipelineCache;
+const memoize_one_1 = __importDefault(require("memoize-one"));
+const frameFunctions_1 = require("../svg/frameFunctions");
+const dataFunctions_1 = require("./dataFunctions");
+const functions_1 = require("../generic_utilities/functions");
+function createNetworkPipelineCache() {
+    return {
+        marginCalc: (0, memoize_one_1.default)((margin, title, size) => {
+            const calculatedMargin = (0, frameFunctions_1.calculateMargin)({ margin, title, size });
+            const { adjustedPosition, adjustedSize } = (0, frameFunctions_1.adjustedPositionSize)({
+                size,
+                margin: calculatedMargin
+            });
+            return { margin: calculatedMargin, adjustedPosition, adjustedSize };
+        }),
+        accessorConversions: (0, memoize_one_1.default)((nodeIDAccessor, sourceAccessor, targetAccessor, nodeSizeAccessor, edgeWidthAccessor) => ({
+            nodeIDAccessor: (0, dataFunctions_1.stringToFn)(nodeIDAccessor, (d) => d ? d.id : undefined),
+            sourceAccessor: (0, dataFunctions_1.stringToFn)(sourceAccessor, (d) => d.source),
+            targetAccessor: (0, dataFunctions_1.stringToFn)(targetAccessor, (d) => d.target),
+            nodeSizeAccessor: typeof nodeSizeAccessor === "number"
+                ? (0, functions_1.genericFunction)(nodeSizeAccessor)
+                : (0, dataFunctions_1.stringToFn)(nodeSizeAccessor, (0, functions_1.genericFunction)(5)),
+            edgeWidthAccessor: (0, dataFunctions_1.stringToFn)(edgeWidthAccessor, (d) => d.weight || 1),
+        })),
+        nodeStyleFns: (0, memoize_one_1.default)((nodeStyle, nodeClass, nodeRenderMode, canvasNodes) => ({
+            nodeStyleFn: (0, dataFunctions_1.stringToFn)(nodeStyle, () => ({}), true),
+            nodeClassFn: (0, dataFunctions_1.stringToFn)(nodeClass, () => "", true),
+            nodeRenderModeFn: (0, dataFunctions_1.stringToFn)(nodeRenderMode, undefined, true),
+            nodeCanvasRenderFn: canvasNodes ? (0, dataFunctions_1.stringToFn)(canvasNodes, undefined, true) : undefined,
+        })),
+        edgeStyleFns: (0, memoize_one_1.default)((edgeStyle, edgeClass, edgeRenderMode, canvasEdges) => ({
+            edgeStyleFn: (0, dataFunctions_1.stringToFn)(edgeStyle, () => ({}), true),
+            edgeClassFn: (0, dataFunctions_1.stringToFn)(edgeClass, () => "", true),
+            edgeRenderModeFn: (0, dataFunctions_1.stringToFn)(edgeRenderMode, undefined, true),
+            edgeCanvasRenderFn: canvasEdges ? (0, dataFunctions_1.stringToFn)(canvasEdges, undefined, true) : undefined,
+        })),
+    };
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOrdinalPipelineCache = createOrdinalPipelineCache;
+const memoize_one_1 = __importDefault(require("memoize-one"));
+const frameFunctions_1 = require("../svg/frameFunctions");
+const dataFunctions_1 = require("./dataFunctions");
+function createOrdinalPipelineCache() {
+    return {
+        marginCalc: (0, memoize_one_1.default)((margin, axes, title, oLabel, projection, size) => {
+            const calculatedMargin = (0, frameFunctions_1.calculateMargin)({ margin, axes, title, oLabel, projection, size });
+            const { adjustedPosition, adjustedSize } = (0, frameFunctions_1.adjustedPositionSize)({
+                size,
+                margin: calculatedMargin,
+                projection
+            });
+            return { margin: calculatedMargin, adjustedPosition, adjustedSize };
+        }),
+        structureData: (0, memoize_one_1.default)((data, renderKey, oAccessor, rAccessor, originalRAccessor, originalOAccessor, multiAxis) => {
+            return (0, frameFunctions_1.keyAndObjectifyBarData)({
+                data,
+                renderKey,
+                oAccessor,
+                rAccessor,
+                originalRAccessor,
+                originalOAccessor,
+                multiAxis
+            });
+        }),
+        accessorConversions: (0, memoize_one_1.default)((baseOAccessor, baseRAccessor, baseRenderKey, basePieceIDAccessor) => ({
+            oAccessor: (0, dataFunctions_1.stringToArrayFn)(baseOAccessor, (d) => d.renderKey),
+            rAccessor: (0, dataFunctions_1.stringToArrayFn)(baseRAccessor, (d) => d.value || 1),
+            renderKey: (0, dataFunctions_1.stringToFn)(baseRenderKey, (d, i) => i),
+            pieceIDAccessor: (0, dataFunctions_1.stringToFn)(basePieceIDAccessor, () => ""),
+        })),
+        styleFns: (0, memoize_one_1.default)((baseConnectorStyle, baseSummaryStyle, baseStyle, basePieceClass, baseSummaryClass, baseConnectorClass, baseRenderMode, baseSummaryRenderMode, baseConnectorRenderMode, canvasPieces, canvasSummaries, canvasConnectors) => ({
+            connectorStyle: (0, dataFunctions_1.stringToFn)(baseConnectorStyle, () => ({}), true),
+            summaryStyle: (0, dataFunctions_1.stringToFn)(baseSummaryStyle, () => ({}), true),
+            pieceStyle: (0, dataFunctions_1.stringToFn)(baseStyle, () => ({}), true),
+            pieceClass: (0, dataFunctions_1.stringToFn)(basePieceClass, () => "", true),
+            summaryClass: (0, dataFunctions_1.stringToFn)(baseSummaryClass, () => "", true),
+            connectorClass: (0, dataFunctions_1.stringToFn)(baseConnectorClass, () => "", true),
+            pieceRenderMode: (0, dataFunctions_1.stringToFn)(baseRenderMode, undefined, true),
+            summaryRenderMode: (0, dataFunctions_1.stringToFn)(baseSummaryRenderMode, undefined, true),
+            connectorRenderMode: (0, dataFunctions_1.stringToFn)(baseConnectorRenderMode, undefined, true),
+            pieceCanvasRender: (0, dataFunctions_1.stringToFn)(canvasPieces, undefined, true),
+            summaryCanvasRender: (0, dataFunctions_1.stringToFn)(canvasSummaries, undefined, true),
+            connectorCanvasRender: (0, dataFunctions_1.stringToFn)(canvasConnectors, undefined, true),
+        })),
+    };
+}

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;

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

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createXYPipelineCache = createXYPipelineCache;
+const memoize_one_1 = __importDefault(require("memoize-one"));
+const frameFunctions_1 = require("../svg/frameFunctions");
+const dataFunctions_1 = require("./dataFunctions");
+const emptyObjectReturnFunction = () => ({});
+const emptyStringReturnFunction = () => "";
+function createXYPipelineCache() {
+    return {
+        annotatedSettings: (0, memoize_one_1.default)((xAccessor, yAccessor, summaryDataAccessor, lineDataAccessor, renderKey, lineType, summaryType, lineIDAccessor) => ({
+            xAccessor: (0, dataFunctions_1.stringToArrayFn)(xAccessor, (d) => d[0]),
+            yAccessor: (0, dataFunctions_1.stringToArrayFn)(yAccessor, (d) => d[1]),
+            summaryDataAccessor: (0, dataFunctions_1.stringToArrayFn)(summaryDataAccessor, (d) => (Array.isArray(d) ? d : d.coordinates)),
+            lineDataAccessor: (0, dataFunctions_1.stringToArrayFn)(lineDataAccessor, (d) => (Array.isArray(d) ? d : d.coordinates)),
+            renderKeyFn: (0, dataFunctions_1.stringToFn)(renderKey, (d, i) => `line-${i}`, true),
+            lineIDAccessor: (0, dataFunctions_1.stringToFn)(lineIDAccessor, (l) => l.semioticLineID),
+        })),
+        marginCalc: (0, memoize_one_1.default)((margin, axes, title, size) => {
+            const calculatedMargin = (0, frameFunctions_1.calculateMargin)({ margin, axes, title, size });
+            const { adjustedPosition, adjustedSize } = (0, frameFunctions_1.adjustedPositionSize)({
+                size,
+                margin: calculatedMargin
+            });
+            return { margin: calculatedMargin, adjustedPosition, adjustedSize };
+        }),
+        summaryStyleFns: (0, memoize_one_1.default)((summaryStyle, summaryClass, summaryRenderMode) => ({
+            summaryStyleFn: (0, dataFunctions_1.stringToFn)(summaryStyle, emptyObjectReturnFunction, true),
+            summaryClassFn: (0, dataFunctions_1.stringToFn)(summaryClass, emptyStringReturnFunction, true),
+            summaryRenderModeFn: (0, dataFunctions_1.stringToFn)(summaryRenderMode, undefined, true),
+        })),
+        lineStyleFns: (0, memoize_one_1.default)((lineStyle, lineClass, lineRenderMode, canvasLines) => ({
+            styleFn: (0, dataFunctions_1.stringToFn)(lineStyle, emptyObjectReturnFunction, true),
+            classFn: (0, dataFunctions_1.stringToFn)(lineClass, emptyStringReturnFunction, true),
+            renderMode: (0, dataFunctions_1.stringToFn)(lineRenderMode, undefined, true),
+            canvasRender: (0, dataFunctions_1.stringToFn)(canvasLines, undefined, true),
+        })),
+        pointStyleFns: (0, memoize_one_1.default)((pointStyle, pointClass, pointRenderMode, canvasPoints) => ({
+            styleFn: (0, dataFunctions_1.stringToFn)(pointStyle, emptyObjectReturnFunction, true),
+            classFn: (0, dataFunctions_1.stringToFn)(pointClass, emptyStringReturnFunction, true),
+            renderMode: (0, dataFunctions_1.stringToFn)(pointRenderMode, undefined, true),
+            canvasRender: (0, dataFunctions_1.stringToFn)(canvasPoints, undefined, true),
+        })),
+        summaryCanvasRender: (0, memoize_one_1.default)((canvasSummaries) => (0, dataFunctions_1.stringToFn)(canvasSummaries, undefined, true)),
+    };
+}

package/ai/dist/src/components/generic_utilities/functions.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericFunction = void 0;
+const genericFunction = value => () => value;
+exports.genericFunction = genericFunction;