svelteplot 0.0.1-alpha.1 → 0.0.1-alpha.11

package/dist/helpers/colors.js

@@ -0,0 +1,200 @@
+import { interpolateBlues, interpolateBrBG, interpolateBuGn, interpolateBuPu, interpolateGnBu, interpolateGreens, interpolateGreys, interpolateOranges, interpolateOrRd, interpolatePiYG, interpolatePRGn, interpolatePuBu, interpolatePuBuGn, interpolatePuOr, interpolatePuRd, interpolatePurples, interpolateRdBu, interpolateRdGy, interpolateRdPu, interpolateRdYlBu, interpolateRdYlGn, interpolateReds, interpolateSpectral, interpolateYlGn, interpolateYlGnBu, interpolateYlOrBr, interpolateYlOrRd, interpolateTurbo, interpolateViridis, interpolateMagma, interpolateInferno, interpolatePlasma, interpolateCividis, interpolateCubehelixDefault, interpolateWarm, interpolateCool, interpolateRainbow, interpolateSinebow, schemeAccent, schemeBlues, schemeBrBG, schemeBuGn, schemeBuPu, schemeCategory10, schemeDark2, schemeGnBu, schemeGreens, schemeGreys, schemeOranges, schemeOrRd, schemePaired, schemePastel1, schemePastel2, schemePiYG, schemePRGn, schemePuBu, schemePuBuGn, schemePuOr, schemePuRd, schemePurples, schemeRdBu, schemeRdGy, schemeRdPu, schemeRdYlBu, schemeRdYlGn, schemeReds, schemeSet1, schemeSet2, schemeSet3, schemeSpectral, schemeTableau10, schemeYlGn, schemeYlGnBu, schemeYlOrBr, schemeYlOrRd } from 'd3-scale-chromatic';
+import { quantize } from 'd3-interpolate';
+export const categoricalSchemes = new Map([
+    ['accent', schemeAccent],
+    ['category10', schemeCategory10],
+    ['dark2', schemeDark2],
+    ['paired', schemePaired],
+    ['pastel1', schemePastel1],
+    ['pastel2', schemePastel2],
+    ['set1', schemeSet1],
+    ['set2', schemeSet2],
+    ['set3', schemeSet3],
+    ['tableau10', schemeTableau10]
+]);
+export function isCategoricalScheme(scheme) {
+    return scheme != null && categoricalSchemes.has(`${scheme}`.toLowerCase());
+}
+const ordinalSchemes = new Map([
+    // diverging
+    ['brbg', scheme11(schemeBrBG, interpolateBrBG)],
+    ['prgn', scheme11(schemePRGn, interpolatePRGn)],
+    ['piyg', scheme11(schemePiYG, interpolatePiYG)],
+    ['puor', scheme11(schemePuOr, interpolatePuOr)],
+    ['rdbu', scheme11(schemeRdBu, interpolateRdBu)],
+    ['rdgy', scheme11(schemeRdGy, interpolateRdGy)],
+    ['rdylbu', scheme11(schemeRdYlBu, interpolateRdYlBu)],
+    ['rdylgn', scheme11(schemeRdYlGn, interpolateRdYlGn)],
+    ['spectral', scheme11(schemeSpectral, interpolateSpectral)],
+    // reversed diverging (for temperature data)
+    ['burd', scheme11r(schemeRdBu, interpolateRdBu)],
+    ['buylrd', scheme11r(schemeRdYlBu, interpolateRdYlBu)],
+    // sequential (single-hue)
+    ['blues', scheme9(schemeBlues, interpolateBlues)],
+    ['greens', scheme9(schemeGreens, interpolateGreens)],
+    ['greys', scheme9(schemeGreys, interpolateGreys)],
+    ['oranges', scheme9(schemeOranges, interpolateOranges)],
+    ['purples', scheme9(schemePurples, interpolatePurples)],
+    ['reds', scheme9(schemeReds, interpolateReds)],
+    // sequential (multi-hue)
+    ['turbo', schemei(interpolateTurbo)],
+    ['viridis', schemei(interpolateViridis)],
+    ['magma', schemei(interpolateMagma)],
+    ['inferno', schemei(interpolateInferno)],
+    ['plasma', schemei(interpolatePlasma)],
+    ['cividis', schemei(interpolateCividis)],
+    ['cubehelix', schemei(interpolateCubehelixDefault)],
+    ['warm', schemei(interpolateWarm)],
+    ['cool', schemei(interpolateCool)],
+    ['bugn', scheme9(schemeBuGn, interpolateBuGn)],
+    ['bupu', scheme9(schemeBuPu, interpolateBuPu)],
+    ['gnbu', scheme9(schemeGnBu, interpolateGnBu)],
+    ['orrd', scheme9(schemeOrRd, interpolateOrRd)],
+    ['pubu', scheme9(schemePuBu, interpolatePuBu)],
+    ['pubugn', scheme9(schemePuBuGn, interpolatePuBuGn)],
+    ['purd', scheme9(schemePuRd, interpolatePuRd)],
+    ['rdpu', scheme9(schemeRdPu, interpolateRdPu)],
+    ['ylgn', scheme9(schemeYlGn, interpolateYlGn)],
+    ['ylgnbu', scheme9(schemeYlGnBu, interpolateYlGnBu)],
+    ['ylorbr', scheme9(schemeYlOrBr, interpolateYlOrBr)],
+    ['ylorrd', scheme9(schemeYlOrRd, interpolateYlOrRd)],
+    // cyclical
+    ['rainbow', schemeicyclical(interpolateRainbow)],
+    ['sinebow', schemeicyclical(interpolateSinebow)]
+]);
+export function isOrdinalScheme(scheme) {
+    return ordinalSchemes.has(scheme);
+}
+function scheme9(scheme, interpolate) {
+    return (n) => {
+        if (n === 1)
+            return [scheme[3][1]]; // favor midpoint
+        if (n === 2)
+            return [scheme[3][1], scheme[3][2]]; // favor darker
+        n = Math.max(3, Math.floor(n));
+        return n > 9 ? quantize(interpolate, n) : scheme[n];
+    };
+}
+function scheme11(scheme, interpolate) {
+    return (n) => {
+        if (n === 2)
+            return [scheme[3][0], scheme[3][2]]; // favor diverging extrema
+        n = Math.max(3, Math.floor(n));
+        return n > 11 ? quantize(interpolate, n) : scheme[n];
+    };
+}
+function scheme11r(scheme, interpolate) {
+    return (n) => {
+        if (n === 2)
+            return [scheme[3][2], scheme[3][0]]; // favor diverging extrema
+        n = Math.max(3, Math.floor(n));
+        return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse();
+    };
+}
+function schemei(interpolate) {
+    return (n) => quantize(interpolate, Math.max(2, Math.floor(n)));
+}
+function schemeicyclical(interpolate) {
+    return (n) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1);
+}
+export function ordinalScheme(scheme) {
+    const s = `${scheme}`.toLowerCase();
+    if (!ordinalSchemes.has(s))
+        throw new Error(`unknown ordinal scheme: ${s}`);
+    return ordinalSchemes.get(s);
+}
+export function ordinalRange(scheme, length) {
+    const s = ordinalScheme(scheme);
+    const r = typeof s === 'function' ? s({ length }) : s;
+    return r.length !== length ? r.slice(0, length) : r;
+}
+// If the specified domain contains only booleans (ignoring null and undefined),
+// returns a corresponding range where false is mapped to the low color and true
+// is mapped to the high color of the specified scheme.
+export function maybeBooleanRange(domain, scheme = 'greys') {
+    const range = new Set();
+    const [f, t] = ordinalRange(scheme, 2);
+    for (const value of domain) {
+        if (value == null)
+            continue;
+        if (value === true)
+            range.add(t);
+        else if (value === false)
+            range.add(f);
+        else
+            return;
+    }
+    return [...range];
+}
+const quantitativeSchemes = new Map([
+    // diverging
+    ['brbg', interpolateBrBG],
+    ['prgn', interpolatePRGn],
+    ['piyg', interpolatePiYG],
+    ['puor', interpolatePuOr],
+    ['rdbu', interpolateRdBu],
+    ['rdgy', interpolateRdGy],
+    ['rdylbu', interpolateRdYlBu],
+    ['rdylgn', interpolateRdYlGn],
+    ['spectral', interpolateSpectral],
+    // reversed diverging (for temperature data)
+    ['burd', (t) => interpolateRdBu(1 - t)],
+    ['buylrd', (t) => interpolateRdYlBu(1 - t)],
+    // sequential (single-hue)
+    ['blues', interpolateBlues],
+    ['greens', interpolateGreens],
+    ['greys', interpolateGreys],
+    ['purples', interpolatePurples],
+    ['reds', interpolateReds],
+    ['oranges', interpolateOranges],
+    // sequential (multi-hue)
+    ['turbo', interpolateTurbo],
+    ['viridis', interpolateViridis],
+    ['magma', interpolateMagma],
+    ['inferno', interpolateInferno],
+    ['plasma', interpolatePlasma],
+    ['cividis', interpolateCividis],
+    ['cubehelix', interpolateCubehelixDefault],
+    ['warm', interpolateWarm],
+    ['cool', interpolateCool],
+    ['bugn', interpolateBuGn],
+    ['bupu', interpolateBuPu],
+    ['gnbu', interpolateGnBu],
+    ['orrd', interpolateOrRd],
+    ['pubugn', interpolatePuBuGn],
+    ['pubu', interpolatePuBu],
+    ['purd', interpolatePuRd],
+    ['rdpu', interpolateRdPu],
+    ['ylgnbu', interpolateYlGnBu],
+    ['ylgn', interpolateYlGn],
+    ['ylorbr', interpolateYlOrBr],
+    ['ylorrd', interpolateYlOrRd],
+    // cyclical
+    ['rainbow', interpolateRainbow],
+    ['sinebow', interpolateSinebow]
+]);
+export function isQuantitativeScheme(scheme) {
+    return quantitativeSchemes.has(scheme);
+}
+export function quantitativeScheme(scheme) {
+    const s = `${scheme}`.toLowerCase();
+    if (!quantitativeSchemes.has(s))
+        throw new Error(`unknown quantitative scheme: ${s}`);
+    return quantitativeSchemes.get(s);
+}
+const divergingSchemes = new Set([
+    'brbg',
+    'prgn',
+    'piyg',
+    'puor',
+    'rdbu',
+    'rdgy',
+    'rdylbu',
+    'rdylgn',
+    'spectral',
+    'burd',
+    'buylrd'
+]);
+export function isDivergingScheme(scheme) {
+    return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase());
+}

