svelteplot 0.0.1-alpha.9 → 0.1.3-next.4

package/dist/helpers/scales.js

@@ -0,0 +1,309 @@
+import { extent, range as d3Range, ascending } from 'd3-array';
+import { isColorOrNull, isDateOrNull, isNumberOrNull, isNumberOrNullOrNaN, isStringOrNull } from './typeChecks.js';
+import { CHANNEL_SCALE, VALID_SCALE_TYPES } from '../constants.js';
+import { isSymbolOrNull } from './typeChecks.js';
+import { resolveProp, toChannelOption } from './resolve.js';
+import isDataRecord from './isDataRecord.js';
+import { createProjection } from './projection.js';
+/**
+ * compute the plot scales
+ */
+export function computeScales(plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, marks, plotDefaults) {
+    const x = createScale('x', plotOptions.x, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults);
+    const y = createScale('y', plotOptions.y, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults);
+    const r = createScale('r', plotOptions.r, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults);
+    const color = createScale('color', plotOptions.color, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults);
+    const opacity = createScale('opacity', plotOptions.opacity, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults);
+    const length = createScale('length', plotOptions.length, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults);
+    const symbol = createScale('symbol', plotOptions.symbol, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults);
+    // create fx and fy scales from mark data directly
+    const fx = createScale('fx', plotOptions.fx, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults);
+    const fy = createScale('fy', plotOptions.fy, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults);
+    const projection = plotOptions.projection
+        ? createProjection({ projOptions: plotOptions.projection, inset: plotOptions.inset }, {
+            width: plotWidth,
+            height: plotHeight,
+            marginBottom: plotOptions.marginBottom,
+            marginLeft: plotOptions.marginLeft,
+            marginRight: plotOptions.marginRight,
+            marginTop: plotOptions.marginTop
+        })
+        : null;
+    return { x, y, r, color, opacity, length, symbol, fx, fy, projection };
+}
+export function createScale(name, scaleOptions, marks, plotOptions, plotWidth, plotHeight, plotHasFilledDotMarks, plotDefaults) {
+    if (!plotOptions.implicitScales && !scaleOptions.scale) {
+        // no scale defined, return a dummy scale
+        const fn = name === 'color' ? () => 'currentColor' : () => 0;
+        fn.range = name === 'color' ? () => ['currentColor'] : () => [0];
+        return { type: 'linear', domain: [0], range: [0], fn, skip: new Map(), isDummy: true };
+    }
+    // gather all marks that use channels which support this scale
+    const dataValues = new Set();
+    const allDataValues = [];
+    const markTypes = new Set();
+    const skip = new Map();
+    let manualActiveMarks = 0;
+    const propNames = new Set();
+    const uniqueScaleProps = new Set();
+    let sortOrdinalDomain = true;
+    for (const mark of marks) {
+        // we only sort the scale domain alphabetically, if none of the
+        // marks that map to it are using the `sort` transform. Note that
+        // we're deliberately checking for !== undefined and not for != null
+        // since the explicit sort transforms like shuffle will set the
+        // sort channel to null to we know that there's an explicit order
+        if (mark.channels.sort !== undefined)
+            sortOrdinalDomain = false;
+        for (const channel of mark.channels) {
+            // channelOptions can be passed as prop, but most often users will just
+            // pass the channel accessor or constant value, so we may need to wrap
+            if (!skip.has(channel))
+                skip.set(channel, new Set());
+            if (mark.data.length > 0) {
+                const channelOptions = isDataRecord(mark.options[channel])
+                    ? mark.options[channel]
+                    : { value: mark.options[channel], scale: CHANNEL_SCALE[channel] };
+                // check if this mark channel is using this scale, which users can prevent
+                // by passing `{ scale: null }` as prop
+                const useScale = channelOptions.scale === name &&
+                    // only use scale if implicit scales are enabled or use has explicitly
+                    // defined a scale
+                    (plotOptions.implicitScales || scaleOptions.scale) &&
+                    // type number means, someone is defining a channel as constant, e.g.
+                    // <Dot r={10} /> in which case we don't want to pass it through a scale
+                    // typeof channelOptions.value !== 'number' &&
+                    typeof channelOptions.value !== 'undefined';
+                if (useScale) {
+                    if (name === 'opacity' && looksLikeOpacity(channelOptions.value)) {
+                        // special handling for opacity scales, where any accessor that looks like
+                        // a number between 0 and 1 will be interpreted as output type
+                        skip.get(channel).add(mark.id);
+                    }
+                    else {
+                        const isOutputType = name === 'color'
+                            ? isColorOrNull
+                            : name === 'symbol'
+                                ? isSymbolOrNull
+                                : false;
+                        let allValuesAreOutputType = !!isOutputType && mark.data.length > 0;
+                        if (isOutputType) {
+                            for (const datum of mark.data) {
+                                const val = resolveProp(channelOptions.value, datum);
+                                allValuesAreOutputType =
+                                    allValuesAreOutputType && val !== null && isOutputType(val);
+                                if (!allValuesAreOutputType)
+                                    break;
+                            }
+                        }
+                        if (allValuesAreOutputType) {
+                            skip.get(channel).add(mark.id);
+                        }
+                        if (typeof channelOptions.value === 'string' &&
+                            !looksLikeANumber(channelOptions.value) &&
+                            !channelOptions.value.startsWith('__') &&
+                            mark.data[0][channelOptions.value] !== undefined) {
+                            propNames.add(channelOptions.value);
+                        }
+                        uniqueScaleProps.add(channelOptions.value);
+                        if (channelOptions.value != null && !allValuesAreOutputType) {
+                            manualActiveMarks++;
+                            markTypes.add(mark.type);
+                            // active mark channel
+                            for (const datum of mark.data) {
+                                const value = resolveProp(channelOptions.value, datum);
+                                dataValues.add(value);
+                                if (name === 'color' && scaleOptions.type === 'quantile') {
+                                    allDataValues.push(value);
+                                }
+                            }
+                        }
+                    }
+                }
+                // special handling of marks using the stackX/stackY transform
+                if ((name === 'x' || name === 'y') &&
+                    mark.options[`__${name}_origField`] &&
+                    !mark.options[`__${name}_origField`].startsWith('__')) {
+                    propNames.add(mark.options[`__${name}_origField`]);
+                }
+            }
+            else {
+                // also skip marks without data to prevent exceptions
+                // (skip.get(channel) as Set<symbol>).add(mark.id);
+            }
+        }
+    }
+    // construct domain from data values
+    const valueArr = [...dataValues.values(), ...(scaleOptions.domain || [])].filter((d) => d != null);
+    const type = scaleOptions.type === 'auto'
+        ? inferScaleType(name, valueArr, markTypes)
+        : scaleOptions.type;
+    if (VALID_SCALE_TYPES[name] && !VALID_SCALE_TYPES[name].has(type)) {
+        throw new Error(`Invalid scale type ${type} for scale
+            ${name}. Valid types are ${[...VALID_SCALE_TYPES[name]].join(', ')}`);
+    }
+    const isOrdinal = type === 'band' || type === 'point' || type === 'ordinal' || type === 'categorical';
+    if (isOrdinal && sortOrdinalDomain) {
+        valueArr.sort(ascending);
+    }
+    const domain = scaleOptions.domain
+        ? scaleOptions.domain
+        : type === 'band' ||
+            type === 'point' ||
+            type === 'ordinal' ||
+            type === 'categorical' ||
+            type === 'quantile' ||
+            type === 'quantile-cont'
+            ? name === 'y'
+                ? valueArr.toReversed()
+                : valueArr
+            : extent(scaleOptions.zero ? [0, ...valueArr] : valueArr);
+    if (!scaleOptions.scale) {
+        throw new Error(`No scale function defined for ${name}`);
+    }
+    const fn = scaleOptions.scale({
+        name,
+        type,
+        domain,
+        scaleOptions,
+        plotOptions,
+        plotWidth,
+        plotHeight,
+        plotHasFilledDotMarks,
+        plotDefaults
+    });
+    const range = fn.range();
+    return {
+        type,
+        domain,
+        range,
+        fn,
+        skip,
+        manualActiveMarks,
+        uniqueScaleProps,
+        autoTitle: type === 'time'
+            ? null
+            : propNames.size === 1
+                ? `${[...propNames.values()][0]}${type === 'log' ? ' (log)' : ''}`
+                : null
+    };
+}
+/**
+ * Infer a scale type based on the scale name, the data values mapped to it and
+ * the mark types that are bound to the scale
+ */
+export function inferScaleType(name, dataValues, markTypes) {
+    if (name === 'color') {
+        if (!dataValues.length)
+            return 'ordinal';
+        if (dataValues.every(isNumberOrNullOrNaN))
+            return 'linear';
+        if (dataValues.every(isDateOrNull))
+            return 'linear';
+        if (dataValues.every(isStringOrNull))
+            return 'categorical';
+        return 'categorical';
+    }
+    if (name === 'symbol')
+        return 'ordinal';
+    // for positional scales, try to pick a scale that's required by the mark types
+    if ((name === 'x' || name === 'y') && markTypes.size === 1) {
+        if (name === 'y' &&
+            (markTypes.has('barX') || markTypes.has('tickX') || markTypes.has('cell')))
+            return 'band';
+        if (name === 'x' &&
+            (markTypes.has('barY') || markTypes.has('tickY') || markTypes.has('cell')))
+            return 'band';
+    }
+    if (!dataValues.length)
+        return 'linear';
+    if (dataValues.length === 1)
+        return 'point';
+    if (dataValues.every(isNumberOrNull))
+        return name === 'r' ? 'sqrt' : 'linear';
+    if (dataValues.every(isDateOrNull))
+        return 'time';
+    if (dataValues.every(isStringOrNull))
+        return markTypes.has('arrow') ? 'point' : 'band';
+    return 'linear';
+}
+const scaledChannelNames = [
+    'x',
+    'x1',
+    'x2',
+    'y',
+    'y1',
+    'y2',
+    'r',
+    'opacity',
+    'fill',
+    'fillOpacity',
+    'stroke',
+    'strokeOpacity',
+    'symbol',
+    'length'
+];
+/**
+ * Mark channels can explicitely or implicitely be exempt from being
+ * mapped to a scale, so everywhere where values are being mapped to
+ * scales, we need to check if the the scale is supposed to be used
+ * not. That's what this function is used for.
+ */
+export function getUsedScales(plot, options, mark) {
+    return Object.fromEntries(scaledChannelNames.map((channel) => {
+        const scale = CHANNEL_SCALE[channel];
+        const skipMarks = plot.scales[scale].skip.get(channel) || new Set();
+        return [
+            channel,
+            !skipMarks.has(mark.id) &&
+                toChannelOption(channel, options[channel]).scale !== null &&
+                !plot.scales[scale].isDummy
+        ];
+    }));
+}
+export function looksLikeANumber(input) {
+    return (Number.isFinite(input) ||
+        (typeof input === 'string' && input.trim().length > 0 && Number.isFinite(+input)));
+}
+function isWithin(number, min, max) {
+    return Number.isFinite(number) && number >= min && number <= max;
+}
+function looksLikeOpacity(input) {
+    return looksLikeANumber(input) && isWithin(+input, 0, 1);
+}
+export function projectXY(scales, x, y, useXScale = true, useYScale = true) {
+    if (scales.projection) {
+        // TODO: pretty sure this is not how projection streams are supposed to be used
+        // efficiantly, in observable plot, all data points of a mark are projected using
+        // the same stream
+        let x_, y_;
+        const stream = scales.projection.stream({
+            point(px, py) {
+                x_ = px;
+                y_ = py;
+            }
+        });
+        stream.point(x, y);
+        return [x_, y_];
+    }
+    return [
+        useXScale ? projectX('x', scales, x) : x,
+        useYScale ? projectY('y', scales, y) : y
+    ];
+}
+export function projectX(channel, scales, value) {
+    return (scales.x.fn(value) +
+        (channel === 'x' && scales.x.type === 'band'
+            ? scales.x.fn.bandwidth() * 0.5
+            : channel === 'x2' && scales.x.type === 'band'
+                ? scales.x.fn.bandwidth()
+                : 0));
+}
+export function projectY(channel, scales, value) {
+    return (scales.y.fn(value) +
+        (channel === 'y' && scales.y.type === 'band'
+            ? scales.y.fn.bandwidth() * 0.5
+            : channel === 'y2' && scales.y.type === 'band'
+                ? scales.y.fn.bandwidth()
+                : 0));
+}

