@ds-mo/ui 13.6.0 → 13.7.0

package/dist/types/utils/chart-grammar.d.ts

@@ -0,0 +1,360 @@
+import type { CurveFactory } from 'd3-shape';
+export type ChartValue = string | number | Date;
+export type ChartKey = string | number;
+export type ChartDataIntent = 'brand' | 'caution' | 'negative' | 'neutral' | 'positive' | 'warning';
+export type ChartChannel<TDatum, TValue> = Extract<keyof TDatum, string> | ((datum: TDatum, index: number, data: readonly TDatum[]) => TValue);
+export type ChartVisual<TDatum, TValue> = TValue | ((datum: TDatum, index: number, data: readonly TDatum[]) => TValue);
+/** Structural boundary accepted by the chart compiler for native D3 scales. */
+export type ChartScale = ((value: ChartValue) => unknown) & {
+    copy?: () => ChartScale;
+    domain: (...values: unknown[]) => unknown;
+    range: (...values: unknown[]) => unknown;
+    bandwidth?: () => number;
+    ticks?: (count?: number) => ChartValue[];
+    tickFormat?: (count?: number) => (value: ChartValue) => string;
+    nice?: (count?: number) => unknown;
+};
+/** A configured D3 scale or a zero-argument D3 scale factory. */
+export type ChartScaleSource = ChartScale | (() => unknown);
+export interface ChartTickOptions {
+    count?: number;
+    values?: readonly ChartValue[];
+    format?: (value: ChartValue, locale: string) => string;
+    /** Minimum measured gap between adjacent tick labels, in CSS pixels. */
+    spacing?: number;
+    /** Length of the tick stub extending away from the plot, in CSS pixels. */
+    size?: number;
+    /** Gap between the end of a tick stub and its label, in CSS pixels. */
+    padding?: number;
+    /** Rotation in degrees. Negative values rotate counter-clockwise. */
+    rotate?: number;
+}
+export interface ChartAxisPresentation {
+    label?: string;
+    /** Render the axis baseline. Defaults to true. */
+    line?: boolean;
+    ticks?: ChartTickOptions;
+}
+export interface ChartAxisOptions {
+    scale: ChartScaleSource;
+    nice?: boolean;
+    grid?: boolean;
+    axis?: false | ChartAxisPresentation;
+}
+export interface ChartMargin {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export type ChartFocusMode = 'none' | 'nearest' | 'nearest-x' | 'nearest-y' | 'group-x' | 'group-y';
+export interface ChartPoint<TDatum = unknown> {
+    key: ChartKey;
+    sceneKey: string;
+    markId: string;
+    datum: TDatum;
+    datumIndex: number;
+    groupValue?: ChartValue;
+    groupLabel?: string;
+    xValue: ChartValue;
+    yValue: ChartValue;
+    /** Primary semantic value for polar, heatmap, and distribution marks. */
+    value?: ChartValue;
+    angleValue?: ChartValue;
+    radiusValue?: ChartValue;
+    x: number;
+    y: number;
+    color: string;
+}
+export interface ChartTooltipItem {
+    label: string;
+    value: string;
+    color?: string;
+}
+export interface ChartTooltipContext<TDatum = unknown> {
+    locale: string;
+    primary: ChartPoint<TDatum>;
+    points: readonly ChartPoint<TDatum>[];
+}
+export interface ChartTooltipOptions<TDatum = unknown> {
+    format?: (point: ChartPoint<TDatum>, locale: string) => string;
+    formatGroupHeading?: (points: readonly ChartPoint<TDatum>[], locale: string) => string;
+    formatGroupItem?: (point: ChartPoint<TDatum>, locale: string) => ChartTooltipItem;
+}
+export type ChartTooltip<TDatum = unknown> = boolean | ChartTooltipOptions<TDatum>;
+export interface ChartColorOptions {
+    domain?: readonly ChartValue[];
+    range?: readonly string[];
+}
+export interface ChartBuildContext {
+    width: number;
+    height: number;
+}
+export interface ChartCartesianCoordinate {
+    type?: 'cartesian';
+}
+export interface ChartPolarCoordinate {
+    type: 'polar';
+    /** Radians measured clockwise from twelve o'clock. */
+    startAngle?: number;
+    /** Radians measured clockwise from twelve o'clock. */
+    endAngle?: number;
+    /** Default inner radius as a fraction of the available radius. */
+    innerRadius?: number;
+    /** Outer radius as a fraction of the available radius. */
+    outerRadius?: number;
+    grid?: 'none' | 'polygon';
+}
+export type ChartCoordinate = ChartCartesianCoordinate | ChartPolarCoordinate;
+export interface ChartPolarAxisOptions {
+    domain?: readonly ChartValue[];
+    label?: string;
+    ticks?: ChartTickOptions;
+    grid?: boolean;
+}
+export interface ChartCenterContent {
+    value?: string;
+    caption?: string;
+}
+export interface ChartCenterOptions extends ChartCenterContent {
+    /** Optional focused content. Authored content remains the default. */
+    focused?: (point: ChartPoint, locale: string) => ChartCenterContent;
+}
+export type ChartMarkKind = 'polar' | 'line-y' | 'area-y' | 'bar-x' | 'bar-y' | 'box-y' | 'dot' | 'rule-x' | 'rule-y' | 'band-x' | 'band-y' | 'rect' | 'cell' | 'text' | 'arc' | 'radial-line' | 'radial-area' | 'radial-dot';
+export interface ChartMark<TDatum = unknown> {
+    kind: ChartMarkKind;
+    data: readonly TDatum[];
+    options: ChartMarkOptions<TDatum>;
+}
+export interface ChartPolarContainerOptions {
+    id?: string;
+    marks: readonly ChartMark[];
+    angle?: ChartPolarAxisOptions;
+    radius?: ChartAxisOptions;
+    /** Radians measured clockwise from twelve o'clock. */
+    startAngle?: number;
+    /** Radians measured clockwise from twelve o'clock. */
+    endAngle?: number;
+    innerRadius?: number;
+    outerRadius?: number;
+    grid?: 'none' | 'polygon';
+    center?: ChartCenterOptions;
+}
+export interface ChartBaseMarkOptions<TDatum> {
+    id?: string;
+    /** Exclude decorative layers from semantic focus while retaining rendering. */
+    interactive?: boolean;
+    key?: ChartChannel<TDatum, ChartKey>;
+    z?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    color?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    value?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    fill?: ChartVisual<TDatum, string>;
+    stroke?: ChartVisual<TDatum, string>;
+    opacity?: ChartVisual<TDatum, number>;
+    fillOpacity?: ChartVisual<TDatum, number>;
+    strokeOpacity?: ChartVisual<TDatum, number>;
+    strokeWidth?: ChartVisual<TDatum, number | string>;
+    strokeDasharray?: ChartVisual<TDatum, string>;
+}
+export interface ChartLineYOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    y?: ChartChannel<TDatum, number | null | undefined>;
+    curve?: CurveFactory;
+}
+export interface ChartAreaYOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    y?: ChartChannel<TDatum, number | null | undefined>;
+    y1?: ChartChannel<TDatum, number | null | undefined>;
+    y2?: ChartChannel<TDatum, number | null | undefined>;
+    curve?: CurveFactory;
+}
+export type ChartBarLayout = 'single' | 'grouped' | 'stacked';
+export interface ChartBarOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    y?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    x1?: ChartChannel<TDatum, number | null | undefined>;
+    x2?: ChartChannel<TDatum, number | null | undefined>;
+    y1?: ChartChannel<TDatum, number | null | undefined>;
+    y2?: ChartChannel<TDatum, number | null | undefined>;
+    layout?: ChartBarLayout;
+    inset?: ChartVisual<TDatum, number>;
+    radius?: ChartVisual<TDatum, number | string>;
+}
+export interface ChartBoxYOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    y?: ChartChannel<TDatum, number | null | undefined>;
+    /** Tukey whisker multiplier. */
+    whisker?: number;
+    inset?: number;
+    radius?: number | string;
+}
+export interface ChartDotOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    y?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    r?: ChartVisual<TDatum, number | string>;
+}
+export interface ChartRuleOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    y?: ChartChannel<TDatum, ChartValue | null | undefined>;
+}
+export interface ChartBandOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x1?: ChartChannel<TDatum, number | null | undefined>;
+    x2?: ChartChannel<TDatum, number | null | undefined>;
+    y1?: ChartChannel<TDatum, number | null | undefined>;
+    y2?: ChartChannel<TDatum, number | null | undefined>;
+}
+export interface ChartRectOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x1?: ChartChannel<TDatum, number | null | undefined>;
+    x2?: ChartChannel<TDatum, number | null | undefined>;
+    y1?: ChartChannel<TDatum, number | null | undefined>;
+    y2?: ChartChannel<TDatum, number | null | undefined>;
+    radius?: ChartVisual<TDatum, number | string>;
+    inset?: ChartVisual<TDatum, number>;
+}
+export interface ChartCellOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    y?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    intensity?: ChartChannel<TDatum, number | null | undefined>;
+    intent?: ChartDataIntent;
+    minimumOpacity?: number;
+    maximumOpacity?: number;
+    inset?: number;
+    radius?: number | string;
+}
+export interface ChartTextOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    x?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    y?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    text?: ChartChannel<TDatum, string | number | null | undefined>;
+    fontFamily?: ChartVisual<TDatum, string>;
+    fontSize?: ChartVisual<TDatum, number | string>;
+    fontWeight?: ChartVisual<TDatum, number | string>;
+    textAnchor?: ChartVisual<TDatum, 'start' | 'middle' | 'end'>;
+    dx?: ChartVisual<TDatum, number>;
+    dy?: ChartVisual<TDatum, number>;
+}
+export interface ChartArcOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    theta1?: ChartChannel<TDatum, number | null | undefined>;
+    theta2?: ChartChannel<TDatum, number | null | undefined>;
+    innerRadius?: ChartVisual<TDatum, number>;
+    outerRadius?: ChartVisual<TDatum, number>;
+    cornerRadius?: ChartVisual<TDatum, number>;
+    padAngle?: ChartVisual<TDatum, number>;
+    label?: ChartChannel<TDatum, string | null | undefined>;
+}
+export interface ChartRadialOptions<TDatum> extends ChartBaseMarkOptions<TDatum> {
+    angle?: ChartChannel<TDatum, ChartValue | null | undefined>;
+    radius?: ChartChannel<TDatum, number | null | undefined>;
+    radius1?: ChartChannel<TDatum, number | null | undefined>;
+    radius2?: ChartChannel<TDatum, number | null | undefined>;
+    curve?: CurveFactory;
+    r?: ChartVisual<TDatum, number | string>;
+}
+export type ChartMarkOptions<TDatum> = ChartLineYOptions<TDatum> | ChartAreaYOptions<TDatum> | ChartBarOptions<TDatum> | ChartBoxYOptions<TDatum> | ChartDotOptions<TDatum> | ChartRuleOptions<TDatum> | ChartBandOptions<TDatum> | ChartRectOptions<TDatum> | ChartCellOptions<TDatum> | ChartTextOptions<TDatum> | ChartArcOptions<TDatum> | ChartRadialOptions<TDatum>;
+export interface ChartSpec<TDatum = unknown> {
+    marks: readonly ChartMark<TDatum>[] | readonly ChartMark<unknown>[];
+    coordinate?: ChartCoordinate;
+    x?: ChartAxisOptions;
+    y?: ChartAxisOptions;
+    angle?: ChartPolarAxisOptions;
+    radius?: ChartAxisOptions;
+    center?: ChartCenterOptions;
+    margin?: number | ChartMargin;
+    guides?: boolean;
+    /** Clip graphical marks to the solved plot rectangle. Defaults to true. */
+    clip?: boolean;
+    color?: ChartColorOptions;
+    focus?: ChartFocusMode;
+    tooltip?: ChartTooltip<TDatum>;
+    maxFocusDistance?: number;
+}
+export type ChartSpecBuilder<TDatum = unknown> = (context: ChartBuildContext) => ChartSpec<TDatum>;
+export interface ChartDefinition<TDatum = unknown> {
+    chart: ChartSpec<TDatum> | ChartSpecBuilder<TDatum>;
+}
+export interface NormalizedStackDatum<TDatum> {
+    data: TDatum;
+    group: ChartKey;
+    series: ChartKey;
+    value: number;
+    proportion: number;
+}
+export interface NormalizeStackOptions<TDatum> {
+    group: ChartChannel<TDatum, ChartKey>;
+    series: ChartChannel<TDatum, ChartKey>;
+    value: ChartChannel<TDatum, number>;
+}
+export interface ChartPieDatum<TDatum> {
+    data: TDatum;
+    index: number;
+    key: ChartKey;
+    label: string;
+    value: number;
+    theta1: number;
+    theta2: number;
+}
+export interface ChartPieOptions<TDatum> {
+    value: ChartChannel<TDatum, number>;
+    key?: ChartChannel<TDatum, ChartKey>;
+    label?: ChartChannel<TDatum, string>;
+    sort?: (a: TDatum, b: TDatum) => number;
+}
+export interface ChartBinDatum<TDatum> {
+    key: string;
+    x1: number;
+    x2: number;
+    x: number;
+    count: number;
+    cumulative: number;
+    rows: readonly TDatum[];
+}
+export interface ChartBinOptions<TDatum> {
+    value: ChartChannel<TDatum, number>;
+    thresholds?: number | readonly number[];
+}
+export interface ChartDensityDatum {
+    key: string;
+    x: number;
+    density: number;
+}
+export interface ChartDensityOptions<TDatum> {
+    value: ChartChannel<TDatum, number>;
+    samples?: number;
+    bandwidth?: number;
+}
+export declare function defineChart<TDatum>(chart: ChartSpec<TDatum> | ChartSpecBuilder<TDatum>): ChartDefinition<TDatum>;
+/** Compose polar marks and guides inside the shared chart scene. */
+export declare function polar(options: ChartPolarContainerOptions): ChartMark;
+export declare function lineY<TDatum>(data: readonly TDatum[], options?: ChartLineYOptions<TDatum>): ChartMark<TDatum>;
+export declare function areaY<TDatum>(data: readonly TDatum[], options?: ChartAreaYOptions<TDatum>): ChartMark<TDatum>;
+export declare function barY<TDatum>(data: readonly TDatum[], options?: ChartBarOptions<TDatum>): ChartMark<TDatum>;
+export declare function barX<TDatum>(data: readonly TDatum[], options?: ChartBarOptions<TDatum>): ChartMark<TDatum>;
+export declare function boxY<TDatum>(data: readonly TDatum[], options?: ChartBoxYOptions<TDatum>): ChartMark<TDatum>;
+export declare function dot<TDatum>(data: readonly TDatum[], options?: ChartDotOptions<TDatum>): ChartMark<TDatum>;
+export declare function ruleX<TDatum>(data: readonly TDatum[], options?: ChartRuleOptions<TDatum>): ChartMark<TDatum>;
+export declare function ruleY<TDatum>(data: readonly TDatum[], options?: ChartRuleOptions<TDatum>): ChartMark<TDatum>;
+export declare function bandX<TDatum>(data: readonly TDatum[], options: ChartBandOptions<TDatum>): ChartMark<TDatum>;
+export declare function bandY<TDatum>(data: readonly TDatum[], options: ChartBandOptions<TDatum>): ChartMark<TDatum>;
+export declare function rect<TDatum>(data: readonly TDatum[], options: ChartRectOptions<TDatum>): ChartMark<TDatum>;
+export declare function cell<TDatum>(data: readonly TDatum[], options: ChartCellOptions<TDatum>): ChartMark<TDatum>;
+export declare function textMark<TDatum>(data: readonly TDatum[], options?: ChartTextOptions<TDatum>): ChartMark<TDatum>;
+export declare function arcMark<TDatum>(data: readonly TDatum[], options?: ChartArcOptions<TDatum>): ChartMark<TDatum>;
+export declare function radialLine<TDatum>(data: readonly TDatum[], options?: ChartRadialOptions<TDatum>): ChartMark<TDatum>;
+export declare function radialArea<TDatum>(data: readonly TDatum[], options?: ChartRadialOptions<TDatum>): ChartMark<TDatum>;
+export declare function radialDot<TDatum>(data: readonly TDatum[], options?: ChartRadialOptions<TDatum>): ChartMark<TDatum>;
+export declare function channelValue<TDatum, TValue>(datum: TDatum, index: number, data: readonly TDatum[], channel: ChartChannel<TDatum, TValue> | undefined): TValue | undefined;
+export declare function visualValue<TDatum, TValue>(datum: TDatum, index: number, data: readonly TDatum[], value: ChartVisual<TDatum, TValue> | undefined, fallback: TValue): TValue;
+export declare function normalizeStack<TDatum>(data: readonly TDatum[], options: NormalizeStackOptions<TDatum>): NormalizedStackDatum<TDatum>[];
+export declare function pieLayout<TDatum>(data: readonly TDatum[], options: ChartPieOptions<TDatum>): ChartPieDatum<TDatum>[];
+export declare function binX<TDatum>(data: readonly TDatum[], options: ChartBinOptions<TDatum>): ChartBinDatum<TDatum>[];
+export declare function cumulativeBins<TDatum>(bins: readonly ChartBinDatum<TDatum>[]): ChartBinDatum<TDatum>[];
+export declare function densityX<TDatum>(data: readonly TDatum[], options: ChartDensityOptions<TDatum>): ChartDensityDatum[];
+export declare function boxStatistics(values: readonly number[], whisker?: number): {
+    q1: number;
+    median: number;
+    q3: number;
+    lower: number;
+    upper: number;
+    outliers: number[];
+} | undefined;
+export declare function chartValueKey(value: unknown): string;
+//# sourceMappingURL=chart-grammar.d.ts.map

