@santi020k/lumen-core 3.0.1 → 4.0.0

package/dist/amount-field.d.ts

@@ -0,0 +1,22 @@
+export interface LumenAmountOptions {
+    locale?: string;
+    fractionDigits?: number;
+    allowNegative?: boolean;
+}
+export interface LumenAmountChangeDetail {
+    /** Editable ASCII decimal draft; intermediate '-' and trailing decimal points are retained. */
+    draft: string;
+    /** Complete decimal string. Undefined for an empty or intermediate draft. */
+    value: string | undefined;
+}
+export declare const getLumenAmountValue: (draft: string) => string | undefined;
+export declare const formatLumenAmountDraft: (draft: string, options?: LumenAmountOptions) => string;
+export declare const parseLumenAmountDraft: (source: string, options?: LumenAmountOptions, strictGrouping?: boolean) => string | undefined;
+export interface LumenAmountFieldController {
+    destroy: () => void;
+    /** Rebind reset handling after moving the existing control to another document or shadow root. */
+    refresh: () => void;
+    setValue: (draft: string) => void;
+}
+export declare const createLumenAmountFieldController: (root: HTMLElement, onChange?: (detail: LumenAmountChangeDetail) => void) => LumenAmountFieldController;
+//# sourceMappingURL=amount-field.d.ts.map

package/dist/amount-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amount-field.d.ts","sourceRoot":"","sources":["../src/amount-field.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,MAAM,WAAW,uBAAuB;IACtC,+FAA+F;IAC/F,KAAK,EAAE,MAAM,CAAA;IACb,6EAA6E;IAC7E,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAC1B;AAqDD,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,KAAG,MAAM,GAAG,SAI5D,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,OAAO,MAAM,EAAE,UAAS,kBAAuB,KAAG,MAcxF,CAAA;AAgDD,eAAO,MAAM,qBAAqB,GAChC,QAAQ,MAAM,EAAE,UAAS,kBAAuB,EAAE,wBAAqB,KACtE,MAAM,GAAG,SAYX,CAAA;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,kGAAkG;IAClG,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAClC;AAeD,eAAO,MAAM,gCAAgC,GAC3C,MAAM,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,KACtE,0BAsIF,CAAA"}

package/dist/amount-field.js