package/dist/helpers/createScale.d.ts

@@ -0,0 +1,5 @@
+import type { ColorScheme, RawValue } from '../types.js';
+declare const Scales: Record<string, (domain: number[], range: [number, number]) => (val: any) => any>;
+export declare function createScale(type: keyof typeof Scales, domain: any, range: any, options?: {}): (val: any) => any;
+export declare function createColorScale(type: any, domain: string[] | [number, number] | [Date, Date] | [boolean | boolean], range: RawValue[] | null, scheme: ColorScheme | null): ((d: any) => any) | (unknown[] & string[] & import("d3-scale").ScaleOrdinal<string, unknown, never>) | import("d3-scale").ScaleSequential<string, never>;
+export {};

package/dist/helpers/createScale.js

@@ -0,0 +1,57 @@
+import { scaleBand, scaleLinear, scaleTime, scaleSqrt, scaleLog, scaleOrdinal } from 'd3-scale';
+import { scaleSequential, scaleDiverging } from 'd3-scale';
+import { getLogTicks } from './getLogTicks.js';
+import { categoricalSchemes, isCategoricalScheme, isQuantitativeScheme, ordinalScheme, quantitativeScheme } from './colors.js';
+import { isColorOrNull } from './typeChecks.js';
+const Scales = {
+    band: scaleBand,
+    linear: scaleLinear,
+    time: scaleTime,
+    sqrt: scaleSqrt,
+    log: scaleLog,
+    ordinal: scaleOrdinal,
+    sequential: scaleSequential,
+    diverging: scaleDiverging
+};
+export function createScale(type, domain, range, options = {}) {
+    const scale = Scales[type](domain, range);
+    // allow setting arbiraty scale options
+    for (const [key, val] of Object.entries(options)) {
+        if (typeof scale[key] === 'function')
+            scale[key](val);
+        else
+            console.warn('unknown scale setter ' + key);
+    }
+    if (type === 'log') {
+        // overwrite scaleLog's internal ticks() method
+        scale.ticks = (count) => getLogTicks(domain, count);
+        // console.log({domain})
+        // console.log(getLogTicks(domain, 5))
+    }
+    return scale;
+}
+const identity = (d) => d;
+export function createColorScale(type, domain, range, scheme) {
+    if (type === 'identity')
+        return identity;
+    if (type === 'band') {
+        if (domain.every(isColorOrNull)) {
+            return identity;
+        }
+        const colorRange = Array.isArray(range)
+            ? range
+            : !scheme
+                ? categoricalSchemes.get('tableau10')
+                : isCategoricalScheme(scheme)
+                    ? categoricalSchemes.get(scheme)
+                    : ordinalScheme(scheme)(domain.length);
+        return scaleOrdinal().domain(domain).range(colorRange);
+    }
+    else if (type === 'linear') {
+        const colorInterpolator = isQuantitativeScheme(scheme)
+            ? quantitativeScheme(scheme)
+            : quantitativeScheme('blues');
+        return scaleSequential(domain, colorInterpolator);
+    }
+    return (d) => d;
+}