package/dist/types/utils/chart-scene.d.ts

@@ -0,0 +1,128 @@
+import { type ChartCenterOptions, type ChartDefinition, type ChartPoint, type ChartSpec, type ChartValue } from './chart-grammar';
+import { type ChartTheme } from './chart-theme';
+export interface ChartTextMeasurement {
+    width: number;
+    height: number;
+}
+export type ChartTextMeasurer = (text: string) => ChartTextMeasurement;
+export interface ChartBounds {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    width: number;
+    height: number;
+}
+interface ChartSceneStyle {
+    fill?: string;
+    stroke?: string;
+    opacity?: number;
+    fillOpacity?: number;
+    strokeOpacity?: number;
+    strokeWidth?: number | string;
+    strokeDasharray?: string;
+    radius?: number | string;
+    fontFamily?: string;
+    fontSize?: number | string;
+    fontWeight?: number | string;
+    textAnchor?: 'start' | 'middle' | 'end';
+}
+interface ChartSceneBaseNode {
+    key: string;
+    markId: string;
+    style: ChartSceneStyle;
+    className?: string;
+    /** Keep discrete nodes visible when their center lies on a plot boundary. */
+    clipToPlot?: boolean;
+}
+export interface ChartScenePath extends ChartSceneBaseNode {
+    type: 'path';
+    d: string;
+    transform?: string;
+}
+export interface ChartSceneRect extends ChartSceneBaseNode {
+    type: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ChartSceneCircle extends ChartSceneBaseNode {
+    type: 'circle';
+    x: number;
+    y: number;
+    radius: number | string;
+}
+export interface ChartSceneLine extends ChartSceneBaseNode {
+    type: 'line';
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
+}
+export interface ChartSceneText extends ChartSceneBaseNode {
+    type: 'text';
+    x: number;
+    y: number;
+    text: string;
+    dx?: number;
+    dy?: number;
+    rotate?: number;
+    dominantBaseline?: 'auto' | 'middle' | 'hanging';
+    measure?: boolean;
+}
+export type ChartSceneNode = ChartScenePath | ChartSceneRect | ChartSceneCircle | ChartSceneLine | ChartSceneText;
+export interface ChartSceneTick {
+    key: string;
+    value: ChartValue;
+    label: string;
+    position: number;
+    boundary: boolean;
+    labelVisible: boolean;
+}
+export interface ChartSceneAxis {
+    label?: string;
+    ticks: ChartSceneTick[];
+    grid: boolean;
+    rotate: number;
+    line: boolean;
+    tickSize: number;
+    tickPadding: number;
+}
+export interface ChartScene {
+    width: number;
+    height: number;
+    coordinate: 'cartesian' | 'polar';
+    plot: ChartBounds;
+    xAxis: ChartSceneAxis;
+    yAxis: ChartSceneAxis;
+    guides: ChartSceneNode[];
+    nodes: ChartSceneNode[];
+    points: ChartPoint[];
+    center?: ChartCenterOptions;
+    focus: NonNullable<ChartSpec['focus']>;
+    maxFocusDistance?: number;
+    tooltip: ChartSpec['tooltip'];
+    clip: boolean;
+    focusDotCircleRadius: number | string;
+    focusDotHaloWidth: number | string;
+    focusDotPointKeys: readonly string[];
+    arcHitRegions: readonly ChartArcHitRegion[];
+}
+interface ChartArcHitRegion {
+    sceneKey: string;
+    centerX: number;
+    centerY: number;
+    innerRadius: number;
+    outerRadius: number;
+    startAngle: number;
+    endAngle: number;
+}
+export declare function resolveDonutPadAngle(gap: number, innerRadius: number, outerRadius: number): number;
+export declare function compileChartScene(definition: ChartDefinition, width: number, height: number, locale?: string, measurer?: ChartTextMeasurer, theme?: ChartTheme): ChartScene;
+export declare function findChartFocus(points: readonly ChartPoint[], mode: NonNullable<ChartSpec['focus']>, x: number, y: number, maxDistance?: number, arcHitRegions?: readonly ChartArcHitRegion[]): {
+    primary: ChartPoint;
+    points: ChartPoint[];
+} | undefined;
+export {};
+//# sourceMappingURL=chart-scene.d.ts.map

package/dist/types/utils/chart-theme.d.ts

@@ -0,0 +1,27 @@
+import type { ChartDataIntent } from './chart-grammar';
+/** Private, renderer-neutral visual defaults resolved by the chart compiler. */
+export interface ChartTheme {
+    seriesStrokeWidth: string;
+    ruleStrokeWidth: string;
+    gridStrokeWidth: string;
+    barRadius: string;
+    polarCornerRadius: number;
+    polarLabelGap: number;
+    dotRadius: number | string;
+    dotHaloWidth: number | string;
+    focusDotRadius: number | string;
+    areaOpacity: number;
+    boxFillOpacity: number;
+    boxMaxWidth: number;
+    heatmapMinimumOpacity: number;
+    heatmapMaximumOpacity: number;
+    cellGap: number;
+    stackGap: number;
+    donutGap: number;
+    annotationFillOpacity: number;
+}
+export declare const defaultChartTheme: ChartTheme;
+/** Resolve chart geometry and opacity recipes from the current TokoMo theme. */
+export declare function resolveChartTheme(element?: Element): ChartTheme;
+export declare function chartIntentColor(intent?: ChartDataIntent): string;
+//# sourceMappingURL=chart-theme.d.ts.map

package/dist/types/utils/chart-types.d.ts

@@ -1,16 +1,3 @@
-/** Shared data shapes for `ds-chart-*` components — kept minimal for the initial scaffold, expect these to grow per component once design is finalized. */
-export interface ChartDatum {
-    label: string;
-    value: number;
-    /** CSS color override; defaults to the next `--color-data-category-*` token. */
-    color?: string;
-}
-export interface ChartSeries {
-    name: string;
-    data: number[];
-    /** CSS color override; defaults to the next `--color-data-category-*` token. */
-    color?: string;
-}
 /** `ds-chart-legend` entry — value is optional so a series name (no single value) can be legended too. */
 export interface ChartLegendItem {
     label: string;

package/dist/types/utils/index.d.ts

@@ -18,6 +18,8 @@ export { resolveSafeUrl } from './safe-url';
 export type { ResolveSafeUrlOptions, SafeUrlProtocol } from './safe-url';
 export { controlWidthClass } from './control-width';
 export type { ControlWidth } from './control-width';
+export { arcMark, areaY, bandX, bandY, barX, barY, binX, boxStatistics, boxY, cell, cumulativeBins, densityX, defineChart, dot, lineY, normalizeStack, pieLayout, polar, radialArea, radialDot, radialLine, rect, ruleX, ruleY, textMark, } from './chart-grammar';
+export type { ChartArcOptions, ChartAreaYOptions, ChartAxisOptions, ChartAxisPresentation, ChartBarLayout, ChartBarOptions, ChartBandOptions, ChartBinDatum, ChartBinOptions, ChartBoxYOptions, ChartBuildContext, ChartCartesianCoordinate, ChartCellOptions, ChartCenterContent, ChartCenterOptions, ChartChannel, ChartColorOptions, ChartCoordinate, ChartDataIntent, ChartDefinition, ChartDensityDatum, ChartDensityOptions, ChartDotOptions, ChartFocusMode, ChartKey, ChartLineYOptions, ChartMargin, ChartMark, ChartMarkKind, ChartPieDatum, ChartPieOptions, ChartPoint, ChartPolarAxisOptions, ChartPolarContainerOptions, ChartPolarCoordinate, ChartRadialOptions, ChartRectOptions, ChartRuleOptions, ChartScale, ChartScaleSource, ChartSpec, ChartSpecBuilder, ChartTextOptions, ChartTickOptions, ChartTooltip, ChartTooltipContext, ChartTooltipItem, ChartTooltipOptions, ChartValue, ChartVisual, NormalizedStackDatum, NormalizeStackOptions, } from './chart-grammar';
 export { CONTROL_SUPPORTING_TEXT_VARIANT, CONTROL_TEXT_VARIANT } from './control-text';
 export type { ControlSize } from './control-text';
 export { choicePopupMinWidth, resolveChoicePopupAlignOffset, } from './choice-popup-alignment';

package/dist/types/utils/token-defaults.d.ts

@@ -6,6 +6,9 @@ export declare const TOKEN_DEFAULTS: {
     readonly space300: "--dimension-space-300";
     readonly space400: "--dimension-space-400";
     readonly radius025: "--dimension-radius-025";
+    readonly strokeWidth012: "--dimension-stroke-width-012";
+    readonly strokeWidth025: "--dimension-stroke-width-025";
+    readonly strokeWidth037: "--dimension-stroke-width-037";
     readonly size200: "--dimension-size-200";
     readonly size300: "--dimension-size-300";
     readonly size400: "--dimension-size-400";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ds-mo/ui",
-  "version": "13.6.0",
+  "version": "13.7.0",
   "description": "CompoMo — composable web components styled with TokoMo design tokens",
   "keywords": [
     "web-components",

package/dist/angular/ds-card-data-viz.d.ts

@@ -1,18 +0,0 @@
-import { ChangeDetectorRef, ElementRef, NgZone, EventEmitter } from '@angular/core';
-import type { Components } from '@ds-mo/ui/components';
-import type { DsCardDataVizCustomEvent } from '@ds-mo/ui/components';
-import * as i0 from "@angular/core";
-export declare class DsCardDataViz {
-    protected z: NgZone;
-    protected el: HTMLDsCardDataVizElement;
-    dsFilterClick: EventEmitter<DsCardDataVizCustomEvent<void>>;
-    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DsCardDataViz, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DsCardDataViz, "ds-card-data-viz", never, { "cardWidth": { "alias": "cardWidth"; "required": false; }; "filterLabel": { "alias": "filterLabel"; "required": false; }; "heading": { "alias": "heading"; "required": true; }; "showFilter": { "alias": "showFilter"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, { "dsFilterClick": "dsFilterClick"; }, never, ["*"], true, never>;
-}
-export declare interface DsCardDataViz extends Components.DsCardDataViz {
-    /**
-     * Emits when the standard header filter control is activated.
-     */
-    dsFilterClick: EventEmitter<DsCardDataVizCustomEvent<void>>;
-}

package/dist/angular/ds-chart-bar.d.ts

@@ -1,12 +0,0 @@
-import { ChangeDetectorRef, ElementRef, NgZone } from '@angular/core';
-import type { Components } from '@ds-mo/ui/components';
-import * as i0 from "@angular/core";
-export declare class DsChartBar {
-    protected z: NgZone;
-    protected el: HTMLDsChartBarElement;
-    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DsChartBar, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DsChartBar, "ds-chart-bar", never, { "categories": { "alias": "categories"; "required": false; }; "data": { "alias": "data"; "required": false; }; "height": { "alias": "height"; "required": false; }; "series": { "alias": "series"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, {}, never, ["*"], true, never>;
-}
-export declare interface DsChartBar extends Components.DsChartBar {
-}

package/dist/angular/ds-chart-bar.js

@@ -1,38 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-/* tslint:disable */
-/* auto-generated angular directive proxies */
-import { ChangeDetectionStrategy, Component } from '@angular/core';
-import { ProxyCmp } from './angular-component-lib/utils.js';
-import { defineCustomElement as defineDsChartBar } from '@ds-mo/ui/components/ds-chart-bar.js';
-import * as i0 from "@angular/core";
-let DsChartBar = class DsChartBar {
-    constructor(c, r, z) {
-        this.z = z;
-        c.detach();
-        this.el = r.nativeElement;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.0", ngImport: i0, type: DsChartBar, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.1.0", type: DsChartBar, isStandalone: true, selector: "ds-chart-bar", inputs: { categories: "categories", data: "data", height: "height", series: "series", variant: "variant", width: "width" }, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
-};
-DsChartBar = __decorate([
-    ProxyCmp({
-        defineCustomElementFn: defineDsChartBar,
-        inputs: ['categories', 'data', 'height', 'series', 'variant', 'width']
-    })
-], DsChartBar);
-export { DsChartBar };
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.0", ngImport: i0, type: DsChartBar, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'ds-chart-bar',
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    template: '<ng-content></ng-content>',
-                    // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property
-                    inputs: ['categories', 'data', 'height', 'series', 'variant', 'width'],
-                }]
-        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.NgZone }] });

package/dist/angular/ds-chart-donut.d.ts

@@ -1,19 +0,0 @@
-import { ChangeDetectorRef, ElementRef, NgZone, EventEmitter } from '@angular/core';
-import type { Components } from '@ds-mo/ui/components';
-import type { DsChartDonutCustomEvent } from '@ds-mo/ui/components';
-import type { ChartDatum as IDsChartDonutChartDatum } from '@ds-mo/ui/components';
-import * as i0 from "@angular/core";
-export declare class DsChartDonut {
-    protected z: NgZone;
-    protected el: HTMLDsChartDonutElement;
-    dsSliceHover: EventEmitter<DsChartDonutCustomEvent<IDsChartDonutChartDatum | null>>;
-    constructor(c: ChangeDetectorRef, r: ElementRef, z: NgZone);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DsChartDonut, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DsChartDonut, "ds-chart-donut", never, { "activeLabel": { "alias": "activeLabel"; "required": false; }; "centerCaption": { "alias": "centerCaption"; "required": false; }; "centerValue": { "alias": "centerValue"; "required": false; }; "cornerRadius": { "alias": "cornerRadius"; "required": false; }; "data": { "alias": "data"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "noDataLabel": { "alias": "noDataLabel"; "required": false; }; "showTooltip": { "alias": "showTooltip"; "required": false; }; "size": { "alias": "size"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; }, { "dsSliceHover": "dsSliceHover"; }, never, ["*"], true, never>;
-}
-export declare interface DsChartDonut extends Components.DsChartDonut {
-    /**
-     * Fires with the hovered/focused slice's datum, or `null` on leave/blur.
-     */
-    dsSliceHover: EventEmitter<DsChartDonutCustomEvent<IDsChartDonutChartDatum | null>>;
-}