@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/license/watch.js

@@ -0,0 +1 @@
+import{reportListenerError}from"./registry.js";import{scheduleAt}from"./timers.js";const DOCUMENT_WAKE_EVENTS=["visibilitychange"];const WINDOW_WAKE_EVENTS=["pageshow","focus"];export function createChangeNotifier(deps){const subscriptions=new Map;const wakeRefCounts=new Map;const onWake=()=>{for(const record of[...subscriptions.keys()])refresh(record)};function refresh(record){const subscription=subscriptions.get(record);if(!subscription)return;const observation=deps.observe(record);if(!observation)return;const changed=subscription.lastKey!==void 0&&subscription.lastKey!==observation.key;const first=subscription.lastKey===void 0;subscription.lastKey=observation.key;rearm(record,subscription,observation.nextBoundary);if(changed||first){for(const listener of[...subscription.listeners]){try{listener(observation.report)}catch(error){reportListenerError(error)}}}}function rearm(record,subscription,boundary){subscription.cancelTimer?.();subscription.cancelTimer=void 0;if(boundary!==void 0){subscription.cancelTimer=scheduleAt(deps.timers,deps.clock(record),boundary,()=>refresh(record))}}function subscribe(record,listener){let subscription=subscriptions.get(record);if(!subscription){const watcher=()=>refresh(record);subscription={listeners:new Set,watcher,wakeTargets:wakeTargetsOf(record),lastKey:void 0,cancelTimer:void 0};subscriptions.set(record,subscription);record.watchers.add(watcher);for(const target of subscription.wakeTargets)retainWakeTarget(target);const initial=deps.observe(record);if(initial){subscription.lastKey=initial.key;rearm(record,subscription,initial.nextBoundary)}}subscription.listeners.add(listener);const active=subscription;let subscribed=true;return()=>{if(!subscribed)return;subscribed=false;active.listeners.delete(listener);if(active.listeners.size>0||subscriptions.get(record)!==active)return;subscriptions.delete(record);record.watchers.delete(active.watcher);active.cancelTimer?.();for(const target of active.wakeTargets)releaseWakeTarget(target)}}function retainWakeTarget(target){const count=wakeRefCounts.get(target)??0;if(count===0){for(const type of eventsFor(target))target.addEventListener(type,onWake)}wakeRefCounts.set(target,count+1)}function releaseWakeTarget(target){const count=(wakeRefCounts.get(target)??1)-1;if(count>0){wakeRefCounts.set(target,count);return}wakeRefCounts.delete(target);for(const type of eventsFor(target))target.removeEventListener(type,onWake)}return{subscribe,refresh}}const documentTargets=new WeakSet;function eventsFor(target){return documentTargets.has(target)?DOCUMENT_WAKE_EVENTS:WINDOW_WAKE_EVENTS}function wakeTargetsOf(record){const globalScope=globalThis;const document=record.document??globalScope.document;const view=document?.defaultView??(record.document?void 0:globalScope.window);const targets=[];if(isEventTarget(document)){documentTargets.add(document);targets.push(document)}if(isEventTarget(view)&&view!==document)targets.push(view);return targets}function isEventTarget(value){return typeof value==="object"&&value!==null&&typeof value.addEventListener==="function"&&typeof value.removeEventListener==="function"}

package/dist/types/components/_shared/brand/brand-decision.d.ts

@@ -0,0 +1,3 @@
+import type { BrandDecision } from './types';
+export declare function sealBrandDecision(decision: BrandDecision): BrandDecision;
+export declare function isBrandDecision(value: unknown): value is BrandDecision;

package/dist/types/components/_shared/brand/brand-export-default.d.ts

