@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/chart/_shared/core/layout/device-pixel-box.d.ts

@@ -0,0 +1,13 @@
+export interface DevicePixelBox {
+    readonly width: number;
+    readonly height: number;
+}
+export interface DevicePixelBoxEntry {
+    readonly target: unknown;
+    readonly devicePixelContentBoxSize?: ReadonlyArray<{
+        readonly inlineSize: number;
+        readonly blockSize: number;
+    }>;
+}
+export declare function devicePixelBoxOf(entries: ReadonlyArray<DevicePixelBoxEntry>, target: unknown): DevicePixelBox | undefined;
+export declare function sameDevicePixelBox(a: DevicePixelBox | undefined, b: DevicePixelBox | undefined): boolean;

package/dist/types/components/chart/_shared/core/layout/frame.d.ts

@@ -0,0 +1,54 @@
+import { type LegendItem, type LegendItemRect, type LegendLayoutResult, type LegendPadding, type LegendRect, type LegendStyle } from './legend';
+import { type TitleLayoutResult, type TitleLayoutStyle, type TitlePadding, type TitleRect, type TitleSpec } from './title';
+import { type PlotAreaAxes, type PlotAreaAxisDescriptor, type PlotAreaAxisPlacement, type PlotAreaAxisRanges, type PlotAreaMargins, type PlotAreaPadding, type PlotAreaPrimaryRanges, type PlotAreaResult, type PlotRect } from './plot-area';
+import type { MeasureLabel, LabelMetrics } from '../axis/label-collision';
+export type { MeasureLabel, LabelMetrics };
+export interface ChartFrameTitleOptions {
+    position?: 'top' | 'bottom';
+    align?: 'start' | 'center' | 'end';
+    padding?: TitlePadding;
+    gap?: number;
+}
+export interface ChartFrameLegendInput {
+    items: LegendItem[];
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    direction?: 'horizontal' | 'vertical';
+    align?: 'start' | 'center' | 'end';
+    padding?: LegendPadding;
+    gap?: number;
+    swatchSize?: number;
+    swatchLabelGap?: number;
+    rowGap?: number;
+    wrap?: boolean;
+}
+export interface ChartFrameInput {
+    outerWidth: number;
+    outerHeight: number;
+    title?: TitleSpec | string | null;
+    subtitle?: TitleSpec | string | null;
+    titleOptions?: ChartFrameTitleOptions;
+    legend?: ChartFrameLegendInput | null;
+    axes?: PlotAreaAxes;
+    axisPadding?: PlotAreaPadding;
+    axisGap?: number;
+    measureLabel?: MeasureLabel;
+}
+export interface ChartFrameRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type ChartFrameStage = 'legend' | 'title' | 'plot';
+export interface ChartFrameMeta {
+    stages: ChartFrameStage[];
+    outer: ChartFrameRect;
+}
+export interface ChartFrameResult {
+    legend: LegendLayoutResult | null;
+    title: TitleLayoutResult | null;
+    plot: PlotAreaResult;
+    meta: ChartFrameMeta;
+}
+export type { LegendItem, LegendItemRect, LegendLayoutResult, LegendPadding, LegendRect, LegendStyle, TitleLayoutResult, TitleLayoutStyle, TitlePadding, TitleRect, TitleSpec, PlotAreaAxes, PlotAreaAxisDescriptor, PlotAreaAxisPlacement, PlotAreaAxisRanges, PlotAreaMargins, PlotAreaPadding, PlotAreaPrimaryRanges, PlotAreaResult, PlotRect, };
+export declare function computeChartFrame(input: ChartFrameInput): ChartFrameResult;

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

