dashtaste 0.0.0-stage → 0.0.1

package/dist/format.js

@@ -0,0 +1,65 @@
+import { deltaSwapped, getTokens, } from './packs/index.js';
+export function formatCompact(value, pack, options = {}) {
+    if (!Number.isFinite(value))
+        return '–';
+    const units = pack === 'cn'
+        ? [
+            [1e8, '亿'],
+            [1e4, '万'],
+        ]
+        : [
+            [1e9, 'B'],
+            [1e6, 'M'],
+            [1e3, 'K'],
+        ];
+    const unit = units.find(([n]) => Math.abs(value) >= Math.max(n, options.compactFrom ?? 10000));
+    const minimumFractionDigits = options.minimumFractionDigits ?? 0;
+    return unit
+        ? `${(value / unit[0]).toLocaleString('en-US', { minimumFractionDigits, maximumFractionDigits: Math.max(minimumFractionDigits, pack === 'cn' ? 2 : 1), useGrouping: false })}${unit[1]}`
+        : options.compactFrom !== undefined || options.minimumFractionDigits !== undefined
+            ? value.toLocaleString('en-US', {
+                minimumFractionDigits,
+                maximumFractionDigits: Math.max(minimumFractionDigits, 2),
+            })
+            : value.toLocaleString('en-US', { maximumFractionDigits: 2 });
+}
+export function formatPercent(value, digits = 1) {
+    return Number.isFinite(value) ? `${(value * 100).toFixed(digits)}%` : '–';
+}
+export function formatDelta(current, previous, pack, options = {}) {
+    const t = getTokens(pack, options.mode);
+    const delta = (current - previous) / Math.abs(previous);
+    const direction = !Number.isFinite(current) || !Number.isFinite(previous) || previous === 0
+        ? 'invalid'
+        : delta === 0
+            ? 'flat'
+            : delta > 0
+                ? 'up'
+                : 'down';
+    const swapped = deltaSwapped(pack, options.deltaColors, options.polarity);
+    const color = direction === 'up'
+        ? swapped
+            ? t.down
+            : t.up
+        : direction === 'down'
+            ? swapped
+                ? t.up
+                : t.down
+            : t.muted;
+    const text = direction === 'invalid'
+        ? '–'
+        : `${direction === 'up' ? '▲ ' : direction === 'down' ? '▼ ' : ''}${formatPercent(Math.abs(delta))}`;
+    return {
+        text: options.label && direction !== 'invalid' ? `${options.label} ${text}` : text,
+        direction,
+        color,
+    };
+}
+/** Uses local calendar fields; no locale-dependent date ordering. */
+export function formatDate(value, pack = 'cn') {
+    const d = new Date(value);
+    if (!Number.isFinite(d.getTime()))
+        return '–';
+    const iso = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+    return pack === 'cn' ? iso : iso;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './engine.js';
+export * from './types.js';
+export * from './packs/index.js';
+export { rules } from './rules/index.js';
+export { extractPage } from './extract.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './engine.js';
+export * from './types.js';
+export * from './packs/index.js';
+export { rules } from './rules/index.js';
+export { extractPage } from './extract.js';

package/dist/packs/cn.d.ts

@@ -0,0 +1,2 @@
+import type { Pack } from './index.js';
+export declare const cn: Pack;

package/dist/packs/cn.js

@@ -0,0 +1,56 @@
+export const cn = {
+    name: 'cn',
+    numberSystem: 'wan-yi',
+    limits: { maxPieSlices: 5, maxRoseSlices: 8, maxKpis: 8, cjkMinFontSize: 12 },
+    deltaColors: 'red-up',
+    typography: {
+        monoFontFamily: 'Geist Mono',
+        axisSize: 12,
+        tracking: '0.06em',
+        body: 14,
+        minimum: 12,
+        fontFamily: 'Instrument Sans',
+        fontFeatureSettings: '"tnum"',
+        headingWeight: 500,
+        bodyWeight: 400,
+    },
+    spacing: [4, 8, 12, 16, 24, 32],
+    screen: { width: 1920, height: 1080, baseFontSize: 16, kpiMinFontSize: 32, kpiMaxFontSize: 128 },
+    light: {
+        page: '#F2F4F2',
+        card: '#FFFFFF',
+        sunken: '#F7F8F7',
+        ink: '#141414',
+        muted: '#636261',
+        subtle: '#7B7B76',
+        hairline: '#E6E6E6',
+        strong: '#DDDDDD',
+        primary: '#141414',
+        brand: '#3E6A88',
+        accent: '#C68A1C',
+        up: '#C8372F',
+        down: '#167D4F',
+        flat: '#636261',
+        other: '#BCBBBA',
+        categorical: ['#3E6A88', '#20293A', '#8080F7', '#B4A85D', '#77C4D6'],
+        sequential: ['#EEF2F5', '#DDE4EA', '#B3CADB', '#74ABD0', '#3E6A88'],
+    },
+    dark: {
+        bg: '#121212',
+        panel: '#171716',
+        sunken: '#0A0B0A',
+        ink: '#EEEEEB',
+        muted: '#959590',
+        subtle: '#7B7B76',
+        hairline: '#2A2926',
+        strong: '#484843',
+        brand: '#74ABD0',
+        accent: '#E8B657',
+        up: '#DB655C',
+        down: '#73B78E',
+        flat: '#959590',
+        other: '#61615C',
+        categorical: ['#74ABD0', '#E5B357', '#9B7EF0', '#466376', '#4B8C9C'],
+        sequential: ['#1F303B', '#2A4456', '#3E6A88', '#74ABD0', '#B3CADB'],
+    },
+};

package/dist/packs/global.d.ts

@@ -0,0 +1,2 @@
+import type { Pack } from './index.js';
+export declare const global: Pack;

package/dist/packs/global.js

@@ -0,0 +1,45 @@
+export const global = {
+    name: 'global',
+    numberSystem: 'k-m-b',
+    limits: { maxPieSlices: 5, maxRoseSlices: 5, maxKpis: 6, cjkMinFontSize: 12 },
+    deltaColors: 'green-up',
+    typography: {
+        monoFontFamily: 'Geist Mono',
+        axisSize: 11,
+        tracking: '0.06em',
+        body: 14,
+        minimum: 12,
+        fontFamily: 'Inter',
+        fontFeatureSettings: '"tnum", "cv11"',
+        headingWeight: 500,
+        bodyWeight: 400,
+    },
+    spacing: [4, 8, 12, 16, 24, 32],
+    light: {
+        paper: '#F4F2EE',
+        ink: '#1A1A18',
+        muted: '#5F5F67',
+        subtle: '#8A8A93',
+        hairline: '#DEDCD6',
+        grid: '#E8E6E0',
+        brand: '#B65A08',
+        other: '#C4C4CC',
+        up: '#107451',
+        down: '#9B1745',
+        categorical: ['#B65A08', '#544D61', '#9B896D', '#243635', '#B8BBC6'],
+        sequential: ['#E8E6E0', '#DDE1F0', '#B4C0F0', '#778CEC', '#B65A08'],
+    },
+    dark: {
+        paper: '#141412',
+        panel: '#191917',
+        ink: '#ECEAE4',
+        muted: '#A1A1AA',
+        hairline: '#26262A',
+        grid: '#242420',
+        brand: '#E6A24B',
+        other: '#4A4A52',
+        up: '#4CC38A',
+        down: '#D65A83',
+        categorical: ['#E6A24B', '#DCD1B5', '#9E849F', '#527371', '#52525E'],
+    },
+};

package/dist/packs/index.d.ts

@@ -0,0 +1,53 @@
+import { global } from './global.js';
+import { cn } from './cn.js';
+export type PackName = 'global' | 'cn';
+export type Mode = 'light' | 'dark';
+export type DeltaColors = 'red-up' | 'green-up' | 'by-polarity';
+export type Polarity = 'higher-is-better' | 'lower-is-better';
+export declare function deltaSwapped(pack: PackName, convention?: DeltaColors, polarity?: Polarity): boolean;
+export interface Tokens {
+    [key: string]: string | readonly string[];
+    ink: string;
+    muted: string;
+    hairline: string;
+    brand: string;
+    other: string;
+    up: string;
+    down: string;
+    categorical: readonly string[];
+}
+export interface Pack {
+    name: PackName;
+    deltaColors: DeltaColors;
+    numberSystem: 'k-m-b' | 'wan-yi';
+    limits: {
+        maxPieSlices: number;
+        maxRoseSlices: number;
+        maxKpis: number;
+        cjkMinFontSize: number;
+    };
+    screen?: {
+        width: number;
+        height: number;
+        baseFontSize: number;
+        kpiMinFontSize: number;
+        kpiMaxFontSize: number;
+    };
+    light: Tokens;
+    dark: Tokens;
+    typography: {
+        monoFontFamily: string;
+        axisSize: number;
+        tracking: string;
+        fontFamily: string;
+        fontFeatureSettings: string;
+        headingWeight: number;
+        bodyWeight: number;
+        body: number;
+        minimum: number;
+    };
+    spacing: readonly number[];
+}
+export declare const packs: Record<PackName, Pack>;
+export { global, cn };
+export declare function getTokens(pack: PackName, mode?: Mode): Tokens;

package/dist/packs/index.js

@@ -0,0 +1,13 @@
+import { global } from './global.js';
+import { cn } from './cn.js';
+export function deltaSwapped(pack, convention, polarity) {
+    const byPolarity = convention === 'by-polarity' || (pack === 'global' && convention === undefined);
+    if (byPolarity)
+        return (pack === 'cn') !== (polarity === 'lower-is-better');
+    return (convention ?? packs[pack].deltaColors) !== packs[pack].deltaColors;
+}
+export const packs = { global, cn };
+export { global, cn };
+export function getTokens(pack, mode = 'light') {
+    return packs[pack][mode];
+}

package/dist/rules/dt001-default-palette.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Multiple series need explicit colours. Any default palette colour is flagged. */
+export declare const dt001: Rule;

package/dist/rules/dt001-default-palette.js

@@ -0,0 +1,11 @@
+import { asArray, series, allColors, defaultColors, rule, charts } from './helpers.js';
+/** Multiple series need explicit colours. Any default palette colour is flagged. */
+export const dt001 = rule(1, 'default-palette', 'error', 'Multiple series need explicit colours. Any default palette colour is flagged.', 'set option.color to the pack palette (dashtaste tokens --pack <pack>)', function check(facts, context, emit) {
+    charts(facts, (option, path) => {
+        if ((series(option).length > 1 &&
+            !asArray(option.color).length &&
+            series(option).some((item) => !item.itemStyle?.color && !item.lineStyle?.color)) ||
+            allColors(option).some((entry) => defaultColors.has(entry.toLowerCase())))
+            emit(path, 'default ECharts palette');
+    });
+});

package/dist/rules/dt002-rainbow-palette.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** More than 6 distinct categorical colours or more than 5 saturated 60-degree hue buckets. */
+export declare const dt002: Rule;

package/dist/rules/dt002-rainbow-palette.js

@@ -0,0 +1,11 @@
+import { allColors, rule, charts } from './helpers.js';
+import { hueBucket } from '../color.js';
+/** More than 6 distinct categorical colours or more than 5 saturated 60-degree hue buckets. */
+export const dt002 = rule(2, 'rainbow-palette', 'warn', 'More than 6 distinct categorical colours or more than 5 saturated 60-degree hue buckets.', 'use the pack palette and group remaining categories as Other', function check(facts, context, emit) {
+    charts(facts, (option, path) => {
+        const colors = allColors(option);
+        if (new Set(colors.map((entry) => entry.toLowerCase())).size > 6 ||
+            new Set(colors.map(hueBucket).filter((entry) => entry !== undefined)).size > 5)
+            emit(path);
+    });
+});

package/dist/rules/dt003-smooth-line.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Line smoothing greater than zero draws values that do not exist. */
+export declare const dt003: Rule;

package/dist/rules/dt003-smooth-line.js

@@ -0,0 +1,9 @@
+import { series, rule, charts } from './helpers.js';
+/** Line smoothing greater than zero draws values that do not exist. */
+export const dt003 = rule(3, 'smooth-line', 'warn', 'Line smoothing greater than zero draws values that do not exist.', 'use straight segments: smooth: false', function check(facts, context, emit) {
+    charts(facts, (option, path) => series(option).forEach((item, index) => {
+        if (item.type === 'line' &&
+            (item.smooth === true || (typeof item.smooth === 'number' && item.smooth > 0)))
+            emit(`${path}.series[${index}]`);
+    }));
+});

package/dist/rules/dt004-symbols-everywhere.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Use small explicit dots only on short series; avoid default symbols everywhere. */
+export declare const dt004: Rule;

package/dist/rules/dt004-symbols-everywhere.js

@@ -0,0 +1,21 @@
+import { asArray, series, rule, charts } from './helpers.js';
+/** Use small explicit dots only on short series; avoid default symbols everywhere. */
+export const dt004 = rule(4, 'symbols-everywhere', 'warn', 'Use small explicit dots only on short series; avoid default symbols everywhere.', 'use dots at most 5px on at most 31 points, or use dots at most 5px on at most 31 points, or set showSymbol: false', function check(facts, context, emit) {
+    charts(facts, (option, path) => series(option).forEach((item, index) => {
+        if (item.type === 'line' &&
+            item.showSymbol !== false &&
+            item.symbol !== 'none' &&
+            asArray(item.data).length > 0 &&
+            !(asArray(item.data).length <= 31 &&
+                item.symbol === 'circle' &&
+                typeof item.symbolSize === 'number' &&
+                item.symbolSize <= 5 &&
+                series(option).filter((s) => s.type === 'line' && s.showSymbol !== false && s.symbol === 'circle').length <= 1) &&
+            !(asArray(item.data).length <= 31 &&
+                item.symbol === 'emptyCircle' &&
+                typeof item.symbolSize === 'number' &&
+                item.symbolSize <= 5 &&
+                item.lineStyle?.type === 'dashed'))
+            emit(`${path}.series[${index}]`);
+    }));
+});

package/dist/rules/dt005-pie-slices.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Maximum 5 slices; cn rose charts allow 8. */
+export declare const dt005: Rule;

package/dist/rules/dt005-pie-slices.js

@@ -0,0 +1,13 @@
+import { packs } from '../packs/index.js';
+import { asArray, series, isPie, rule, charts } from './helpers.js';
+/** Maximum 5 slices; cn rose charts allow 8. */
+export const dt005 = rule(5, 'pie-slices', 'warn', 'Maximum 5 slices; cn rose charts allow 8.', 'use horizontal bars or combine small parts into Other', function check(facts, context, emit) {
+    charts(facts, (option, path) => series(option).forEach((item, index) => {
+        if (isPie(item) &&
+            asArray(item.data).length >
+                (item.roseType
+                    ? packs[context.pack].limits.maxRoseSlices
+                    : packs[context.pack].limits.maxPieSlices))
+            emit(`${path}.series[${index}]`);
+    }));
+});

package/dist/rules/dt006-pie-overuse.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** More than one pie per page or radius ratio above 0.75 warns. A global pie is informational. */
+export declare const dt006: Rule;

package/dist/rules/dt006-pie-overuse.js

@@ -0,0 +1,14 @@
+import { series, isPie, pieRadii, rule, charts } from './helpers.js';
+/** More than one pie per page or radius ratio above 0.75 warns. A global pie is informational. */
+export const dt006 = rule(6, 'pie-overuse', 'warn', 'More than one pie per page or radius ratio above 0.75 warns. A global pie is informational.', 'prefer horizontal bars; keep donut radius ratio at most 0.75', function check(facts, context, emit) {
+    const count = facts.charts.reduce((n, entry) => n + series(entry.option).filter(isPie).length, 0);
+    charts(facts, (option, path) => series(option).forEach((item, index) => {
+        if (!isPie(item))
+            return;
+        const channels = pieRadii(item);
+        if (count > 1 || (channels.length === 2 && channels[0] / channels[1] > 0.75))
+            emit(`${path}.series[${index}]`);
+        else if (context.pack === 'global')
+            emit(`${path}.series[${index}]`, 'prefer bars for part comparison', 'info');
+    }));
+});

package/dist/rules/dt007-three-d.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** 3D series, axes, coordinates, and pseudo-3D pie decoration distort comparisons. */
+export declare const dt007: Rule;

package/dist/rules/dt007-three-d.js

@@ -0,0 +1,16 @@
+import { walk, rule, charts } from './helpers.js';
+/** 3D series, axes, coordinates, and pseudo-3D pie decoration distort comparisons. */
+export const dt007 = rule(7, 'three-d', 'error', '3D series, axes, coordinates, and pseudo-3D pie decoration distort comparisons.', 'use flat 2D charts', function check(facts, context, emit) {
+    charts(facts, (option, path) => {
+        let bad = false;
+        walk(option, (key, value) => {
+            if ((/3d|globe/i.test(key) && value !== false && value != null) ||
+                (typeof value === 'string' &&
+                    (/3d|globe/i.test(value) || value === 'surface') &&
+                    ['type', 'coordinateSystem'].includes(key)))
+                bad = true;
+        });
+        if (bad)
+            emit(path);
+    });
+});

package/dist/rules/dt008-dual-axis.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Multiple value axes obscure comparisons, including mixed bar and line charts. */
+export declare const dt008: Rule;

package/dist/rules/dt008-dual-axis.js

@@ -0,0 +1,10 @@
+import { valueAxes, rule, charts } from './helpers.js';
+/** Multiple value axes obscure comparisons, including mixed bar and line charts. */
+export const dt008 = rule(8, 'dual-axis', 'warn', 'Multiple value axes obscure comparisons, including mixed bar and line charts.', 'use one value axis or aligned small multiples', function check(facts, context, emit) {
+    charts(facts, (option, path) => {
+        const axes = valueAxes(option);
+        if (axes.length < 2)
+            return;
+        emit(path);
+    });
+});

package/dist/rules/dt009-missing-unit.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Value axes need a name, formatter, unit metadata, or units in rendered ticks. */
+export declare const dt009: Rule;

package/dist/rules/dt009-missing-unit.js

@@ -0,0 +1,8 @@
+import { valueAxes, hasUnit, rule, charts } from './helpers.js';
+/** Value axes need a name, formatter, unit metadata, or units in rendered ticks. */
+export const dt009 = rule(9, 'missing-unit', 'warn', 'Value axes need a name, formatter, unit metadata, or units in rendered ticks.', 'put units in axis names, rendered ticks, or formatter metadata', function check(facts, context, emit) {
+    charts(facts, (option, path) => valueAxes(option).forEach((axis) => {
+        if (!hasUnit(axis))
+            emit(`${path}.${axis._path}`);
+    }));
+});

package/dist/rules/dt010-bar-baseline.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Bar value axes must start at zero; positive min and scale: true distort lengths. */
+export declare const dt010: Rule;

package/dist/rules/dt010-bar-baseline.js

@@ -0,0 +1,11 @@
+import { series, valueAxes, rule, charts } from './helpers.js';
+/** Bar value axes must start at zero; positive min and scale: true distort lengths. */
+export const dt010 = rule(10, 'bar-baseline', 'error', 'Bar value axes must start at zero; positive min and scale: true distort lengths.', 'set min: 0 and scale: false', function check(facts, context, emit) {
+    charts(facts, (option, path) => {
+        valueAxes(option).forEach((axis) => {
+            const bars = series(option).filter((item) => item.type === 'bar' && (item[`${axis._dimension}AxisIndex`] ?? 0) === axis._index);
+            if (bars.length && ((typeof axis.min === 'number' && axis.min > 0) || axis.scale === true))
+                emit(`${path}.${axis._path}`);
+        });
+    });
+});

package/dist/rules/dt011-raw-large-numbers.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** At data maximum magnitude 10000 or above, axis, visible data label, and tooltip channels need formatters. */
+export declare const dt011: Rule;

package/dist/rules/dt011-raw-large-numbers.js

@@ -0,0 +1,21 @@
+import { series, valueAxes, seriesValues, rule, charts } from './helpers.js';
+/** At data maximum magnitude 10000 or above, axis, visible data label, and tooltip channels need formatters. */
+export const dt011 = rule(11, 'raw-large-numbers', 'warn', 'At data maximum magnitude 10000 or above, axis, visible data label, and tooltip channels need formatters.', 'format compact units: cn 万/亿; global K/M', function check(facts, context, emit) {
+    charts(facts, (option, path) => {
+        if (!series(option).some((item) => seriesValues(item).some((value) => Math.abs(value) >= 10000)))
+            return;
+        valueAxes(option).forEach((axis) => {
+            if (!axis.axisLabel?.formatter)
+                emit(`${path}.${axis._path}.axisLabel`);
+        });
+        series(option).forEach((item, index) => {
+            if (item.label?.show && !item.label.formatter)
+                emit(`${path}.series[${index}].label`);
+        });
+        if (option.tooltip?.show !== false &&
+            (option.tooltip || series(option).some((item) => item.tooltip)) &&
+            !option.tooltip?.formatter &&
+            !option.tooltip?.valueFormatter)
+            emit(`${path}.tooltip`);
+    });
+});

package/dist/rules/dt012-unit-system.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** String formatter templates must use the selected compact unit system. */
+export declare const dt012: Rule;

package/dist/rules/dt012-unit-system.js

@@ -0,0 +1,12 @@
+import { walk, rule, charts } from './helpers.js';
+/** String formatter templates must use the selected compact unit system. */
+export const dt012 = rule(12, 'unit-system', 'warn', 'String formatter templates must use the selected compact unit system.', 'use cn 万/亿 or global K/M/B consistently', function check(facts, context, emit) {
+    charts(facts, (option, path) => {
+        walk(option, (key, value) => {
+            if (/formatter/i.test(key) &&
+                typeof value === 'string' &&
+                (context.pack === 'cn' ? /(?:\}|\d|\s)[KMB]\b/.test(value) : /[万亿]/.test(value)))
+                emit(path, 'formatter uses another unit system');
+        });
+    });
+});