@@ -0,0 +1,207 @@
+const amountLimit = 1024;
+const validateFractionDigits = (digits) => {
+    if (!Number.isInteger(digits) || digits < 0 || digits > 20) {
+        throw new RangeError('Amount fractionDigits must be an integer from 0 to 20.');
+    }
+};
+const amountFormat = (options) => {
+    const fractionDigits = options.fractionDigits ?? 2;
+    let locale = options.locale ?? 'en-US';
+    validateFractionDigits(fractionDigits);
+    let formatter;
+    try {
+        formatter = new Intl.NumberFormat(locale, { useGrouping: true, maximumFractionDigits: 0 });
+    }
+    catch {
+        locale = 'en-US';
+        formatter = new Intl.NumberFormat(locale, { useGrouping: true, maximumFractionDigits: 0 });
+    }
+    const decimal = new Intl.NumberFormat(locale).formatToParts(1.1).find(part => part.type === 'decimal')?.value ?? '.';
+    const group = formatter.formatToParts(1000000).find(part => part.type === 'group')?.value;
+    const minus = formatter.formatToParts(-1).find(part => part.type === 'minusSign')?.value ?? '-';
+    const digitFormatter = new Intl.NumberFormat(locale, { useGrouping: false });
+    const digits = Array.from({ length: 10 }, (_, digit) => digitFormatter.format(digit));
+    return { formatter, decimal, group, minus, digits, fractionDigits };
+};
+const validDraft = (draft, options) => {
+    if (draft.length > amountLimit)
+        return false;
+    const { fractionDigits } = amountFormat(options);
+    const negative = draft.startsWith('-');
+    if (negative && !options.allowNegative)
+        return false;
+    const unsigned = negative ? draft.slice(1) : draft;
+    const pieces = unsigned.split('.');
+    if (pieces.length > 2 || (pieces.length === 2 && fractionDigits === 0))
+        return false;
+    const fraction = pieces[1] ?? '';
+    return pieces.every(piece => /^[0-9]*$/u.test(piece)) && fraction.length <= fractionDigits;
+};
+export const getLumenAmountValue = (draft) => {
+    if (!/^-?[0-9]+(?:\.[0-9]+)?$/u.test(draft) || draft.length > amountLimit)
+        return undefined;
+    return draft;
+};
+export const formatLumenAmountDraft = (draft, options = {}) => {
+    if (!validDraft(draft, options))
+        throw new RangeError('Amount value must be an ASCII decimal draft within the configured precision.');
+    if (draft === '')
+        return '';
+    const { formatter, decimal, minus, digits } = amountFormat(options);
+    const negative = draft.startsWith('-');
+    const unsigned = negative ? draft.slice(1) : draft;
+    const [integer = '', fraction] = unsigned.split('.');
+    const formattedInteger = integer ? formatter.format(BigInt(integer)) : '';
+    const localizedFraction = Array.from(fraction ?? '', digit => digits[Number(digit)] ?? digit).join('');
+    // Use an unsigned formatter so intermediate negative drafts never acquire a rounded sign.
+    return `${negative ? minus : ''}${formattedInteger}${fraction !== undefined ? decimal + localizedFraction : ''}`;
+};
+/** Strict grouping for paste; ordinary editing can temporarily disturb existing group separators. */
+const normalizeLeadingDecimal = (draft) => {
+    if (draft.startsWith('.'))
+        return `0${draft}`;
+    return draft.startsWith('-.') ? `-0${draft.slice(1)}` : draft;
+};
+const translateAmountCharacters = (source, options) => {
+    const { decimal, group, minus, digits } = amountFormat(options);
+    const characters = new Map(digits.map((digit, index) => [digit, String(index)]));
+    for (let index = 0; index < 10; index += 1)
+        characters.set(String(index), String(index));
+    characters.set(decimal, '.');
+    characters.set(minus, '-');
+    characters.set('-', '-');
+    if (group)
+        characters.set(group, '');
+    for (const mark of ['\u061c', '\u200e', '\u200f'])
+        characters.set(mark, '');
+    let draft = '';
+    for (const character of source.trim()) {
+        const translated = characters.get(character);
+        if (translated === undefined)
+            return undefined;
+        draft += translated;
+    }
+    return draft;
+};
+const validGrouping = (source, draft, options) => {
+    const { decimal, group } = amountFormat(options);
+    if (!group || !source.includes(group))
+        return true;
+    const [integer, fraction = ''] = source.trim().split(decimal);
+    return !fraction.includes(group) && integer === formatLumenAmountDraft(draft, options).split(decimal)[0];
+};
+export const parseLumenAmountDraft = (source, options = {}, strictGrouping = true) => {
+    if (source.length > amountLimit)
+        return undefined;
+    const translated = translateAmountCharacters(source, options);
+    if (translated === undefined || !validDraft(translated, options))
+        return undefined;
+    const draft = normalizeLeadingDecimal(translated);
+    if (strictGrouping && !validGrouping(source, draft, options))
+        return undefined;
+    return draft;
+};
+const placeAmountCaret = (input, group, logical) => {
+    let caret = 0;
+    let count = 0;
+    while (caret < input.value.length && count < logical) {
+        if (input.value[caret] !== group)
+            count += 1;
+        caret += 1;
+    }
+    input.setSelectionRange(caret, caret);
+};
+export const createLumenAmountFieldController = (root, onChange) => {
+    const input = root.querySelector('[data-ui-amount-input]');
+    const submission = root.querySelector('[data-ui-amount-value]');
+    if (!input || !submission)
+        throw new Error('AmountField requires visible and submission inputs.');
+    const options = {
+        locale: root.getAttribute('locale') ?? 'en-US',
+        fractionDigits: Number(root.getAttribute('fraction-digits') ?? 2),
+        allowNegative: root.hasAttribute('allow-negative')
+    };
+    const initial = root.getAttribute('default-value') ?? root.getAttribute('value') ?? '';
+    let draft = root.getAttribute('value') ?? initial;
+    let composing = false;
+    let destroyed = false;
+    let resetTimer;
+    const sync = () => {
+        input.value = formatLumenAmountDraft(draft, options);
+        submission.value = getLumenAmountValue(draft) ?? '';
+        input.setCustomValidity(draft !== '' && getLumenAmountValue(draft) === undefined ? root.getAttribute('invalid-message') ?? 'Enter a complete amount.' : '');
+    };
+    const group = amountFormat(options).group;
+    const logicalCount = (text) => Array.from(text).filter(character => character !== group).length;
+    const emitChange = () => {
+        const detail = { draft, value: getLumenAmountValue(draft) };
+        const EventType = root.ownerDocument.defaultView?.CustomEvent;
+        if (EventType)
+            root.dispatchEvent(new EventType('ui:amount-change', { bubbles: true, detail }));
+        onChange?.(detail);
+    };
+    const update = (event) => {
+        if (composing || input.matches(':disabled') || input.readOnly)
+            return;
+        const logical = logicalCount(input.value.slice(0, input.selectionStart ?? input.value.length));
+        const parsed = parseLumenAmountDraft(input.value, options, 'inputType' in event && event.inputType === 'insertFromPaste');
+        if (parsed === undefined) {
+            sync();
+            input.setCustomValidity(root.getAttribute('invalid-message') ?? 'Enter a valid amount using the displayed locale and precision.');
+            return;
+        }
+        draft = parsed;
+        sync();
+        placeAmountCaret(input, group, logical);
+        emitChange();
+    };
+    const startComposition = () => {
+        composing = true;
+    };
+    const endComposition = (event) => {
+        composing = false;
+        update(event);
+    };
+    const reset = (event) => {
+        if (event.target !== input.form)
+            return;
+        clearTimeout(resetTimer);
+        resetTimer = setTimeout(() => {
+            if (destroyed || event.defaultPrevented || event.target !== input.form)
+                return;
+            draft = root.getAttribute('default-value') ?? initial;
+            sync();
+            onChange?.({ draft, value: getLumenAmountValue(draft) });
+        });
+    };
+    sync();
+    input.addEventListener('input', update);
+    input.addEventListener('compositionstart', startComposition);
+    input.addEventListener('compositionend', endComposition);
+    let eventRoot;
+    const refresh = () => {
+        const current = input.getRootNode();
+        if (destroyed || current === eventRoot)
+            return;
+        clearTimeout(resetTimer);
+        eventRoot?.removeEventListener('reset', reset, { capture: true });
+        eventRoot = current;
+        eventRoot.addEventListener('reset', reset, { capture: true });
+    };
+    refresh();
+    return {
+        refresh,
+        setValue: value => {
+            draft = value;
+            sync();
+        },
+        destroy: () => {
+            destroyed = true;
+            clearTimeout(resetTimer);
+            input.removeEventListener('input', update);
+            input.removeEventListener('compositionstart', startComposition);
+            input.removeEventListener('compositionend', endComposition);
+            eventRoot?.removeEventListener('reset', reset, { capture: true });
+        }
+    };
+};

