layerchart 2.0.0-next.0 → 2.0.0-next.2

package/dist/utils/connectorUtils.js

@@ -0,0 +1,111 @@
+import { line as d3Line, curveLinear } from 'd3-shape';
+function isSamePoint(p1, p2) {
+    return Math.abs(p1.x - p2.x) < 1e-6 && Math.abs(p1.y - p2.y) < 1e-6;
+}
+function createDirectPath(source, target) {
+    if (isSamePoint(source, target))
+        return '';
+    return `M ${source.x} ${source.y} L ${target.x} ${target.y}`;
+}
+function isNearZero(value) {
+    return Math.abs(value) < 1e-6;
+}
+function createSquarePath({ source, target, sweep }) {
+    if (sweep === 'horizontal-vertical') {
+        return `M ${source.x} ${source.y} L ${target.x} ${source.y} L ${target.x} ${target.y}`;
+    }
+    else {
+        return `M ${source.x} ${source.y} L ${source.x} ${target.y} L ${target.x} ${target.y}`;
+    }
+}
+function createBeveledPath(opts) {
+    const { radius, dx, dy, source, target, sweep } = opts;
+    const effectiveRadius = Math.max(0, Math.min(radius, Math.abs(dx), Math.abs(dy)));
+    if (isNearZero(effectiveRadius)) {
+        return createSquarePath(opts);
+    }
+    const signX = Math.sign(dx);
+    const signY = Math.sign(dy);
+    if (sweep === 'horizontal-vertical') {
+        const pBeforeCorner = { x: target.x - effectiveRadius * signX, y: source.y };
+        const pAfterCorner = { x: target.x, y: source.y + effectiveRadius * signY };
+        return `M ${source.x} ${source.y} L ${pBeforeCorner.x} ${pBeforeCorner.y} L ${pAfterCorner.x} ${pAfterCorner.y} L ${target.x} ${target.y}`;
+    }
+    else {
+        const pBeforeCorner = { x: source.x, y: target.y - effectiveRadius * signY };
+        const pAfterCorner = { x: source.x + effectiveRadius * signX, y: target.y };
+        return `M ${source.x} ${source.y} L ${pBeforeCorner.x} ${pBeforeCorner.y} L ${pAfterCorner.x} ${pAfterCorner.y} L ${target.x} ${target.y}`;
+    }
+}
+function createRoundedPath(opts) {
+    const { radius, dx, dy, source, target, sweep } = opts;
+    const effectiveRadius = Math.max(0, Math.min(radius, Math.abs(dx), Math.abs(dy)));
+    if (isNearZero(effectiveRadius)) {
+        return createSquarePath(opts);
+    }
+    const signX = Math.sign(dx);
+    const signY = Math.sign(dy);
+    if (sweep === 'horizontal-vertical') {
+        const pBeforeCorner = { x: target.x - effectiveRadius * signX, y: source.y };
+        const pAfterCorner = { x: target.x, y: source.y + effectiveRadius * signY };
+        const sweepFlag = signX * signY > 0 ? 1 : 0;
+        return `M ${source.x} ${source.y} L ${pBeforeCorner.x} ${pBeforeCorner.y} A ${effectiveRadius} ${effectiveRadius} 0 0 ${sweepFlag} ${pAfterCorner.x} ${pAfterCorner.y} L ${target.x} ${target.y}`;
+    }
+    else {
+        const pBeforeCorner = { x: source.x, y: target.y - effectiveRadius * signY };
+        const pAfterCorner = { x: source.x + effectiveRadius * signX, y: target.y };
+        const sweepFlag = signX * signY > 0 ? 0 : 1;
+        return `M ${source.x} ${source.y} L ${pBeforeCorner.x} ${pBeforeCorner.y} A ${effectiveRadius} ${effectiveRadius} 0 0 ${sweepFlag} ${pAfterCorner.x} ${pAfterCorner.y} L ${target.x} ${target.y}`;
+    }
+}
+const pathStrategies = {
+    square: createSquarePath,
+    beveled: createBeveledPath,
+    rounded: createRoundedPath,
+};
+export function getConnectorPresetPath(opts) {
+    const { source, target, type } = opts;
+    if (isSamePoint(source, target))
+        return '';
+    const dx = target.x - source.x;
+    const dy = target.y - source.y;
+    // straight line cases
+    if (type === 'straight' || isNearZero(dx) || isNearZero(dy)) {
+        return createDirectPath(source, target);
+    }
+    return (pathStrategies[type] || pathStrategies.square)({ ...opts, dx, dy });
+}
+const FALLBACK_PATH = 'M0,0L0,0';
+export function getConnectorD3Path({ source, target, sweep, curve }) {
+    const dx = target.x - source.x;
+    const dy = target.y - source.y;
+    const line = d3Line().curve(curve);
+    let points = [];
+    const isAligned = isNearZero(dx) || isNearZero(dy);
+    if (sweep === 'none' || isAligned) {
+        points = [
+            [source.x, source.y],
+            [target.x, target.y],
+        ];
+    }
+    else if (sweep === 'horizontal-vertical') {
+        points = [
+            [source.x, source.y],
+            [target.x, source.y],
+            [target.x, target.y],
+        ];
+    }
+    else if (sweep === 'vertical-horizontal') {
+        points = [
+            [source.x, source.y],
+            [source.x, target.y],
+            [target.x, target.y],
+        ];
+    }
+    if (points.length === 2 && isNearZero(dx) && isNearZero(dx))
+        return FALLBACK_PATH;
+    const d = line(points);
+    if (!d || d.includes('NaN'))
+        return FALLBACK_PATH;
+    return d;
+}