package/dist/rules/dt013-delta-convention.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Directional deltas must follow the page convention and metric polarity: global by polarity; cn red-up by default. */
+export declare const dt013: Rule;

package/dist/rules/dt013-delta-convention.js

@@ -0,0 +1,21 @@
+import { rule, sameColor, deltaDirection, conventionColor } from './helpers.js';
+import { deltaSwapped, getTokens } from '../packs/index.js';
+/** Directional deltas must follow the page convention and metric polarity: global by polarity; cn red-up by default. */
+export const dt013 = rule(13, 'delta-convention', 'error', 'Directional deltas must follow the page convention and metric polarity: global by polarity; cn red-up by default.', 'apply one deltaColors convention to the whole page', function check(facts, context, emit) {
+    const tokens = getTokens(context.pack, context.mode);
+    for (const delta of facts.deltas ?? []) {
+        const swap = deltaSwapped(context.pack, facts.page?.deltaColors, delta.polarity);
+        const dir = delta.direction ?? deltaDirection(delta.text);
+        const expected = dir === 'up'
+            ? swap
+                ? tokens.down
+                : tokens.up
+            : dir === 'down'
+                ? swap
+                    ? tokens.up
+                    : tokens.down
+                : tokens.muted;
+        if (!conventionColor(delta.color, expected) && !sameColor(delta.color, tokens.muted))
+            emit(delta.selector);
+    }
+});