@@ -0,0 +1,32 @@
+import type { BrandCorner, BrandRect } from './types';
+export interface BrandExportOptions {
+    readonly lockup?: {
+        readonly outline: string;
+    };
+    readonly placement?: BrandRect;
+    readonly opacity?: number;
+    readonly color?: string;
+    readonly background?: string | null;
+    readonly corner?: BrandCorner;
+    readonly height?: number;
+    readonly frame?: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+export type BrandExportView = {
+    readonly mode: 'default';
+} | {
+    readonly mode: 'custom';
+    readonly src: string;
+    readonly width: number;
+    readonly height: number;
+};
+export declare const DEFAULT_BRAND_EXPORT_VIEW: BrandExportView;
+export declare function pickBrandColor(background?: string | null): string;
+export declare function brandExportMarkColor(options: BrandExportOptions): string;
+export declare function brandExportViewRect(frame: {
+    readonly width: number;
+    readonly height: number;
+}, view: BrandExportView, options?: BrandExportOptions): BrandRect | null;
+export declare function addBrandViewToSvg(markup: string, view: BrandExportView, options?: BrandExportOptions): string;

package/dist/types/components/_shared/brand/brand-export.d.ts

@@ -0,0 +1,34 @@
+import type { BrandExportOptions } from './brand-export-default';
+import type { BrandDecision, BrandRect } from './types';
+export { pickBrandColor } from './brand-export-default';
+export type { BrandExportOptions } from './brand-export-default';
+export interface BrandCanvasOptions extends BrandExportOptions {
+    readonly pixelRatio?: number;
+    readonly image?: CanvasImageSource | null;
+}
+export interface BrandCanvasContext {
+    readonly canvas?: {
+        readonly width: number;
+        readonly height: number;
+    } | null;
+    globalAlpha: number;
+    fillStyle: unknown;
+    save(): void;
+    restore(): void;
+    translate(x: number, y: number): void;
+    scale(x: number, y: number): void;
+    beginPath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    closePath(): void;
+    fill(): void;
+    drawImage(image: CanvasImageSource, dx: number, dy: number, dw: number, dh: number): void;
+}
+export declare function brandExportRect(frame: {
+    readonly width: number;
+    readonly height: number;
+}, decision?: BrandDecision, options?: BrandExportOptions): BrandRect | null;
+export declare function addBrandToSvg(markup: string, decision?: BrandDecision, options?: BrandExportOptions): string;
+export declare function drawBrandOnCanvas(ctx: BrandCanvasContext, decision: BrandDecision | undefined, options: BrandCanvasOptions): 'default' | 'custom' | 'none';
+export declare function loadBrandImage(decision?: BrandDecision, doc?: Document): Promise<HTMLImageElement | null>;

package/dist/types/components/_shared/brand/brand-integrity.d.ts

@@ -0,0 +1,2 @@
+export declare function releaseBrandIntegrity(host: HTMLElement): void;
+export declare function protectDefaultBrand(host: HTMLElement, node: HTMLElement | undefined, style?: Record<string, string>): void;

package/dist/types/components/_shared/brand/brand-lockup-default.d.ts

@@ -0,0 +1,5 @@
+export declare const BRAND_LOCKUP_WIDTH = 118;
+export declare const BRAND_LOCKUP_HEIGHT = 32;
+export declare const BRAND_LOCKUP_STROKE = 2.8;
+export declare const BRAND_LOCKUP_SYMBOL_PATH = "M6.52 16H9.52Q10.77 16 10.48 17.25L7.82 28.75Q7.54 30 6.29 30H3.29Q2.04 30 2.32 28.75L4.98 17.25Q5.27 16 6.52 16ZM17.63 9H20.63Q21.88 9 21.6 10.25L17.32 28.75Q17.04 30 15.79 30H12.79Q11.54 30 11.82 28.75L16.1 10.25Q16.38 9 17.63 9ZM28.75 2H31.75Q33 2 32.71 3.25L26.82 28.75Q26.54 30 25.29 30H22.29Q21.04 30 21.32 28.75L27.21 3.25Q27.5 2 28.75 2Z";
+export declare const BRAND_LOCKUP_WORDMARK_PATH = "M44.66 12.32Q44.17 12.32 43.76 12.45Q43.36 12.57 43.13 12.82Q42.89 13.07 42.89 13.39Q42.87 13.78 43.22 14.07Q43.57 14.36 44.38 14.51L47.11 15.03Q49.21 15.42 50.23 16.34Q51.25 17.26 51.25 18.79Q51.25 20.2 50.41 21.28Q49.58 22.36 48.11 22.95Q46.65 23.54 44.74 23.54Q42.74 23.54 41.28 22.97Q39.82 22.41 38.99 21.37Q38.16 20.34 38 18.93H42.56Q42.7 19.63 43.28 20.01Q43.86 20.38 44.77 20.38Q45.31 20.38 45.72 20.26Q46.14 20.13 46.37 19.89Q46.61 19.64 46.61 19.3Q46.61 18.84 46.2 18.57Q45.79 18.3 44.91 18.13L42.51 17.69Q40.44 17.32 39.38 16.3Q38.33 15.27 38.35 13.67Q38.35 12.26 39.1 11.26Q39.85 10.26 41.25 9.74Q42.65 9.21 44.58 9.21Q46.48 9.21 47.88 9.76Q49.28 10.31 50.06 11.34Q50.84 12.37 50.91 13.78H46.67Q46.59 13.1 46.04 12.71Q45.49 12.32 44.66 12.32ZM52.76 28.43V24.98L53.52 25.03Q54.01 25.03 54.53 25.03Q54.94 25.03 55.22 24.97Q55.49 24.91 55.71 24.72Q55.93 24.53 56.06 24.17L56.21 23.82L51.29 9.39H56.06L58.54 19.22H58.7L61.2 9.39H66.02L60.83 24.56Q60.19 26.41 58.82 27.46Q57.45 28.5 55.03 28.5Q53.69 28.5 52.76 28.43ZM66.69 9.39H71.25V23.28H66.69ZM66.62 5.65Q66.62 5.07 66.95 4.57Q67.27 4.08 67.8 3.79Q68.33 3.5 68.96 3.5Q69.59 3.5 70.12 3.79Q70.65 4.08 70.97 4.57Q71.28 5.07 71.28 5.65Q71.28 6.23 70.97 6.73Q70.65 7.23 70.12 7.52Q69.59 7.81 68.96 7.81Q68.33 7.81 67.8 7.52Q67.27 7.23 66.95 6.73Q66.62 6.23 66.62 5.65ZM72.55 16.33Q72.55 13.96 73.31 12.36Q74.06 10.76 75.31 9.98Q76.55 9.21 78.05 9.21Q79.09 9.21 79.87 9.57Q80.65 9.92 81.16 10.49Q81.66 11.06 81.96 11.79H82.05V4.76H86.62V23.28H82.1V21.03H81.96Q81.66 21.74 81.14 22.27Q80.63 22.81 79.84 23.14Q79.06 23.48 78.07 23.48Q76.53 23.48 75.27 22.67Q74.02 21.86 73.29 20.25Q72.55 18.63 72.55 16.33ZM82.17 16.32Q82.17 15.22 81.87 14.42Q81.58 13.61 81.02 13.19Q80.46 12.77 79.68 12.77Q78.9 12.77 78.35 13.19Q77.81 13.62 77.52 14.43Q77.23 15.23 77.23 16.32Q77.23 17.42 77.52 18.23Q77.81 19.04 78.35 19.48Q78.9 19.92 79.68 19.92Q80.46 19.92 81.02 19.48Q81.57 19.05 81.87 18.23Q82.17 17.41 82.17 16.32ZM94.76 17.58 93.65 17.68Q92.92 17.76 92.48 18.17Q92.05 18.58 92.05 19.21Q92.05 19.62 92.26 19.92Q92.47 20.22 92.85 20.38Q93.23 20.54 93.71 20.54Q94.39 20.54 94.95 20.26Q95.52 19.98 95.85 19.48Q96.18 18.99 96.18 18.35L96.14 13.79Q96.14 13.35 95.93 13.04Q95.73 12.73 95.33 12.57Q94.93 12.41 94.4 12.41Q93.6 12.41 93.1 12.76Q92.6 13.11 92.5 13.78H88.24Q88.35 12.5 89.09 11.46Q89.83 10.42 91.2 9.82Q92.56 9.21 94.48 9.21Q96.31 9.21 97.73 9.78Q99.14 10.34 99.93 11.39Q100.72 12.43 100.72 13.82V23.28H96.42V21.35H96.32Q95.93 22.06 95.35 22.53Q94.77 23.01 94.01 23.26Q93.25 23.51 92.28 23.51Q90.93 23.51 89.91 23.05Q88.89 22.59 88.31 21.67Q87.72 20.76 87.72 19.43Q87.72 17.25 89.13 16.22Q90.54 15.19 92.85 15.05Q93.31 15.01 95.18 14.94L96.33 14.89L96.36 17.51Q95.69 17.53 94.76 17.58ZM108.47 13.89 110.77 9.39H115.36L111.54 16.32L115.52 23.28H110.97L108.47 18.71L106.04 23.28H101.42L105.43 16.32L101.64 9.39H106.26Z";

package/dist/types/components/_shared/brand/brand-logo.d.ts

@@ -0,0 +1,22 @@
+import type { BrandDecision, BrandLogoInvalidReason, BrandLogoRequest, BrandProduct, BrandPurpose } from './types';
+export declare const BRAND_LOGO_NONE = "none";
+export declare const BRAND_LOGO_MAX_BYTES: number;
+export declare const BRAND_LOGO_MAX_SIDE = 2048;
+export declare const BRAND_PENDING_TIMEOUT_MS = 10000;
+export declare const BRAND_FEATURE: Readonly<Record<BrandProduct, 'chart.branding' | 'grid.branding'>>;
+export declare function parseBrandLogo(value: unknown): BrandLogoRequest;
+export declare function brandNeedsEntitlement(requested: unknown): boolean;
+export interface BrandDecisionInput {
+    readonly requested: unknown;
+    readonly entitlementState?: string;
+    readonly pendingTimedOut?: boolean;
+    readonly purpose?: BrandPurpose;
+}
+export declare function decideBrand(input: BrandDecisionInput): BrandDecision;
+export declare function brandRefusal(product: BrandProduct, decision: BrandDecision): {
+    product: BrandProduct;
+    feature: 'chart.branding' | 'grid.branding';
+    state: string;
+    code: 'license-required';
+} | null;
+export declare function describeBrandLogoProblem(reason: BrandLogoInvalidReason): string;

package/dist/types/components/_shared/brand/brand-mark-default.d.ts

@@ -0,0 +1,52 @@
+export declare const BRAND_MARK_CLASS = "sy-brand-mark";
+export declare const BRAND_ATTR = "data-sy-brand";
+export declare const BRAND_PRODUCT_ATTR = "data-sy-brand-product";
+export declare const BRAND_MARK_VIEWBOX_WIDTH = 1026;
+export declare const BRAND_MARK_VIEWBOX_HEIGHT = 400;
+export declare const BRAND_MARK_VIEWBOX = "0 0 1026 400";
+export declare const BRAND_MARK_PATH = "M91 164q-12 0-22 3-9 4-15 10-5 5-5 13 0 8 8 14 8 6 26 10l35 7q30 6 44 19 15 12 15 33 0 17-10 31-11 13-31 20-20 8-47 8-39 0-62-15-23-14-27-41h44q5 26 44 26 21 0 33-7 13-7 13-19-1-10-9-16-8-6-25-9l-34-7q-29-6-44-19-16-13-16-33 0-17 11-30 10-13 29-21 19-7 45-7 23 0 41 7 18 7 29 19 10 12 12 29h-41q-3-12-13-19-11-6-28-6zm109 235v-31q10 0 19 0 9 0 14-1 5-2 11-7 5-5 10-17l5-12-80-194h46l55 148h2l55-148h46l-90 216q-9 24-26 35-18 12-44 12-14 0-23-1zm195-262h43v191h-43zm-5-52q0-6 4-11 3-5 10-8 6-3 13-3 7 0 13 3 7 3 10 8 4 5 4 11 0 6-4 11-3 5-10 8-6 3-13 3-7 0-13-3-7-3-10-8-4-5-4-11zm68 148q0-31 12-53 12-22 32-34 21-12 48-12 18 0 31 6 12 5 19 12 7 7 12 16h2v-95h43v255h-41v-30h-4q-8 14-23 24-14 10-40 10-26 0-47-12-20-12-32-34-12-23-12-53zm158-1q0-20-7-35-7-14-19-23-13-8-31-8-19 0-32 9-12 8-19 23-6 15-6 34 0 20 6 35 7 15 20 24 13 9 31 9 18 0 30-9 13-8 20-23 7-16 7-36zm146-15q13-1 29-2 17-1 28-1v-15q0-17-12-26-11-8-33-8-18 0-29 6-12 7-15 18h-43q2-16 14-28 11-13 31-20 19-7 44-7 21 0 40 6 19 6 32 20 13 15 13 41v127h-41v-26h-2q-7 13-23 22-17 8-41 8-21 0-38-7-16-6-26-20-10-13-10-31 0-30 23-42 23-13 59-15zm1 85q17 0 30-6 12-5 19-15 7-10 7-22v-17l-51 3q-22 1-34 8-12 8-12 22 0 13 11 20 12 7 30 7zm189-244 38-58h36l-53 75 53 74h-36l-38-56-38 56h-36l52-74-52-75h37z";
+export declare const BRAND_MARK_HEIGHT = 16;
+export declare const BRAND_MARK_WIDTH: number;
+export declare const BRAND_COLOR_LIGHT = "#172027";
+export declare const BRAND_COLOR_DARK = "#edf0f4";
+export declare const BRAND_CORNER_ATTR = "data-sy-brand-corner";
+export declare const BRAND_ERROR_ATTR = "data-sy-brand-error";
+export declare const BRAND_MARK_INSET_X = 8;
+export declare const BRAND_MARK_INSET_Y = 6;
+export declare const BRAND_MARK_OPACITY = 0.6;
+export declare function isBrandImageSource(src: unknown): src is string;
+export declare function brandRect(frame: {
+    readonly width: number;
+    readonly height: number;
+}, size: {
+    readonly width: number;
+    readonly height: number;
+}, corner?: 'br' | 'bl' | 'tr' | 'tl', inset?: {
+    readonly x: number;
+    readonly y: number;
+}): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare function chooseBrandCorner(frame: {
+    readonly width: number;
+    readonly height: number;
+}, size: {
+    readonly width: number;
+    readonly height: number;
+}, obstacles: ReadonlyArray<{
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}>, preferred?: 'br' | 'bl' | 'tr' | 'tl'): {
+    corner: 'br' | 'bl' | 'tr' | 'tl';
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};

package/dist/types/components/_shared/brand/brand-mark.d.ts

@@ -0,0 +1,22 @@
+import type { BrandCorner, BrandDecision, BrandProduct } from './types';
+export { BRAND_ATTR, BRAND_COLOR_DARK, BRAND_COLOR_LIGHT, BRAND_CORNER_ATTR, BRAND_ERROR_ATTR, BRAND_MARK_CLASS, BRAND_MARK_HEIGHT, BRAND_MARK_INSET_X, BRAND_MARK_INSET_Y, BRAND_MARK_OPACITY, BRAND_MARK_PATH, BRAND_MARK_VIEWBOX, BRAND_MARK_VIEWBOX_HEIGHT, BRAND_MARK_VIEWBOX_WIDTH, BRAND_MARK_WIDTH, BRAND_PRODUCT_ATTR, brandRect, chooseBrandCorner, isBrandImageSource, } from './brand-mark-default';
+export declare const BRAND_CUSTOM_MAX_WIDTH = 120;
+export declare const BRAND_CUSTOM_MAX_HEIGHT = 32;
+export declare const BRAND_MARK_SVG: string;
+export declare function brandDisplayMode(decision?: BrandDecision): 'default' | 'custom' | 'pending' | null;
+export declare function brandMarkSize(decision?: BrandDecision, height?: number): {
+    width: number;
+    height: number;
+};
+export interface BrandElementOptions {
+    readonly product?: BrandProduct;
+    readonly corner?: BrandCorner;
+    readonly onCustomLogoError?: () => void;
+}
+export declare function brandMarkStyle(options?: BrandElementOptions): Record<string, string>;
+export declare const BRAND_IMAGE_STYLE: Readonly<Record<string, string>>;
+export declare function brandMarkAttributes(decision?: BrandDecision, options?: BrandElementOptions): Record<string, string> | null;
+export declare function brandImageAttributes(src: string): Record<string, string> | null;
+export declare function createBrandElement(doc: Document, decision?: BrandDecision, options?: BrandElementOptions): HTMLElement | null;
+export declare function mountBrand(container: Element, decision?: BrandDecision, options?: BrandElementOptions): HTMLElement | null;
+export declare const BRAND_MARK_CSS: string;

package/dist/types/components/_shared/brand/index.d.ts

@@ -0,0 +1,5 @@
+export * from './brand-mark';
+export * from './brand-logo';
+export * from './brand-export';
+export { isBrandDecision } from './brand-decision';
+export type * from './types';

package/dist/types/components/_shared/brand/types.d.ts

@@ -0,0 +1,41 @@
+export type BrandProduct = 'chart' | 'grid';
+export type BrandCorner = 'br' | 'bl' | 'tr' | 'tl';
+export type BrandMode = 'default' | 'none' | 'custom' | 'hidden-pending';
+export type BrandLogoMime = 'image/png' | 'image/jpeg' | 'image/webp';
+export type BrandLogoInvalidReason = 'not-a-string' | 'unsupported-source' | 'unsupported-type' | 'malformed' | 'too-large' | 'signature-mismatch' | 'bad-dimensions';
+export type BrandLogoRequest = {
+    readonly kind: 'default';
+} | {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'custom';
+    readonly src: string;
+    readonly mime: BrandLogoMime;
+    readonly bytes: number;
+    readonly width: number;
+    readonly height: number;
+} | {
+    readonly kind: 'invalid';
+    readonly reason: BrandLogoInvalidReason;
+};
+export type BrandEntitlementState = 'none' | 'pending' | 'valid' | 'insufficient' | 'not-yet-valid' | 'expired' | 'invalid' | 'revoked' | 'unsupported-environment';
+export type BrandPurpose = 'screen' | 'export';
+export interface BrandDecision {
+    readonly mode: BrandMode;
+    readonly requested: BrandLogoRequest['kind'];
+    readonly refused?: boolean;
+    readonly state?: string;
+    readonly invalid?: BrandLogoInvalidReason;
+    readonly logo?: {
+        readonly src: string;
+        readonly mime: BrandLogoMime;
+        readonly width: number;
+        readonly height: number;
+    };
+}
+export interface BrandRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}