package/dist/helpers/getBaseStyles.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelAccessor, MarkStyleProps, DataRow } from '../types.js';
+export default function (datum: DataRow, props: Partial<Record<MarkStyleProps, ChannelAccessor>>): string;

package/dist/helpers/getBaseStyles.js

@@ -0,0 +1,18 @@
+import { MARK_PROP_CHANNEL } from '../contants.js';
+import resolveChannel from './resolveChannel.js';
+const styleProps = {
+    fill: 'fill',
+    stroke: 'stroke',
+    strokeWidth: 'stroke-width',
+    strokeDasharray: 'stroke-dasharray',
+    fillOpacity: 'fill-opacity',
+    strokeOpacity: 'stroke-opacity',
+    fontSize: 'font-size',
+    opacity: 'opacity'
+};
+export default function (datum, props) {
+    return Object.entries(styleProps)
+        .filter(([key, cssKey]) => cssKey && props[key] != null)
+        .map(([key, cssKey]) => `${cssKey}: ${resolveChannel(MARK_PROP_CHANNEL[key], datum, props[key])}`)
+        .join(';');
+}

package/dist/helpers/getLogTicks.d.ts

@@ -0,0 +1 @@
+export declare function getLogTicks(domain: [number, number], count?: number): number[];

package/dist/helpers/getLogTicks.js

