semiotic 2.0.3 → 3.0.0-beta.2

package/ai/dist/src/components/processing/layouts/hierarchyLayout.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hierarchyLayouts = exports.hierarchicalTypeHash = void 0;
+const d3_hierarchy_1 = require("d3-hierarchy");
+exports.hierarchicalTypeHash = {
+    dendrogram: d3_hierarchy_1.tree,
+    tree: d3_hierarchy_1.tree,
+    circlepack: d3_hierarchy_1.pack,
+    cluster: d3_hierarchy_1.cluster,
+    treemap: d3_hierarchy_1.treemap,
+    partition: d3_hierarchy_1.partition
+};
+// Hierarchy layouts don't use the standard layout handler pattern because
+// they are applied during data loading (via hierarchicalTypeHash), not during
+// the layout dispatch phase. These entries exist so the layout map recognizes
+// these types as valid and falls through to the default node positioning.
+const hierarchyFallthrough = ({ projectedNodes, projectedEdges }) => {
+    projectedNodes.forEach((node) => {
+        node.x = node.x === undefined ? (node.x0 + node.x1) / 2 : node.x;
+        node.y = node.y === undefined ? node.y0 : node.y;
+    });
+    return { projectedNodes, projectedEdges };
+};
+exports.hierarchyLayouts = {
+    tree: hierarchyFallthrough,
+    dendrogram: hierarchyFallthrough,
+    cluster: hierarchyFallthrough,
+    treemap: hierarchyFallthrough,
+    circlepack: hierarchyFallthrough,
+    partition: hierarchyFallthrough
+};

package/ai/dist/src/components/processing/layouts/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allNetworkLayouts = exports.arcLayout = exports.matrixLayout = exports.simpleLayouts = exports.hierarchicalTypeHash = exports.hierarchyLayouts = exports.motifsLayout = exports.forceLayout = exports.sankeyOrientHash = exports.sankeyLayout = exports.chordLayout = void 0;
+const chordLayout_1 = require("./chordLayout");
+const sankeyLayout_1 = require("./sankeyLayout");
+const forceLayout_1 = require("./forceLayout");
+const hierarchyLayout_1 = require("./hierarchyLayout");
+const simpleLayouts_1 = require("./simpleLayouts");
+var chordLayout_2 = require("./chordLayout");
+Object.defineProperty(exports, "chordLayout", { enumerable: true, get: function () { return chordLayout_2.chordLayout; } });
+var sankeyLayout_2 = require("./sankeyLayout");
+Object.defineProperty(exports, "sankeyLayout", { enumerable: true, get: function () { return sankeyLayout_2.sankeyLayout; } });
+Object.defineProperty(exports, "sankeyOrientHash", { enumerable: true, get: function () { return sankeyLayout_2.sankeyOrientHash; } });
+var forceLayout_2 = require("./forceLayout");
+Object.defineProperty(exports, "forceLayout", { enumerable: true, get: function () { return forceLayout_2.forceLayout; } });
+Object.defineProperty(exports, "motifsLayout", { enumerable: true, get: function () { return forceLayout_2.motifsLayout; } });
+var hierarchyLayout_2 = require("./hierarchyLayout");
+Object.defineProperty(exports, "hierarchyLayouts", { enumerable: true, get: function () { return hierarchyLayout_2.hierarchyLayouts; } });
+Object.defineProperty(exports, "hierarchicalTypeHash", { enumerable: true, get: function () { return hierarchyLayout_2.hierarchicalTypeHash; } });
+var simpleLayouts_2 = require("./simpleLayouts");
+Object.defineProperty(exports, "simpleLayouts", { enumerable: true, get: function () { return simpleLayouts_2.simpleLayouts; } });
+Object.defineProperty(exports, "matrixLayout", { enumerable: true, get: function () { return simpleLayouts_2.matrixLayout; } });
+Object.defineProperty(exports, "arcLayout", { enumerable: true, get: function () { return simpleLayouts_2.arcLayout; } });
+exports.allNetworkLayouts = {
+    chord: chordLayout_1.chordLayout,
+    sankey: sankeyLayout_1.sankeyLayout,
+    flowchart: sankeyLayout_1.sankeyLayout,
+    force: forceLayout_1.forceLayout,
+    motifs: forceLayout_1.motifsLayout,
+    ...hierarchyLayout_1.hierarchyLayouts,
+    ...simpleLayouts_1.simpleLayouts
+};

