semiotic 2.0.3 → 3.0.0-beta.2

package/ai/dist/src/components/visualizationLayerBehavior/axis.js

@@ -0,0 +1,301 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.axisLines = exports.baselineGenerator = exports.axisLabels = void 0;
+exports.generateTickValues = generateTickValues;
+exports.axisPieces = axisPieces;
+const React = __importStar(require("react"));
+const horizontalTornTickGenerator = (width, ticks, y, orient) => {
+    const step = width / ticks;
+    let currentStep = 0;
+    let tickPath = `M0,${y}`;
+    const mod = orient === "right" ? -1 : 1;
+    while (currentStep <= width) {
+        tickPath += `L${currentStep},${y}`;
+        if (currentStep < width) {
+            tickPath += `L${currentStep + step / 2},${y + 10 * mod}`;
+        }
+        currentStep += step;
+    }
+    return tickPath;
+};
+const verticalTornTickGenerator = (height, ticks, x, orient) => {
+    const step = height / ticks;
+    let currentStep = 0;
+    let tickPath = `M${x},0`;
+    const mod = orient === "bottom" ? -1 : 1;
+    while (currentStep <= height) {
+        tickPath += `L${x},${currentStep}`;
+        if (currentStep < height) {
+            tickPath += `L${x + 10 * mod},${currentStep + step / 2}`;
+        }
+        currentStep += step;
+    }
+    return tickPath;
+};
+const generateTornBaseline = (orient, baselineSettings) => {
+    let tornD = "";
+    const { x1, x2, y1, y2 } = baselineSettings;
+    if (orient === "left" || orient === "right") {
+        const calcWidth = Math.abs(x2 - x1);
+        const ticks = Math.ceil(calcWidth / 40);
+        tornD = horizontalTornTickGenerator(calcWidth, ticks, orient === "right" ? 0 : y1, orient);
+    }
+    else {
+        const calcHeight = Math.abs(y2 - y1);
+        const ticks = Math.ceil(calcHeight / 40);
+        tornD = verticalTornTickGenerator(calcHeight, ticks, x1, orient);
+    }
+    return tornD;
+};
+const defaultTickLineGenerator = ({ xy, orient, i, className = "", jaggedBase }) => {
+    let genD = `M${xy.x1},${xy.y1}L${xy.x2},${xy.y2}`;
+    if (jaggedBase && i === 0) {
+        genD = generateTornBaseline(orient, xy);
+    }
+    return (React.createElement("path", { key: i, fill: "none", stroke: "currentColor", strokeWidth: "1px", d: genD, className: `tick-line tick ${orient} ${className}` }));
+};
+const outboundTickLineGenerator = ({ xy, orient, i, className = "" }) => {
+    const tickLength = 8;
+    let genD = `M-4,${xy.y1}L${xy.x1},${xy.y2}`;
+    if (orient === "left") {
+        genD = `M${xy.x1 - tickLength},${xy.y1}L${xy.x1},${xy.y2}`;
+    }
+    else if (orient === "right") {
+        genD = `M${xy.x2},${xy.y1}L${xy.x2 + tickLength},${xy.y2}`;
+    }
+    else if (orient === "top") {
+        genD = `M${xy.x1},${xy.y1 - tickLength}L${xy.x1},${xy.y1}`;
+    }
+    else if (orient === "bottom") {
+        genD = `M${xy.x1},${xy.y2}L${xy.x1},${xy.y2 + tickLength}`;
+    }
+    return (React.createElement("path", { key: i, fill: "none", stroke: "currentColor", strokeWidth: "1px", d: genD, className: `outbound-tick-line tick ${orient} ${className}` }));
+};
+function generateTickValues(tickValues, ticks, scale) {
+    const axisSize = Math.abs(scale.range()[1] - scale.range()[0]);
+    if (!tickValues) {
+        if (!ticks) {
+            ticks = Math.max(1, Math.floor(axisSize / 40));
+        }
+        tickValues = (scale.ticks && scale.ticks(ticks)) || scale.domain();
+    }
+    return tickValues;
+}
+function axisPieces({ renderMode = () => undefined, padding = 5, scale, ticks, tickValues = generateTickValues(undefined, ticks, scale), orient = "left", size, footer = false, tickSize = footer
+    ? -10
+    : ["top", "bottom"].find((d) => d === orient)
+        ? (size ? size[1] : 0)
+        : (size ? size[0] : 0), jaggedBase }) {
+    //returns x1 (start of line), x2 (end of line) associated with the value of the tick
+    let axisDomain = [], position1, position2, domain1, domain2, tposition1, tposition2, textPositionMod = 0, textPositionMod2 = 0, defaultAnchor = "middle";
+    switch (orient) {
+        case "top":
+            position1 = "x1";
+            position2 = "x2";
+            domain1 = "y1";
+            domain2 = "y2";
+            axisDomain = [0, tickSize];
+            tposition1 = "tx";
+            tposition2 = "ty";
+            textPositionMod -= 20 - padding;
+            break;
+        case "bottom":
+            position1 = "x1";
+            position2 = "x2";
+            domain1 = "y2";
+            domain2 = "y1";
+            axisDomain = size ? [size[1], size[1] - tickSize] : [0, -tickSize];
+            tposition1 = "tx";
+            tposition2 = "ty";
+            textPositionMod += 20 + padding;
+            break;
+        case "right":
+            position1 = "y2";
+            position2 = "y1";
+            domain1 = "x2";
+            domain2 = "x1";
+            axisDomain = size ? [size[0], size[0] - tickSize] : [0, -tickSize];
+            tposition1 = "ty";
+            tposition2 = "tx";
+            textPositionMod += 5 + padding;
+            textPositionMod2 += 5;
+            defaultAnchor = "start";
+            break;
+        //left
+        default:
+            position1 = "y1";
+            position2 = "y2";
+            domain1 = "x1";
+            domain2 = "x2";
+            axisDomain = [0, tickSize];
+            tposition1 = "ty";
+            tposition2 = "tx";
+            textPositionMod -= 5 + padding;
+            textPositionMod2 += 5;
+            defaultAnchor = "end";
+            break;
+    }
+    let generatedTicks = tickValues instanceof Function ? tickValues({ orient }) : tickValues;
+    if (jaggedBase &&
+        generatedTicks.find((t) => t === scale.domain()[0]) === undefined) {
+        generatedTicks = [scale.domain()[0], ...generatedTicks];
+    }
+    return generatedTicks.map((tick, i) => {
+        const tickPosition = scale(tick);
+        return {
+            [position1]: tickPosition,
+            [position2]: tickPosition,
+            [domain1]: axisDomain[0],
+            [domain2]: axisDomain[1],
+            [tposition1]: tickPosition + textPositionMod2,
+            [tposition2]: axisDomain[0] + textPositionMod,
+            defaultAnchor,
+            renderMode: renderMode(tick, i),
+            value: tick
+        };
+    });
+}
+const axisLabels = ({ axisParts, tickFormat, rotate = 0, center = false, orient }) => {
+    // Pre-format all values
+    const entries = axisParts.map((axisPart, i) => ({
+        axisPart,
+        i,
+        formatted: tickFormat(axisPart.value, i)
+    }));
+    // Collision-aware filtering: skip labels that would overlap.
+    // Only applies to non-rotated text labels (rotation changes bounding box).
+    const isHorizontal = orient === "top" || orient === "bottom";
+    const isVertical = orient === "left" || orient === "right";
+    let visible = entries;
+    if (!rotate && entries.length > 1) {
+        const CHAR_WIDTH = 8;
+        const LINE_HEIGHT = 14;
+        const MIN_GAP = 8;
+        const textOf = (formatted) => {
+            if (typeof formatted === "string")
+                return formatted;
+            if (typeof formatted === "number")
+                return String(formatted);
+            return null; // React element — can't estimate width, always keep
+        };
+        if (isHorizontal) {
+            const sorted = [...entries].sort((a, b) => a.axisPart.tx - b.axisPart.tx);
+            let lastRight = -Infinity;
+            const keep = new Set();
+            for (const entry of sorted) {
+                const text = textOf(entry.formatted);
+                if (!text) {
+                    keep.add(entry.i);
+                    continue;
+                }
+                const halfW = (text.length * CHAR_WIDTH) / 2;
+                if (entry.axisPart.tx - halfW >= lastRight + MIN_GAP) {
+                    keep.add(entry.i);
+                    lastRight = entry.axisPart.tx + halfW;
+                }
+            }
+            visible = entries.filter((e) => keep.has(e.i));
+        }
+        else if (isVertical) {
+            const sorted = [...entries].sort((a, b) => a.axisPart.ty - b.axisPart.ty);
+            let lastBottom = -Infinity;
+            const keep = new Set();
+            for (const entry of sorted) {
+                if (entry.axisPart.ty >= lastBottom + LINE_HEIGHT + MIN_GAP) {
+                    keep.add(entry.i);
+                    lastBottom = entry.axisPart.ty;
+                }
+            }
+            visible = entries.filter((e) => keep.has(e.i));
+        }
+    }
+    return visible.map(({ axisPart, i, formatted: renderedValue }) => {
+        if (typeof renderedValue !== "object" || renderedValue instanceof Date) {
+            renderedValue = (React.createElement("text", { textAnchor: axisPart.defaultAnchor, className: "axis-label" }, renderedValue.toString ? renderedValue.toString() : renderedValue));
+        }
+        let textX = axisPart.tx;
+        let textY = axisPart.ty;
+        if (center) {
+            switch (orient) {
+                case "right":
+                    textX -= (axisPart.x2 - axisPart.x1) / 2;
+                    break;
+                case "left":
+                    textX += (axisPart.x2 - axisPart.x1) / 2;
+                    break;
+                case "top":
+                    textY += (axisPart.y2 - axisPart.y1) / 2;
+                    break;
+                case "bottom":
+                    textY -= (axisPart.y2 - axisPart.y1) / 2;
+                    break;
+            }
+        }
+        return (React.createElement("g", { key: i, pointerEvents: "none", transform: `translate(${textX},${textY}) rotate(${rotate})`, className: "axis-label" }, renderedValue));
+    });
+};
+exports.axisLabels = axisLabels;
+const baselineGenerator = (orient, size, className) => {
+    const offsets = {
+        left: { x: 0, y: 0, width: 0, height: size ? size[1] : 0 },
+        right: { x: size ? size[0] : 0, y: 0, width: 0, height: size ? size[1] : 0 },
+        top: { x: 0, y: 0, width: size ? size[0] : 0, height: 0 },
+        bottom: { x: 0, y: size ? size[1] : 0, width: size ? size[0] : 0, height: 0 }
+    };
+    const orientOffset = offsets[orient];
+    return (React.createElement("line", { key: "baseline", className: `axis-baseline ${className}`, stroke: "currentColor", strokeLinecap: "square", x1: orientOffset.x, x2: orientOffset.x + orientOffset.width, y1: orientOffset.y, y2: orientOffset.y + orientOffset.height }));
+};
+exports.baselineGenerator = baselineGenerator;
+const axisLines = ({ axisParts, orient, tickLineGenerator = defaultTickLineGenerator, className, jaggedBase, scale, showOutboundTickLines = false }) => {
+    const axisLines = axisParts.map((axisPart, i) => tickLineGenerator({
+        xy: axisPart,
+        orient,
+        i,
+        className,
+        jaggedBase,
+        scale
+    }));
+    const outboundAxisLines = showOutboundTickLines
+        ? axisParts.map((axisPart, i) => outboundTickLineGenerator({
+            xy: axisPart,
+            orient,
+            i,
+            className
+        }))
+        : [];
+    return [...axisLines, outboundAxisLines];
+};
+exports.axisLines = axisLines;