@fundar/data-chart-telling 0.0.64 → 1.0.0

package/dist/utils/color.js

@@ -1,141 +0,0 @@
-import { interpolateRgb } from 'd3-interpolate';
-import { isBrowser } from '../stores/device';
-export function resolveCssColor(color) {
-    if (!isBrowser)
-        return color;
-    if (!color.startsWith('var('))
-        return color;
-    const varName = color.slice(4, -1).trim();
-    const value = getComputedStyle(document.documentElement)
-        .getPropertyValue(varName)
-        .trim();
-    return value || color;
-}
-export function normalize(v, min, max) {
-    if (v == null)
-        return 0;
-    const denom = max - min || 1;
-    return Math.max(0, Math.min(1, (v - min) / denom));
-}
-/** Cycles through a discrete palette by series index — the default colour for an unstyled series. */
-export function paletteColor(index, palette) {
-    if (palette.length === 0)
-        return 'currentColor';
-    return palette[index % palette.length];
-}
-function clamp01(v) {
-    return Math.max(0, Math.min(1, v));
-}
-function linearToSrgb8(c) {
-    const s = c <= 0.0031308 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
-    return clamp01(s) * 255;
-}
-/**
- * Parses `oklch(L C H)` directly instead of round-tripping through the
- * browser's computed style: Chromium/Firefox serialize computed oklch()
- * values back as oklch() (not rgb()), so the generic browser-fallback
- * below sees an unchanged string on the second pass and its
- * infinite-loop guard mistakes that for a parse failure.
- */
-function parseOklch(color) {
-    const match = /^oklch\(\s*([\d.]+)(%)?\s+([\d.]+)\s+([\d.]+)/i.exec(color.trim());
-    if (!match)
-        return null;
-    const L = match[2] ? Number(match[1]) / 100 : Number(match[1]);
-    const C = Number(match[3]);
-    const H = (Number(match[4]) * Math.PI) / 180;
-    const a = C * Math.cos(H);
-    const b = C * Math.sin(H);
-    const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
-    const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
-    const s_ = L - 0.0894841775 * a - 1.291485548 * b;
-    const l = l_ ** 3;
-    const m = m_ ** 3;
-    const s = s_ ** 3;
-    const r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
-    const g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
-    const bl = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
-    return [linearToSrgb8(r), linearToSrgb8(g), linearToSrgb8(bl)];
-}
-function parseRgb(color) {
-    const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(color.trim());
-    if (hex) {
-        const digits = hex[1].length === 3 ? hex[1].split('').map((c) => c + c).join('') : hex[1];
-        const num = parseInt(digits, 16);
-        return [(num >> 16) & 255, (num >> 8) & 255, num & 255];
-    }
-    const rgb = /^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)/i.exec(color);
-    if (rgb)
-        return [Number(rgb[1]), Number(rgb[2]), Number(rgb[3])];
-    const oklch = parseOklch(color);
-    if (oklch)
-        return oklch;
-    // Named colors, hsl(), and any other CSS color syntax: resolved to
-    // `rgb(...)` via the browser's computed style, then reparsed.
-    if (!isBrowser)
-        return null;
-    const el = document.createElement('div');
-    el.style.color = color;
-    document.body.appendChild(el);
-    const computed = getComputedStyle(el).color;
-    document.body.removeChild(el);
-    if (!computed || computed === color)
-        return null;
-    return parseRgb(computed);
-}
-function relativeLuminance([r, g, b]) {
-    const [rs, gs, bs] = [r, g, b].map((c) => {
-        const s = c / 255;
-        return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
-    });
-    return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
-}
-/** WCAG contrast ratio between two colors, from 1 (no contrast) to 21 (black on white). */
-export function contrastRatio(colorA, colorB) {
-    const a = parseRgb(resolveCssColor(colorA));
-    const b = parseRgb(resolveCssColor(colorB));
-    if (!a || !b)
-        return 1;
-    const lA = relativeLuminance(a);
-    const lB = relativeLuminance(b);
-    const lighter = Math.max(lA, lB);
-    const darker = Math.min(lA, lB);
-    return (lighter + 0.05) / (darker + 0.05);
-}
-/**
- * The `candidates` entry with the highest WCAG contrast ratio against
- * `background`. Defaults to plain white/black; pass a grayscale or other
- * palette to widen the choice. Falls back to the first candidate when
- * `background` can't be parsed.
- */
-export function contrastTextColor(background, candidates = ['#ffffff', '#000000']) {
-    if (candidates.length === 0)
-        return '#000000';
-    let best = candidates[0];
-    let bestRatio = -Infinity;
-    for (const candidate of candidates) {
-        const ratio = contrastRatio(background, candidate);
-        if (ratio > bestRatio) {
-            bestRatio = ratio;
-            best = candidate;
-        }
-    }
-    return best;
-}
-export function makeColorScale(min, max, colorMin, colorMax) {
-    const resolvedMin = resolveCssColor(colorMin);
-    const resolvedMax = resolveCssColor(colorMax);
-    let interpolator;
-    try {
-        interpolator = interpolateRgb(resolvedMin, resolvedMax);
-    }
-    catch {
-        return () => '#ccc';
-    }
-    return (v) => {
-        if (v == null)
-            return '#ccc';
-        const t = normalize(v, min, max);
-        return interpolator(t);
-    };
-}