package/dist/utils/createId.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a unique ID for a given prefix and uid.
+ *
+ * @param prefix - prefix to use for the id
+ * @param uid - the uid generated by $props.id()
+ */
+export declare function createId(prefix: string, uid: string): string;

package/dist/utils/createId.js

@@ -0,0 +1,9 @@
+/**
+ * Creates a unique ID for a given prefix and uid.
+ *
+ * @param prefix - prefix to use for the id
+ * @param uid - the uid generated by $props.id()
+ */
+export function createId(prefix, uid) {
+    return `${prefix}-${uid}`;
+}

package/dist/utils/debug.d.ts

@@ -0,0 +1 @@
+export declare function printDebug(obj: Record<string, any>): void;

package/dist/utils/debug.js

@@ -0,0 +1,84 @@
+import { rgb } from 'd3-color';
+import { toTitleCase } from './string.js';
+import { findScaleName } from './chart.js';
+const indent = '    ';
+function printObject(obj) {
+    Object.entries(obj).forEach(([key, value]) => {
+        console.log(`${indent}${key}:`, value);
+    });
+}
+function getRgb(clr) {
+    const { r, g, b, opacity: o } = rgb(clr);
+    if (![r, g, b].every((c) => c >= 0 && c <= 255)) {
+        return false;
+    }
+    return { r, g, b, o };
+}
+function printValues(scale, method, extraSpace = '') {
+    const values = scale[method]();
+    const colorValues = colorizeArray(values);
+    if (colorValues) {
+        printColorArray(colorValues, method, values);
+    }
+    else {
+        console.log(`${indent}${indent}${toTitleCase(method)}:${extraSpace}`, values);
+    }
+}
+function printColorArray(colorValues, method, values) {
+    console.log(`${indent}${indent}${toTitleCase(method)}:    %cArray%c(${values.length}) ` +
+        colorValues[0] +
+        '%c ]', 'color: #1377e4', 'color: #737373', 'color: #1478e4', ...colorValues[1], 'color: #1478e4');
+}
+function colorizeArray(arr) {
+    const colors = [];
+    const a = arr.map((d, i) => {
+        const rgbo = getRgb(d);
+        if (rgbo !== false) {
+            colors.push(rgbo);
+            // Add a space to the last item
+            const space = i === arr.length - 1 ? ' ' : '';
+            return `%c ${d}${space}`;
+        }
+        return d;
+    });
+    if (colors.length) {
+        return [
+            `%c[ ${a.join(', ')}`,
+            colors.map((d) => `background-color: rgba(${d.r}, ${d.g}, ${d.b}, ${d.o}); color:${contrast(d)};`),
+        ];
+    }
+    return null;
+}
+function printScale(s, scale, acc) {
+    const scaleName = findScaleName(scale);
+    console.log(`${indent}${s}:`);
+    console.log(`${indent}${indent}Accessor: "${acc.toString()}"`);
+    console.log(`${indent}${indent}Type: ${scaleName}`);
+    printValues(scale, 'domain');
+    printValues(scale, 'range', ' ');
+}
+/**
+ * Calculate human-perceived lightness from RGB
+ * This doesn't take opacity into account
+ * https://stackoverflow.com/a/596243
+ */
+function contrast({ r, g, b }) {
+    const luminance = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+    return luminance > 0.6 ? 'black' : 'white';
+}
+export function printDebug(obj) {
+    console.log('/********* LayerChart Debug ************/');
+    console.log('Bounding box:');
+    printObject(obj.boundingBox);
+    console.log('Data:');
+    console.log(indent, obj.data);
+    if (obj.flatData) {
+        console.log('flatData:');
+        console.log(indent, obj.flatData);
+    }
+    console.log('Scales:');
+    Object.keys(obj.activeGetters).forEach((g) => {
+        printScale(g, obj[`${g}Scale`], obj[g]);
+    });
+    console.log('/************ End LayerChart Debug ***************/\n');
+}