package/ai/dist/src/components/processing/layouts/sankeyLayout.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sankeyLayout = exports.sankeyOrientHash = void 0;
+const d3_sankey_circular_1 = require("d3-sankey-circular");
+exports.sankeyOrientHash = {
+    left: d3_sankey_circular_1.sankeyLeft,
+    right: d3_sankey_circular_1.sankeyRight,
+    center: d3_sankey_circular_1.sankeyCenter,
+    justify: d3_sankey_circular_1.sankeyJustify
+};
+const sankeyLayout = ({ projectedNodes, projectedEdges, networkSettings, adjustedSize, nodeIDAccessor }) => {
+    const { orient = "center", iterations = 100, nodePadding, nodePaddingRatio = nodePadding ? undefined : 0.5, nodeWidth = networkSettings.type === "flowchart" ? 2 : 24, customSankey, direction = "right", showArrows = false } = networkSettings;
+    const sankeyOrient = exports.sankeyOrientHash[orient];
+    const actualSankey = customSankey || d3_sankey_circular_1.sankeyCircular;
+    let frameExtent = [[0, 0], adjustedSize];
+    if (networkSettings.direction === "up" ||
+        networkSettings.direction === "down") {
+        frameExtent = [
+            [0, 0],
+            [adjustedSize[1], adjustedSize[0]]
+        ];
+    }
+    // CREATE FAKE EDGES TO GET UP TO PASSED VALUE
+    let resultEdges = projectedEdges;
+    const generateEphemeralEdges = projectedNodes.some((n) => !n.createdByFrame && n.value > 0);
+    if (generateEphemeralEdges) {
+        const edgeValueMap = new Map();
+        for (const edge of projectedEdges) {
+            if (!edgeValueMap.has(edge.source.id)) {
+                edgeValueMap.set(edge.source.id, {
+                    source: 0,
+                    target: 0
+                });
+            }
+            if (!edgeValueMap.has(edge.target.id)) {
+                edgeValueMap.set(edge.target.id, {
+                    source: 0,
+                    target: 0
+                });
+            }
+            edgeValueMap.get(edge.source.id).source += edge.value;
+            edgeValueMap.get(edge.target.id).target += edge.value;
+        }
+        for (const node of projectedNodes) {
+            if (!node.createdByFrame) {
+                let maxEdgeValue = 0;
+                if (edgeValueMap.has(node.id)) {
+                    maxEdgeValue = Math.max(edgeValueMap.get(node.id).source, edgeValueMap.get(node.id).target);
+                }
+                if (node.value > maxEdgeValue) {
+                    projectedEdges.push({
+                        source: node,
+                        target: node,
+                        value: node.value - maxEdgeValue,
+                        ephemeral: true
+                    });
+                }
+            }
+        }
+    }
+    const frameSankey = actualSankey()
+        .extent(frameExtent)
+        .links(projectedEdges)
+        .nodes(projectedNodes)
+        .nodeAlign(sankeyOrient)
+        .nodeId(nodeIDAccessor)
+        .nodeWidth(nodeWidth)
+        .iterations(iterations);
+    if (generateEphemeralEdges) {
+        resultEdges = projectedEdges.filter((e) => !e.ephemeral);
+    }
+    if (frameSankey.nodePaddingRatio && nodePaddingRatio) {
+        frameSankey.nodePaddingRatio(nodePaddingRatio);
+    }
+    else if (nodePadding) {
+        frameSankey.nodePadding(nodePadding);
+    }
+    frameSankey();
+    projectedNodes.forEach((d) => {
+        d.height = d.y1 - d.y0;
+        d.width = d.x1 - d.x0;
+        d.x = d.x0 + d.width / 2;
+        d.y = d.y0 + d.height / 2;
+        d.radius = d.height / 2;
+        d.direction = direction;
+    });
+    const finalEdges = generateEphemeralEdges ? resultEdges : projectedEdges;
+    finalEdges.forEach((d) => {
+        d.showArrows = showArrows;
+        d.sankeyWidth = d.width;
+        d.direction = direction;
+        d.width = undefined;
+    });
+    return { projectedNodes, projectedEdges: finalEdges };
+};
+exports.sankeyLayout = sankeyLayout;