@@ -0,0 +1,57 @@
+import { ticks as ticksArray } from 'd3-array';
+export function getLogTicks(domain, count = 6) {
+    const inverted = domain[0] < 0 && domain[1] < 0;
+    if (inverted)
+        domain = [domain[0] * -1, domain[1] * -1];
+    const reversed = domain[1] < domain[0];
+    if (reversed)
+        domain = domain.slice(0).reverse();
+    if (domain[0] < 0 || domain[1] < 0)
+        return [];
+    if (domain[0] === 0)
+        return ticksArray(domain[0], domain[1], count - 2);
+    let mult = Math.pow(10, Math.floor(Math.log10(Math.abs(domain[1] - domain[0]))) - 1);
+    count += 2;
+    let candidates = getTickCandidates(domain, mult);
+    if (candidates[0].num > count) {
+        // too many ticks
+        while (candidates[0].num > count) {
+            mult *= 10;
+            candidates = getTickCandidates(domain, mult);
+        }
+    }
+    else if (candidates[candidates.length - 1].num < count) {
+        // not enough ticks, let's fallback to linear ticks
+        const ticksList = ticksArray(domain[0], domain[1], count - 2);
+        if (reversed)
+            ticksList.reverse();
+        return ticksList;
+    }
+    count -= 2;
+    const ticksList = candidates
+        .map((d) => ({
+        ...d,
+        ticks: d.ticks.filter((t) => t >= domain[0] && t <= domain[1])
+    }))
+        .map((d) => ({ ...d, diff: Math.abs(d.ticks.length - count) }))
+        .sort((a, b) => a.diff - b.diff)[0].ticks;
+    if (reversed)
+        ticksList.reverse();
+    if (inverted)
+        return ticksList.map((t) => t * -1);
+    return ticksList;
+}
+const logSeries = [[10], [5, 4, 5], [3, 10 / 3], [2, 2.5, 2], [1.5, 2, 5 / 3, 2]];
+function getTickCandidates(domain, mult = 1) {
+    return logSeries.map((factors) => {
+        let i = Math.pow(10, Math.floor(Math.log10(domain[0])));
+        let f = 0;
+        const r = [i];
+        while (i < domain[1] && r.length < 50) {
+            i *= factors[f] * mult;
+            r.push(i);
+            f = (f + 1) % factors.length;
+        }
+        return { ticks: r, num: r.length };
+    });
+}

