semiotic 2.0.2 → 3.0.0-beta.1

package/ai/dist/src/components/processing/xyDrawing.js

@@ -0,0 +1,484 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateXYFrame = void 0;
+const React = __importStar(require("react"));
+const d3_scale_1 = require("d3-scale");
+const Axis_1 = __importDefault(require("../Axis"));
+const axis_1 = require("../visualizationLayerBehavior/axis");
+const dataFunctions_1 = require("../data/dataFunctions");
+const general_1 = require("../visualizationLayerBehavior/general");
+const frameFunctions_1 = require("../svg/frameFunctions");
+const screenScales = ({ xExtent, yExtent, adjustedSize, xScaleType, yScaleType }) => {
+    const xDomain = [0, adjustedSize[0]];
+    const yDomain = [adjustedSize[1], 0];
+    const xScale = xScaleType;
+    const yScale = yScaleType;
+    if (xScaleType.domain) {
+        xScaleType.domain(xExtent);
+    }
+    if (yScaleType.domain) {
+        yScaleType.domain(yExtent);
+    }
+    xScaleType.range(xDomain);
+    yScaleType.range(yDomain);
+    return { xScale, yScale };
+};
+const naturalLanguageLineType = {
+    line: { items: "line", chart: "line chart" },
+    area: { items: "summary", chart: "summary chart" },
+    summary: { items: "summary", chart: "summary chart" },
+    cumulative: { items: "line", chart: "cumulative chart" },
+    "cumulative-reverse": { items: "line", chart: "cumulative chart" },
+    linepercent: { items: "line", chart: "line chart" },
+    stackedarea: { items: "stacked area", chart: "stacked area chart" },
+    "stackedarea-invert": { items: "stacked area", chart: "stacked area chart" },
+    stackedpercent: { items: "stacked area", chart: "stacked area chart" },
+    "stackedpercent-invert": {
+        items: "stacked area",
+        chart: "stacked area chart"
+    },
+    bumparea: { items: "ranked area", chart: "ranked area chart" },
+    "bumparea-invert": { items: "ranked area", chart: "ranked area chart" },
+    bumpline: { items: "ranked line", chart: "ranked line chart" },
+    difference: {
+        items: "line",
+        chart: "difference chart"
+    }
+};
+const calculateXYFrame = (currentProps, prevState, updateData, cache) => {
+    const { legend, lines, lineClass, pointStyle, pointRenderMode, pointClass, summaryClass, canvasLines, canvasPoints, canvasSummaries, defined, size, renderKey, lineType, summaryType, customLineMark, customPointMark, customSummaryMark, summaryStyle, summaryRenderMode, lineStyle, lineRenderMode, xExtent: baseXExtent, yExtent: baseYExtent, title, xScaleType: baseXScaleType = (0, d3_scale_1.scaleLinear)(), yScaleType: baseYScaleType = (0, d3_scale_1.scaleLinear)(), lineIDAccessor, invertX, invertY, showLinePoints, showSummaryPoints, points, lineDataAccessor, summaryDataAccessor, yAccessor, xAccessor, useSummariesAsInteractionLayer, filterRenderedLines, filterRenderedSummaries, filterRenderedPoints, annotations } = currentProps;
+    let { projectedLines, projectedPoints, projectedSummaries, summaries, fullDataset } = currentProps;
+    if (summaryType && points && !summaries) {
+        summaries = [{ coordinates: points }];
+    }
+    else if (summaryType &&
+        summaryType.type === "linebounds" &&
+        lines &&
+        !summaries) {
+        summaries = lines;
+    }
+    const castXScaleType = baseXScaleType;
+    const xScaleType = baseXScaleType.domain ? baseXScaleType : castXScaleType();
+    const castYScaleType = baseYScaleType;
+    const yScaleType = baseYScaleType.domain ? baseYScaleType : castYScaleType();
+    const cachedAccessors = cache.annotatedSettings(xAccessor, yAccessor, summaryDataAccessor, lineDataAccessor, renderKey, lineType, summaryType, lineIDAccessor);
+    const annotatedSettings = {
+        ...cachedAccessors,
+        lineType: (0, frameFunctions_1.objectifyType)(lineType),
+        summaryType: (0, frameFunctions_1.objectifyType)(summaryType),
+        summaries: !summaries || (Array.isArray(summaries) && summaries.length === 0)
+            ? undefined
+            : !Array.isArray(summaries)
+                ? [summaries]
+                : !summaryDataAccessor && !summaries[0].coordinates
+                    ? [{ coordinates: summaries }]
+                    : summaries,
+        lines: !lines || (Array.isArray(lines) && lines.length === 0)
+            ? undefined
+            : !Array.isArray(lines)
+                ? [lines]
+                : !lineDataAccessor && !lines[0].coordinates
+                    ? [{ coordinates: lines }]
+                    : lines,
+        title: typeof title === "object" &&
+            !React.isValidElement(title) &&
+            title !== null
+            ? title
+            : { title, orient: "top" },
+        xExtent: Array.isArray(baseXExtent)
+            ? baseXExtent
+            : !baseXExtent
+                ? undefined
+                : baseXExtent.extent,
+        yExtent: Array.isArray(baseYExtent)
+            ? baseYExtent
+            : !baseYExtent
+                ? undefined
+                : baseYExtent.extent
+    };
+    if (annotatedSettings.lineType.type === "area") {
+        annotatedSettings.lineType.y1 = () => 0;
+        annotatedSettings.lineType.simpleLine = false;
+    }
+    const { summaryStyleFn, summaryClassFn, summaryRenderModeFn } = cache.summaryStyleFns(summaryStyle, summaryClass, summaryRenderMode);
+    const generatedAxes = currentProps.axes &&
+        currentProps.axes.map((axisFnOrObject) => typeof axisFnOrObject === "function"
+            ? axisFnOrObject({ size: currentProps.size })
+            : axisFnOrObject);
+    const { margin, adjustedPosition, adjustedSize } = cache.marginCalc(currentProps.margin, generatedAxes, annotatedSettings.title, currentProps.size);
+    let calculatedXExtent = [], calculatedYExtent = [], yExtent, xExtent, xExtentSettings, yExtentSettings;
+    if (typeof baseXExtent === "object") {
+        xExtentSettings = baseXExtent;
+    }
+    else {
+        xExtentSettings = { extent: baseXExtent };
+    }
+    if (typeof baseYExtent === "object") {
+        yExtentSettings = baseYExtent;
+    }
+    else {
+        yExtentSettings = { extent: baseYExtent };
+    }
+    let xScale, yScale;
+    if (updateData ||
+        (currentProps.dataVersion &&
+            currentProps.dataVersion !== prevState.dataVersion)) {
+        //This will always fire at this point because xExtent/yExtent are just defined up there so revisit this logic
+        if (!xExtent ||
+            !yExtent ||
+            !fullDataset ||
+            (!projectedLines && !projectedPoints && !projectedSummaries)) {
+            ;
+            ({
+                xExtent,
+                yExtent,
+                projectedLines,
+                projectedPoints,
+                projectedSummaries,
+                fullDataset,
+                calculatedXExtent,
+                calculatedYExtent
+            } = (0, dataFunctions_1.calculateDataExtent)({
+                lineDataAccessor: annotatedSettings.lineDataAccessor,
+                summaryDataAccessor: annotatedSettings.summaryDataAccessor,
+                xAccessor: annotatedSettings.xAccessor,
+                yAccessor: annotatedSettings.yAccessor,
+                lineType: annotatedSettings.lineType,
+                summaryType: annotatedSettings.summaryType,
+                summaries: annotatedSettings.summaries,
+                points,
+                lines: annotatedSettings.lines,
+                showLinePoints,
+                showSummaryPoints,
+                xExtent: baseXExtent,
+                yExtent: baseYExtent,
+                invertX,
+                invertY,
+                adjustedSize,
+                margin,
+                summaryStyleFn,
+                summaryClassFn,
+                summaryRenderModeFn,
+                chartSize: size,
+                xScaleType,
+                yScaleType,
+                defined,
+                filterRenderedLines,
+                filterRenderedSummaries,
+                filterRenderedPoints,
+                annotations
+            }));
+        }
+        ;
+        ({ xScale, yScale } = screenScales({
+            xExtent,
+            yExtent,
+            adjustedSize,
+            xScaleType: xScaleType.copy(),
+            yScaleType: yScaleType.copy()
+        }));
+    }
+    else {
+        ;
+        ({
+            xExtent,
+            yExtent,
+            projectedLines,
+            projectedPoints,
+            projectedSummaries,
+            fullDataset,
+            calculatedXExtent,
+            calculatedYExtent
+        } = prevState);
+        if (adjustedSize[0] === prevState.adjustedSize[0] &&
+            adjustedSize[1] === prevState.adjustedSize[1]) {
+            xScale = prevState.xScale;
+            yScale = prevState.yScale;
+        }
+        else {
+            ;
+            ({ xScale, yScale } = screenScales({
+                xExtent,
+                yExtent,
+                adjustedSize,
+                xScaleType,
+                yScaleType
+            }));
+        }
+    }
+    xExtent =
+        Array.isArray(xExtentSettings.extent) && xExtentSettings.extent.length === 2
+            ? xExtentSettings.extent
+            : xExtent;
+    yExtent =
+        Array.isArray(yExtentSettings.extent) && yExtentSettings.extent.length === 2
+            ? yExtentSettings.extent
+            : yExtent;
+    const canvasDrawing = [];
+    let axes;
+    let axesTickLines;
+    const existingBaselines = {};
+    if (generatedAxes) {
+        axesTickLines = [];
+        axes = generatedAxes.map((d, i) => {
+            let axisClassname = d.className || "";
+            axisClassname += " axis";
+            let axisScale = yScale;
+            if (existingBaselines[d.orient]) {
+                d.baseline = d.baseline || false;
+            }
+            existingBaselines[d.orient] = true;
+            if (d.orient === "top" || d.orient === "bottom") {
+                axisClassname += " x";
+                axisScale = xScale;
+            }
+            else {
+                axisClassname += " y";
+            }
+            axisClassname += ` ${d.orient}`;
+            let tickValues;
+            if (d.tickValues && Array.isArray(d.tickValues)) {
+                tickValues = d.tickValues;
+            }
+            else if (d.tickValues instanceof Function) {
+                //otherwise assume a function
+                tickValues = d.tickValues(fullDataset, currentProps.size, axisScale);
+            }
+            const axisSize = [adjustedSize[0], adjustedSize[1]];
+            const axisParts = (0, axis_1.axisPieces)({
+                padding: d.padding,
+                tickValues,
+                scale: axisScale,
+                ticks: d.ticks,
+                orient: d.orient,
+                size: axisSize,
+                footer: d.footer,
+                tickSize: d.tickSize,
+                jaggedBase: d.jaggedBase
+            });
+            const axisTickLines = (React.createElement("g", { key: `axes-tick-lines-${i}`, className: `axis ${axisClassname}` },
+                (0, axis_1.axisLines)({
+                    axisParts,
+                    orient: d.orient,
+                    tickLineGenerator: d.tickLineGenerator,
+                    className: axisClassname,
+                    jaggedBase: d.jaggedBase,
+                    scale: axisScale,
+                    showOutboundTickLines: d.showOutboundTickLines
+                }),
+                d.baseline === "under" &&
+                    (0, axis_1.baselineGenerator)(d.orient, adjustedSize, d.className)));
+            axesTickLines.push(axisTickLines);
+            return (React.createElement(Axis_1.default, { ...d, key: d.key || `axis-${i}`, annotationFunction: d.axisAnnotationFunction, axisParts: axisParts, size: axisSize, margin: margin, tickValues: tickValues, scale: axisScale, className: axisClassname, xyPoints: fullDataset }));
+        });
+    }
+    let legendSettings;
+    if (legend) {
+        legendSettings = legend === true ? {} : legend;
+        if (projectedLines && !legendSettings.legendGroups) {
+            const typeString = annotatedSettings.lineType.type;
+            const type = typeof typeString === "string" &&
+                ["stackedarea", "stackedpercent", "bumparea"].indexOf(typeString) === -1
+                ? "line"
+                : "fill";
+            const legendGroups = [
+                {
+                    styleFn: currentProps.lineStyle,
+                    type,
+                    items: projectedLines.map((d) => Object.assign({ label: annotatedSettings.lineIDAccessor(d) }, d))
+                }
+            ];
+            legendSettings.legendGroups = legendGroups;
+        }
+    }
+    const areaAnnotations = [];
+    if (annotatedSettings.summaryType.label && projectedSummaries) {
+        projectedSummaries.forEach((d, i) => {
+            if (d.bounds) {
+                const bounds = Array.isArray(d.bounds) ? d.bounds : [d.bounds];
+                bounds.forEach((labelBounds) => {
+                    const label = typeof annotatedSettings.summaryType.label === "function"
+                        ? annotatedSettings.summaryType.label(d)
+                        : annotatedSettings.summaryType.label;
+                    if (label && label !== null) {
+                        const labelPosition = label.position || "center";
+                        const labelCenter = [
+                            xScale(labelBounds[labelPosition][0]),
+                            yScale(labelBounds[labelPosition][1])
+                        ];
+                        const labelContent = label.content || ((p) => p.value || p.id || i);
+                        areaAnnotations.push({
+                            x: labelCenter[0],
+                            y: labelCenter[1],
+                            dx: label.dx,
+                            dy: label.dy,
+                            className: label.className,
+                            type: label.type || "callout",
+                            note: label.note || { title: labelContent(d) },
+                            subject: label.subject || { text: labelContent(d) },
+                            connector: label.connector
+                        });
+                    }
+                });
+            }
+        });
+    }
+    else if (annotatedSettings.summaryType.showSlope &&
+        projectedSummaries &&
+        projectedSummaries[0]) {
+        const firstSummary = projectedSummaries[0];
+        const firstPoint = firstSummary._xyfCoordinates[0];
+        const finalPoint = firstSummary._xyfCoordinates[firstSummary._xyfCoordinates.length - 1];
+        areaAnnotations.push({
+            x: firstPoint[0],
+            y: firstPoint[1],
+            x1: finalPoint[0],
+            x2: finalPoint[1],
+            type: "trendline-annotation",
+            value: firstSummary.value,
+            r2: firstSummary.r2
+        });
+    }
+    const lineAriaLabel = annotatedSettings.lineType.type !== undefined &&
+        typeof annotatedSettings.lineType.type === "string" &&
+        naturalLanguageLineType[annotatedSettings.lineType.type];
+    const xyFrameRender = {
+        lines: {
+            accessibleTransform: (data, i) => ({
+                ...data[i].data[data[i].data.length - 1],
+                type: "frame-hover"
+            }),
+            data: projectedLines,
+            ...cache.lineStyleFns(lineStyle, lineClass, lineRenderMode, canvasLines),
+            customMark: customLineMark,
+            type: annotatedSettings.lineType,
+            defined: defined,
+            renderKeyFn: annotatedSettings.renderKeyFn,
+            ariaLabel: lineAriaLabel,
+            axesData: generatedAxes,
+            behavior: general_1.createLines
+        },
+        summaries: {
+            accessibleTransform: (data, i) => ({ ...data[i], type: "frame-hover" }),
+            data: projectedSummaries,
+            styleFn: summaryStyleFn,
+            classFn: summaryClassFn,
+            renderMode: summaryRenderModeFn,
+            canvasRender: cache.summaryCanvasRender(canvasSummaries),
+            customMark: customSummaryMark,
+            type: annotatedSettings.summaryType,
+            renderKeyFn: annotatedSettings.renderKeyFn,
+            behavior: general_1.createSummaries
+        },
+        points: {
+            accessibleTransform: (data, i) => ({
+                type: "frame-hover",
+                ...(data[i].data || data[i])
+            }),
+            data: projectedPoints,
+            ...cache.pointStyleFns(pointStyle, pointClass, pointRenderMode, canvasPoints),
+            customMark: customPointMark,
+            renderKeyFn: annotatedSettings.renderKeyFn,
+            showLinePoints,
+            behavior: general_1.createPoints
+        }
+    };
+    if (xExtentSettings.onChange &&
+        prevState.calculatedXExtent.join(",") !== calculatedXExtent.join(",")) {
+        xExtentSettings.onChange(calculatedXExtent);
+    }
+    if (yExtentSettings.onChange &&
+        prevState.calculatedYExtent.join(",") !== calculatedYExtent.join(",")) {
+        yExtentSettings.onChange(calculatedYExtent);
+    }
+    let overlay = undefined;
+    if (useSummariesAsInteractionLayer && projectedSummaries) {
+        overlay = (0, general_1.createSummaries)({
+            xScale,
+            yScale,
+            data: projectedSummaries
+        }).map((m, i) => ({
+            ...m.props,
+            style: { fillOpacity: 0 },
+            overlayData: projectedSummaries && projectedSummaries[i] // luckily createSummaries is a map fn
+        }));
+    }
+    return {
+        lineData: currentProps.lines,
+        pointData: currentProps.points,
+        summaryData: currentProps.summaries,
+        dataVersion: currentProps.dataVersion,
+        projectedLines,
+        projectedPoints,
+        projectedSummaries,
+        canvasDrawing,
+        fullDataset,
+        adjustedPosition,
+        adjustedSize,
+        backgroundGraphics: currentProps.backgroundGraphics,
+        foregroundGraphics: currentProps.foregroundGraphics,
+        axesData: generatedAxes,
+        axes,
+        axesTickLines,
+        renderNumber: prevState.renderNumber + 1,
+        xScale,
+        yScale,
+        xAccessor: annotatedSettings.xAccessor,
+        yAccessor: annotatedSettings.yAccessor,
+        xExtent: [
+            xExtent[0] === undefined ? calculatedXExtent[0] : xExtent[0],
+            xExtent[1] === undefined ? calculatedXExtent[1] : xExtent[1]
+        ],
+        yExtent: [
+            yExtent[0] === undefined ? calculatedYExtent[0] : yExtent[0],
+            yExtent[1] === undefined ? calculatedYExtent[1] : yExtent[1]
+        ],
+        calculatedXExtent,
+        calculatedYExtent,
+        margin,
+        legendSettings,
+        areaAnnotations,
+        xyFrameRender,
+        size,
+        annotatedSettings,
+        overlay,
+        props: currentProps
+    };
+};
+exports.calculateXYFrame = calculateXYFrame;