package/ai/dist/src/components/processing/layouts/simpleLayouts.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleLayouts = exports.arcLayout = exports.matrixLayout = void 0;
+const matrixLayout = ({ projectedNodes, projectedEdges, networkSettings, adjustedSize }) => {
+    let sortedNodes = projectedNodes;
+    if (networkSettings.sort) {
+        sortedNodes = [...projectedNodes].sort(networkSettings.sort);
+    }
+    const gridSize = Math.min(...adjustedSize);
+    const stepSize = gridSize / (sortedNodes.length + 1);
+    sortedNodes.forEach((node, index) => {
+        node.x = 0;
+        node.y = (index + 1) * stepSize;
+    });
+    return { projectedNodes: sortedNodes, projectedEdges };
+};
+exports.matrixLayout = matrixLayout;
+const arcLayout = ({ projectedNodes, projectedEdges, networkSettings, adjustedSize }) => {
+    let sortedNodes = projectedNodes;
+    if (networkSettings.sort) {
+        sortedNodes = [...projectedNodes].sort(networkSettings.sort);
+    }
+    const stepSize = adjustedSize[0] / (sortedNodes.length + 2);
+    sortedNodes.forEach((node, index) => {
+        node.x = (index + 1) * stepSize;
+        node.y = adjustedSize[1] / 2;
+    });
+    return { projectedNodes: sortedNodes, projectedEdges };
+};
+exports.arcLayout = arcLayout;
+exports.simpleLayouts = {
+    matrix: exports.matrixLayout,
+    arc: exports.arcLayout
+};

package/ai/dist/src/components/processing/layouts/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseGraphSettings = exports.baseNetworkSettings = exports.baseNodeProps = exports.emptyArray = void 0;
+exports.emptyArray = [];
+exports.baseNodeProps = {
+    id: undefined,
+    degree: 0,
+    inDegree: 0,
+    outDegree: 0,
+    x: 0,
+    y: 0,
+    x1: 0,
+    x0: 0,
+    y1: 0,
+    y0: 0,
+    height: 0,
+    width: 0,
+    radius: 0,
+    r: 0,
+    direction: undefined,
+    textHeight: 0,
+    textWidth: 0,
+    fontSize: 0,
+    scale: 1,
+    nodeSize: 0,
+    component: -99,
+    shapeNode: false
+};
+exports.baseNetworkSettings = {
+    hierarchicalNetwork: false
+};
+exports.baseGraphSettings = {
+    nodeHash: new Map(),
+    edgeHash: new Map(),
+    nodes: [],
+    edges: [],
+    hierarchicalNetwork: false,
+    type: "force"
+};

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;

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RingBuffer = void 0;
+class RingBuffer {
+    constructor(_capacity) {
+        this._capacity = _capacity;
+        this.head = 0;
+        this._size = 0;
+        if (_capacity < 1) {
+            throw new Error("RingBuffer capacity must be at least 1");
+        }
+        this.buffer = new Array(_capacity);
+    }
+    push(value) {
+        let evicted;
+        if (this._size === this._capacity) {
+            // Buffer is full — the slot at head is the oldest item
+            evicted = this.buffer[this.head];
+        }
+        else {
+            this._size++;
+        }
+        this.buffer[this.head] = value;
+        this.head = (this.head + 1) % this._capacity;
+        return evicted;
+    }
+    pushMany(values) {
+        const evicted = [];
+        for (const v of values) {
+            const e = this.push(v);
+            if (e !== undefined) {
+                evicted.push(e);
+            }
+        }
+        return evicted;
+    }
+    get(index) {
+        if (index < 0 || index >= this._size)
+            return undefined;
+        const realIndex = (this.head - this._size + index + this._capacity) % this._capacity;
+        return this.buffer[realIndex];
+    }
+    peek() {
+        if (this._size === 0)
+            return undefined;
+        return this.buffer[(this.head - 1 + this._capacity) % this._capacity];
+    }
+    peekOldest() {
+        if (this._size === 0)
+            return undefined;
+        return this.buffer[(this.head - this._size + this._capacity) % this._capacity];
+    }
+    [Symbol.iterator]() {
+        let i = 0;
+        const self = this;
+        return {
+            next() {
+                if (i >= self._size)
+                    return { done: true, value: undefined };
+                return { done: false, value: self.get(i++) };
+            }
+        };
+    }
+    toArray() {
+        const result = [];
+        for (const item of this) {
+            result.push(item);
+        }
+        return result;
+    }
+    resize(newCapacity) {
+        if (newCapacity < 1) {
+            throw new Error("RingBuffer capacity must be at least 1");
+        }
+        const items = this.toArray();
+        const evicted = [];
+        while (items.length > newCapacity) {
+            evicted.push(items.shift());
+        }
+        this._capacity = newCapacity;
+        this.buffer = new Array(newCapacity);
+        this.head = 0;
+        this._size = 0;
+        for (const item of items) {
+            this.push(item);
+        }
+        return evicted;
+    }
+    clear() {
+        this.buffer = new Array(this._capacity);
+        this.head = 0;
+        this._size = 0;
+    }
+    get size() {
+        return this._size;
+    }
+    get capacity() {
+        return this._capacity;
+    }
+    get full() {
+        return this._size === this._capacity;
+    }
+}
+exports.RingBuffer = RingBuffer;