package/dist/utils/filterObject.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Remove undefined fields from an object
+ * @param obj The object to filter
+ * @param comparisonObk An object that, for any key, if the key is not present on that object, the
+ * key will be filtered out. Note, this ignores the value on that object
+ */
+export declare function filterObject(obj: object, comparisonObj?: {}): {
+    [k: string]: any;
+};

package/dist/utils/filterObject.js

@@ -0,0 +1,12 @@
+/**
+ * Remove undefined fields from an object
+ * @param obj The object to filter
+ * @param comparisonObk An object that, for any key, if the key is not present on that object, the
+ * key will be filtered out. Note, this ignores the value on that object
+ */
+export function filterObject(obj, comparisonObj = {}) {
+    return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {
+        // @ts-expect-error - shh
+        return value !== undefined && comparisonObj[key] === undefined;
+    }));
+}

package/dist/utils/graph/dagre.d.ts

@@ -0,0 +1,34 @@
+import dagre from '@dagrejs/dagre';
+import { type DagreProps } from '../../components/Dagre.svelte';
+/**
+ * Build `dagre.graphlib.Graph` instance from DagreGraphData (`{ nodes, edges }`)
+ */
+export declare function dagreGraph(data: DagreProps['data'], { nodes, nodeId, edges, directed, multigraph, compound, ranker, direction, align, rankSeparation, nodeSeparation, edgeSeparation, nodeWidth, nodeHeight, edgeLabelWidth, edgeLabelHeight, edgeLabelPosition, edgeLabelOffset, filterNodes, }?: {
+    nodes?: DagreProps['nodes'];
+    nodeId?: DagreProps['nodeId'];
+    edges?: DagreProps['edges'];
+    directed?: DagreProps['directed'];
+    multigraph?: DagreProps['multigraph'];
+    compound?: DagreProps['compound'];
+    ranker?: DagreProps['ranker'];
+    direction?: DagreProps['direction'];
+    align?: DagreProps['align'];
+    rankSeparation?: DagreProps['rankSeparation'];
+    nodeSeparation?: DagreProps['nodeSeparation'];
+    edgeSeparation?: DagreProps['edgeSeparation'];
+    nodeWidth?: DagreProps['nodeWidth'];
+    nodeHeight?: DagreProps['nodeHeight'];
+    edgeLabelWidth?: DagreProps['edgeLabelWidth'];
+    edgeLabelHeight?: DagreProps['edgeLabelHeight'];
+    edgeLabelPosition?: DagreProps['edgeLabelPosition'];
+    edgeLabelOffset?: DagreProps['edgeLabelOffset'];
+    filterNodes?: DagreProps['filterNodes'];
+}): dagre.graphlib.Graph<{}>;
+/**
+ * Get all upstream predecessors for dagre nodeId
+ */
+export declare function dagreAncestors(graph: dagre.graphlib.Graph, nodeId: string, maxDepth?: number, currentDepth?: number): dagre.Node[];
+/**
+ * Get all downstream descendants for dagre nodeId
+ */
+export declare function dagreDescendants(graph: dagre.graphlib.Graph, nodeId: string, maxDepth?: number, currentDepth?: number): dagre.Node[];