@@ -0,0 +1,9 @@
+export { computePlotArea, type LabelMetrics, type MeasureLabel, type PlotAreaAxes, type PlotAreaAxisDescriptor, type PlotAreaAxisPlacement, type PlotAreaAxisRanges, type PlotAreaInput, type PlotAreaMargins, type PlotAreaPadding, type PlotAreaPrimaryRanges, type PlotAreaResult, type PlotAreaSide, type PlotRect, } from './plot-area';
+export { computeTitleLayout, type TitleLayoutInput, type TitleLayoutResult, type TitleLayoutStyle, type TitleLineStyle, type TitlePadding, type TitleRect, type TitleSpec, } from './title';
+export { computeLegendLayout, type LegendFloatBoxStyle, type LegendItem, type LegendItemRect, type LegendLayoutInput, type LegendLayoutResult, type LegendPadding, type LegendRect, type LegendStyle, } from './legend';
+export { createLegendToggleState, createLegendPositionState, dragLegendBy, hitTestLegend, isLegendItemDisabled, nextFocusableItem, toggleLegendItem, type LegendHitTestInput, type LegendHitTestResult, type LegendKbState, type LegendPositionState, type LegendToggleState, } from './legend-interaction';
+export { computeChartFrame, type ChartFrameInput, type ChartFrameLegendInput, type ChartFrameMeta, type ChartFrameRect, type ChartFrameResult, type ChartFrameStage, type ChartFrameTitleOptions, } from './frame';
+export { computeCartesianFrame, isInsidePlot, type CartesianDataExtent, type CartesianFrameInput, type CartesianFrameMargins, type CartesianFrameResult, type CartesianGridLine, type CartesianRequiredTicksInput, type CartesianTickEntry, type InlineLinearScale, } from './cartesian-frame';
+export { cartesianCrosshairGeometry, cartesianHitTest, cartesianTooltipAnchor, type CartesianCrosshairGeometryInput, type CartesianCrosshairGeometryResult, type CartesianHitInput, type CartesianHitResult, type CartesianTooltipAnchorInput, type CartesianTooltipAnchorResult, } from './cartesian-frame-interaction';
+export { thinAxisTicks, thinGridLines, type ThinTicksOptions, type ThinnableGridLine, type ThinnableTick, } from './axis-label-thinning';
+export * from './device-pixel-box';

package/dist/types/components/chart/_shared/core/layout/label-geometry.d.ts

@@ -0,0 +1,19 @@
+export interface LabelGeometryPoint {
+    x: number;
+    y: number;
+}
+export interface LabelGeometryBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface LabelGeometryStroke {
+    a: LabelGeometryPoint;
+    b: LabelGeometryPoint;
+    width: number;
+}
+export declare function labelStrokeOverlapsBox(stroke: LabelGeometryStroke, box: LabelGeometryBox): boolean;
+export declare const labelBoxesOverlap: (a: LabelGeometryBox, b: LabelGeometryBox) => boolean;
+export declare function labelTriangleOverlapsBox(points: ReadonlyArray<LabelGeometryPoint>, box: LabelGeometryBox): boolean;
+export declare function labelTriangleCoordinatesOverlapBox(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, box: LabelGeometryBox): boolean;

package/dist/types/components/chart/_shared/core/layout/label-obstacle-index.d.ts

@@ -0,0 +1,35 @@
+import { type LabelGeometryBox as Box, type LabelGeometryPoint as Point, type LabelGeometryStroke as Stroke } from './label-geometry.ts';
+type Triangle = {
+    a: readonly [
+        number,
+        number
+    ];
+    b: readonly [
+        number,
+        number
+    ];
+    c: readonly [
+        number,
+        number
+    ];
+};
+export declare class LabelObstacleIndex {
+    private readonly left;
+    private readonly top;
+    private readonly columns;
+    private readonly rows;
+    private readonly cells;
+    private query;
+    private readonly cell;
+    constructor(clip: Box, cell?: number);
+    private bounds;
+    add(box: Box, triangle?: ReadonlyArray<Point>, stroke?: Stroke, test?: (box: Box) => boolean): void;
+    addTriangleMesh(triangles: ReadonlyArray<Triangle>, view: {
+        scaleX: number;
+        scaleY: number;
+        translateX: number;
+        translateY: number;
+    }, origin: Point, bounds?: Box): void;
+    overlaps(box: Box): boolean;
+}
+export {};

package/dist/types/components/chart/_shared/core/layout/legend-interaction.d.ts