package/ai/dist/src/components/realtime/renderers/barRenderer.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.barRenderer = void 0;
+const BinAccumulator_1 = require("../BinAccumulator");
+const DEFAULT_PALETTE = [
+    "#4e79a7", "#f28e2b", "#e15759", "#76b7b2",
+    "#59a14f", "#edc948", "#b07aa1", "#ff9da7",
+    "#9c755f", "#bab0ac"
+];
+const barRenderer = (ctx, data, scales, layout, style, accessors, annotations, options) => {
+    const binSize = options?.binSize;
+    if (!binSize)
+        return;
+    const { time: timeScale, value: valueScale } = scales;
+    const { timeAxis } = layout;
+    const { time: getTime, value: getValue, category: getCategory } = accessors;
+    const barColors = options?.barColors;
+    const barStyle = options?.barStyle;
+    const bins = (0, BinAccumulator_1.computeBins)(data, getTime, getValue, binSize, getCategory);
+    if (bins.size === 0)
+        return;
+    const [domainMin, domainMax] = timeScale.domain();
+    const gap = barStyle?.gap ?? 1;
+    const hasCategories = getCategory != null;
+    // Determine category order: barColors keys first, then alphabetical for unlisted
+    let categoryOrder = null;
+    if (hasCategories) {
+        const allCategories = new Set();
+        for (const bin of bins.values()) {
+            for (const cat of bin.categories.keys()) {
+                allCategories.add(cat);
+            }
+        }
+        const colorKeys = barColors ? Object.keys(barColors) : [];
+        const listed = new Set(colorKeys);
+        const unlisted = Array.from(allCategories).filter(c => !listed.has(c)).sort();
+        categoryOrder = [...colorKeys.filter(k => allCategories.has(k)), ...unlisted];
+    }
+    // Bar stroke settings
+    const hasBarStroke = barStyle?.stroke != null;
+    if (hasBarStroke) {
+        ctx.strokeStyle = barStyle.stroke;
+        ctx.lineWidth = barStyle?.strokeWidth ?? 1;
+    }
+    for (const bin of bins.values()) {
+        if (timeAxis === "x") {
+            const clampedStart = Math.max(bin.start, domainMin);
+            const clampedEnd = Math.min(bin.end, domainMax);
+            if (clampedStart >= clampedEnd)
+                continue;
+            const rawX0 = timeScale(clampedStart);
+            const rawX1 = timeScale(clampedEnd);
+            const x0 = Math.min(rawX0, rawX1) + gap / 2;
+            const x1 = Math.max(rawX0, rawX1) - gap / 2;
+            const barWidth = x1 - x0;
+            if (barWidth <= 0)
+                continue;
+            if (hasCategories && categoryOrder) {
+                let cumulativeBase = 0;
+                let paletteIdx = 0;
+                for (const cat of categoryOrder) {
+                    const catVal = bin.categories.get(cat) || 0;
+                    if (catVal === 0)
+                        continue;
+                    const yBottom = valueScale(cumulativeBase);
+                    const yTop = valueScale(cumulativeBase + catVal);
+                    const rectY = Math.min(yBottom, yTop);
+                    const rectH = Math.abs(yBottom - yTop);
+                    ctx.fillStyle = (barColors && barColors[cat]) || DEFAULT_PALETTE[paletteIdx % DEFAULT_PALETTE.length];
+                    ctx.fillRect(x0, rectY, barWidth, rectH);
+                    if (hasBarStroke)
+                        ctx.strokeRect(x0, rectY, barWidth, rectH);
+                    cumulativeBase += catVal;
+                    paletteIdx++;
+                }
+            }
+            else {
+                const yZero = valueScale(0);
+                const yTop = valueScale(bin.total);
+                const rectY = Math.min(yZero, yTop);
+                const rectH = Math.abs(yZero - yTop);
+                ctx.fillStyle = barStyle?.fill || style.stroke || "#007bff";
+                ctx.fillRect(x0, rectY, barWidth, rectH);
+                if (hasBarStroke)
+                    ctx.strokeRect(x0, rectY, barWidth, rectH);
+            }
+        }
+        else {
+            // timeAxis === "y": horizontal bars
+            const clampedStart = Math.max(bin.start, domainMin);
+            const clampedEnd = Math.min(bin.end, domainMax);
+            if (clampedStart >= clampedEnd)
+                continue;
+            const rawY0 = timeScale(clampedStart);
+            const rawY1 = timeScale(clampedEnd);
+            const y0 = Math.min(rawY0, rawY1) + gap / 2;
+            const y1 = Math.max(rawY0, rawY1) - gap / 2;
+            const barHeight = y1 - y0;
+            if (barHeight <= 0)
+                continue;
+            if (hasCategories && categoryOrder) {
+                let cumulativeBase = 0;
+                let paletteIdx = 0;
+                for (const cat of categoryOrder) {
+                    const catVal = bin.categories.get(cat) || 0;
+                    if (catVal === 0)
+                        continue;
+                    const xLeft = valueScale(cumulativeBase);
+                    const xRight = valueScale(cumulativeBase + catVal);
+                    const rectX = Math.min(xLeft, xRight);
+                    const rectW = Math.abs(xRight - xLeft);
+                    ctx.fillStyle = (barColors && barColors[cat]) || DEFAULT_PALETTE[paletteIdx % DEFAULT_PALETTE.length];
+                    ctx.fillRect(rectX, y0, rectW, barHeight);
+                    if (hasBarStroke)
+                        ctx.strokeRect(rectX, y0, rectW, barHeight);
+                    cumulativeBase += catVal;
+                    paletteIdx++;
+                }
+            }
+            else {
+                const xZero = valueScale(0);
+                const xEnd = valueScale(bin.total);
+                const rectX = Math.min(xZero, xEnd);
+                const rectW = Math.abs(xEnd - xZero);
+                ctx.fillStyle = barStyle?.fill || style.stroke || "#007bff";
+                ctx.fillRect(rectX, y0, rectW, barHeight);
+                if (hasBarStroke)
+                    ctx.strokeRect(rectX, y0, rectW, barHeight);
+            }
+        }
+    }
+};
+exports.barRenderer = barRenderer;

package/ai/dist/src/components/realtime/renderers/candlestickRenderer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.candlestickRenderer = void 0;
+const candlestickRenderer = () => {
+    throw new Error("candlestickRenderer: Not yet implemented");
+};
+exports.candlestickRenderer = candlestickRenderer;