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

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

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