package/dist/rules/dt014-delta-colour-only.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Directional colour must be accompanied by an arrow or signed number. */
+export declare const dt014: Rule;

package/dist/rules/dt014-delta-colour-only.js

@@ -0,0 +1,16 @@
+import { rule, sameColor } from './helpers.js';
+import { rgb } from '../color.js';
+import { getTokens } from '../packs/index.js';
+/** Directional colour must be accompanied by an arrow or signed number. */
+export const dt014 = rule(14, 'delta-colour-only', 'warn', 'Directional colour must be accompanied by an arrow or signed number.', 'add ▲/▼ or an explicit sign', function check(facts, context, emit) {
+    const tokens = getTokens(context.pack, context.mode);
+    for (const delta of facts.deltas ?? []) {
+        const hasDirection = /[▲▼↑↓]|[+-]\s*\d/.test(delta.text);
+        if (hasDirection || sameColor(delta.color, tokens.muted))
+            continue;
+        const channels = rgb(delta.color);
+        const hasDirectionalColor = channels && Math.max(...channels) - Math.min(...channels) > 0.08;
+        if (hasDirectionalColor)
+            emit(delta.selector);
+    }
+});

package/dist/rules/dt015-low-contrast-text.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Text needs 4.5:1; at least 24px or 18.66px bold needs 3:1. Chart label defaults use 4.5:1. */
+export declare const dt015: Rule;