package/dist/attachments.d.ts

@@ -0,0 +1,15 @@
+export type LumenAttachmentPreviewState = 'error' | 'loading' | 'ready' | 'unavailable';
+export interface LumenAttachmentPreviewLabels {
+    error: string;
+    loading: string;
+    unavailable: string;
+}
+export declare const lumenAttachmentPreviewLabels: Readonly<LumenAttachmentPreviewLabels>;
+export declare const resolveLumenAttachmentPreviewState: (src?: unknown, contentType?: unknown, state?: LumenAttachmentPreviewState, failed?: boolean) => LumenAttachmentPreviewState;
+export interface LumenAttachmentPreviewController {
+    destroy: () => void;
+    refresh: () => void;
+}
+/** Enhances a browser-owned image; never fetches a file or embeds a document. */
+export declare const createLumenAttachmentPreviewController: (root: HTMLElement) => LumenAttachmentPreviewController;
+//# sourceMappingURL=attachments.d.ts.map

package/dist/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../src/attachments.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,2BAA2B,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,aAAa,CAAA;AAEvF,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,4BAA4B,CAI/E,CAAA;AAQD,eAAO,MAAM,kCAAkC,GAC7C,MAAM,OAAO,EACb,cAAc,OAAO,EACrB,QAAQ,2BAA2B,EACnC,gBAAc,KACb,2BAMF,CAAA;AAID,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,iFAAiF;AACjF,eAAO,MAAM,sCAAsC,GAAI,MAAM,WAAW,KAAG,gCAqI1E,CAAA"}

