layerchart 2.0.0-next.1 → 2.0.0-next.10

package/dist/utils/graph.d.ts

@@ -1,37 +0,0 @@
-import type { SankeyExtraProperties, SankeyGraph, SankeyLink, SankeyNodeMinimal } from 'd3-sankey';
-import type { hierarchy as d3Hierarchy } from 'd3-hierarchy';
-import dagre from '@dagrejs/dagre';
-/**
- * Convert CSV rows in format: 'source,target,value' to SankeyGraph
- */
-export declare function graphFromCsv(csv: string): SankeyGraph<any, any>;
-/**
- * Convert d3-hierarchy to graph (nodes/links)
- */
-export declare function graphFromHierarchy(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 graphFromNode(node: SankeyNodeMinimal<any, any>): {
-    nodes: any[];
-    links: any[];
-};
-/**
- * Get distinct nodes from link.source and link.target
- */
-export declare function nodesFromLinks<N extends SankeyExtraProperties, L extends SankeyExtraProperties>(links: Array<SankeyLink<N, L>>): any[];
-/**
- * Get all upstream predecessors for dagre nodeId
- */
-export declare function ancestors(graph: dagre.graphlib.Graph, nodeId: string, maxDepth?: number, currentDepth?: number): dagre.Node[];
-/**
- * Get all downstream descendants for dagre nodeId
- */
-export declare function descendants(graph: dagre.graphlib.Graph, nodeId: string, maxDepth?: number, currentDepth?: number): dagre.Node[];

package/dist/utils/rect.js

@@ -1,107 +0,0 @@
-import { derived } from 'svelte/store';
-import { max, min } from 'd3-array';
-import { isScaleBand } from './scales.js';
-import { accessor } from './common.js';
-export function createDimensionGetter(context, options) {
-    const { xScale, yScale, x: xAccessor, y: yAccessor, x1: x1Accessor, y1: y1Accessor, x1Scale, y1Scale, } = context;
-    return derived([xScale, x1Scale, yScale, y1Scale, xAccessor, yAccessor, x1Accessor, y1Accessor], ([$xScale, $x1Scale, $yScale, $y1Scale, $xAccessor, $yAccessor, $x1Accessor, $y1Accessor]) => {
-        const insets = resolveInsets(options?.insets);
-        // Use `xscale.domain()` instead of `$xDomain` to include `nice()` being applied
-        const [minXDomain, maxXDomain] = $xScale.domain();
-        const [minYDomain, maxYDomain] = $yScale.domain();
-        const _x = accessor(options?.x ?? $xAccessor);
-        const _y = accessor(options?.y ?? $yAccessor);
-        const _x1 = accessor(options?.x1 ?? $x1Accessor);
-        const _y1 = accessor(options?.y1 ?? $y1Accessor);
-        // @ts-expect-error
-        return function getter(item) {
-            if (isScaleBand($yScale)) {
-                // Horizontal band
-                const y = firstValue($yScale(_y(item)) ?? 0) + ($y1Scale ? $y1Scale(_y1(item)) : 0) + insets.top;
-                const height = Math.max(0, $yScale.bandwidth
-                    ? ($y1Scale ? ($y1Scale.bandwidth?.() ?? 0) : $yScale.bandwidth()) -
-                        insets.bottom -
-                        insets.top
-                    : 0);
-                const xValue = _x(item);
-                let left = 0;
-                let right = 0;
-                if (Array.isArray(xValue)) {
-                    // Array contains both top and bottom values (stack, etc);
-                    left = min(xValue);
-                    right = max(xValue);
-                }
-                else if (xValue == null) {
-                    // null/undefined value
-                    left = 0;
-                    right = 0;
-                }
-                else if (xValue > 0) {
-                    // Positive value
-                    left = max([0, minXDomain]);
-                    right = xValue;
-                }
-                else {
-                    // Negative value
-                    left = xValue;
-                    right = min([0, maxXDomain]);
-                }
-                const x = $xScale(left) + insets.left;
-                const width = Math.max(0, $xScale(right) - $xScale(left) - insets.left - insets.right);
-                return { x, y, width, height };
-            }
-            else {
-                // Vertical band or linear
-                const x = firstValue($xScale(_x(item))) + ($x1Scale ? $x1Scale(_x1(item)) : 0) + insets.left;
-                const width = Math.max(0, $xScale.bandwidth
-                    ? ($x1Scale ? ($x1Scale.bandwidth?.() ?? 0) : $xScale.bandwidth()) -
-                        insets.left -
-                        insets.right
-                    : 0);
-                const yValue = _y(item);
-                let top = 0;
-                let bottom = 0;
-                if (Array.isArray(yValue)) {
-                    // Array contains both top and bottom values (stack, etc);
-                    top = max(yValue);
-                    bottom = min(yValue);
-                }
-                else if (yValue == null) {
-                    // null/undefined value
-                    top = 0;
-                    bottom = 0;
-                }
-                else if (yValue > 0) {
-                    // Positive value
-                    top = yValue;
-                    bottom = max([0, minYDomain]);
-                }
-                else {
-                    // Negative value
-                    top = min([0, maxYDomain]);
-                    bottom = yValue;
-                }
-                const y = $yScale(top) + insets.top;
-                const height = $yScale(bottom) - $yScale(top) - insets.bottom - insets.top;
-                return { x, y, width, height };
-            }
-        };
-    });
-}
-/**
- * If value is an array, returns first item, else returns original value
- * Useful when x/y getters for band scale are an array (such as for histograms)
- */
-export function firstValue(value) {
-    return Array.isArray(value) ? value[0] : value;
-}
-function resolveInsets(insets) {
-    const all = insets?.all ?? 0;
-    const x = insets?.x ?? all;
-    const y = insets?.y ?? all;
-    const left = insets?.left ?? x;
-    const right = insets?.right ?? x;
-    const top = insets?.top ?? y;
-    const bottom = insets?.bottom ?? y;
-    return { left, right, bottom, top };
-}

package/dist/utils/scales.d.ts

@@ -1,66 +0,0 @@
-import { tweened, spring } from 'svelte/motion';
-import { type MotionOptions } from '../stores/motionStore.js';
-import { type ScaleBand } from 'd3-scale';
-export interface AnyScale<Domain = any, Range = any, Input = Domain, Output = any> {
-    (value: Input): Output;
-    invert?: (value: Output) => Input;
-    domain(): Domain[];
-    domain(domain: Iterable<Domain>): this;
-    range(): Range[];
-    range(range: Iterable<Range>): this;
-    bandwidth?: Function;
-    ticks?: Function;
-    tickFormat?: Function;
-    copy(): Function;
-}
-export type DomainType = (number | string | Date | null | undefined)[] | null;
-/**
- * Implemenation for missing `scaleBand().invert()`
- *
- *  See: https://stackoverflow.com/questions/38633082/d3-getting-invert-value-of-band-scales
- *      https://github.com/d3/d3-scale/pull/64
- *      https://github.com/vega/vega-scale/blob/master/src/scaleBand.js#L118
- *      https://observablehq.com/@d3/ordinal-brushing
- * 			https://github.com/d3/d3-scale/blob/11777dac7d4b0b3e229d658aee3257ea67bd5ffa/src/band.js#L32
- * 			https://gist.github.com/LuisSevillano/d53a1dc529eef518780c6df99613e2fd
- */
-export declare function scaleBandInvert(scale: ScaleBand<any>): (value: number) => any;
-export declare function isScaleBand(scale: AnyScale<any, any>): scale is ScaleBand<any>;
-/**
- *  Generic way to invert a scale value, handling scaleBand and continuous scales (linear, time, etc).
- *  Useful to map mouse event location (x,y) to domain value
- */
-export declare function scaleInvert(scale: AnyScale<any, any>, value: number): any;
-/** Create new copy of scale with domain and range */
-export declare function createScale(scale: AnyScale, domain: DomainType, range: any[] | readonly any[] | Function, context?: Record<any, any>): AnyScale<any, any, any, any>;
-/** Create a `scaleBand()` within another scaleBand()'s bandwidth (typically a x1 of an x0 scale, used for grouping) */
-export declare function groupScaleBand<Domain extends {
-    toString(): string;
-}>(scale: ScaleBand<Domain>, flatData: any[], groupBy: string, padding?: {
-    inner?: number;
-    outer?: number;
-}): ScaleBand<string>;
-/**
- * Animate d3-scale as domain and/or range are updated using tweened store
- */
-export declare function tweenedScale<Domain, Range>(scale: any, tweenedOptions?: Parameters<typeof tweened<any>>[1]): {
-    subscribe: (this: void, run: import("svelte/store").Subscriber<any>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
-    domain: (values: Domain) => Promise<void>;
-    range: (values: Range) => Promise<void>;
-};
-/**
- * Animate d3-scale as domain and/or range are updated using spring store
- */
-export declare function springScale<Domain, Range>(scale: AnyScale, springOptions?: Parameters<typeof spring>[1]): {
-    subscribe: (this: void, run: import("svelte/store").Subscriber<any>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
-    domain: (values: Domain) => Promise<void>;
-    range: (values: Range) => Promise<void>;
-};
-/**
- * Create a store wrapper around a d3-scale which interpolates the domain and/or range using `tweened()` or `spring()` stores.  Fallbacks to `writable()` store if not interpolating
- */
-export declare function motionScale<Domain, Range>(scale: AnyScale, options: MotionOptions): {
-    subscribe: (this: void, run: import("svelte/store").Subscriber<any>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
-    domain: (values: Domain) => void | Promise<void>;
-    range: (values: Range) => void | Promise<void>;
-};

package/dist/utils/scales.js

@@ -1,136 +0,0 @@
-import { derived } from 'svelte/store';
-import { tweened, spring } from 'svelte/motion';
-import { motionStore } from '../stores/motionStore.js';
-import { scaleBand } from 'd3-scale';
-import { unique } from '@layerstack/utils';
-/**
- * Implemenation for missing `scaleBand().invert()`
- *
- *  See: https://stackoverflow.com/questions/38633082/d3-getting-invert-value-of-band-scales
- *      https://github.com/d3/d3-scale/pull/64
- *      https://github.com/vega/vega-scale/blob/master/src/scaleBand.js#L118
- *      https://observablehq.com/@d3/ordinal-brushing
- * 			https://github.com/d3/d3-scale/blob/11777dac7d4b0b3e229d658aee3257ea67bd5ffa/src/band.js#L32
- * 			https://gist.github.com/LuisSevillano/d53a1dc529eef518780c6df99613e2fd
- */
-export function scaleBandInvert(scale) {
-    const domain = scale.domain();
-    const eachBand = scale.step();
-    const paddingOuter = eachBand * (scale.paddingOuter?.() ?? scale.padding()); // `scaleBand` uses paddingOuter(), while `scalePoint` uses padding() for outer paddding - https://github.com/d3/d3-scale#point_padding
-    return function (value) {
-        const index = Math.floor((value - paddingOuter / 2) / eachBand);
-        return domain[Math.max(0, Math.min(index, domain.length - 1))];
-    };
-}
-export function isScaleBand(scale) {
-    return typeof scale.bandwidth === 'function';
-}
-/**
- *  Generic way to invert a scale value, handling scaleBand and continuous scales (linear, time, etc).
- *  Useful to map mouse event location (x,y) to domain value
- */
-export function scaleInvert(scale, value) {
-    if (isScaleBand(scale)) {
-        return scaleBandInvert(scale)(value);
-    }
-    else {
-        return scale.invert?.(value);
-    }
-}
-/** Create new copy of scale with domain and range */
-export function createScale(scale, domain, range, context) {
-    const scaleCopy = scale.copy();
-    if (domain) {
-        scaleCopy.domain(domain);
-    }
-    if (typeof range === 'function') {
-        scaleCopy.range(range(context));
-    }
-    else {
-        scaleCopy.range(range);
-    }
-    return scaleCopy;
-}
-/** Create a `scaleBand()` within another scaleBand()'s bandwidth (typically a x1 of an x0 scale, used for grouping) */
-export function groupScaleBand(scale, flatData, groupBy, padding) {
-    //
-    const groupKeys = unique(flatData.map((d) => d[groupBy]));
-    let newScale = scaleBand().domain(groupKeys).range([0, scale.bandwidth()]);
-    if (padding) {
-        if (padding.inner) {
-            newScale = newScale.paddingInner(padding.inner);
-        }
-        if (padding.outer) {
-            newScale = newScale.paddingOuter(padding.outer);
-        }
-    }
-    return newScale;
-}
-/**
- * Animate d3-scale as domain and/or range are updated using tweened store
- */
-export function tweenedScale(scale, tweenedOptions = {}) {
-    const tweenedDomain = tweened(undefined, tweenedOptions);
-    const tweenedRange = tweened(undefined, tweenedOptions);
-    const tweenedScale = derived([tweenedDomain, tweenedRange], ([domain, range]) => {
-        const scaleInstance = scale.domain ? scale : scale(); // support `scaleLinear` or `scaleLinear()` (which could have `.interpolate()` and others set)
-        if (domain) {
-            scaleInstance.domain(domain);
-        }
-        if (range) {
-            scaleInstance.range(range);
-        }
-        return scaleInstance;
-    });
-    return {
-        subscribe: tweenedScale.subscribe,
-        domain: (values) => tweenedDomain.set(values),
-        range: (values) => tweenedRange.set(values),
-    };
-}
-/**
- * Animate d3-scale as domain and/or range are updated using spring store
- */
-export function springScale(scale, springOptions = {}) {
-    const domainStore = spring(undefined, springOptions);
-    const rangeStore = spring(undefined, springOptions);
-    const tweenedScale = derived([domainStore, rangeStore], ([domain, range]) => {
-        // @ts-expect-error
-        const scaleInstance = scale.domain ? scale : scale(); // support `scaleLinear` or `scaleLinear()` (which could have `.interpolate()` and others set)
-        if (domain) {
-            scaleInstance.domain(domain);
-        }
-        if (range) {
-            scaleInstance.range(range);
-        }
-        return scaleInstance;
-    });
-    return {
-        subscribe: tweenedScale.subscribe,
-        domain: (values) => domainStore.set(values),
-        range: (values) => rangeStore.set(values),
-    };
-}
-/**
- * Create a store wrapper around a d3-scale which interpolates the domain and/or range using `tweened()` or `spring()` stores.  Fallbacks to `writable()` store if not interpolating
- */
-export function motionScale(scale, options) {
-    const domainStore = motionStore(undefined, options);
-    const rangeStore = motionStore(undefined, options);
-    const tweenedScale = derived([domainStore, rangeStore], ([domain, range]) => {
-        // @ts-expect-error
-        const scaleInstance = scale.domain ? scale : scale(); // support `scaleLinear` or `scaleLinear()` (which could have `.interpolate()` and others set)
-        if (domain) {
-            scaleInstance.domain(domain);
-        }
-        if (range) {
-            scaleInstance.range(range);
-        }
-        return scaleInstance;
-    });
-    return {
-        subscribe: tweenedScale.subscribe,
-        domain: (values) => domainStore.set(values),
-        range: (values) => rangeStore.set(values),
-    };
-}