package/dist/rules/dt015-low-contrast-text.js

@@ -0,0 +1,28 @@
+import { asArray, rule, charts, background } from './helpers.js';
+import { contrast } from '../color.js';
+function contrastThreshold(fontSize = 0, fontWeight = 400) {
+    const isBold = fontWeight === 'bold' || (typeof fontWeight === 'number' && fontWeight >= 700);
+    return fontSize >= 24 || (fontSize >= 18.66 && isBold) ? 3 : 4.5;
+}
+/** Text needs 4.5:1; at least 24px or 18.66px bold needs 3:1. Chart label defaults use 4.5:1. */
+export const dt015 = rule(15, 'low-contrast-text', 'error', 'Text needs 4.5:1; at least 24px or 18.66px bold needs 3:1. Chart label defaults use 4.5:1.', 'increase text contrast against its background', function check(facts, context, emit) {
+    for (const text of facts.texts ?? []) {
+        const limit = contrastThreshold(text.fontSize, text.fontWeight);
+        if (contrast(text.color, text.background) < limit)
+            emit(text.selector);
+    }
+    charts(facts, (option, path) => {
+        for (const [key, entries] of [
+            ['xAxis', asArray(option.xAxis)],
+            ['yAxis', asArray(option.yAxis)],
+            ['legend', asArray(option.legend)],
+        ])
+            entries.forEach((entry, index) => {
+                const style = key === 'legend' ? entry.textStyle : entry.axisLabel;
+                if (typeof style?.color === 'string' &&
+                    contrast(style.color, background(facts, context, option)) <
+                        contrastThreshold(style.fontSize, style.fontWeight))
+                    emit(`${path}.${key}[${index}]`);
+            });
+    });
+});