package/dist/types/components/chart/_shared/core/a11y/a11y.d.ts

@@ -0,0 +1,16 @@
+export interface ChartAriaInput {
+    readonly type?: string;
+    readonly title?: string;
+    readonly pointCount?: number;
+    readonly seriesCount?: number;
+    readonly seriesNames?: ReadonlyArray<string>;
+    readonly dataTableInMenu?: boolean;
+}
+export declare function chartRoleDescription(type: string | undefined): string;
+export declare function buildChartAriaLabel(input: ChartAriaInput): string;
+export declare function chartFrameAriaPointCount(type: string, frame: unknown): number | undefined;
+export declare function resolveChartAriaPointCount(type: string, payloadCount: number, frameCount?: number, variant?: string): number | undefined;
+export declare function prefersReducedMotion(): boolean;
+export type MenuKeyAction = 'next' | 'prev' | 'first' | 'last' | 'select' | 'close' | null;
+export declare function menuKeyAction(key: string): MenuKeyAction;
+export declare function nextMenuIndex(action: MenuKeyAction, current: number, count: number, selectable: (index: number) => boolean): number;

package/dist/types/components/chart/_shared/core/a11y/contrast.d.ts

@@ -0,0 +1,24 @@
+export interface RgbColor {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a?: number;
+}
+export type WcagTextLevel = 'AAA' | 'AA' | 'fail';
+export declare const WCAG_AA_NORMAL = 4.5;
+export declare const WCAG_AA_LARGE = 3;
+export declare const WCAG_AAA_NORMAL = 7;
+export declare const WCAG_AAA_LARGE = 4.5;
+export declare const LARGE_TEXT_PX = 24;
+export declare const LARGE_BOLD_TEXT_PX = 18.66;
+export declare function parseCssColor(input: string | null | undefined): RgbColor | null;
+export declare function compositeOver(fg: RgbColor, bg: RgbColor): RgbColor;
+export declare function relativeLuminance(c: RgbColor): number;
+export declare function contrastRatio(fg: RgbColor, bg: RgbColor): number;
+export declare function isLargeText(fontSizePx: number, bold: boolean): boolean;
+export declare function wcagTextLevel(ratio: number, large: boolean): WcagTextLevel;
+export declare function fallbackHex(token: string): string | null;
+export declare function toHex(c: RgbColor): string;
+export declare function mixToward(c: RgbColor, target: RgbColor, t: number): RgbColor;
+export declare function ensureContrast(fg: RgbColor, bg: RgbColor, min?: number): RgbColor;
+export declare function readableTextColor(color: string, background: string, min?: number): string;