package/dist/attachments.js

@@ -0,0 +1,123 @@
+export const lumenAttachmentPreviewLabels = {
+    error: 'Could not load the preview.',
+    loading: 'Loading preview…',
+    unavailable: 'A preview is not available for this file.'
+};
+const isImageContentType = (contentType) => {
+    if (contentType === undefined || contentType === null || contentType === '')
+        return true;
+    return typeof contentType === 'string' && contentType.trim().toLowerCase().startsWith('image/');
+};
+export const resolveLumenAttachmentPreviewState = (src, contentType, state, failed = false) => {
+    if (state === 'loading' || state === 'error' || state === 'unavailable')
+        return state;
+    if (typeof src !== 'string' || !src.trim() || !isImageContentType(contentType))
+        return 'unavailable';
+    return failed ? 'error' : 'ready';
+};
+const requestedState = (value) => value === 'error' || value === 'loading' || value === 'ready' || value === 'unavailable' ? value : undefined;
+/** Enhances a browser-owned image; never fetches a file or embeds a document. */
+export const createLumenAttachmentPreviewController = (root) => {
+    const owned = (selector) => Array.from(root.querySelectorAll(selector)).find(element => element.closest('[data-ui-attachment-preview]') === root);
+    const currentImage = () => {
+        const candidate = owned('[data-ui-attachment-preview-image]');
+        const isImage = (element) => element?.namespaceURI === 'http://www.w3.org/1999/xhtml' && element.localName === 'img';
+        return isImage(candidate) ? candidate : undefined;
+    };
+    let image = currentImage();
+    const abort = new AbortController();
+    const cachedFailure = (candidate) => Boolean(candidate?.getAttribute('src') && candidate.complete && candidate.naturalWidth === 0);
+    const attribute = (name) => root.getAttribute(name) ?? root.getAttribute(`data-ui-attachment-preview-${name}`);
+    let failed = cachedFailure(image);
+    let source = image?.getAttribute('src') ?? '';
+    let retryKey = attribute('retry-key') ?? '';
+    let previous;
+    let destroyed = false;
+    const reloadImage = () => {
+        if (image && source)
+            image.setAttribute('src', source);
+    };
+    const updateSource = () => {
+        const nextImage = currentImage();
+        if (image !== nextImage) {
+            image = nextImage;
+            failed = cachedFailure(image);
+        }
+        const nextSource = image?.getAttribute('src') ?? '';
+        const nextRetryKey = attribute('retry-key') ?? '';
+        if (source === nextSource && retryKey === nextRetryKey)
+            return;
+        const retry = retryKey !== nextRetryKey;
+        source = nextSource;
+        retryKey = nextRetryKey;
+        failed = !retry && cachedFailure(image);
+        if (retry)
+            reloadImage();
+    };
+    const renderState = (state) => {
+        const media = owned('[data-slot="attachment-preview-media"]');
+        const message = owned('[data-ui-attachment-preview-message]');
+        root.dataset.state = state;
+        root.setAttribute('aria-busy', String(state === 'loading'));
+        if (media)
+            media.hidden = state !== 'ready';
+        if (!message)
+            return;
+        message.hidden = state === 'ready';
+        if (state !== 'ready')
+            message.textContent = attribute(`${state}-label`) ?? lumenAttachmentPreviewLabels[state];
+    };
+    const refresh = () => {
+        if (destroyed)
+            return;
+        updateSource();
+        const state = resolveLumenAttachmentPreviewState(source, attribute('content-type'), requestedState(attribute('state')), failed);
+        renderState(state);
+        if (previous !== undefined && previous !== state) {
+            const EventConstructor = root.ownerDocument.defaultView?.CustomEvent ?? CustomEvent;
+            root.dispatchEvent(new EventConstructor('ui:attachment-preview-change', { bubbles: true, detail: { state } }));
+        }
+        previous = state;
+    };
+    root.addEventListener('error', event => {
+        if (!root.isConnected || event.target !== currentImage())
+            return;
+        failed = true;
+        refresh();
+    }, { capture: true, signal: abort.signal });
+    root.addEventListener('load', event => {
+        if (!root.isConnected || event.target !== currentImage())
+            return;
+        failed = false;
+        refresh();
+    }, { capture: true, signal: abort.signal });
+    const observer = new MutationObserver(records => {
+        if (records.some(record => record.type === 'attributes' || Array.from(record.addedNodes).some(node => node.nodeType === 1) || Array.from(record.removedNodes).some(node => node.nodeType === 1)))
+            refresh();
+    });
+    observer.observe(root, { subtree: true,
+        childList: true,
+        attributes: true,
+        attributeFilter: [
+            'src',
+            'state',
+            'content-type',
+            'retry-key',
+            'error-label',
+            'loading-label',
+            'unavailable-label',
+            'data-ui-attachment-preview-state',
+            'data-ui-attachment-preview-content-type',
+            'data-ui-attachment-preview-retry-key',
+            'data-ui-attachment-preview-error-label',
+            'data-ui-attachment-preview-loading-label',
+            'data-ui-attachment-preview-unavailable-label'
+        ] });
+    refresh();
+    return { refresh,
+        destroy: () => {
+            destroyed = true;
+            abort.abort();
+            observer.disconnect();
+        } };
+};