package/dist/rules/dt016-thin-line-contrast.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Line colours need at least 3:1 against the chart background. */
+export declare const dt016: Rule;

package/dist/rules/dt016-thin-line-contrast.js

@@ -0,0 +1,12 @@
+import { series, seriesColor, rule, charts, background } from './helpers.js';
+import { contrast } from '../color.js';
+/** Line colours need at least 3:1 against the chart background. */
+export const dt016 = rule(16, 'thin-line-contrast', 'warn', 'Line colours need at least 3:1 against the chart background.', 'darken light-mode lines or lighten dark-mode lines', function check(facts, context, emit) {
+    charts(facts, (option, path) => series(option).forEach((item, index) => {
+        const lineColor = seriesColor(item, index, option);
+        if (item.type === 'line' &&
+            typeof lineColor === 'string' &&
+            contrast(lineColor, background(facts, context, option)) < 3)
+            emit(`${path}.series[${index}]`);
+    }));
+});

package/dist/rules/dt017-gradient-decoration.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Card/page gradients and linear or radial chart fills add decoration. */
+export declare const dt017: Rule;

package/dist/rules/dt017-gradient-decoration.js

@@ -0,0 +1,15 @@
+import { walk, rule, charts } from './helpers.js';
+/** Card/page gradients and linear or radial chart fills add decoration. */
+export const dt017 = rule(17, 'gradient-decoration', 'warn', 'Card/page gradients and linear or radial chart fills add decoration.', 'use solid backgrounds and fills', function check(facts, context, emit) {
+    for (const entry of facts.gradients ?? [])
+        emit(entry.selector);
+    charts(facts, (option, path) => {
+        let found = false;
+        walk(option, (key, value) => {
+            if (key === 'type' && typeof value === 'string' && ['linear', 'radial'].includes(value))
+                found = true;
+        });
+        if (found)
+            emit(path);
+    });
+});

package/dist/rules/dt018-glow.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from '../types.js';
+/** Coloured CSS shadows with blur at least 12px, or chart shadowBlur at least 10, create glow. */
+export declare const dt018: Rule;