package/dist/types/components/chart/_shared/core/a11y/index.d.ts

@@ -0,0 +1,2 @@
+export * from './a11y';
+export * from './contrast';

package/dist/types/components/chart/_shared/core/action/action-contract.d.ts

@@ -0,0 +1,29 @@
+export type ChartActionType = 'zoomTo' | 'dataZoom' | 'zoomBy' | 'panBy' | 'resetZoom' | 'brush' | 'clearBrush' | 'visualMap' | 'clearVisualMap' | 'showTip' | 'hideTip' | 'showCrosshair' | 'hideCrosshair' | 'highlight' | 'downplay' | 'select' | 'unselect' | 'legendSelect' | 'legendUnSelect' | 'restore' | 'replaceData' | 'appendData' | 'export' | 'print' | 'showDataTable' | 'hideDataTable' | 'connect' | 'disconnect' | 'addDrawing' | 'removeDrawing' | 'removeDrawings' | 'clearDrawings' | 'undoDrawing' | 'redoDrawing' | 'selectDrawings' | 'setDrawings' | 'drawingMode' | 'exportDrawings' | 'importDrawings' | 'setDrawingSpace';
+export interface ChartAction {
+    type: ChartActionType | (string & {});
+    payload?: Record<string, unknown> | null;
+    [field: string]: unknown;
+}
+export interface ChartActionResult {
+    type: string;
+    handled: boolean;
+    result?: unknown;
+    error?: string;
+}
+export interface ChartActionEventDetail {
+    type: string;
+    payload: Record<string, unknown>;
+    handled: boolean;
+}
+export declare const CHART_ACTIONS: Readonly<Record<ChartActionType, {
+    method: string;
+    fields: ReadonlyArray<string>;
+}>>;
+export declare const CHART_ACTION_TYPES: ReadonlyArray<ChartActionType>;
+export declare function isKnownChartAction(type: string): type is ChartActionType;
+export interface NormalizedChartAction {
+    type: string;
+    payload: Record<string, unknown>;
+}
+export declare function normalizeChartAction(input: unknown): NormalizedChartAction | null;
+export declare function actionNumber(payload: Record<string, unknown>, ...keys: string[]): number | undefined;