package/dist/utils/graph/dagre.js

@@ -0,0 +1,78 @@
+import dagre from '@dagrejs/dagre';
+import { Align, EdgeLabelPosition, RankDir } from '../../components/Dagre.svelte';
+/**
+ * Build `dagre.graphlib.Graph` instance from DagreGraphData (`{ nodes, edges }`)
+ */
+export function dagreGraph(data, { nodes = (d) => d.nodes, nodeId = (d) => d.id, edges = (d) => d.edges, directed = true, multigraph = false, compound = false, ranker = 'network-simplex', direction = 'top-bottom', align, rankSeparation = 50, nodeSeparation = 50, edgeSeparation = 10, nodeWidth = 100, nodeHeight = 50, edgeLabelWidth = 100, edgeLabelHeight = 20, edgeLabelPosition = 'center', edgeLabelOffset = 10, filterNodes = () => true, } = {}) {
+    let g = new dagre.graphlib.Graph({ directed, multigraph, compound });
+    g.setGraph({
+        ranker: ranker,
+        rankdir: RankDir[direction],
+        align: align ? Align[align] : undefined,
+        ranksep: rankSeparation,
+        nodesep: nodeSeparation,
+        edgesep: edgeSeparation,
+    });
+    g.setDefaultEdgeLabel(() => ({}));
+    const dataNodes = nodes(data);
+    for (const n of dataNodes) {
+        const id = nodeId(n);
+        g.setNode(nodeId(n), {
+            id,
+            label: typeof n.label === 'string' ? n.label : id,
+            width: nodeWidth,
+            height: nodeHeight,
+            ...(typeof n.label === 'object' ? n.label : null),
+        });
+        if (n.parent) {
+            g.setParent(id, n.parent);
+        }
+    }
+    const nodeEdges = edges(data);
+    for (const e of nodeEdges) {
+        const { source, target, label, ...rest } = e;
+        g.setEdge(e.source, e.target, label
+            ? {
+                label: label,
+                labelpos: EdgeLabelPosition[edgeLabelPosition],
+                labeloffset: edgeLabelOffset,
+                width: edgeLabelWidth,
+                height: edgeLabelHeight,
+                ...rest,
+            }
+            : {});
+    }
+    if (filterNodes) {
+        g = g.filterNodes((nodeId) => filterNodes(nodeId, g));
+    }
+    dagre.layout(g);
+    return g;
+}
+/**
+ * Get all upstream predecessors for dagre nodeId
+ */
+export function dagreAncestors(graph, nodeId, maxDepth = Infinity, currentDepth = 0) {
+    if (currentDepth === maxDepth) {
+        return [];
+    }
+    const predecessors = graph.predecessors(nodeId) ?? [];
+    return [
+        ...predecessors,
+        // @ts-expect-error: Types from dagre appear incorrect
+        ...predecessors.flatMap((pId) => dagreAncestors(graph, pId, maxDepth, currentDepth + 1)),
+    ];
+}
+/**
+ * Get all downstream descendants for dagre nodeId
+ */
+export function dagreDescendants(graph, nodeId, maxDepth = Infinity, currentDepth = 0) {
+    if (currentDepth === maxDepth) {
+        return [];
+    }
+    const predecessors = graph.successors(nodeId) ?? [];
+    return [
+        ...predecessors,
+        // @ts-expect-error: Types from dagre appear incorrect
+        ...predecessors.flatMap((pId) => dagreDescendants(graph, pId, maxDepth, currentDepth + 1)),
+    ];
+}