package/dist/helpers/time.d.ts

@@ -0,0 +1,6 @@
+export declare const intervalDuration: unique symbol;
+export declare const intervalType: unique symbol;
+export declare function parseTimeInterval(input: any): (string | number)[];
+export declare function maybeTimeInterval(input: any): any;
+export declare function maybeUtcInterval(input: any): any;
+export declare function generalizeTimeInterval(interval: any, n: any): any;

package/dist/helpers/time.js

@@ -0,0 +1,282 @@
+/**
+ * @license
+ * Copyright 2020-2023 Observable, Inc.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any purpose
+ * with or without fee is hereby granted, provided that the above copyright notice
+ * and this permission notice appear in all copies.
+ */
+import { bisector } from 'd3-array';
+import { utcSecond, utcMinute, utcHour, unixDay, utcWeek, utcMonth, utcYear, utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday, timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear, timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday } from 'd3-time';
+// import {orderof} from "./options.js";
+const durationSecond = 1000;
+const durationMinute = durationSecond * 60;
+const durationHour = durationMinute * 60;
+const durationDay = durationHour * 24;
+const durationWeek = durationDay * 7;
+const durationMonth = durationDay * 30;
+const durationYear = durationDay * 365;
+// See https://github.com/d3/d3-time/blob/9e8dc940f38f78d7588aad68a54a25b1f0c2d97b/src/ticks.js#L14-L33
+const tickIntervals = [
+    ['millisecond', 1],
+    ['2 milliseconds', 2],
+    ['5 milliseconds', 5],
+    ['10 milliseconds', 10],
+    ['20 milliseconds', 20],
+    ['50 milliseconds', 50],
+    ['100 milliseconds', 100],
+    ['200 milliseconds', 200],
+    ['500 milliseconds', 500],
+    ['second', durationSecond],
+    ['5 seconds', 5 * durationSecond],
+    ['15 seconds', 15 * durationSecond],
+    ['30 seconds', 30 * durationSecond],
+    ['minute', durationMinute],
+    ['5 minutes', 5 * durationMinute],
+    ['15 minutes', 15 * durationMinute],
+    ['30 minutes', 30 * durationMinute],
+    ['hour', durationHour],
+    ['3 hours', 3 * durationHour],
+    ['6 hours', 6 * durationHour],
+    ['12 hours', 12 * durationHour],
+    ['day', durationDay],
+    ['2 days', 2 * durationDay],
+    ['week', durationWeek],
+    ['2 weeks', 2 * durationWeek], // https://github.com/d3/d3-time/issues/46
+    ['month', durationMonth],
+    ['3 months', 3 * durationMonth],
+    ['6 months', 6 * durationMonth], // https://github.com/d3/d3-time/issues/46
+    ['year', durationYear],
+    ['2 years', 2 * durationYear],
+    ['5 years', 5 * durationYear],
+    ['10 years', 10 * durationYear],
+    ['20 years', 20 * durationYear],
+    ['50 years', 50 * durationYear],
+    ['100 years', 100 * durationYear] // TODO generalize to longer time scales
+];
+const durations = new Map([
+    ['second', durationSecond],
+    ['minute', durationMinute],
+    ['hour', durationHour],
+    ['day', durationDay],
+    ['monday', durationWeek],
+    ['tuesday', durationWeek],
+    ['wednesday', durationWeek],
+    ['thursday', durationWeek],
+    ['friday', durationWeek],
+    ['saturday', durationWeek],
+    ['sunday', durationWeek],
+    ['week', durationWeek],
+    ['month', durationMonth],
+    ['year', durationYear]
+]);
+const timeIntervals = new Map([
+    ['second', timeSecond],
+    ['minute', timeMinute],
+    ['hour', timeHour],
+    ['day', timeDay], // https://github.com/d3/d3-time/issues/62
+    ['monday', timeMonday],
+    ['tuesday', timeTuesday],
+    ['wednesday', timeWednesday],
+    ['thursday', timeThursday],
+    ['friday', timeFriday],
+    ['saturday', timeSaturday],
+    ['sunday', timeSunday],
+    ['week', timeWeek],
+    ['month', timeMonth],
+    ['year', timeYear]
+]);
+const utcIntervals = new Map([
+    ['second', utcSecond],
+    ['minute', utcMinute],
+    ['hour', utcHour],
+    ['day', unixDay],
+    ['monday', utcMonday],
+    ['tuesday', utcTuesday],
+    ['wednesday', utcWednesday],
+    ['thursday', utcThursday],
+    ['friday', utcFriday],
+    ['saturday', utcSaturday],
+    ['sunday', utcSunday],
+    ['week', utcWeek],
+    ['month', utcMonth],
+    ['year', utcYear]
+]);
+// These hidden fields describe standard intervals so that we can, for example,
+// generalize a scale’s time interval to a larger ticks time interval to reduce
+// the number of displayed ticks. TODO We could instead allow the interval
+// implementation to expose a “generalize” method that returns a larger, aligned
+// interval; that would allow us to move this logic to D3, and allow
+// generalization even when a custom interval is provided.
+export const intervalDuration = Symbol('intervalDuration');
+export const intervalType = Symbol('intervalType');
+// We greedily mutate D3’s standard intervals on load so that the hidden fields
+// are available even if specified as e.g. d3.utcMonth instead of "month".
+for (const [name, interval] of timeIntervals) {
+    interval[intervalDuration] = durations.get(name);
+    interval[intervalType] = 'time';
+}
+for (const [name, interval] of utcIntervals) {
+    interval[intervalDuration] = durations.get(name);
+    interval[intervalType] = 'utc';
+}
+const utcFormatIntervals = [
+    ['year', utcYear, 'utc'],
+    ['month', utcMonth, 'utc'],
+    ['day', unixDay, 'utc', 6 * durationMonth],
+    ['hour', utcHour, 'utc', 3 * durationDay],
+    ['minute', utcMinute, 'utc', 6 * durationHour],
+    ['second', utcSecond, 'utc', 30 * durationMinute]
+];
+const timeFormatIntervals = [
+    ['year', timeYear, 'time'],
+    ['month', timeMonth, 'time'],
+    ['day', timeDay, 'time', 6 * durationMonth],
+    ['hour', timeHour, 'time', 3 * durationDay],
+    ['minute', timeMinute, 'time', 6 * durationHour],
+    ['second', timeSecond, 'time', 30 * durationMinute]
+];
+// An interleaved array of UTC and local time intervals, in descending order
+// from largest to smallest, used to determine the most specific standard time
+// format for a given array of dates. This is a subset of the tick intervals
+// listed above; we only need the breakpoints where the format changes.
+const formatIntervals = [
+    utcFormatIntervals[0],
+    timeFormatIntervals[0],
+    utcFormatIntervals[1],
+    timeFormatIntervals[1],
+    utcFormatIntervals[2],
+    timeFormatIntervals[2],
+    // Below day, local time typically has an hourly offset from UTC and hence the
+    // two are aligned and indistinguishable; therefore, we only consider UTC, and
+    // we don’t consider these if the domain only has a single value.
+    ...utcFormatIntervals.slice(3)
+];
+export function parseTimeInterval(input) {
+    let name = `${input}`.toLowerCase();
+    if (name.endsWith('s'))
+        name = name.slice(0, -1); // drop plural
+    let period = 1;
+    const match = /^(?:(\d+)\s+)/.exec(name);
+    if (match) {
+        name = name.slice(match[0].length);
+        period = +match[1];
+    }
+    switch (name) {
+        case 'quarter':
+            name = 'month';
+            period *= 3;
+            break;
+        case 'half':
+            name = 'month';
+            period *= 6;
+            break;
+    }
+    let interval = utcIntervals.get(name);
+    if (!interval)
+        throw new Error(`unknown interval: ${input}`);
+    if (period > 1 && !interval.every)
+        throw new Error(`non-periodic interval: ${name}`);
+    return [name, period];
+}
+export function maybeTimeInterval(input) {
+    return asInterval(parseTimeInterval(input), 'time');
+}
+export function maybeUtcInterval(input) {
+    return asInterval(parseTimeInterval(input), 'utc');
+}
+function asInterval([name, period], type) {
+    let interval = (type === 'time' ? timeIntervals : utcIntervals).get(name);
+    if (period > 1) {
+        interval = interval.every(period);
+        interval[intervalDuration] = durations.get(name) * period;
+        interval[intervalType] = type;
+    }
+    return interval;
+}
+// If the given interval is a standard time interval, we may be able to promote
+// it a larger aligned time interval, rather than showing every nth tick.
+export function generalizeTimeInterval(interval, n) {
+    if (!(n > 1))
+        return; // no need to generalize
+    const duration = interval[intervalDuration];
+    if (!tickIntervals.some(([, d]) => d === duration))
+        return; // nonstandard or unknown interval
+    if (duration % durationDay === 0 && durationDay < duration && duration < durationMonth)
+        return; // not generalizable
+    const [i] = tickIntervals[bisector(([, step]) => Math.log(step)).center(tickIntervals, Math.log(duration * n))];
+    return (interval[intervalType] === 'time' ? maybeTimeInterval : maybeUtcInterval)(i);
+}
+// function formatTimeInterval(name, type, anchor) {
+//     const format = type === 'time' ? timeFormat : utcFormat;
+//     // For tips and legends, use a format that doesn’t require context.
+//     if (anchor == null) {
+//         return format(
+//             name === 'year'
+//                 ? '%Y'
+//                 : name === 'month'
+//                   ? '%Y-%m'
+//                   : name === 'day'
+//                     ? '%Y-%m-%d'
+//                     : name === 'hour' || name === 'minute'
+//                       ? '%Y-%m-%dT%H:%M'
+//                       : name === 'second'
+//                         ? '%Y-%m-%dT%H:%M:%S'
+//                         : '%Y-%m-%dT%H:%M:%S.%L'
+//         );
+//     }
+//     // Otherwise, assume that this is for axis ticks.
+//     const template = getTimeTemplate(anchor);
+//     switch (name) {
+//         case 'millisecond':
+//             return formatConditional(format('.%L'), format(':%M:%S'), template);
+//         case 'second':
+//             return formatConditional(format(':%S'), format('%-I:%M'), template);
+//         case 'minute':
+//             return formatConditional(format('%-I:%M'), format('%p'), template);
+//         case 'hour':
+//             return formatConditional(format('%-I %p'), format('%b %-d'), template);
+//         case 'day':
+//             return formatConditional(format('%-d'), format('%b'), template);
+//         case 'month':
+//             return formatConditional(format('%b'), format('%Y'), template);
+//         case 'year':
+//             return format('%Y');
+//     }
+//     throw new Error('unable to format time ticks');
+// }
+// function getTimeTemplate(anchor) {
+//     return anchor === 'left' || anchor === 'right'
+//         ? (f1, f2) => `\n${f1}\n${f2}` // extra newline to keep f1 centered
+//         : anchor === 'top'
+//           ? (f1, f2) => `${f2}\n${f1}`
+//           : (f1, f2) => `${f1}\n${f2}`;
+// }
+// function getFormatIntervals(type) {
+//     return type === 'time'
+//         ? timeFormatIntervals
+//         : type === 'utc'
+//           ? utcFormatIntervals
+//           : formatIntervals;
+// }
+// Given an array of dates, returns the largest compatible standard time
+// interval. If no standard interval is compatible (other than milliseconds,
+// which is universally compatible), returns undefined.
+// export function inferTimeFormat(type, dates, anchor) {
+//     const step = max(pairs(dates, (a, b) => Math.abs(b - a))); // maybe undefined!
+//     if (step < 1000) return formatTimeInterval('millisecond', 'utc', anchor);
+//     for (const [name, interval, intervalType, maxStep] of getFormatIntervals(type)) {
+//         if (step > maxStep) break; // e.g., 52 weeks
+//         if (name === 'hour' && !step) break; // e.g., domain with a single date
+//         if (dates.every((d) => interval.floor(d) >= d))
+//             return formatTimeInterval(name, intervalType, anchor);
+//     }
+// }
+// function formatConditional(format1, format2, template) {
+//     return (x, i, X) => {
+//         const f1 = format1(x, i); // always shown
+//         const f2 = format2(x, i); // only shown if different
+//         const j = i - orderof(X); // detect reversed domains
+//         return i !== j && X[j] !== undefined && f2 === format2(X[j], j) ? f1 : template(f1, f2);
+//     };
+// }