package/dist/types/components/chart/_shared/core/action/index.d.ts

@@ -0,0 +1,2 @@
+export { actionNumber, CHART_ACTION_TYPES, CHART_ACTIONS, isKnownChartAction, normalizeChartAction } from './action-contract';
+export type { ChartAction, ChartActionEventDetail, ChartActionResult, ChartActionType, NormalizedChartAction } from './action-contract';

package/dist/types/components/chart/_shared/core/adapter/animatable-mark.d.ts

@@ -0,0 +1,51 @@
+export interface AnimatableMarkProgress {
+    readonly t: number;
+    readonly easedT: number;
+}
+export interface AnimatableMarkEnterEntry<TDatum, TKey extends string | number> {
+    readonly key: TKey;
+    readonly datum: TDatum;
+    readonly index: number;
+}
+export interface AnimatableMarkUpdateEntry<TDatum, TKey extends string | number> {
+    readonly key: TKey;
+    readonly datum: TDatum;
+    readonly index: number;
+    readonly prevIndex: number;
+}
+export interface AnimatableMarkExitEntry<TDatum, TKey extends string | number> {
+    readonly key: TKey;
+    readonly datum: TDatum;
+    readonly index: number;
+}
+export type MarkLifecycleEvent<TDatum, TKey extends string | number> = {
+    readonly kind: 'enter';
+    readonly entries: ReadonlyArray<AnimatableMarkEnterEntry<TDatum, TKey>>;
+} | {
+    readonly kind: 'update';
+    readonly entries: ReadonlyArray<AnimatableMarkUpdateEntry<TDatum, TKey>>;
+} | {
+    readonly kind: 'exit';
+    readonly entries: ReadonlyArray<AnimatableMarkExitEntry<TDatum, TKey>>;
+} | {
+    readonly kind: 'interpolate';
+    readonly progress: AnimatableMarkProgress;
+};
+export interface MarkLifecycleHooks<TDatum, TKey extends string | number> {
+    readonly enter: ReadonlyArray<AnimatableMarkEnterEntry<TDatum, TKey>>;
+    readonly update: ReadonlyArray<AnimatableMarkUpdateEntry<TDatum, TKey>>;
+    readonly exit: ReadonlyArray<AnimatableMarkExitEntry<TDatum, TKey>>;
+    readonly interpolate: AnimatableMarkProgress;
+}
+export interface AnimatableMark<TDatum, TKey extends string | number, TVisual> {
+    readonly id: string;
+    keyOf(datum: TDatum): TKey;
+    enter(entries: ReadonlyArray<AnimatableMarkEnterEntry<TDatum, TKey>>): void;
+    update(entries: ReadonlyArray<AnimatableMarkUpdateEntry<TDatum, TKey>>): void;
+    exit(entries: ReadonlyArray<AnimatableMarkExitEntry<TDatum, TKey>>): void;
+    interpolate(progress: AnimatableMarkProgress, entries: ReadonlyArray<TVisual>): void;
+}
+export declare function isAnimatableMark(x: unknown): x is AnimatableMark<unknown, string | number, unknown>;
+export declare function isMarkLifecycleEventOfKind<K extends MarkLifecycleEvent<unknown, string | number>['kind']>(event: MarkLifecycleEvent<unknown, string | number>, expected: K): event is Extract<MarkLifecycleEvent<unknown, string | number>, {
+    kind: K;
+}>;