package/dist/bullet-chart.d.ts

@@ -0,0 +1,33 @@
+import { type LumenChartDomain, type LumenChartTone } from './charts.js';
+export interface LumenBulletRange {
+    end: number;
+    label: string;
+    tone?: LumenChartTone;
+}
+export interface LumenBulletOptions {
+    domain?: LumenChartDomain | undefined;
+    ranges?: readonly LumenBulletRange[] | undefined;
+}
+/** A zero-based actual-versus-target comparison with optional qualitative ranges. */
+export declare const createLumenBulletGeometry: (value: number | null, target: number, options?: LumenBulletOptions) => {
+    domain: LumenChartDomain;
+    ranges: {
+        start: number;
+        startRatio: number;
+        endRatio: number;
+        end: number;
+        label: string;
+        tone?: LumenChartTone;
+    }[];
+    target: number;
+    targetRatio: number;
+    ticks: {
+        value: number;
+        position: number;
+    }[];
+    valid: boolean;
+    value: number | null;
+    valueStartRatio: number;
+    valueWidthRatio: number;
+};
+//# sourceMappingURL=bullet-chart.d.ts.map

package/dist/bullet-chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bullet-chart.d.ts","sourceRoot":"","sources":["../src/bullet-chart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAyC,MAAM,aAAa,CAAA;AAE/G,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,cAAc,CAAA;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAA;IACrC,MAAM,CAAC,EAAE,SAAS,gBAAgB,EAAE,GAAG,SAAS,CAAA;CACjD;AAoED,qFAAqF;AACrF,eAAO,MAAM,yBAAyB,GAAI,OAAO,MAAM,GAAG,IAAI,EAAE,QAAQ,MAAM,EAAE,UAAS,kBAAuB;;;;;;aA7EzG,MAAM;eACJ,MAAM;eACN,cAAc;;;;;;;;;;;;CAyGtB,CAAA"}