package/dist/utils/delta.d.ts

@@ -1,12 +0,0 @@
-import type { Series } from '../types/plots/data/common';
-import type { DeltaConfig } from '../types/markers/line';
-export type ResolvedDelta = {
-    cfg: DeltaConfig;
-    at: number;
-    from: number;
-    to: number;
-    diff: number;
-    mid: number;
-};
-export declare function resolveXDeltas<T extends Record<string, unknown>>(allSeries: Series<T>[], configs: DeltaConfig[]): ResolvedDelta[];
-export declare function resolveYDeltas<T extends Record<string, unknown>>(allSeries: Series<T>[], configs: DeltaConfig[]): ResolvedDelta[];

package/dist/utils/delta.js

@@ -1,69 +0,0 @@
-import { resolveAccessor } from '../plots/utils/accessors';
-/**
- * Sorts `data` by `sortBy`, then finds the first adjacent pair where `scanBy`
- * brackets `target` and linearly interpolates `measureBy` at that crossing.
- *
- * X delta usage: sortBy=getX, scanBy=getX, measureBy=getY  → Y at given X
- * Y delta usage: sortBy=getX, scanBy=getY, measureBy=getX  → X at given Y (first crossing)
- */
-function interpolate(data, sortBy, scanBy, measureBy, target) {
-    const sorted = [...data].sort((a, b) => sortBy(a) - sortBy(b));
-    for (let i = 0; i < sorted.length; i++) {
-        if (scanBy(sorted[i]) === target)
-            return measureBy(sorted[i]);
-    }
-    for (let i = 0; i < sorted.length - 1; i++) {
-        const s0 = scanBy(sorted[i]);
-        const s1 = scanBy(sorted[i + 1]);
-        if ((s0 <= target && target <= s1) || (s1 <= target && target <= s0)) {
-            const t = (target - s0) / (s1 - s0);
-            return measureBy(sorted[i]) + t * (measureBy(sorted[i + 1]) - measureBy(sorted[i]));
-        }
-    }
-    return null;
-}
-function resolveXDeltaEndpoint(allSeries, target, atX) {
-    if (target.type === 'axis')
-        return target.value ?? 0;
-    const s = allSeries.find(s => s.name === target.series);
-    if (!s)
-        return null;
-    const getX = (d) => Number(resolveAccessor(s.x)(d));
-    const getY = (d) => Number(resolveAccessor(s.y)(d));
-    return interpolate(s.data, getX, getX, getY, atX);
-}
-function resolveYDeltaEndpoint(allSeries, target, atY) {
-    if (target.type === 'axis')
-        return target.value ?? 0;
-    const s = allSeries.find(s => s.name === target.series);
-    if (!s)
-        return null;
-    const getX = (d) => Number(resolveAccessor(s.x)(d));
-    const getY = (d) => Number(resolveAccessor(s.y)(d));
-    return interpolate(s.data, getX, getY, getX, atY);
-}
-function buildDelta(cfg, from, to) {
-    const diff = Math.abs(from - to);
-    const mid = (from + to) / 2;
-    return { cfg, at: Number(cfg.at), from, to, diff, mid };
-}
-export function resolveXDeltas(allSeries, configs) {
-    return configs.flatMap(cfg => {
-        const atX = Number(cfg.at);
-        const from = resolveXDeltaEndpoint(allSeries, cfg.from, atX);
-        const to = cfg.to ? resolveXDeltaEndpoint(allSeries, cfg.to, atX) : 0;
-        if (from === null || to === null)
-            return [];
-        return [buildDelta(cfg, from, to)];
-    });
-}
-export function resolveYDeltas(allSeries, configs) {
-    return configs.flatMap(cfg => {
-        const atY = Number(cfg.at);
-        const from = resolveYDeltaEndpoint(allSeries, cfg.from, atY);
-        const to = cfg.to ? resolveYDeltaEndpoint(allSeries, cfg.to, atY) : 0;
-        if (from === null || to === null)
-            return [];
-        return [buildDelta(cfg, from, to)];
-    });
-}