package/dist/helpers/isDataRecord.d.ts

@@ -0,0 +1,2 @@
+import type { DataRecord } from '../types.js';
+export default function (value: any): value is DataRecord;

package/dist/helpers/isDataRecord.js

@@ -0,0 +1,13 @@
+export default function (value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (Object.prototype.toString.call(value) !== '[object Object]')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null)
+        return true;
+    const Ctor = Object.prototype.hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+    return (typeof Ctor === 'function' &&
+        Ctor instanceof Ctor &&
+        Function.prototype.call(Ctor) === Function.prototype.call(value));
+}

package/dist/helpers/mergeDeep.d.ts

@@ -0,0 +1,5 @@
+type ObjectType = {
+    [key: string]: any;
+};
+export default function mergeDeep(target: ObjectType, ...sources: ObjectType[]): ObjectType;
+export {};

package/dist/helpers/mergeDeep.js

@@ -0,0 +1,26 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+export default function mergeDeep(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key]) {
+                    Object.assign(target, { [key]: {} });
+                }
+                else {
+                    target[key] = Object.assign({}, target[key]);
+                }
+                mergeDeep(target[key], source[key]);
+            }
+            else if (source[key] !== null) {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(target, ...sources);
+}

package/dist/helpers/removeIdenticalLines.d.ts

@@ -0,0 +1 @@
+export default function removeIdenticalLines(input: string[][]): string[][];

package/dist/helpers/removeIdenticalLines.js

@@ -0,0 +1,16 @@
+export default function removeIdenticalLines(input) {
+    const uniqueLines = [];
+    if (!input.length)
+        return input;
+    for (let c = 0; c < input.length; c++) {
+        uniqueLines.push([]);
+    }
+    for (let l = 0; l < input[0].length; l++) {
+        const isIdentical = input.every((value) => input[0][l] === value[l]);
+        for (let c = 0; c < input.length; c++) {
+            if (!isIdentical)
+                uniqueLines[c].push(input[c][l]);
+        }
+    }
+    return uniqueLines;
+}

package/dist/helpers/resolveChannel.d.ts