package/dist/types/components/chart/_shared/core/adapter/deferred-pro-renderer.d.ts

@@ -0,0 +1,8 @@
+export type DeferredRendererClass<R> = new (canvas: HTMLCanvasElement) => R;
+export interface DeferredProRendererOptions {
+    readonly label?: string;
+}
+export declare const PRO_RENDERER_LOAD_FAILED_PREFIX = "Pro renderer module failed to load: ";
+export declare function isProRendererLoadFailure(error: unknown): boolean;
+export declare function preloadDeferredRenderer(load: () => Promise<unknown>): Promise<void>;
+export declare function createDeferredProRenderer<R extends object>(canvas: HTMLCanvasElement, load: () => Promise<DeferredRendererClass<R>>, opts?: DeferredProRendererOptions): R;

package/dist/types/components/chart/_shared/core/adapter/gpu-availability.d.ts

@@ -0,0 +1,10 @@
+export declare const GPU_PRO_NOT_IN_BUILD_REASON = "Pro renderer not included in this build";
+export declare const GPU_NO_WEBGPU_REASON = "browser does not support WebGPU";
+export interface GpuTierAvailability {
+    available: boolean;
+    reason?: string;
+}
+export declare function gpuTierAvailability(options: {
+    proModulePresent: boolean;
+    nav?: unknown;
+}): GpuTierAvailability;