package/dist/utils/edgeAwareAnchor.d.ts

@@ -1,34 +0,0 @@
-export type HorizontalAnchor = 'start' | 'middle' | 'end';
-export type VerticalAnchor = 'top' | 'middle' | 'bottom';
-export type AnchorPlacement = {
-    textAnchor: HorizontalAnchor;
-    lineAnchor: VerticalAnchor;
-    dx: number;
-    dy: number;
-};
-/**
- * Flips (or nudges) a label's anchor/offset when its default placement
- * would push it past a pixel box — e.g. the plot's own inner content box.
- * `extent` should be measured off-DOM (see `measureTextWidth`) rather than
- * via `getBBox()` on the rendered label — feeding a `getBBox()` reading back
- * into anything reactive to the plot's own layout (like svelteplot's shared
- * margin-auto-sizing context) risks a feedback loop between this
- * component's own effect and svelteplot's.
- */
-export declare function resolveEdgeAwareAnchor(args: {
-    /** Pixel position of the anchored point. */
-    px: number;
-    py: number;
-    /** Size of the box the label must stay within — typically the plot's own inner content box. */
-    width: number;
-    height: number;
-    textAnchor: HorizontalAnchor;
-    lineAnchor: VerticalAnchor;
-    /** Desired distance from the point, in pixels — sign is resolved from the (possibly flipped) anchor. */
-    gapX: number;
-    gapY: number;
-    extent: {
-        width: number;
-        height: number;
-    };
-}): AnchorPlacement;

package/dist/utils/edgeAwareAnchor.js

@@ -1,60 +0,0 @@
-/**
- * Flips (or nudges) a label's anchor/offset when its default placement
- * would push it past a pixel box — e.g. the plot's own inner content box.
- * `extent` should be measured off-DOM (see `measureTextWidth`) rather than
- * via `getBBox()` on the rendered label — feeding a `getBBox()` reading back
- * into anything reactive to the plot's own layout (like svelteplot's shared
- * margin-auto-sizing context) risks a feedback loop between this
- * component's own effect and svelteplot's.
- */
-export function resolveEdgeAwareAnchor(args) {
-    const { px, py, width, height, gapX, gapY, extent } = args;
-    let { textAnchor, lineAnchor } = args;
-    let dx;
-    let dy;
-    if (textAnchor === 'start') {
-        dx = gapX;
-        if (px + dx + extent.width > width) {
-            textAnchor = 'end';
-            dx = -gapX;
-        }
-    }
-    else if (textAnchor === 'end') {
-        dx = -gapX;
-        if (px + dx - extent.width < 0) {
-            textAnchor = 'start';
-            dx = gapX;
-        }
-    }
-    else {
-        const half = extent.width / 2;
-        dx = 0;
-        if (px - half < 0)
-            dx = half - px;
-        else if (px + half > width)
-            dx = width - (px + half);
-    }
-    if (lineAnchor === 'top') {
-        dy = gapY;
-        if (py + dy + extent.height > height) {
-            lineAnchor = 'bottom';
-            dy = -gapY;
-        }
-    }
-    else if (lineAnchor === 'bottom') {
-        dy = -gapY;
-        if (py + dy - extent.height < 0) {
-            lineAnchor = 'top';
-            dy = gapY;
-        }
-    }
-    else {
-        const half = extent.height / 2;
-        dy = 0;
-        if (py - half < 0)
-            dy = half - py;
-        else if (py + half > height)
-            dy = height - (py + half);
-    }
-    return { textAnchor, lineAnchor, dx, dy };
-}

package/dist/utils/interpolate.d.ts