package/dist/bullet-chart.js

@@ -0,0 +1,80 @@
+import { lumenChartTones, scaleLumenChartValue } from './charts.js';
+const validBulletTone = (value) => value === undefined || lumenChartTones.some(tone => tone === value);
+const validBulletRange = (range) => {
+    if (typeof range !== 'object' || range === null)
+        return false;
+    if (!('end' in range) || !('label' in range))
+        return false;
+    return Number.isFinite(range.end) && typeof range.label === 'string' &&
+        validBulletTone('tone' in range ? range.tone : undefined);
+};
+const validatedBulletRanges = (input) => {
+    if (!Array.isArray(input))
+        return null;
+    const rows = Array.from(input);
+    return rows.every(validBulletRange) ? rows : null;
+};
+const automaticBulletDomain = (values) => {
+    let minimum = 0;
+    let maximum = 0;
+    for (const number of values) {
+        if (!Number.isFinite(number))
+            continue;
+        minimum = Math.min(minimum, number);
+        maximum = Math.max(maximum, number);
+    }
+    return { min: minimum, max: minimum === maximum ? minimum + 1 : maximum };
+};
+const validBulletDomain = (domain) => {
+    const finite = Number.isFinite(domain.min) && Number.isFinite(domain.max);
+    return finite && domain.min < domain.max && domain.min <= 0 && domain.max >= 0;
+};
+const orderedBulletRanges = (ranges, domain) => {
+    let previousEnd = domain.min;
+    return ranges.every(range => {
+        const valid = range.label.trim().length > 0 && range.end > previousEnd;
+        previousEnd = range.end;
+        return valid;
+    });
+};
+const resolveBulletModel = (value, target, options) => {
+    const { ranges: configuredRanges = [] } = options;
+    const inputRanges = validatedBulletRanges(configuredRanges);
+    const finiteRanges = inputRanges !== null;
+    const ranges = [...inputRanges ?? []].sort((left, right) => left.end - right.end);
+    const values = [0, target, ...ranges.map(range => range.end), ...value === null ? [] : [value]];
+    const requested = options.domain ?? automaticBulletDomain(values);
+    const domain = validBulletDomain(requested) ? requested : { min: 0, max: 1 };
+    const withinDomain = values.every(number => Number.isFinite(number) && number >= domain.min && number <= domain.max);
+    const valid = finiteRanges && validBulletDomain(requested) && withinDomain && orderedBulletRanges(ranges, domain);
+    return { domain, ranges, valid };
+};
+/** A zero-based actual-versus-target comparison with optional qualitative ranges. */
+export const createLumenBulletGeometry = (value, target, options = {}) => {
+    const { domain, ranges, valid } = resolveBulletModel(value, target, options);
+    const position = (number) => scaleLumenChartValue(number, domain, 0, 1);
+    const zero = position(0);
+    const actual = valid && value !== null ? position(value) : zero;
+    let start = domain.min;
+    return {
+        domain,
+        ranges: valid ?
+            ranges.map(range => {
+                const segment = { ...range, start, startRatio: position(start), endRatio: position(range.end) };
+                start = range.end;
+                return segment;
+            }) :
+            [],
+        target,
+        targetRatio: valid ? position(target) : zero,
+        ticks: valid ?
+            [domain.min, domain.min / 2 + domain.max / 2, domain.max].map(tick => ({
+                value: tick, position: position(tick)
+            })) :
+            [],
+        valid,
+        value,
+        valueStartRatio: Math.min(zero, actual),
+        valueWidthRatio: Math.abs(actual - zero)
+    };
+};

package/dist/chart-activation.d.ts