package/dist/helpers/typeChecks.d.ts

@@ -1,7 +1,10 @@
 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 isBooleanOrNull(v: RawValue): v is boolean;
+export declare function isDate(v: RawValue): boolean;
+export declare function isDateOrNull(v: RawValue | null | undefined): boolean;
+export declare function isNumberOrNull(v: RawValue | null | undefined): boolean;
+export declare function isNumberOrNullOrNaN(v: RawValue | null | undefined): boolean;
+export declare function isStringOrNull(v: RawValue | null | undefined): v is string | null | undefined;
+export declare function isSymbolOrNull(v: RawValue | null | undefined): boolean;
+export declare function isColorOrNull(v: RawValue | null | undefined): boolean;
 export declare function isOpacityOrNull(v: RawValue): boolean;

package/dist/helpers/typeChecks.js

@@ -1,21 +1,42 @@
-import chroma from 'chroma-js';
-import { isDate, isFinite } from 'underscore';
+import { isSymbol } from './symbols.js';
+import { color } from 'd3-color';
+import { CSS_COLOR, CSS_COLOR_MIX, CSS_COLOR_CONTRAST, CSS_VAR, CSS_URL, CSS_RGBA } from '../constants.js';
 export function isBooleanOrNull(v) {
     return v == null || typeof v === 'boolean';
 }