@@ -0,0 +1,39 @@
+import type { LegendRect, LegendItemRect } from './legend';
+export interface LegendHitTestInput {
+    legendRect: LegendRect;
+    itemRects: ReadonlyArray<LegendItemRect>;
+    pointerX: number;
+    pointerY: number;
+    tolerance?: number;
+}
+export interface LegendHitTestResult {
+    index: number | null;
+    itemRect: LegendItemRect | null;
+}
+export interface LegendToggleState {
+    readonly disabled: ReadonlySet<number>;
+    readonly count: number;
+}
+export interface LegendKbState {
+    readonly focusedIndex: number | null;
+    readonly count: number;
+}
+export declare function hitTestLegend(input: LegendHitTestInput): LegendHitTestResult;
+export declare function createLegendToggleState(itemCount: number, initiallyDisabled?: ReadonlyArray<number>): LegendToggleState;
+export declare function toggleLegendItem(state: LegendToggleState, index: number): LegendToggleState;
+export declare function isLegendItemDisabled(state: LegendToggleState, index: number): boolean;
+export declare function nextFocusableItem(state: LegendKbState, direction: 1 | -1): LegendKbState;
+export interface LegendPositionState {
+    readonly x: number;
+    readonly y: number;
+}
+export declare function createLegendPositionState(x: number, y: number): LegendPositionState;
+export declare function dragLegendBy(state: LegendPositionState, dx: number, dy: number, bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, legendSize: {
+    width: number;
+    height: number;
+}): LegendPositionState;

package/dist/types/components/chart/_shared/core/layout/legend.d.ts

@@ -0,0 +1,81 @@
+import type { MeasureLabel, LabelMetrics } from '../axis/label-collision';
+export type { MeasureLabel, LabelMetrics };
+export declare const EST_CHAR_WIDTH_PX = 6.5;
+export declare const EST_LINE_HEIGHT_PX = 12;
+export interface LegendItem {
+    label: string;
+    swatchColor: string;
+    swatchShape?: 'square' | 'circle' | 'line';
+    disabled?: boolean;
+    seriesIndex?: number;
+    id?: string | number;
+}
+export interface LegendPadding {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export interface LegendLayoutInput {
+    outerWidth: number;
+    outerHeight: number;
+    items: LegendItem[];
+    position?: 'top' | 'bottom' | 'left' | 'right' | 'float';
+    floatAlign?: 'start' | 'center' | 'end';
+    floatVerticalAlign?: 'top' | 'middle' | 'bottom';
+    floatOffsetX?: number;
+    floatOffsetY?: number;
+    floatBackground?: string;
+    floatBorderColor?: string;
+    floatBorderWidth?: number;
+    floatBorderRadius?: number;
+    floatBoxShadow?: string;
+    direction?: 'horizontal' | 'vertical';
+    align?: 'start' | 'center' | 'end';
+    gap?: number;
+    swatchSize?: number;
+    swatchLabelGap?: number;
+    padding?: LegendPadding;
+    rowGap?: number;
+    wrap?: boolean;
+    measureLabel?: MeasureLabel;
+    fontSize?: number;
+    fontWeight?: 'normal' | 'bold' | number;
+    fontFamily?: string;
+    color?: string;
+}
+export interface LegendRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface LegendItemRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    swatchRect: LegendRect;
+    labelRect: LegendRect;
+}
+export interface LegendStyle {
+    fontSize: string;
+    fontWeight: string | number;
+    fontFamily: string;
+    color: string;
+}
+export interface LegendFloatBoxStyle {
+    background: string;
+    borderColor: string;
+    borderWidth: number;
+    borderRadius: number;
+    boxShadow: string;
+}
+export interface LegendLayoutResult {
+    legendRect: LegendRect | null;
+    itemRects: LegendItemRect[];
+    remainingOuter: LegendRect;
+    style: LegendStyle;
+    floatBoxStyle?: LegendFloatBoxStyle;
+}
+export declare function computeLegendLayout(input: LegendLayoutInput): LegendLayoutResult;

package/dist/types/components/chart/_shared/core/layout/plot-area.d.ts