@@ -0,0 +1,32 @@
+import type { LumenChartDatum, LumenHeatmapDatum, LumenRangeDatum } from './charts.js';
+/** Data identities and values, never pixel coordinates or application navigation. */
+export type LumenChartDatumActivationDetail = {
+    datumId?: string;
+    kind: 'series';
+    seriesId: string;
+    x: number | string;
+    y: number;
+} | {
+    datumId?: string;
+    kind: 'heatmap';
+    value: number;
+    x: number | string;
+    y: number | string;
+} | {
+    datumId?: string;
+    high: number;
+    kind: 'range';
+    low: number;
+    x: number | string;
+};
+/** Validate untrusted event data and copy only the documented fields. */
+export declare const parseLumenChartDatumActivation: (value: unknown) => LumenChartDatumActivationDetail | null;
+export declare const createLumenChartDatumActivation: (seriesId: string, datum: LumenChartDatum) => LumenChartDatumActivationDetail | null;
+export declare const createLumenHeatmapDatumActivation: (datum: LumenHeatmapDatum) => LumenChartDatumActivationDetail | null;
+export declare const createLumenRangeDatumActivation: (datum: LumenRangeDatum) => LumenChartDatumActivationDetail | null;
+export interface LumenChartActivationController {
+    destroy: () => void;
+}
+/** Native buttons provide the keyboard path; decorative SVG marks use the same click path. */
+export declare const createLumenChartActivationController: (root: HTMLElement) => LumenChartActivationController;
+//# sourceMappingURL=chart-activation.d.ts.map

package/dist/chart-activation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-activation.d.ts","sourceRoot":"","sources":["../src/chart-activation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAEtF,qFAAqF;AACrF,MAAM,MAAM,+BAA+B,GACvC;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GACvF;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAC5F;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAA;AAqCpF,yEAAyE;AACzE,eAAO,MAAM,8BAA8B,GAAI,OAAO,OAAO,KAAG,+BAA+B,GAAG,IAUjG,CAAA;AAED,eAAO,MAAM,+BAA+B,GAC1C,UAAU,MAAM,EAChB,OAAO,eAAe,KACrB,+BAA+B,GAAG,IAMnC,CAAA;AAEF,eAAO,MAAM,iCAAiC,GAC5C,OAAO,iBAAiB,KACvB,+BAA+B,GAAG,IAMnC,CAAA;AAEF,eAAO,MAAM,+BAA+B,GAC1C,OAAO,eAAe,KACrB,+BAA+B,GAAG,IAMnC,CAAA;AAEF,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AA0BD,8FAA8F;AAC9F,eAAO,MAAM,oCAAoC,GAAI,MAAM,WAAW,KAAG,8BAqBxE,CAAA"}

package/dist/chart-activation.js