package/dist/types/components/chart/_shared/core/adapter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './streamable-series';
+export * from './animatable-mark';

package/dist/types/components/chart/_shared/core/adapter/streamable-series.d.ts

@@ -0,0 +1,18 @@
+export type StreamableSeriesEvent = 'appended' | 'windowSlid' | 'replaced';
+export interface StreamableSeriesSource<TDatum> {
+    subscribe(event: StreamableSeriesEvent, listener: (detail: unknown) => void): () => void;
+    getSnapshot(): ReadonlyArray<TDatum>;
+}
+export type StreamableChannelView = Float64Array | Float32Array;
+export interface StreamableSeries<TDatum, TChannel extends number = number> {
+    readonly id: string;
+    attachStream(source: StreamableSeriesSource<TDatum>): () => void;
+    getCurrentData(): ReadonlyArray<TDatum>;
+    getChannelView(channel: TChannel): StreamableChannelView | null;
+}
+export interface StreamableSeriesAdvanced<TDatum, TChannel extends number = number> extends StreamableSeries<TDatum, TChannel> {
+    applyFilter(predicate: ((datum: TDatum) => boolean) | null): void;
+    applyAggregate(aggregator: ((window: ReadonlyArray<TDatum>) => ReadonlyArray<TDatum>) | null): void;
+}
+export declare function isStreamableSeries(x: unknown): x is StreamableSeries<unknown, number>;
+export declare function isStreamableSeriesAdvanced(x: unknown): x is StreamableSeriesAdvanced<unknown, number>;

package/dist/types/components/chart/_shared/core/animation/flip.d.ts

@@ -0,0 +1,65 @@
+import type { JoinResult, JoinEnterEntry, JoinUpdateEntry, JoinExitEntry } from './transition';
+export interface FlipRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+export type FlipMeasurement<TKey extends string | number> = ReadonlyMap<TKey, FlipRect> | {
+    readonly [k: string]: FlipRect;
+};
+export interface FlipDelta {
+    readonly dx: number;
+    readonly dy: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+}
+export interface FlipEntry<TKey extends string | number> {
+    readonly key: TKey;
+    readonly first: FlipRect;
+    readonly last: FlipRect;
+    readonly delta: FlipDelta;
+}
+export interface FlipResult<TKey extends string | number> {
+    readonly entered: ReadonlyArray<{
+        readonly key: TKey;
+        readonly last: FlipRect;
+    }>;
+    readonly updated: ReadonlyArray<FlipEntry<TKey>>;
+    readonly exited: ReadonlyArray<{
+        readonly key: TKey;
+        readonly first: FlipRect;
+    }>;
+}
+export interface FlipTransform {
+    readonly tx: number;
+    readonly ty: number;
+    readonly sx: number;
+    readonly sy: number;
+}
+export interface FlipSnapshot<TKey extends string | number> {
+    readonly t: number;
+    readonly easedT: number;
+    readonly transforms: ReadonlyMap<TKey, FlipTransform>;
+    readonly phase: 'running' | 'complete';
+}
+export interface FlipOptions<TKey extends string | number> {
+    readonly durationMs?: number;
+    readonly easing?: (t: number) => number;
+    readonly now?: () => number;
+    readonly onStart?: (entries: ReadonlyArray<FlipEntry<TKey>>) => void;
+    readonly onProgress?: (snapshot: FlipSnapshot<TKey>) => void;
+    readonly onComplete?: (snapshot: FlipSnapshot<TKey>) => void;
+}
+export interface Flip<TKey extends string | number> {
+    begin(first: FlipMeasurement<TKey>, last: FlipMeasurement<TKey>): FlipResult<TKey>;
+    tick(currentTime?: number): FlipSnapshot<TKey> | null;
+    isActive(): boolean;
+    cancel(): void;
+}
+export declare function computeFlip<TKey extends string | number>(input: {
+    readonly first: FlipMeasurement<TKey>;
+    readonly last: FlipMeasurement<TKey>;
+}): FlipResult<TKey>;
+export declare function createFlip<TKey extends string | number>(opts?: FlipOptions<TKey>): Flip<TKey>;
+export declare function flipFromJoin<TDatum, TKey extends string | number>(join: JoinResult<TDatum, TKey>, firstOf: (entry: JoinUpdateEntry<TDatum, TKey> | JoinExitEntry<TDatum, TKey>) => FlipRect | undefined, lastOf: (entry: JoinUpdateEntry<TDatum, TKey> | JoinEnterEntry<TDatum, TKey>) => FlipRect | undefined): FlipResult<TKey>;

package/dist/types/components/chart/_shared/core/animation/heatmap-animator.d.ts