@@ -0,0 +1,83 @@
+import type { MeasureLabel, LabelMetrics } from '../axis/label-collision';
+export type { MeasureLabel, LabelMetrics };
+export declare const EST_CHAR_WIDTH_PX = 6.5;
+export declare const EST_LINE_HEIGHT_PX = 12;
+export interface PlotAreaAxisDescriptor {
+    labels: ReadonlyArray<string>;
+    tickSize?: number;
+    lineWidth?: number;
+    labelRotation?: 0 | 45 | 90;
+    labelPadding?: number;
+    titleHeight?: number;
+}
+export type PlotAreaSide = PlotAreaAxisDescriptor | ReadonlyArray<PlotAreaAxisDescriptor | null | undefined> | null | undefined;
+export interface PlotAreaAxes {
+    top?: PlotAreaSide;
+    right?: PlotAreaSide;
+    bottom?: PlotAreaSide;
+    left?: PlotAreaSide;
+}
+export interface PlotAreaPadding {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export interface PlotAreaInput {
+    outerWidth: number;
+    outerHeight: number;
+    axes: PlotAreaAxes;
+    padding?: PlotAreaPadding;
+    axisGap?: number;
+    measureLabel?: MeasureLabel;
+}
+export interface PlotRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface PlotAreaMargins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface PlotAreaAxisPlacement {
+    range: [
+        number,
+        number
+    ];
+    crossOffset: number;
+}
+export interface PlotAreaAxisRanges {
+    top?: PlotAreaAxisPlacement[];
+    right?: PlotAreaAxisPlacement[];
+    bottom?: PlotAreaAxisPlacement[];
+    left?: PlotAreaAxisPlacement[];
+}
+export interface PlotAreaPrimaryRanges {
+    top?: [
+        number,
+        number
+    ];
+    right?: [
+        number,
+        number
+    ];
+    bottom?: [
+        number,
+        number
+    ];
+    left?: [
+        number,
+        number
+    ];
+}
+export interface PlotAreaResult {
+    plot: PlotRect;
+    margins: PlotAreaMargins;
+    axisRanges: PlotAreaAxisRanges;
+    primaryRanges: PlotAreaPrimaryRanges;
+}
+export declare function computePlotArea(input: PlotAreaInput): PlotAreaResult;

package/dist/types/components/chart/_shared/core/layout/title.d.ts

@@ -0,0 +1,55 @@
+import type { MeasureLabel, LabelMetrics } from '../axis/label-collision';
+export type { MeasureLabel, LabelMetrics };
+export declare const EST_CHAR_WIDTH_PX = 6.5;
+export declare const EST_LINE_HEIGHT_PX = 12;
+export interface TitleSpec {
+    text: string;
+    fontSize?: number;
+    fontWeight?: 'normal' | 'bold' | number;
+    fontFamily?: string;
+    color?: string;
+    paddingY?: number;
+}
+export interface TitlePadding {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export interface TitleLayoutInput {
+    outerWidth: number;
+    outerHeight: number;
+    title?: TitleSpec | string | null;
+    subtitle?: TitleSpec | string | null;
+    gap?: number;
+    padding?: TitlePadding;
+    position?: 'top' | 'bottom';
+    align?: 'start' | 'center' | 'end';
+    measureLabel?: MeasureLabel;
+}
+export interface TitleRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface TitleLineStyle {
+    fontSize: string;
+    fontWeight: string | number;
+    fontFamily: string;
+    color: string;
+    textAlign: 'left' | 'center' | 'right';
+    paddingY: number;
+}
+export interface TitleLayoutStyle {
+    title?: TitleLineStyle;
+    subtitle?: TitleLineStyle;
+}
+export interface TitleLayoutResult {
+    stripRect: TitleRect | null;
+    titleRect: TitleRect | null;
+    subtitleRect: TitleRect | null;
+    remainingOuter: TitleRect;
+    style: TitleLayoutStyle;
+}
+export declare function computeTitleLayout(input: TitleLayoutInput): TitleLayoutResult;

package/dist/types/components/chart/_shared/core/license/chart-license-bridge.d.ts

@@ -0,0 +1,46 @@
+import type { LicenseDiagnosticCode, SyidaxLicenseError } from '../../../../../license/errors';
+import type { Entitlement, EntitlementCode, EntitlementState, LicenseChangeListener, LicenseContext } from '../../../../../license/types';
+import type { ChartLicenseFeature } from './chart-license-features';
+export type ChartEntitlementState = EntitlementState | 'load-failed';
+export type ChartEntitlementCode = EntitlementCode | 'load-failed';
+export interface ChartEntitlement {
+    readonly product: 'chart';
+    readonly feature: ChartLicenseFeature;
+    readonly state: ChartEntitlementState;
+    readonly code: ChartEntitlementCode;
+    readonly allowed: boolean;
+}
+export interface ChartLicenseChange {
+    readonly feature: ChartLicenseFeature;
+    readonly state: ChartEntitlementState;
+    readonly previousState: ChartEntitlementState;
+}
+export type ChartLicenseListener = (change: ChartLicenseChange) => void;
+export interface ChartLicenseRuntimeApi {
+    resolveLicenseContext(element: Element): LicenseContext;
+    getEntitlement(context: LicenseContext, product: 'chart', feature?: string): Entitlement;
+    whenLicenseSettled(context: LicenseContext): Promise<void>;
+    onLicenseChange(listener: LicenseChangeListener, options?: {
+        readonly context?: LicenseContext;
+    }): () => void;
+}
+export type ChartLicenseRuntimeState = 'idle' | 'loading' | 'loaded' | 'load-failed';
+export interface EnsureChartEntitlementOptions {
+    readonly timeoutMs?: number;
+}
+export interface ChartRefusalOptions {
+    readonly tag?: string;
+    readonly method?: string;
+    readonly code?: LicenseDiagnosticCode;
+    readonly reason?: unknown;
+}
+export declare function toLicenseEntitlementState(state: ChartEntitlementState): EntitlementState;
+export declare function licenseDiagnosticCodeOf(state: ChartEntitlementState): LicenseDiagnosticCode | undefined;
+export declare function getChartLicenseRuntimeState(): ChartLicenseRuntimeState;
+export declare function retryChartLicenseRuntime(): Promise<boolean>;
+export declare function entitlementFor(el: Element, feature: ChartLicenseFeature): ChartEntitlement;
+export declare function ensureEntitlement(el: Element, feature: ChartLicenseFeature, options?: EnsureChartEntitlementOptions): Promise<ChartEntitlement>;
+export declare function subscribe(el: Element, listener: ChartLicenseListener): () => void;
+export declare function refuseChartFeature(el: Element | null | undefined, entitlement: Pick<ChartEntitlement, 'feature' | 'state'>, options?: ChartRefusalOptions): SyidaxLicenseError;
+export declare function reflectLicenseState(el: Element | null | undefined, feature: ChartLicenseFeature | null, state: ChartEntitlementState | 'module-missing' | null): void;
+export declare function setLicenseFrozen(el: Element | null | undefined, frozen: boolean): void;

package/dist/types/components/chart/_shared/core/license/chart-license-features.d.ts

@@ -0,0 +1,13 @@
+import { CHART_FEATURES } from '../../../../../license/generated/chart-features.generated.ts';
+export type ChartCommonFeatureId = keyof typeof CHART_FEATURES;
+export declare const CHART_FEATURE: Readonly<{
+    webgpu: 'chart.webgpu' & ChartCommonFeatureId;
+    streaming: 'chart.streaming' & ChartCommonFeatureId;
+    stock: 'chart.stock' & ChartCommonFeatureId;
+    branding: 'chart.branding' & ChartCommonFeatureId;
+}>;
+export type ChartCommonProFeature = (typeof CHART_FEATURE)[keyof typeof CHART_FEATURE];
+export type ChartTypeFeatureId = `chart.type.${string}`;
+export type ChartLicenseFeature = ChartCommonProFeature | ChartTypeFeatureId;
+export declare function chartTypeFeatureId(type: string): ChartTypeFeatureId;
+export declare function isChartLicenseFeature(value: unknown): value is ChartLicenseFeature;

package/dist/types/components/chart/_shared/core/license/chart-license-notice.d.ts

@@ -0,0 +1,24 @@
+import type { ChartEntitlementState } from './chart-license-bridge';
+export declare const CHART_LICENSE_NOTICE_CLASS = "sy-chart-license-notice";
+export declare const CHART_LICENSE_FROZEN_CLASS = "sy-chart-license-frozen";
+export type ChartLicenseNoticeState = ChartEntitlementState | 'module-missing';
+export type ChartLicenseNoticeKind = 'pending' | 'required' | 'expired' | 'not-yet-valid' | 'not-accepted' | 'unsupported-environment' | 'load-failed' | 'module-missing';
+export interface ChartLicenseNotice {
+    readonly kind: ChartLicenseNoticeKind;
+    readonly title: string;
+    readonly body: string;
+    readonly role: 'status';
+    readonly busy: boolean;
+    readonly attrs: {
+        readonly 'data-license-state': ChartLicenseNoticeState;
+        readonly 'data-license-feature': string;
+    };
+}
+export interface ChartLicenseNoticeInput {
+    readonly state: ChartLicenseNoticeState;
+    readonly feature: string;
+    readonly type: string;
+    readonly tag?: string;
+}
+export declare const CHART_LICENSE_FROZEN_TEXT = "Chart Pro license expired: updates paused";
+export declare function chartLicenseNotice(input: ChartLicenseNoticeInput): ChartLicenseNotice | null;

package/dist/types/components/chart/_shared/core/limits/point-cap.d.ts

@@ -0,0 +1,9 @@
+export declare const STANDARD_ENGINE_MAX_POINTS = 100000000;
+export declare const CHUNK_STAGING_MAX_BYTES = 268435456;
+export declare function capPointCount(total: number, ...limits: ReadonlyArray<number | undefined>): number;
+export declare function formatPointCapWarning(tag: string, total: number, max: number, reason?: string): string;
+export type PointCapWarner = (tag: string, total: number, max: number, reason?: string) => void;
+export declare function createPointCapWarner(log?: (message: string) => void): PointCapWarner;
+export declare function capValuesView<T extends {
+    readonly length: number;
+}>(values: T, max: number): T;

package/dist/types/components/chart/_shared/core/loading/chart-build-tier.d.ts

@@ -0,0 +1 @@
+export declare const CHART_BUILD_TIER: 'community' | 'pro' | undefined;

package/dist/types/components/chart/_shared/core/loading/chart-element-loader.d.ts

@@ -0,0 +1,51 @@
+import type { ChartTypeName } from './chart-type-table';
+import type { ChartEntitlementState } from '../license/chart-license-bridge';
+export type ChartLoadStatus = 'idle' | 'license-pending' | 'loading' | 'ready' | 'license-required' | 'module-missing' | 'out-of-scope' | 'load-failed' | 'unknown-type' | 'unsupported-environment';
+export type ChartBuildTier = 'community' | 'pro';
+export interface ChartTypeLoadDetail {
+    readonly type: string;
+    readonly tag?: string;
+    readonly status: ChartLoadStatus;
+    readonly entitlement?: ChartEntitlementState;
+    readonly reason?: string;
+    readonly attempt: number;
+    readonly repeatedFailure?: true;
+}
+export interface ChartBuildInventory {
+    readonly tier: ChartBuildTier;
+    readonly types: readonly string[];
+}
+export interface ChartTypeModule {
+    readonly type: ChartTypeName;
+    readonly tags: readonly string[];
+    readonly load: () => Promise<unknown>;
+    readonly build?: ChartBuildInventory;
+}
+export interface RegisterChartTypesOptions {
+    readonly replace?: boolean;
+}
+export type ChartElementRegistry = Pick<CustomElementRegistry, 'get'>;
+export interface PeekChartTypeOptions {
+    readonly host?: Element;
+    readonly registry?: ChartElementRegistry;
+    readonly buildTier?: ChartBuildTier;
+    readonly attempt?: number;
+}
+export interface EnsureChartTypeOptions extends PeekChartTypeOptions {
+    readonly signal?: AbortSignal;
+    readonly settleTimeoutMs?: number;
+    readonly onProgress?: (detail: ChartTypeLoadDetail) => void;
+}
+export declare class ChartLoadError extends Error {
+    readonly code: ChartLoadStatus;
+    readonly detail: ChartTypeLoadDetail;
+    constructor(detail: ChartTypeLoadDetail, options?: {
+        readonly cause?: unknown;
+    });
+}
+export declare function isChartLoadError(value: unknown): value is ChartLoadError;
+export declare function registerChartTypes(modules: Iterable<ChartTypeModule>, options?: RegisterChartTypesOptions): void;
+export declare function hasChartTypeLoader(type: string): boolean;
+export declare function onChartTypesRegistered(listener: () => void): () => void;
+export declare function peekChartType(type: string, options?: PeekChartTypeOptions): ChartTypeLoadDetail;
+export declare function ensureChartType(type: string, options?: EnsureChartTypeOptions): Promise<ChartTypeLoadDetail>;

package/dist/types/components/chart/_shared/core/loading/chart-load-controller.d.ts

@@ -0,0 +1,51 @@
+import type { ChartBuildTier, ChartElementRegistry, ChartTypeLoadDetail, EnsureChartTypeOptions } from './chart-element-loader';
+export type ChartLoadRegistry = ChartElementRegistry & Partial<Pick<CustomElementRegistry, 'whenDefined'>>;
+export interface ChartLoadPageVisibility {
+    readonly hidden: boolean;
+    addEventListener(type: 'visibilitychange', listener: () => void): void;
+    removeEventListener(type: 'visibilitychange', listener: () => void): void;
+}
+export interface ChartLoadControllerOptions {
+    readonly host: () => HTMLElement | undefined;
+    readonly onChange: (detail: ChartTypeLoadDetail) => void;
+    readonly ensure?: (type: string, options?: EnsureChartTypeOptions) => Promise<ChartTypeLoadDetail>;
+    readonly timeoutMs?: () => number;
+    readonly registry?: () => ChartLoadRegistry | undefined;
+    readonly buildTier?: () => ChartBuildTier | undefined;
+    readonly page?: () => ChartLoadPageVisibility | undefined;
+}
+export declare class ChartLoadController {
+    private readonly options;
+    private current;
+    private requestedType;
+    private attempt;
+    private seq;
+    private inflight;
+    private disposed;
+    private abort;
+    private watchers;
+    private settleWaiters;
+    private child;
+    private stopChildBudget;
+    private childToken;
+    private lastFailure;
+    constructor(options: ChartLoadControllerOptions);
+    get detail(): ChartTypeLoadDetail;
+    request(type: string): ChartTypeLoadDetail;
+    retry(): void;
+    dispose(): void;
+    whenSettled(): Promise<ChartTypeLoadDetail>;
+    attachChild(el: HTMLElement | undefined | null): void;
+    private run;
+    private finish;
+    private set;
+    private rerun;
+    private watchLicense;
+    private watchAvailability;
+    private cancelWork;
+    private flushSettled;
+    private clearChildTimer;
+    private pageVisibility;
+    private startChildBudget;
+    private detachChild;
+}

package/dist/types/components/chart/_shared/core/loading/chart-type-rows.d.ts

@@ -0,0 +1 @@
+export declare const CHART_TYPE_ROWS = "area ~ fs,bar ~ fs,bar-3d = pp,box-plot ~ pp,bubble ~ fs,calendar-heatmap = pp,candlestick ~ pp,chord = pp,column ~ fs,dendrogram = pp,density-map = pp,dot-plot ~ fo,dumbbell ~ fo,error-bar ~ pp,flow-lines = pp geo-map,funnel ~ fo,gantt ~ pp,gauge ~ fo,geo-map = pp,heatmap = pp,histogram ~ fs,icicle = pp,item ~ fo,line ~ fs,lollipop ~ fo,marimekko ~ fo,network-graph = pp,ohlc ~ pp candlestick,parallel-coordinates = pp,pareto ~ fo,pictorial ~ fo,pie ~ fo,polar ~ fs,pyramid sy-funnel-chart fo funnel,radar ~ fo,sankey = pp,scatter ~ fs,scatter-3d = pp,spectrogram = pp,stem-leaf ~ fo,sunburst = pp,surface-3d = pp,theme-river = pp,tilemap = fo,tornado ~ fo,treemap = pp,variwide ~ fo,wafer-map = fo,waterfall ~ pp,word-cloud = fo";

package/dist/types/components/chart/_shared/core/loading/chart-type-table.d.ts

@@ -0,0 +1,33 @@
+import type { CHART_TYPES } from '../../../../../license/generated/chart-features.generated.ts';
+import type { ChartEngineClass } from '../engine/types';
+import { CHART_FEATURE } from '../license/chart-license-features';
+import type { ChartTypeFeatureId } from '../license/chart-license-features';
+export type ChartTypeName = keyof typeof CHART_TYPES;
+export type ChartElementTag = (typeof CHART_TYPES)[ChartTypeName]['tag'];
+export type ChartTypeTier = 'free' | 'pro';
+export type ChartGpuFailure = 'standard-fallback' | 'unavailable' | 'no-gpu-path';
+export interface ChartTypeInfo {
+    readonly type: ChartTypeName;
+    readonly tag: ChartElementTag;
+    readonly requires: readonly string[];
+    readonly tier: ChartTypeTier;
+    readonly feature: ChartTypeFeatureId;
+    readonly licenseFeature: ChartTypeFeatureId | null;
+    readonly requiredFeatures: readonly string[];
+    readonly engineClass: ChartEngineClass;
+    readonly standardRenderer: boolean;
+    readonly webgpuRenderer: boolean;
+    readonly gpuFailure: ChartGpuFailure;
+}
+type PascalTag<S extends string> = S extends `${infer Head}-${infer Tail}` ? `${Capitalize<Head>}${PascalTag<Tail>}` : Capitalize<S>;
+export type ChartElMap = {
+    readonly [Tag in ChartElementTag as PascalTag<Tag>]: Tag;
+};
+export declare function pascalTagName(tag: string): string;
+export declare const CHART_TYPE_TABLE: Readonly<Record<ChartTypeName, ChartTypeInfo>>;
+export declare const CHART_TYPE_NAMES: readonly ChartTypeName[];
+export declare const ChartEl: ChartElMap;
+export declare function isChartTypeName(value: unknown): value is ChartTypeName;
+export declare function chartTypeInfo(type: unknown): ChartTypeInfo | undefined;
+export declare function chartEngineLicenseFeature(type: unknown): ChartTypeFeatureId | typeof CHART_FEATURE.webgpu | null;
+export {};

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

@@ -0,0 +1,6 @@
+export { CHART_TYPE_NAMES, CHART_TYPE_TABLE, ChartEl, chartEngineLicenseFeature, chartTypeInfo, isChartTypeName, pascalTagName } from './chart-type-table';
+export type { ChartElMap, ChartElementTag, ChartGpuFailure, ChartTypeInfo, ChartTypeName, ChartTypeTier } from './chart-type-table';
+export { ChartLoadError, ensureChartType, hasChartTypeLoader, isChartLoadError, onChartTypesRegistered, peekChartType, registerChartTypes, } from './chart-element-loader';
+export type { ChartBuildInventory, ChartBuildTier, ChartElementRegistry, ChartLoadStatus, ChartTypeLoadDetail, ChartTypeModule, EnsureChartTypeOptions, PeekChartTypeOptions, RegisterChartTypesOptions, } from './chart-element-loader';
+export { ChartLoadController } from './chart-load-controller';
+export type { ChartLoadControllerOptions, ChartLoadPageVisibility, ChartLoadRegistry } from './chart-load-controller';

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

@@ -0,0 +1 @@
+export * from './locale';