package/ai/dist/src/components/realtime/BinAccumulator.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeBins = computeBins;
+exports.computeBinExtent = computeBinExtent;
+function computeBins(data, getTime, getValue, binSize, getCategory) {
+    const bins = new Map();
+    for (const d of data) {
+        const t = getTime(d);
+        const v = getValue(d);
+        if (t == null || v == null || Number.isNaN(t) || Number.isNaN(v))
+            continue;
+        const binStart = Math.floor(t / binSize) * binSize;
+        let bin = bins.get(binStart);
+        if (!bin) {
+            bin = { start: binStart, end: binStart + binSize, total: 0, categories: new Map() };
+            bins.set(binStart, bin);
+        }
+        bin.total += v;
+        if (getCategory) {
+            const cat = getCategory(d);
+            bin.categories.set(cat, (bin.categories.get(cat) || 0) + v);
+        }
+    }
+    return bins;
+}
+function computeBinExtent(data, getTime, getValue, binSize, getCategory) {
+    const bins = computeBins(data, getTime, getValue, binSize, getCategory);
+    if (bins.size === 0)
+        return [0, 0];
+    let maxTotal = 0;
+    for (const bin of bins.values()) {
+        if (bin.total > maxTotal)
+            maxTotal = bin.total;
+    }
+    return [0, maxTotal];
+}