@@ -0,0 +1,27 @@
+import type { HeatmapEasing } from '../contract/heatmap-contract.ts';
+export declare function applyHeatmapEasing(t: number, easing: HeatmapEasing): number;
+export interface HeatmapTweenEntry {
+    startedAt: number;
+    pausedElapsed: number;
+    paused: boolean;
+    duration: number;
+    easing: HeatmapEasing;
+}
+export interface HeatmapTweenOptions {
+    duration: number;
+    easing: HeatmapEasing;
+}
+export interface HeatmapAnimator {
+    start(key: string, opts: HeatmapTweenOptions): void;
+    progressAt(key: string, now: number): number | undefined;
+    has(key: string): boolean;
+    isActive(key: string, now: number): boolean;
+    tick(now: number): void;
+    pauseAll(now: number): void;
+    resumeAll(now: number): void;
+    hasActive(): boolean;
+    cancel(key: string): void;
+    clear(): void;
+    entries(): ReadonlyMap<string, HeatmapTweenEntry>;
+}
+export declare function createHeatmapAnimator(): HeatmapAnimator;

package/dist/types/components/chart/_shared/core/animation/index.d.ts

@@ -0,0 +1,4 @@
+export * from './tween';
+export * from './transition';
+export * from './flip';
+export * from './interruptible';

package/dist/types/components/chart/_shared/core/animation/interruptible.d.ts

@@ -0,0 +1,48 @@
+export type InterruptibleChannelMap = Record<string, number>;
+export interface InterruptibleSnapshot<TMap extends InterruptibleChannelMap> {
+    readonly t: number;
+    readonly easedT: number;
+    readonly values: Readonly<TMap>;
+}
+export interface InterruptibleTweenOptions<TMap extends InterruptibleChannelMap> {
+    readonly durationMs?: number;
+    readonly easing?: (t: number) => number;
+    readonly now?: () => number;
+    readonly onProgress?: (snapshot: InterruptibleSnapshot<TMap>) => void;
+    readonly onComplete?: (snapshot: InterruptibleSnapshot<TMap>) => void;
+}
+export interface InterruptibleRetargetInput<TMap extends InterruptibleChannelMap> {
+    readonly from?: Readonly<TMap>;
+    readonly to: Readonly<TMap>;
+}
+export interface InterruptibleTween<TMap extends InterruptibleChannelMap> {
+    retarget(input: InterruptibleRetargetInput<TMap>): void;
+    tick(currentTime?: number): InterruptibleSnapshot<TMap> | null;
+    isActive(): boolean;
+    cancel(): void;
+    getValues(): Readonly<TMap> | null;
+}
+export interface ComposedRetargetInput<TMap extends InterruptibleChannelMap> {
+    readonly from?: Readonly<TMap>;
+    readonly to: Readonly<TMap>;
+    readonly durationMs?: number;
+    readonly easing?: (t: number) => number;
+}
+export interface ComposedTweensSnapshot<TKey extends string, TMap extends InterruptibleChannelMap> {
+    readonly values: Readonly<Record<TKey, Readonly<TMap>>>;
+    readonly allComplete: boolean;
+}
+export interface ComposeTweensOptions<TKey extends string> {
+    readonly now?: () => number;
+    readonly onAllComplete?: () => void;
+    readonly onTweenComplete?: (key: TKey) => void;
+}
+export interface ComposedTweens<TKey extends string, TMap extends InterruptibleChannelMap> {
+    retarget(key: TKey, input: ComposedRetargetInput<TMap>): void;
+    tick(currentTime?: number): ComposedTweensSnapshot<TKey, TMap> | null;
+    cancel(key?: TKey): void;
+    isActive(key?: TKey): boolean;
+    getActiveKeys(): ReadonlyArray<TKey>;
+}
+export declare function createInterruptibleTween<TMap extends InterruptibleChannelMap>(opts?: InterruptibleTweenOptions<TMap>): InterruptibleTween<TMap>;
+export declare function composeTweens<TKey extends string, TMap extends InterruptibleChannelMap>(opts?: ComposeTweensOptions<TKey>): ComposedTweens<TKey, TMap>;

package/dist/types/components/chart/_shared/core/animation/morph-paint-order.d.ts

@@ -0,0 +1,9 @@
+export interface MorphPaintOrder {
+    paintOrder?: number;
+    passive?: boolean;
+    depth?: number;
+}
+export declare function compareMorphPaintOrder(a: MorphPaintOrder, b: MorphPaintOrder): number;
+export declare function orderedMorphSources<T extends MorphPaintOrder>(marks: ReadonlyArray<T>): Array<T & {
+    paintOrder: number;
+}>;

package/dist/types/components/chart/_shared/core/animation/scene3d-exit.d.ts

@@ -0,0 +1,24 @@
+export interface Scene3DExitTiming {
+    elapsed: number;
+    duration: number;
+    easing: 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
+}
+interface TweenEntry {
+    startedAt: number;
+    pausedElapsed: number;
+    paused: boolean;
+    duration: number;
+    easing: Scene3DExitTiming['easing'];
+}
+export declare function scene3DExitTiming(entry: TweenEntry | undefined, now: number): Scene3DExitTiming | undefined;
+export declare function scene3DExitFade(layer: {
+    opacity: number;
+    exitRemainingMs?: number;
+}, progress: number, timing?: Scene3DExitTiming): {
+    opacity: number;
+    exitRemainingMs?: undefined;
+} | {
+    opacity: number;
+    exitRemainingMs: number;
+};
+export {};

package/dist/types/components/chart/_shared/core/animation/stream-interp.d.ts

@@ -0,0 +1,2 @@
+export declare function lerpStreamWindow(prev: ArrayLike<number>, next: ArrayLike<number>, t: number): Float32Array;
+export declare function capStreamDuration(configuredMs: number, lastEventTime: number | undefined, now: number): number;