@@ -0,0 +1,2 @@
+import type { ChannelName, ChannelAccessor, DataRow, RawValue } from '../types';
+export default function (channel: ChannelName, datum: DataRow, accessor?: ChannelAccessor): RawValue;

package/dist/helpers/resolveChannel.js

@@ -0,0 +1,28 @@
+import isDataRecord from './isDataRecord.js';
+export default function (channel, datum, accessor = null) {
+    if ((channel === 'x' || channel === 'y') && Array.isArray(datum) && accessor === null) {
+        // special case for [[x0,y0], [x1,y1], ...] format
+        return datum[channel === 'x' ? 0 : 1];
+    }
+    else if (isDataRecord(datum)) {
+        // use accessor function
+        if (typeof accessor === 'function')
+            return accessor(datum.___orig___ ? datum.___orig___ : datum);
+        // use accessor string
+        if (typeof accessor === 'string' && datum[accessor] !== undefined)
+            return datum[accessor];
+        // fallback to channel name as accessor
+        if (accessor === null && datum[channel] !== undefined)
+            return datum[channel];
+        // interpret accessor as constant
+        return accessor;
+    }
+    else {
+        // return single value or accessor
+        return typeof accessor === 'function'
+            ? accessor(datum)
+            : accessor !== null
+                ? accessor
+                : datum;
+    }
+}

package/dist/helpers/symbols.d.ts

@@ -0,0 +1,5 @@
+import { type SymbolType } from 'd3-shape';
+export declare const sqrt3: number;
+export declare const sqrt4_3: number;
+export declare function isSymbol(value: string | SymbolType): boolean;
+export declare function maybeSymbol(symbol: SymbolType | string): SymbolType;

package/dist/helpers/symbols.js

@@ -0,0 +1,51 @@
+import { symbolAsterisk, symbolDiamond2, symbolPlus, symbolSquare2, symbolTriangle2, symbolX as symbolTimes, symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye } from 'd3-shape';
+export const sqrt3 = Math.sqrt(3);
+export const sqrt4_3 = 2 / sqrt3;
+const symbolHexagon = {
+    draw(context, size) {
+        const rx = Math.sqrt(size / Math.PI), ry = rx * sqrt4_3, hy = ry / 2;
+        context.moveTo(0, ry);
+        context.lineTo(rx, hy);
+        context.lineTo(rx, -hy);
+        context.lineTo(0, -ry);
+        context.lineTo(-rx, -hy);
+        context.lineTo(-rx, hy);
+        context.closePath();
+    }
+};
+const symbols = new Map([
+    ['asterisk', symbolAsterisk],
+    ['circle', symbolCircle],
+    ['cross', symbolCross],
+    ['diamond', symbolDiamond],
+    ['diamond2', symbolDiamond2],
+    ['hexagon', symbolHexagon],
+    ['plus', symbolPlus],
+    ['square', symbolSquare],
+    ['square2', symbolSquare2],
+    ['star', symbolStar],
+    ['times', symbolTimes],
+    ['triangle', symbolTriangle],
+    ['triangle2', symbolTriangle2],
+    ['wye', symbolWye]
+]);
+function isSymbolObject(value) {
+    if (typeof value === 'string')
+        return false;
+    return value && typeof value.draw === 'function';
+}
+export function isSymbol(value) {
+    if (isSymbolObject(value))
+        return true;
+    if (typeof value !== 'string')
+        return false;
+    return symbols.has(value.toLowerCase());
+}
+export function maybeSymbol(symbol) {
+    if (symbol == null || isSymbolObject(symbol))
+        return symbol;
+    const value = symbols.get(`${symbol}`.toLowerCase());
+    if (value)
+        return value;
+    throw new Error(`invalid symbol: ${symbol}`);
+}

package/dist/helpers/typeChecks.d.ts