+export function isDate(v) {
+    return v instanceof Date && !isNaN(v.getTime());
+}
 export function isDateOrNull(v) {
     return v == null || isDate(v);
 }
 export function isNumberOrNull(v) {
-    return v == null || isFinite(v);
+    return v == null || Number.isFinite(v) || (typeof v === 'string' && !Number.isNaN(+v));
+}
+export function isNumberOrNullOrNaN(v) {
+    return (v == null ||
+        Number.isFinite(v) ||
+        Number.isNaN(v) ||
+        (typeof v === 'string' && !Number.isNaN(+v)));
 }
 export function isStringOrNull(v) {
     return v == null || typeof v === 'string';
 }
+export function isSymbolOrNull(v) {
+    return v == null || ((typeof v === 'string' || typeof v === 'object') && isSymbol(v));
+}
 export function isColorOrNull(v) {
-    // todo: maybe not use chroma.js here to save kb
-    return v == null || (typeof v === 'string' && chroma.valid(v));
+    return (v == null ||
+        (typeof v === 'string' &&
+            (v === 'currentColor' ||
+                CSS_VAR.test(v) ||
+                CSS_COLOR.test(v) ||
+                CSS_COLOR_MIX.test(v) ||
+                CSS_COLOR_CONTRAST.test(v) ||
+                CSS_RGBA.test(v) ||
+                CSS_URL.test(v) ||
+                color(v) !== null)));
 }
 export function isOpacityOrNull(v) {
-    return v == null || (typeof v === 'number' && isFinite(v) && v >= 0 && v <= 1);
+    return v == null || (typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 1);
 }