semiotic 2.0.3 → 3.0.0-beta.2

package/ai/dist/src/components/stream/OrdinalPipelineStore.js

@@ -0,0 +1,786 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrdinalPipelineStore = void 0;
+const d3_scale_1 = require("d3-scale");
+const RingBuffer_1 = require("../realtime/RingBuffer");
+const IncrementalExtent_1 = require("../realtime/IncrementalExtent");
+const accessorUtils_1 = require("./accessorUtils");
+const barScene_1 = require("./ordinalSceneBuilders/barScene");
+const pointScene_1 = require("./ordinalSceneBuilders/pointScene");
+const pieScene_1 = require("./ordinalSceneBuilders/pieScene");
+const statisticalScene_1 = require("./ordinalSceneBuilders/statisticalScene");
+const timelineScene_1 = require("./ordinalSceneBuilders/timelineScene");
+const connectorScene_1 = require("./ordinalSceneBuilders/connectorScene");
+const SCENE_BUILDERS = {
+    bar: barScene_1.buildBarScene,
+    clusterbar: barScene_1.buildClusterBarScene,
+    point: pointScene_1.buildPointScene,
+    swarm: pointScene_1.buildSwarmScene,
+    pie: pieScene_1.buildPieScene,
+    donut: pieScene_1.buildPieScene,
+    boxplot: statisticalScene_1.buildBoxplotScene,
+    violin: statisticalScene_1.buildViolinScene,
+    histogram: statisticalScene_1.buildHistogramScene,
+    ridgeline: statisticalScene_1.buildRidgelineScene,
+    timeline: timelineScene_1.buildTimelineScene,
+};
+// ── OrdinalPipelineStore ───────────────────────────────────────────────
+class OrdinalPipelineStore {
+    constructor(config) {
+        this.rExtent = new IncrementalExtent_1.IncrementalExtent();
+        /** Per-accessor extents for multiAxis mode */
+        this.rExtents = [];
+        /** All resolved rAccessors (length > 1 when multiAxis) */
+        this.rAccessors = [];
+        /** Discovered categories in insertion order */
+        this.categories = new Set();
+        /** Lazy color map built from colorScheme for resolvePieceStyle */
+        this._colorSchemeMap = null;
+        this._colorSchemeIndex = 0;
+        // ── Pulse tracking ──────────────────────────────────────────────────
+        this.timestampBuffer = null;
+        // ── Transition animation ────────────────────────────────────────────
+        this.activeTransition = null;
+        this.prevPositionMap = new Map();
+        // ── Staleness tracking ──────────────────────────────────────────────
+        this.lastIngestTime = 0;
+        this.scales = null;
+        /** Per-accessor scales for multiAxis */
+        this.multiScales = [];
+        this.scene = [];
+        this.columns = {};
+        this.version = 0;
+        this.config = config;
+        this.buffer = new RingBuffer_1.RingBuffer(config.windowSize);
+        // Resolve accessors
+        this.getO = (0, accessorUtils_1.resolveStringAccessor)(config.oAccessor || config.categoryAccessor, "category");
+        const isStreaming = config.runtimeMode === "streaming";
+        // Resolve rAccessor — may be an array for multiAxis
+        const rawR = config.rAccessor;
+        if (Array.isArray(rawR)) {
+            this.rAccessors = rawR.map(acc => (0, accessorUtils_1.resolveAccessor)(acc, "value"));
+            this.getR = this.rAccessors[0];
+            this.rExtents = rawR.map(() => new IncrementalExtent_1.IncrementalExtent());
+        }
+        else {
+            if (isStreaming && (config.timeAccessor || config.valueAccessor)) {
+                this.getR = (0, accessorUtils_1.resolveAccessor)(config.valueAccessor || rawR, "value");
+            }
+            else {
+                this.getR = (0, accessorUtils_1.resolveAccessor)(rawR, "value");
+            }
+            this.rAccessors = [this.getR];
+            this.rExtents = [this.rExtent];
+        }
+        this.getStack = (0, accessorUtils_1.resolveStringAccessor)(config.stackBy);
+        this.getGroup = (0, accessorUtils_1.resolveStringAccessor)(config.groupBy);
+        this.getColor = (0, accessorUtils_1.resolveStringAccessor)(config.colorAccessor);
+        this.getConnector = (0, accessorUtils_1.resolveStringAccessor)(config.connectorAccessor);
+        if (config.pulse) {
+            this.timestampBuffer = new RingBuffer_1.RingBuffer(config.windowSize);
+        }
+    }
+    // ── Data ingestion ───────────────────────────────────────────────────
+    ingest(changeset) {
+        const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+        this.lastIngestTime = now;
+        if (changeset.bounded) {
+            this.buffer.clear();
+            this.rExtent.clear();
+            this.categories.clear();
+            if (this.timestampBuffer)
+                this.timestampBuffer.clear();
+            const targetSize = changeset.totalSize || changeset.inserts.length;
+            if (targetSize > this.buffer.capacity) {
+                this.buffer.resize(targetSize);
+                if (this.timestampBuffer && targetSize > this.timestampBuffer.capacity) {
+                    this.timestampBuffer.resize(targetSize);
+                }
+            }
+            for (const d of changeset.inserts) {
+                this.buffer.push(d);
+                if (this.timestampBuffer)
+                    this.timestampBuffer.push(now);
+                this.categories.add(this.getO(d));
+                this.pushValueExtent(d);
+            }
+        }
+        else {
+            // Streaming append
+            for (const d of changeset.inserts) {
+                const evicted = this.buffer.push(d);
+                if (this.timestampBuffer)
+                    this.timestampBuffer.push(now);
+                this.categories.add(this.getO(d));
+                this.pushValueExtent(d);
+                if (evicted != null) {
+                    this.evictValueExtent(evicted);
+                }
+            }
+        }
+        return true;
+    }
+    pushValueExtent(d) {
+        if (this.config.chartType === "timeline") {
+            const range = this.getRawRange(d);
+            if (range) {
+                this.rExtent.push(range[0]);
+                this.rExtent.push(range[1]);
+            }
+        }
+        else if (this.rAccessors.length > 1) {
+            // MultiAxis: track extents per accessor
+            for (let i = 0; i < this.rAccessors.length; i++) {
+                this.rExtents[i].push(this.rAccessors[i](d));
+            }
+            // Also push to primary extent for single-scale fallback
+            this.rExtent.push(this.getR(d));
+        }
+        else {
+            this.rExtent.push(this.getR(d));
+        }
+    }
+    evictValueExtent(d) {
+        if (this.config.chartType === "timeline") {
+            const range = this.getRawRange(d);
+            if (range) {
+                this.rExtent.evict(range[0]);
+                this.rExtent.evict(range[1]);
+            }
+        }
+        else if (this.rAccessors.length > 1) {
+            for (let i = 0; i < this.rAccessors.length; i++) {
+                this.rExtents[i].evict(this.rAccessors[i](d));
+            }
+            this.rExtent.evict(this.getR(d));
+        }
+        else {
+            this.rExtent.evict(this.getR(d));
+        }
+    }
+    /** For timeline type: resolve rAccessor as a [start, end] pair */
+    getRawRange(d) {
+        const acc = this.config.rAccessor;
+        if (!acc)
+            return null;
+        const result = typeof acc === "function" ? acc(d) : d[acc];
+        if (Array.isArray(result) && result.length >= 2) {
+            return [+result[0], +result[1]];
+        }
+        return null;
+    }
+    // ── Scene computation ────────────────────────────────────────────────
+    computeScene(layout) {
+        const { config, buffer } = this;
+        if (buffer.size === 0) {
+            this.scales = null;
+            this.scene = [];
+            this.columns = {};
+            this.version++;
+            return;
+        }
+        // Recalculate dirty extents
+        if (this.rExtent.dirty) {
+            this.rExtent.recalculate(buffer, this.getR);
+        }
+        const data = buffer.toArray();
+        const projection = config.projection || "vertical";
+        // 1. Resolve category extent
+        const oExtent = config.oExtent || this.resolveCategories(data);
+        // 2. Compute value extent
+        const rDomain = this.computeValueDomain(data, oExtent);
+        // 3. Build scales
+        const isVertical = projection === "vertical";
+        const isHorizontal = projection === "horizontal";
+        const isRadial = projection === "radial";
+        const padding = config.barPadding != null ? config.barPadding / (isVertical ? layout.width : layout.height) : 0.1;
+        let oScale;
+        let rScale;
+        if (isRadial) {
+            // Radial: oScale maps to [0, 2π], rScale maps outward
+            oScale = (0, d3_scale_1.scaleBand)().domain(oExtent).range([0, 1]).padding(0);
+            const maxR = Math.min(layout.width, layout.height) / 2;
+            const innerR = config.innerRadius || 0;
+            rScale = (0, d3_scale_1.scaleLinear)().domain(rDomain).range([innerR, maxR]);
+        }
+        else if (isHorizontal) {
+            oScale = (0, d3_scale_1.scaleBand)().domain(oExtent).range([0, layout.height]).padding(padding);
+            rScale = (0, d3_scale_1.scaleLinear)().domain(rDomain).range([0, layout.width]);
+        }
+        else {
+            // vertical (default)
+            oScale = (0, d3_scale_1.scaleBand)().domain(oExtent).range([0, layout.width]).padding(padding);
+            rScale = (0, d3_scale_1.scaleLinear)().domain(rDomain).range([layout.height, 0]);
+        }
+        this.scales = { o: oScale, r: rScale, projection };
+        // 3b. Build per-accessor scales for multiAxis mode
+        if (this.rAccessors.length > 1 && config.multiAxis) {
+            this.multiScales = this.rAccessors.map((acc, i) => {
+                const ext = this.rExtents[i];
+                if (ext.dirty)
+                    ext.recalculate(buffer, acc);
+                let [min, max] = ext.extent;
+                if (min === Infinity) {
+                    min = 0;
+                    max = 1;
+                }
+                const pad = config.extentPadding || 0.05;
+                const range = max - min;
+                const padAmt = range > 0 ? range * pad : 1;
+                min -= padAmt;
+                max += padAmt;
+                if (min > 0)
+                    min = 0;
+                if (isHorizontal)
+                    return (0, d3_scale_1.scaleLinear)().domain([min, max]).range([0, layout.width]);
+                return (0, d3_scale_1.scaleLinear)().domain([min, max]).range([layout.height, 0]);
+            });
+        }
+        else {
+            this.multiScales = [];
+        }
+        // 3c. Expand data for multi-accessor: each datum becomes N pieces with rIndex
+        let expandedData = data;
+        if (this.rAccessors.length > 1) {
+            expandedData = data.flatMap(d => this.rAccessors.map((acc, rIndex) => ({
+                ...d,
+                __rIndex: rIndex,
+                __rValue: acc(d),
+                __rName: this.resolveRAccessorName(rIndex)
+            })));
+        }
+        // 4. Build projected columns
+        this.columns = this.buildColumns(expandedData, oExtent, oScale, projection, layout);
+        // Snapshot positions for transition animation
+        if (this.config.transition && this.scene.length > 0) {
+            this.snapshotPositions();
+        }
+        // 5. Build scene graph
+        this.scene = this.buildSceneNodes(expandedData, layout);
+        // Apply decay/pulse to discrete scene nodes
+        if (this.config.decay) {
+            this.applyDecay(this.scene, data);
+        }
+        if (this.config.pulse) {
+            this.applyPulse(this.scene, data);
+        }
+        // Start transition animation
+        if (this.config.transition && this.prevPositionMap.size > 0) {
+            this.startTransition();
+        }
+        this.version++;
+    }
+    resolveRAccessorName(index) {
+        const acc = Array.isArray(this.config.rAccessor) ? this.config.rAccessor[index] : this.config.rAccessor;
+        return typeof acc === "string" ? acc : `value${index}`;
+    }
+    // ── Category resolution ──────────────────────────────────────────────
+    resolveCategories(data) {
+        const cats = Array.from(this.categories);
+        const sort = this.config.oSort;
+        // In streaming mode, preserve insertion order by default to avoid
+        // jarring category shuffling as values fluctuate in the sliding window
+        if (this.config.runtimeMode === "streaming" && sort === undefined) {
+            return cats;
+        }
+        if (sort === false)
+            return cats;
+        if (typeof sort === "function") {
+            return cats.sort(sort);
+        }
+        // Default: sort by total value descending (unless explicitly "asc")
+        const sums = new Map();
+        for (const d of data) {
+            const cat = this.getO(d);
+            sums.set(cat, (sums.get(cat) || 0) + Math.abs(this.getR(d)));
+        }
+        if (sort === "asc") {
+            return cats.sort((a, b) => (sums.get(a) || 0) - (sums.get(b) || 0));
+        }
+        // Default, true, "desc", or undefined → descending
+        return cats.sort((a, b) => (sums.get(b) || 0) - (sums.get(a) || 0));
+    }
+    // ── Value domain computation ─────────────────────────────────────────
+    computeValueDomain(data, oExtent) {
+        const chartType = this.config.chartType;
+        const pad = this.config.extentPadding || 0.05;
+        // For radial pie/donut, the value axis represents proportions
+        // But for radial point (radar), use actual data values
+        if (this.config.projection === "radial" && (chartType === "pie" || chartType === "donut")) {
+            return [0, 1];
+        }
+        let min = 0;
+        let max = 0;
+        if (chartType === "bar" && this.getStack) {
+            // Stacked bars: compute per-category stacked sums
+            const posSums = new Map();
+            const negSums = new Map();
+            for (const d of data) {
+                const cat = this.getO(d);
+                const val = this.getR(d);
+                if (val >= 0) {
+                    posSums.set(cat, (posSums.get(cat) || 0) + val);
+                }
+                else {
+                    negSums.set(cat, (negSums.get(cat) || 0) + val);
+                }
+            }
+            for (const s of posSums.values())
+                if (s > max)
+                    max = s;
+            for (const s of negSums.values())
+                if (s < min)
+                    min = s;
+        }
+        else if (chartType === "bar") {
+            // Non-stacked bars: pieces within each category are summed,
+            // so the domain must cover the per-category total
+            const catSums = new Map();
+            for (const d of data) {
+                const cat = this.getO(d);
+                const val = this.getR(d);
+                catSums.set(cat, (catSums.get(cat) || 0) + val);
+            }
+            for (const s of catSums.values()) {
+                if (s > max)
+                    max = s;
+                if (s < min)
+                    min = s;
+            }
+        }
+        else if (chartType === "clusterbar") {
+            // Cluster bars: individual values (side-by-side)
+            for (const d of data) {
+                const val = this.getR(d);
+                if (val > max)
+                    max = val;
+                if (val < min)
+                    min = val;
+            }
+        }
+        else {
+            // Points, swarm, summary types: raw data extent
+            const dataMin = this.rExtent.extent[0];
+            const dataMax = this.rExtent.extent[1];
+            if (dataMin !== Infinity)
+                min = dataMin;
+            if (dataMax !== -Infinity)
+                max = dataMax;
+        }
+        // Apply user-specified extents
+        if (this.config.rExtent) {
+            if (this.config.rExtent[0] != null)
+                min = this.config.rExtent[0];
+            if (this.config.rExtent[1] != null)
+                max = this.config.rExtent[1];
+        }
+        // Apply padding
+        const range = max - min;
+        const padAmount = range > 0 ? range * pad : 1;
+        if (!this.config.rExtent?.[0])
+            min -= padAmount;
+        if (!this.config.rExtent?.[1])
+            max += padAmount;
+        // Bars should include zero
+        if (chartType === "bar" || chartType === "clusterbar") {
+            if (min > 0)
+                min = 0;
+            if (max < 0)
+                max = 0;
+        }
+        return [min, max];
+    }
+    // ── Column projection ────────────────────────────────────────────────
+    buildColumns(data, oExtent, oScale, projection, layout) {
+        const columns = {};
+        // Group data by category
+        const grouped = new Map();
+        for (const d of data) {
+            const cat = this.getO(d);
+            if (!grouped.has(cat))
+                grouped.set(cat, []);
+            grouped.get(cat).push(d);
+        }
+        // Compute total for radial proportions
+        let total = 0;
+        if (projection === "radial") {
+            for (const d of data) {
+                total += Math.abs(this.getR(d));
+            }
+        }
+        // Dynamic column widths: compute proportional widths instead of uniform bands
+        const dcw = this.config.dynamicColumnWidth;
+        let dynamicWidths = null;
+        if (dcw && projection !== "radial") {
+            dynamicWidths = new Map();
+            let totalWidth = 0;
+            for (const cat of oExtent) {
+                const pieceData = grouped.get(cat) || [];
+                let colValue;
+                if (typeof dcw === "string") {
+                    colValue = pieceData.reduce((s, d) => s + (Number(d[dcw]) || 0), 0);
+                }
+                else {
+                    colValue = dcw(pieceData);
+                }
+                dynamicWidths.set(cat, colValue);
+                totalWidth += colValue;
+            }
+            // Normalize to available space
+            const availableSpace = projection === "horizontal" ? layout.height : layout.width;
+            const paddingTotal = oScale.padding() * oScale.step() * oExtent.length;
+            const usableSpace = availableSpace - paddingTotal;
+            if (totalWidth > 0) {
+                for (const [cat, val] of dynamicWidths) {
+                    dynamicWidths.set(cat, (val / totalWidth) * usableSpace);
+                }
+            }
+        }
+        let cumulativePct = 0;
+        let cumulativeX = 0;
+        for (const cat of oExtent) {
+            const pieceData = grouped.get(cat) || [];
+            const catSum = pieceData.reduce((s, d) => s + Math.abs(this.getR(d)), 0);
+            const pct = total > 0 ? catSum / total : 0;
+            let bandStart;
+            let bandwidth;
+            if (dynamicWidths) {
+                bandStart = cumulativeX;
+                bandwidth = dynamicWidths.get(cat) || oScale.bandwidth();
+                cumulativeX += bandwidth + (oScale.padding() * oScale.step());
+            }
+            else {
+                bandStart = oScale(cat) ?? 0;
+                bandwidth = oScale.bandwidth();
+            }
+            columns[cat] = {
+                name: cat,
+                x: bandStart,
+                y: 0,
+                width: bandwidth,
+                middle: bandStart + bandwidth / 2,
+                padding: oScale.padding() * oScale.step(),
+                pieceData,
+                pct,
+                pctStart: cumulativePct
+            };
+            cumulativePct += pct;
+        }
+        return columns;
+    }
+    // ── Scene graph building ─────────────────────────────────────────────
+    getSceneContext() {
+        return {
+            scales: this.scales,
+            columns: this.columns,
+            config: this.config,
+            getR: this.getR,
+            getStack: this.getStack,
+            getGroup: this.getGroup,
+            getColor: this.getColor,
+            getConnector: this.getConnector,
+            getO: this.getO,
+            multiScales: this.multiScales,
+            rAccessors: this.rAccessors,
+            resolvePieceStyle: (d, category) => this.resolvePieceStyle(d, category),
+            resolveSummaryStyle: (d, category) => this.resolveSummaryStyle(d, category),
+            getRawRange: (d) => this.getRawRange(d)
+        };
+    }
+    buildSceneNodes(data, layout) {
+        if (!this.scales)
+            return [];
+        const ctx = this.getSceneContext();
+        const builder = SCENE_BUILDERS[this.config.chartType];
+        let nodes = builder ? builder(ctx, layout) : [];
+        // Build connectors if configured
+        if (this.getConnector && this.scales) {
+            const connectorNodes = (0, connectorScene_1.buildConnectors)(ctx, nodes, layout);
+            // Connectors render behind pieces
+            nodes = [...connectorNodes, ...nodes];
+        }
+        return nodes;
+    }
+    // ── Style resolution ─────────────────────────────────────────────────
+    resolvePieceStyle(d, category) {
+        if (typeof this.config.pieceStyle === "function") {
+            return this.config.pieceStyle(d, category);
+        }
+        if (this.config.pieceStyle && typeof this.config.pieceStyle === "object") {
+            return this.config.pieceStyle;
+        }
+        if (this.config.barColors && category) {
+            return { fill: this.config.barColors[category] || "#007bff" };
+        }
+        // Use colorScheme (or default palette) to generate colors by category
+        if (category) {
+            return { fill: this.getColorFromScheme(category) };
+        }
+        return { fill: "#007bff" };
+    }
+    getColorFromScheme(key) {
+        if (!this._colorSchemeMap)
+            this._colorSchemeMap = new Map();
+        const existing = this._colorSchemeMap.get(key);
+        if (existing)
+            return existing;
+        const palette = Array.isArray(this.config.colorScheme)
+            ? this.config.colorScheme
+            : ["#4e79a7", "#f28e2b", "#e15759", "#76b7b2", "#59a14f", "#edc948", "#b07aa1", "#ff9da7", "#9c755f", "#bab0ac"];
+        const color = palette[this._colorSchemeIndex % palette.length];
+        this._colorSchemeIndex++;
+        this._colorSchemeMap.set(key, color);
+        return color;
+    }
+    resolveSummaryStyle(d, category) {
+        if (typeof this.config.summaryStyle === "function") {
+            return this.config.summaryStyle(d, category);
+        }
+        if (this.config.summaryStyle && typeof this.config.summaryStyle === "object") {
+            return this.config.summaryStyle;
+        }
+        return { fill: "#007bff", fillOpacity: 0.6, stroke: "#007bff", strokeWidth: 1 };
+    }
+    // ── Decay ────────────────────────────────────────────────────────────
+    computeDecayOpacity(bufferIndex, bufferSize) {
+        const decay = this.config.decay;
+        if (!decay || bufferSize <= 1)
+            return 1;
+        const minOpacity = decay.minOpacity ?? 0.1;
+        const age = bufferSize - 1 - bufferIndex;
+        switch (decay.type) {
+            case "linear": {
+                const t = 1 - age / (bufferSize - 1);
+                return minOpacity + t * (1 - minOpacity);
+            }
+            case "exponential": {
+                const halfLife = decay.halfLife ?? bufferSize / 2;
+                const t = Math.pow(0.5, age / halfLife);
+                return minOpacity + t * (1 - minOpacity);
+            }
+            case "step": {
+                const threshold = decay.stepThreshold ?? bufferSize * 0.5;
+                return age < threshold ? 1 : minOpacity;
+            }
+            default:
+                return 1;
+        }
+    }
+    applyDecay(nodes, data) {
+        if (!this.config.decay)
+            return;
+        const bufferSize = data.length;
+        if (bufferSize <= 1)
+            return;
+        const indexMap = new Map();
+        for (let i = 0; i < data.length; i++) {
+            indexMap.set(data[i], i);
+        }
+        for (const node of nodes) {
+            if (node.type === "connector" || node.type === "violin" || node.type === "boxplot" || node.type === "wedge")
+                continue;
+            const idx = indexMap.get(node.datum);
+            if (idx == null)
+                continue;
+            const decayOpacity = this.computeDecayOpacity(idx, bufferSize);
+            const baseOpacity = node.style?.opacity ?? 1;
+            node.style = { ...node.style, opacity: baseOpacity * decayOpacity };
+        }
+    }
+    // ── Pulse ───────────────────────────────────────────────────────────
+    applyPulse(nodes, data) {
+        if (!this.config.pulse || !this.timestampBuffer)
+            return;
+        const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+        const duration = this.config.pulse.duration ?? 500;
+        const pulseColor = this.config.pulse.color ?? "rgba(255,255,255,0.6)";
+        const indexMap = new Map();
+        for (let i = 0; i < data.length; i++) {
+            indexMap.set(data[i], i);
+        }
+        for (const node of nodes) {
+            if (node.type === "connector" || node.type === "violin" || node.type === "boxplot" || node.type === "wedge")
+                continue;
+            const idx = indexMap.get(node.datum);
+            if (idx == null)
+                continue;
+            const insertTime = this.timestampBuffer.get(idx);
+            if (insertTime == null)
+                continue;
+            const age = now - insertTime;
+            if (age < duration) {
+                const intensity = 1 - age / duration;
+                node._pulseIntensity = intensity;
+                node._pulseColor = pulseColor;
+            }
+        }
+    }
+    get hasActivePulses() {
+        if (!this.config.pulse || !this.timestampBuffer || this.timestampBuffer.size === 0)
+            return false;
+        const now = typeof performance !== "undefined" ? performance.now() : Date.now();
+        const duration = this.config.pulse.duration ?? 500;
+        const newest = this.timestampBuffer.peek();
+        return newest != null && (now - newest) < duration;
+    }
+    // ── Transitions ─────────────────────────────────────────────────────
+    snapshotPositions() {
+        this.prevPositionMap.clear();
+        for (let i = 0; i < this.scene.length; i++) {
+            const node = this.scene[i];
+            if (node.type === "point") {
+                this.prevPositionMap.set(`p:${i}`, { x: node.x, y: node.y, r: node.r });
+            }
+            else if (node.type === "rect") {
+                const key = `r:${node.group || ""}:${node.datum?.category ?? i}`;
+                this.prevPositionMap.set(key, { x: node.x, y: node.y, w: node.w, h: node.h });
+            }
+        }
+    }
+    startTransition() {
+        if (!this.config.transition || this.prevPositionMap.size === 0)
+            return;
+        const duration = this.config.transition.duration ?? 300;
+        let hasChanges = false;
+        for (let i = 0; i < this.scene.length; i++) {
+            const node = this.scene[i];
+            let key = null;
+            if (node.type === "point") {
+                key = `p:${i}`;
+            }
+            else if (node.type === "rect") {
+                key = `r:${node.group || ""}:${node.datum?.category ?? i}`;
+            }
+            if (!key)
+                continue;
+            const prev = this.prevPositionMap.get(key);
+            if (!prev)
+                continue;
+            if (node.type === "point") {
+                if (prev.x !== node.x || prev.y !== node.y) {
+                    node._targetX = node.x;
+                    node._targetY = node.y;
+                    node.x = prev.x;
+                    node.y = prev.y;
+                    hasChanges = true;
+                }
+            }
+            else if (node.type === "rect") {
+                if (prev.x !== node.x || prev.y !== node.y || prev.w !== node.w || prev.h !== node.h) {
+                    node._targetX = node.x;
+                    node._targetY = node.y;
+                    node._targetW = node.w;
+                    node._targetH = node.h;
+                    node.x = prev.x;
+                    node.y = prev.y;
+                    node.w = prev.w ?? node.w;
+                    node.h = prev.h ?? node.h;
+                    hasChanges = true;
+                }
+            }
+        }
+        if (hasChanges) {
+            this.activeTransition = {
+                startTime: typeof performance !== "undefined" ? performance.now() : Date.now(),
+                duration
+            };
+        }
+    }
+    advanceTransition(now) {
+        if (!this.activeTransition)
+            return false;
+        const elapsed = now - this.activeTransition.startTime;
+        const rawT = Math.min(elapsed / this.activeTransition.duration, 1);
+        const t = this.config.transition?.easing === "linear"
+            ? rawT
+            : 1 - Math.pow(1 - rawT, 3);
+        for (const node of this.scene) {
+            if (node.type === "point") {
+                if (node._targetX === undefined)
+                    continue;
+                const key = `p:${0}`;
+                const prev = this.prevPositionMap.get(key);
+                if (!prev)
+                    continue;
+                node.x = prev.x + (node._targetX - prev.x) * t;
+                node.y = prev.y + (node._targetY - prev.y) * t;
+            }
+            else if (node.type === "rect") {
+                if (node._targetX === undefined)
+                    continue;
+                const key = `r:${node.group || ""}:${node.datum?.category ?? 0}`;
+                const prev = this.prevPositionMap.get(key);
+                if (!prev)
+                    continue;
+                node.x = prev.x + (node._targetX - prev.x) * t;
+                node.y = prev.y + (node._targetY - prev.y) * t;
+                if (prev.w !== undefined) {
+                    node.w = prev.w + (node._targetW - prev.w) * t;
+                    node.h = prev.h + (node._targetH - prev.h) * t;
+                }
+            }
+        }
+        if (rawT >= 1) {
+            for (const node of this.scene) {
+                if (node.type === "point") {
+                    if (node._targetX === undefined)
+                        continue;
+                    node.x = node._targetX;
+                    node.y = node._targetY;
+                    node._targetX = undefined;
+                    node._targetY = undefined;
+                }
+                else if (node.type === "rect") {
+                    if (node._targetX === undefined)
+                        continue;
+                    node.x = node._targetX;
+                    node.y = node._targetY;
+                    node.w = node._targetW;
+                    node.h = node._targetH;
+                    node._targetX = undefined;
+                    node._targetY = undefined;
+                    node._targetW = undefined;
+                    node._targetH = undefined;
+                }
+            }
+            this.activeTransition = null;
+            return false;
+        }
+        return true;
+    }
+    // ── Public accessors ─────────────────────────────────────────────────
+    getData() {
+        return this.buffer.toArray();
+    }
+    clear() {
+        this.buffer.clear();
+        this.rExtent.clear();
+        this.categories.clear();
+        if (this.timestampBuffer)
+            this.timestampBuffer.clear();
+        this.prevPositionMap.clear();
+        this.activeTransition = null;
+        this.lastIngestTime = 0;
+        this.scales = null;
+        this.scene = [];
+        this.columns = {};
+        this.version++;
+    }
+    get size() {
+        return this.buffer.size;
+    }
+    getOAccessor() {
+        return this.getO;
+    }
+    getRAccessor() {
+        return this.getR;
+    }
+    updateConfig(config) {
+        if (config.colorScheme !== this.config.colorScheme) {
+            this._colorSchemeMap = null;
+            this._colorSchemeIndex = 0;
+        }
+        Object.assign(this.config, config);
+    }
+}
+exports.OrdinalPipelineStore = OrdinalPipelineStore;