@@ -0,0 +1,97 @@
+const isAxisValue = (value) => typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value));
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const parseSeries = (value) => {
+    if (typeof value.seriesId !== 'string' || !isAxisValue(value.x) || !isFiniteNumber(value.y))
+        return null;
+    return { kind: 'series', seriesId: value.seriesId, x: value.x, y: value.y };
+};
+const parseHeatmap = (value) => {
+    if (!isAxisValue(value.x) || !isAxisValue(value.y) || !isFiniteNumber(value.value))
+        return null;
+    return { kind: 'heatmap', value: value.value, x: value.x, y: value.y };
+};
+const parseRange = (value) => {
+    if (!isAxisValue(value.x) || !isFiniteNumber(value.low) || !isFiniteNumber(value.high) ||
+        value.low > value.high)
+        return null;
+    return { high: value.high, kind: 'range', low: value.low, x: value.x };
+};
+const parseDatum = (value) => {
+    switch (value.kind) {
+        case 'series': return parseSeries(value);
+        case 'heatmap': return parseHeatmap(value);
+        case 'range': return parseRange(value);
+        default: return null;
+    }
+};
+/** Validate untrusted event data and copy only the documented fields. */
+export const parseLumenChartDatumActivation = (value) => {
+    if (!isRecord(value))
+        return null;
+    if ('datumId' in value && typeof value.datumId !== 'string')
+        return null;
+    const detail = parseDatum(value);
+    if (!detail)
+        return null;
+    return typeof value.datumId === 'string' ? { ...detail, datumId: value.datumId } : detail;
+};
+export const createLumenChartDatumActivation = (seriesId, datum) => parseLumenChartDatumActivation({
+    ...(datum.id === undefined ? {} : { datumId: datum.id }),
+    kind: 'series',
+    seriesId,
+    x: datum.x,
+    y: datum.y
+});
+export const createLumenHeatmapDatumActivation = (datum) => parseLumenChartDatumActivation({
+    ...(datum.id === undefined ? {} : { datumId: datum.id }),
+    kind: 'heatmap',
+    value: datum.value,
+    x: datum.x,
+    y: datum.y
+});
+export const createLumenRangeDatumActivation = (datum) => parseLumenChartDatumActivation({
+    ...(datum.id === undefined ? {} : { datumId: datum.id }),
+    high: datum.high,
+    kind: 'range',
+    low: datum.low,
+    x: datum.x
+});
+const ownedActivationTarget = (root, target) => {
+    const ElementConstructor = root.ownerDocument.defaultView?.Element;
+    if (!ElementConstructor || !(target instanceof ElementConstructor))
+        return null;
+    const element = target.closest('[data-ui-chart-datum]');
+    if (element?.closest('[data-ui-chart-activation]') !== root)
+        return null;
+    if (element.closest('[inert], [hidden], [disabled], [aria-disabled="true"]'))
+        return null;
+    return element;
+};
+const parseSerializedDatum = (serialized) => {
+    try {
+        const value = JSON.parse(serialized);
+        return parseLumenChartDatumActivation(value);
+    }
+    catch {
+        return null;
+    }
+};
+/** Native buttons provide the keyboard path; decorative SVG marks use the same click path. */
+export const createLumenChartActivationController = (root) => {
+    const activate = (event) => {
+        if (event.defaultPrevented || event.button !== 0 || !root.isConnected)
+            return;
+        const target = ownedActivationTarget(root, event.target);
+        const serialized = target?.getAttribute('data-ui-chart-datum');
+        if (!serialized)
+            return;
+        const detail = parseSerializedDatum(serialized);
+        if (detail)
+            root.dispatchEvent(new CustomEvent('ui:chart-datum-activate', { bubbles: true, composed: true, detail }));
+    };
+    root.addEventListener('click', activate);
+    return { destroy: () => {
+            root.removeEventListener('click', activate);
+        } };
+};

package/dist/chart-interaction.d.ts

@@ -0,0 +1,12 @@
+export interface LumenChartCursorChangeDetail {
+    x: number | string | null;
+}
+export type LumenChartCursorChangeEvent = CustomEvent<LumenChartCursorChangeDetail>;
+export interface LumenChartInteractionController {
+    destroy: () => void;
+    select: (x: number | string | null) => void;
+    setControlledCursor: (x: number | string | null | undefined) => void;
+}
+/** Optional DOM enhancement shared by web adapters; no global listeners or application data transport. */
+export declare const createLumenChartInteractionController: (root: HTMLElement) => LumenChartInteractionController;
+//# sourceMappingURL=chart-interaction.d.ts.map

package/dist/chart-interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-interaction.d.ts","sourceRoot":"","sources":["../src/chart-interaction.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,4BAA4B;IAC3C,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;CAC1B;AAED,MAAM,MAAM,2BAA2B,GAAG,WAAW,CAAC,4BAA4B,CAAC,CAAA;AAEnF,MAAM,WAAW,+BAA+B;IAC9C,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IAC3C,mBAAmB,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,KAAK,IAAI,CAAA;CACrE;AA4ED,0GAA0G;AAC1G,eAAO,MAAM,qCAAqC,GAAI,MAAM,WAAW,KAAG,+BAqSzE,CAAA"}