package/dist/utils/graph/dagre.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/{graph.test.js → graph/dagre.test.js}

@@ -1,6 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import dagre from '@dagrejs/dagre';
-import { ancestors, descendants } from './graph.js';
+import { dagreGraph, dagreAncestors, dagreDescendants } from './dagre.js';
 const exampleGraph = {
     nodes: [
         { id: 'A' },
@@ -25,60 +24,47 @@ const exampleGraph = {
         { source: 'H', target: 'I' },
     ],
 };
-function buildGraph(data) {
-    const g = new dagre.graphlib.Graph();
-    g.setGraph({});
-    data.nodes.forEach((n) => {
-        g.setNode(n.id, {
-            label: n.id,
-        });
-    });
-    data.edges.forEach((e) => {
-        g.setEdge(e.source, e.target);
-    });
-    return g;
-}
-describe('accessors', () => {
+describe('dagreAncestors', () => {
     it('start of graph ', () => {
-        const graph = buildGraph(exampleGraph);
-        const actual = ancestors(graph, 'A');
+        const graph = dagreGraph(exampleGraph);
+        const actual = dagreAncestors(graph, 'L');
         expect(actual).length(0);
     });
     it('middle of graph ', () => {
-        const graph = buildGraph(exampleGraph);
-        const actual = ancestors(graph, 'E');
+        const graph = dagreGraph(exampleGraph);
+        const actual = dagreAncestors(graph, 'E');
         expect(actual).to.have.members(['A', 'B', 'C', 'D']);
     });
     it('end of graph ', () => {
-        const graph = buildGraph(exampleGraph);
-        const actual = ancestors(graph, 'I');
+        const graph = dagreGraph(exampleGraph);
+        const actual = dagreAncestors(graph, 'I');
         expect(actual).to.have.members(['A', 'B', 'C', 'D', 'E', 'G', 'H']);
     });
     it('max depth', () => {
-        const graph = buildGraph(exampleGraph);
-        const actual = ancestors(graph, 'H', 2);
+        const graph = dagreGraph(exampleGraph);
+        const actual = dagreAncestors(graph, 'H', 2);
         expect(actual).to.have.members(['B', 'D', 'E', 'G']);
     });
 });
-describe('descendants', () => {
+describe('dagreDescendants', () => {
     it('start of graph ', () => {
-        const graph = buildGraph(exampleGraph);
-        const actual = descendants(graph, 'A');
+        const graph = dagreGraph(exampleGraph);
+        const actual = dagreDescendants(graph, 'A');
         expect(actual).to.have.members(['B', 'E', 'F', 'H', 'I']);
     });
     it('middle of graph ', () => {
-        const graph = buildGraph(exampleGraph);
-        const actual = descendants(graph, 'E');
+        const graph = dagreGraph(exampleGraph);
+        const actual = dagreDescendants(graph, 'E');
         expect(actual).to.have.members(['H', 'I']);
     });
     it('end of graph ', () => {
-        const graph = buildGraph(exampleGraph);
-        const actual = descendants(graph, 'I');
+        const graph = dagreGraph(exampleGraph);
+        const actual = dagreDescendants(graph, 'I');
         expect(actual).length(0);
     });
     it('max depth', () => {
-        const graph = buildGraph(exampleGraph);
-        const actual = descendants(graph, 'B', 2);
+        const graph = dagreGraph(exampleGraph);
+        const actual = dagreDescendants(graph, 'B', 2);
         expect(actual).to.have.members(['E', 'F', 'H']);
     });
 });

package/dist/utils/graph/sankey.d.ts

@@ -0,0 +1,28 @@
+import type { SankeyExtraProperties, SankeyGraph, SankeyLink, SankeyNodeMinimal } from 'd3-sankey';
+import type { hierarchy as d3Hierarchy } from 'd3-hierarchy';
+/**
+ * Convert CSV rows in format: 'source,target,value' to SankeyGraph
+ */
+export declare function sankeyGraphFromCsv(csv: string): SankeyGraph<any, any>;
+/**
+ * Convert d3-hierarchy to graph (nodes/links)
+ */
+export declare function sankeyGraphFromHierarchy(hierarchy: ReturnType<typeof d3Hierarchy>): {
+    nodes: import("d3-hierarchy").HierarchyNode<unknown>[];
+    links: {
+        value: number | undefined;
+        source: import("d3-hierarchy").HierarchyNode<unknown>;
+        target: import("d3-hierarchy").HierarchyNode<unknown>;
+    }[];
+};
+/**
+ * Create graph from node (and target node/links downward)
+ */
+export declare function sankeyGraphFromNode(node: SankeyNodeMinimal<any, any>): {
+    nodes: any[];
+    links: any[];
+};
+/**
+ * Get distinct nodes from link.source and link.target
+ */
+export declare function sankeyNodesFromLinks<N extends SankeyExtraProperties, L extends SankeyExtraProperties>(links: Array<SankeyLink<N, L>>): any[];

package/dist/utils/{graph.js → graph/sankey.js}

@@ -1,9 +1,8 @@
 import { csvParseRows } from 'd3-dsv';
-import dagre from '@dagrejs/dagre';
 /**
  * Convert CSV rows in format: 'source,target,value' to SankeyGraph
  */
-export function graphFromCsv(csv) {
+export function sankeyGraphFromCsv(csv) {
     const links = csvParseRows(csv, ([source, target, value /*, linkColor = color*/]) => source && target
         ? {
             source,
@@ -13,12 +12,12 @@ export function graphFromCsv(csv) {
             // color: linkColor,
         }
         : null);
-    return { nodes: nodesFromLinks(links), links };
+    return { nodes: sankeyNodesFromLinks(links), links };
 }
 /**
  * Convert d3-hierarchy to graph (nodes/links)
  */
-export function graphFromHierarchy(hierarchy) {
+export function sankeyGraphFromHierarchy(hierarchy) {
     return {
         nodes: hierarchy.descendants(),
         links: hierarchy.links().map((link) => ({ ...link, value: link.target.value })),
@@ -27,33 +26,34 @@ export function graphFromHierarchy(hierarchy) {
 /**
  * Create graph from node (and target node/links downward)
  */
-export function graphFromNode(node) {
+export function sankeyGraphFromNode(node) {
     const nodes = [node];
     const links = [];
-    node.sourceLinks?.forEach((link) => {
+    for (const link of node.sourceLinks ?? []) {
         nodes.push(link.target);
         links.push(link);
         if (link.target.sourceLinks.length) {
-            const targetData = graphFromNode(link.target);
+            const targetData = sankeyGraphFromNode(link.target);
             // Only add new nodes
-            targetData.nodes.forEach((node) => {
+            for (const node of targetData.nodes) {
                 if (!nodes.includes(node)) {
                     nodes.push(node);
                 }
-            });
-            targetData.links.forEach((link) => {
+            }
+            // Only add new links
+            for (const link of targetData.links) {
                 if (!links.includes(link)) {
                     links.push(link);
                 }
-            });
+            }
         }
-    });
+    }
     return { nodes, links };
 }
 /**
  * Get distinct nodes from link.source and link.target
  */
-export function nodesFromLinks(links) {
+export function sankeyNodesFromLinks(links) {
     const nodesByName = new Map();
     for (const link of links) {
         if (!nodesByName.has(link.source)) {
@@ -65,31 +65,3 @@ export function nodesFromLinks(links) {
     }
     return Array.from(nodesByName.values());
 }
-/**
- * Get all upstream predecessors for dagre nodeId
- */
-export function ancestors(graph, nodeId, maxDepth = Infinity, currentDepth = 0) {
-    if (currentDepth === maxDepth) {
-        return [];
-    }
-    const predecessors = graph.predecessors(nodeId) ?? [];
-    return [
-        ...predecessors,
-        // @ts-expect-error: Types from dagre appear incorrect
-        ...predecessors.flatMap((pId) => ancestors(graph, pId, maxDepth, currentDepth + 1)),
-    ];
-}
-/**
- * Get all downstream descendants for dagre nodeId
- */
-export function descendants(graph, nodeId, maxDepth = Infinity, currentDepth = 0) {
-    if (currentDepth === maxDepth) {
-        return [];
-    }
-    const predecessors = graph.successors(nodeId) ?? [];
-    return [
-        ...predecessors,
-        // @ts-expect-error: Types from dagre appear incorrect
-        ...predecessors.flatMap((pId) => descendants(graph, pId, maxDepth, currentDepth + 1)),
-    ];
-}

package/dist/utils/index.d.ts

@@ -1,7 +1,6 @@
 export * from './canvas.js';
 export * from './common.js';
 export * from './geo.js';
-export * from './graph.js';
 export * from './hierarchy.js';
 export * from './math.js';
 export * from './path.js';
@@ -9,3 +8,6 @@ export * from './pivot.js';
 export * from './stack.js';
 export * from './ticks.js';
 export * from './threshold.js';
+export * from './types.js';
+export * from './graph/dagre.js';
+export * from './graph/sankey.js';

package/dist/utils/index.js

@@ -1,7 +1,6 @@
 export * from './canvas.js';
 export * from './common.js';
 export * from './geo.js';
-export * from './graph.js';
 export * from './hierarchy.js';
 export * from './math.js';
 export * from './path.js';
@@ -9,3 +8,6 @@ export * from './pivot.js';
 export * from './stack.js';
 export * from './ticks.js';
 export * from './threshold.js';
+export * from './types.js';
+export * from './graph/dagre.js';
+export * from './graph/sankey.js';

package/dist/utils/key.svelte.d.ts

@@ -0,0 +1,3 @@
+export declare function createKey<T>(getValue: () => T): {
+    readonly current: any;
+};

package/dist/utils/key.svelte.js

@@ -0,0 +1,11 @@
+import { objectId } from '@layerstack/utils/object';
+// TODO: investigate if this is necessary with Svelte 5
+export function createKey(getValue) {
+    const value = $derived(getValue());
+    const key = $derived(value && typeof value === 'object' ? objectId(value) : value);
+    return {
+        get current() {
+            return key;
+        },
+    };
+}

package/dist/utils/legendPayload.d.ts

@@ -0,0 +1,7 @@
+export type LegendPayload = {
+    key: string;
+    label?: string;
+    color?: string;
+};
+export declare function setLegendPayloadContext(payload: LegendPayload[]): LegendPayload[];
+export declare function getLegendPayloadContext(): LegendPayload[];

package/dist/utils/legendPayload.js

@@ -0,0 +1,8 @@
+import { Context } from 'runed';
+const _LegendPayloadContext = new Context('LegendContext');
+export function setLegendPayloadContext(payload) {
+    return _LegendPayloadContext.set(payload);
+}
+export function getLegendPayloadContext() {
+    return _LegendPayloadContext.getOr([]);
+}