@@ -0,0 +1,7 @@
+import type { RawValue } from '../types.js';
+export declare function isBooleanOrNull(v: RawValue): boolean;
+export declare function isDateOrNull(v: RawValue): boolean;
+export declare function isNumberOrNull(v: RawValue): boolean;
+export declare function isStringOrNull(v: RawValue): boolean;
+export declare function isColorOrNull(v: RawValue): boolean;
+export declare function isOpacityOrNull(v: RawValue): boolean;

package/dist/helpers/typeChecks.js

@@ -0,0 +1,21 @@
+import chroma from 'chroma-js';
+import { isDate, isFinite } from 'underscore';
+export function isBooleanOrNull(v) {
+    return v == null || typeof v === 'boolean';
+}
+export function isDateOrNull(v) {
+    return v == null || isDate(v);
+}
+export function isNumberOrNull(v) {
+    return v == null || isFinite(v);
+}
+export function isStringOrNull(v) {
+    return v == null || typeof v === 'string';
+}
+export function isColorOrNull(v) {
+    // todo: maybe not use chroma.js here to save kb
+    return v == null || (typeof v === 'string' && chroma.valid(v));
+}
+export function isOpacityOrNull(v) {
+    return v == null || (typeof v === 'number' && isFinite(v) && v >= 0 && v <= 1);
+}

package/dist/helpers/wrapArray.d.ts

@@ -0,0 +1,2 @@
+import type { DataRow } from '../types.js';
+export default function (data: DataRow[]): (Date | [number, number] | import("../types.js").DataRecord)[];

package/dist/helpers/wrapArray.js

@@ -0,0 +1,4 @@
+import { isObject } from 'underscore';
+export default function (data) {
+    return data.map((d) => (isObject(d) ? d : { value: d }));
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { default as AxisX } from './marks/AxisX.svelte';
+export { default as AxisY } from './marks/AxisY.svelte';
+export { default as ColorLegend } from './marks/ColorLegend.svelte';
+export { default as Area } from './marks/Area.svelte';
+export { default as AreaX } from './marks/AreaX.svelte';
+export { default as AreaY } from './marks/AreaY.svelte';
+export { default as Dot } from './marks/Dot.svelte';
+export { default as DotX } from './marks/DotX.svelte';
+export { default as DotY } from './marks/DotY.svelte';
+export { default as Frame } from './marks/Frame.svelte';
+export { default as GridX } from './marks/GridX.svelte';
+export { default as GridY } from './marks/GridY.svelte';
+export { default as Line } from './marks/Line.svelte';
+export { default as LineX } from './marks/LineX.svelte';
+export { default as LineY } from './marks/LineY.svelte';
+export { default as Plot } from './Plot.svelte';
+export { default as RuleX } from './marks/RuleX.svelte';
+export { default as RuleY } from './marks/RuleY.svelte';
+export { default as SymbolLegend } from './marks/SymbolLegend.svelte';

package/dist/index.js

@@ -0,0 +1,20 @@
+// Reexport your entry components here
+export { default as AxisX } from './marks/AxisX.svelte';
+export { default as AxisY } from './marks/AxisY.svelte';
+export { default as ColorLegend } from './marks/ColorLegend.svelte';
+export { default as Area } from './marks/Area.svelte';
+export { default as AreaX } from './marks/AreaX.svelte';
+export { default as AreaY } from './marks/AreaY.svelte';
+export { default as Dot } from './marks/Dot.svelte';
+export { default as DotX } from './marks/DotX.svelte';
+export { default as DotY } from './marks/DotY.svelte';
+export { default as Frame } from './marks/Frame.svelte';
+export { default as GridX } from './marks/GridX.svelte';
+export { default as GridY } from './marks/GridY.svelte';
+export { default as Line } from './marks/Line.svelte';
+export { default as LineX } from './marks/LineX.svelte';
+export { default as LineY } from './marks/LineY.svelte';
+export { default as Plot } from './Plot.svelte';
+export { default as RuleX } from './marks/RuleX.svelte';
+export { default as RuleY } from './marks/RuleY.svelte';
+export { default as SymbolLegend } from './marks/SymbolLegend.svelte';