layerchart 2.0.0-next.1 → 2.0.0-next.2

package/dist/stores/motionStore.d.ts

@@ -1,30 +0,0 @@
-import { spring, tweened } from 'svelte/motion';
-export type SpringOptions = Parameters<typeof spring<any>>[1];
-export type TweenedOptions = Parameters<typeof tweened<any>>[1];
-export type MotionOptions = {
-    spring?: boolean | SpringOptions;
-    tweened?: boolean | TweenedOptions;
-};
-export type PropMotionOptions = {
-    spring?: boolean | SpringOptions | {
-        [prop: string]: SpringOptions;
-    };
-    tweened?: boolean | TweenedOptions | {
-        [prop: string]: TweenedOptions;
-    };
-};
-/**
- * Convenient wrapper to create a motion store (spring(), tweened()) based on properties, or fall back to basic writable() store
- */
-export declare function motionStore<T = any>(value: T, options: MotionOptions): import("svelte/motion").Spring<T> | import("svelte/motion").Tweened<T> | import("svelte/store").Writable<T>;
-/**
- * Helper to resolve motion options with specific property option (useful for specifying per-prop delays)
- */
-export declare function resolveOptions(prop: string, options: PropMotionOptions): {
-    spring: any;
-    tweened: any;
-};
-export declare function motionFinishHandler(): {
-    subscribe: (this: void, run: import("svelte/store").Subscriber<boolean>, invalidate?: () => void) => import("svelte/store").Unsubscriber;
-    handle: (promise: Promise<void> | void) => void;
-};

package/dist/stores/motionStore.js

@@ -1,62 +0,0 @@
-import { writable } from 'svelte/store';
-import { spring, tweened } from 'svelte/motion';
-/**
- * Convenient wrapper to create a motion store (spring(), tweened()) based on properties, or fall back to basic writable() store
- */
-export function motionStore(value, options) {
-    if (options.spring) {
-        return spring(value, options.spring === true ? undefined : options.spring);
-    }
-    else if (options.tweened) {
-        return tweened(value, options.tweened === true ? undefined : options.tweened);
-    }
-    else {
-        return writable(value);
-    }
-}
-/**
- * Helper to resolve motion options with specific property option (useful for specifying per-prop delays)
- */
-export function resolveOptions(prop, options) {
-    return {
-        spring: typeof options.spring === 'boolean' || options.spring == null
-            ? options.spring
-            : prop in options.spring
-                ? //@ts-expect-error
-                    options.spring[prop]
-                : Object.keys(options.spring).some((key) => ['precision', 'damping', 'stiffness'].includes(key))
-                    ? options.tweened
-                    : false,
-        tweened: typeof options.tweened === 'boolean' || options.tweened == null
-            ? options.tweened
-            : prop in options.tweened
-                ? //@ts-expect-error
-                    options.tweened[prop]
-                : Object.keys(options.tweened).some((key) => ['delay', 'duration', 'easing'].includes(key))
-                    ? options.tweened
-                    : false,
-    };
-}
-export function motionFinishHandler() {
-    let latestIndex = 0;
-    const moving = writable(false);
-    const handle = function (promise) {
-        latestIndex += 1;
-        if (!promise) {
-            // The store returned nothing, which means that the motion store is immediate.
-            moving.set(false);
-            return;
-        }
-        let thisIndex = latestIndex;
-        moving.set(true);
-        promise.then(() => {
-            if (thisIndex === latestIndex) {
-                moving.set(false);
-            }
-        });
-    };
-    return {
-        subscribe: moving.subscribe,
-        handle,
-    };
-}

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>;
-};