@@ -1,31 +0,0 @@
-import type { EasingName, EasingFn } from '../types/charts/interpolate';
-import type { TimeValue, TimelineInterpolation } from '../types/layout/timeline';
-import type { AxisValue } from '../types/layout/scales';
-import type { Accessor } from '../types/plots/data/common';
-export declare function resolveEasing(easing?: EasingName | EasingFn): EasingFn;
-/**
- * Brackets a continuous target position `x` within one key-group's sorted
- * rows and tweens between the two real rows it falls between — the leading
- * edge moves continuously instead of snapping between steps. Returns every
- * already-passed real row plus the synthetic tween row (or just the clamped
- * first/last row when `x` is outside the group's range). A caller that wants
- * a single replacing "frame" (e.g. a bar snapshot) takes just the last entry.
- */
-export declare function interpolateSeries<TRow>({ rows, x, getTime, getValue, create, segmentEasing, }: {
-    rows: TRow[];
-    x: TimeValue;
-    getTime: (row: TRow) => TimeValue;
-    getValue: (row: TRow) => number;
-    create: (lower: TRow, upper: TRow, x: TimeValue, value: number) => TRow;
-    segmentEasing: EasingFn;
-}): TRow[];
-/**
- * Resolves `TimelineConfig.interpolate` (`true` | a partial config | unset)
- * into a fully-populated {@link TimelineInterpolation}, falling back to the
- * chart-supplied `value`/`key` defaults — used by `LineChart`/`BarChart` so
- * consumers can write `interpolate: true` instead of repeating their own `y`/`z`.
- */
-export declare function resolveTimelineInterpolation<TRow extends Record<string, unknown>>(interpolate: boolean | TimelineInterpolation<TRow> | undefined, defaults: {
-    value: Accessor<TRow, AxisValue>;
-    key?: Accessor<TRow, unknown>;
-}): TimelineInterpolation<TRow> | undefined;

package/dist/utils/interpolate.js

@@ -1,71 +0,0 @@
-const EASINGS = {
-    linear: (t) => t,
-    quadIn: (t) => t * t,
-    quadOut: (t) => 1 - (1 - t) * (1 - t),
-    cubicIn: (t) => t * t * t,
-    cubicOut: (t) => 1 - Math.pow(1 - t, 3),
-    quartIn: (t) => t * t * t * t,
-    quartOut: (t) => 1 - Math.pow(1 - t, 4),
-    expoOut: (t) => (t === 1 ? 1 : 1 - Math.pow(2, -10 * t)),
-};
-export function resolveEasing(easing) {
-    if (!easing)
-        return EASINGS.linear;
-    if (typeof easing === 'function')
-        return easing;
-    return EASINGS[easing] ?? EASINGS.linear;
-}
-/**
- * Brackets a continuous target position `x` within one key-group's sorted
- * rows and tweens between the two real rows it falls between — the leading
- * edge moves continuously instead of snapping between steps. Returns every
- * already-passed real row plus the synthetic tween row (or just the clamped
- * first/last row when `x` is outside the group's range). A caller that wants
- * a single replacing "frame" (e.g. a bar snapshot) takes just the last entry.
- */
-export function interpolateSeries({ rows, x, getTime, getValue, create, segmentEasing, }) {
-    if (!rows.length)
-        return [];
-    const sorted = [...rows].sort((a, b) => Number(getTime(a)) - Number(getTime(b)));
-    if (x <= getTime(sorted[0]))
-        return [sorted[0]];
-    const result = [];
-    for (let i = 0; i < sorted.length - 1; i++) {
-        const d0 = sorted[i];
-        const d1 = sorted[i + 1];
-        const t0 = getTime(d0);
-        const t1 = getTime(d1);
-        if (x >= t1) {
-            result.push(d0);
-            continue;
-        }
-        if (x >= t0 && x < t1) {
-            const tRaw = (Number(x) - Number(t0)) / (Number(t1) - Number(t0));
-            const t = segmentEasing(tRaw);
-            const value = getValue(d0) + (getValue(d1) - getValue(d0)) * t;
-            result.push(d0);
-            result.push(create(d0, d1, x, value));
-            return result;
-        }
-    }
-    const last = sorted[sorted.length - 1];
-    if (x >= getTime(last))
-        result.push(last);
-    return result;
-}
-/**
- * Resolves `TimelineConfig.interpolate` (`true` | a partial config | unset)
- * into a fully-populated {@link TimelineInterpolation}, falling back to the
- * chart-supplied `value`/`key` defaults — used by `LineChart`/`BarChart` so
- * consumers can write `interpolate: true` instead of repeating their own `y`/`z`.
- */
-export function resolveTimelineInterpolation(interpolate, defaults) {
-    if (!interpolate)
-        return undefined;
-    const config = interpolate === true ? {} : interpolate;
-    return {
-        ...config,
-        value: config.value ?? defaults.value,
-        key: config.key ?? defaults.key,
-    };
-}