package/ai/dist/src/components/realtime/IncrementalExtent.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncrementalExtent = void 0;
+class IncrementalExtent {
+    constructor() {
+        this._min = Infinity;
+        this._max = -Infinity;
+        this._dirty = false;
+    }
+    push(value) {
+        if (Number.isNaN(value))
+            return;
+        if (value < this._min)
+            this._min = value;
+        if (value > this._max)
+            this._max = value;
+    }
+    evict(value) {
+        if (value === this._min || value === this._max) {
+            this._dirty = true;
+        }
+    }
+    recalculate(values, accessor) {
+        this._min = Infinity;
+        this._max = -Infinity;
+        for (const v of values) {
+            const n = accessor ? accessor(v) : v;
+            if (Number.isNaN(n))
+                continue;
+            if (n < this._min)
+                this._min = n;
+            if (n > this._max)
+                this._max = n;
+        }
+        this._dirty = false;
+    }
+    clear() {
+        this._min = Infinity;
+        this._max = -Infinity;
+        this._dirty = false;
+    }
+    get extent() {
+        return [this._min, this._max];
+    }
+    get min() {
+        return this._min;
+    }
+    get max() {
+        return this._max;
+    }
+    get dirty() {
+        return this._dirty;
+    }
+}
+exports.IncrementalExtent = IncrementalExtent;