@abdullahjaswal/tickyr-charts-solid 0.1.0

package/dist/personalization/axes/null-behavior.d.ts

@@ -0,0 +1,3 @@
+export type NullBehavior = "empty" | "cross-hatch" | "background";
+export declare const DEFAULT_NULL_BEHAVIOR: NullBehavior;
+export declare function resolveNullBehavior(input: NullBehavior | undefined): NullBehavior;

package/dist/personalization/axes/number-format.d.ts

@@ -0,0 +1,18 @@
+import { DigitGrouping, NumberAbbreviation } from '../locale/formatter';
+export type NumberFormatPreset = "standard" | "compact" | "pk-grouping" | "pk-compact" | "percent" | "currency";
+/** Allow a user-supplied function to bypass all built-in behavior. */
+export type NumberFormatInput = NumberFormatPreset | ((n: number) => string);
+export interface ResolvedNumberFormat {
+    readonly preset: NumberFormatPreset | null;
+    /** Non-null when the host passed a literal function. */
+    readonly custom: ((n: number) => string) | null;
+    /** Derived `digitGrouping` for the underlying formatter. */
+    readonly digitGrouping: DigitGrouping;
+    /** Derived `numberAbbreviation`. */
+    readonly numberAbbreviation: NumberAbbreviation;
+    /** When the preset is `'percent'` or `'currency'`, the formatter
+     *  routes through a percent / currency code path. */
+    readonly mode: "number" | "percent" | "currency";
+}
+export declare const DEFAULT_NUMBER_FORMAT: NumberFormatPreset;
+export declare function resolveNumberFormat(input: NumberFormatInput | undefined): ResolvedNumberFormat;

package/dist/personalization/axes/pan-zoom.d.ts

@@ -0,0 +1,42 @@
+export type PanEdgeBehavior = 
+/** Hard stop at the data extents. */
+"stop"
+/** Allow over-pan with a small empty band. */
+ | "overshoot"
+/** Wrap around (rarely useful for finance - left for completeness). */
+ | "wrap";
+export type WheelBehavior = 
+/** Mouse-wheel zooms (default). Hosts may flip to scroll-only. */
+"zoom"
+/** Wheel scrolls the page; charts ignore wheel. */
+ | "scroll"
+/** Wheel zooms only with the modifier key held. */
+ | "ctrl-zoom";
+export type PanAxis = "x" | "y" | "both";
+export type ZoomAnchor = 
+/** Anchor at the mouse / touch position (default). */
+"pointer"
+/** Anchor at the chart center. */
+ | "center";
+export interface PanZoomOptions {
+    readonly panEnabled: boolean;
+    readonly zoomEnabled: boolean;
+    readonly zoomAnchor: ZoomAnchor;
+    readonly panEdgeBehavior: PanEdgeBehavior;
+    readonly panInertia: boolean;
+    readonly wheelBehavior: WheelBehavior;
+    readonly panAxis: PanAxis;
+    readonly doubleClickReset: boolean;
+    readonly yAxisManualRescale: boolean;
+}
+export declare const DEFAULT_PAN_ZOOM_OPTIONS: PanZoomOptions;
+export type PanZoomOptionsInput = {
+    readonly [K in keyof PanZoomOptions]?: PanZoomOptions[K] | undefined;
+};
+export declare function resolvePanZoomOptions(input: PanZoomOptionsInput | undefined): PanZoomOptions;
+/** Decay velocity by friction `f` over `dtMs`. `f` defaults to 0.95 /
+ *  16ms (≈ ~6% per frame). Returns the new velocity. Below `eps`, the
+ *  caller should stop the animation. */
+export declare function applyInertiaDecay(velocity: number, dtMs: number, friction?: number): number;
+/** Sentinel - when |velocity| drops below this, stop the loop. */
+export declare const INERTIA_EPSILON = 0.01;

package/dist/personalization/axes/pattern.d.ts

@@ -0,0 +1,26 @@
+export type PatternPreset = "solid" | "diagonal-lines" | "diagonal-lines-reverse" | "cross-hatch" | "dots" | "circles" | "grid" | "horizontal-lines" | "vertical-lines" | "plus" | "chevron" | "zigzag" | "waves" | "checkerboard" | "hexagons" | "bricks";
+/** Host-supplied input - string preset, config form, or a literal
+ *  `CanvasPattern` (full dev control). */
+export type PatternInput = PatternPreset | {
+    readonly type: PatternPreset;
+    readonly scale?: number;
+    readonly lineWidth?: number;
+    readonly color?: string;
+} | CanvasPattern;
+export type PatternColorInput = "auto" | string;
+export interface ResolvedPattern {
+    readonly type: PatternPreset;
+    readonly scale: number;
+    readonly lineWidth: number;
+    /** `'auto'` triggers per-mark color derivation at draw time (uses the
+     *  mark's own fill color with OKLCH L-shift); a literal string forces
+     *  uniform pattern color. */
+    readonly color: "auto" | string;
+    /** Literal `CanvasPattern` (custom dev pattern). When non-null, the
+     *  rendering primitive uses it directly and ignores `type`. */
+    readonly customPattern: CanvasPattern | null;
+}
+export declare const DEFAULT_PATTERN: PatternInput;
+export declare const DEFAULT_PATTERN_SCALE = 1;
+export declare const DEFAULT_PATTERN_COLOR: PatternColorInput;
+export declare function resolvePattern(input: PatternInput | undefined, scale: number | undefined, color: PatternColorInput | undefined): ResolvedPattern;

package/dist/personalization/axes/point-markers.d.ts

@@ -0,0 +1,55 @@
+export type MarkerStyle = "circle" | "square" | "diamond" | "triangle" | "triangle-down" | "cross" | "plus" | "star" | "direction" | "custom";
+/** Custom-icon shapes accepted by `MarkerConfig.icon` / `upIcon` / `downIcon`.
+ *  Evaluated synchronously per draw - no async resolution, no React-component
+ *  offscreen rendering (that's a future sweep when we add
+ *  bitmap-cache infra). */
+export type MarkerIcon = 
+/** SVG path-data string (e.g. `"M-1,-1 L1,1 ..."`). Parsed to a cached
+ *  `Path2D` once per unique string at first use. */
+string
+/** Pre-built `Path2D` - used directly. */
+ | Path2D
+/** Direct-draw function - called per point with translated origin.
+ *  Receives a context whose origin is at (x, y) and scaled to half-size,
+ *  so the function should draw the shape in [-1, 1] coordinates. */
+ | ((ctx: CanvasRenderingContext2D) => void);
+export interface MarkerConfig {
+    style?: MarkerStyle;
+    /** Diameter / longest side, in CSS px. Floored to `MIN_MARKER_SIZE` (1.5)
+     *  internally so markers don't disappear at extreme zoom-out. Default 5. */
+    size?: number;
+    /** Fill color. `'auto'` = the line's resolved color. `'none'` = no fill. */
+    fill?: "auto" | "none" | string;
+    /** Stroke color. `'auto'` matches `fill`. `'none'` = no stroke. */
+    stroke?: "auto" | "none" | string;
+    /** Stroke width in CSS px. `0` (default) = no border. */
+    strokeWidth?: number;
+    /** Up-arrow color when `style: 'direction'`. `'auto'` = `palette.up`. */
+    upColor?: "auto" | string;
+    /** Down-arrow color when `style: 'direction'`. `'auto'` = `palette.down`. */
+    downColor?: "auto" | string;
+    /** Custom up/down icons for `style: 'direction'`. Defaults to the built-in
+     *  chevron when `undefined`. */
+    upIcon?: MarkerIcon;
+    downIcon?: MarkerIcon;
+    /** Required when `style: 'custom'`. Used for every data point. */
+    icon?: MarkerIcon;
+}
+export type PointMarkers = boolean | MarkerConfig;
+export interface ResolvedMarkerConfig {
+    readonly style: MarkerStyle;
+    readonly size: number;
+    readonly fill: "auto" | "none" | string;
+    readonly stroke: "auto" | "none" | string;
+    readonly strokeWidth: number;
+    readonly upColor: "auto" | string;
+    readonly downColor: "auto" | string;
+    readonly upIcon: MarkerIcon | undefined;
+    readonly downIcon: MarkerIcon | undefined;
+    readonly icon: MarkerIcon | undefined;
+}
+/** `null` = no markers (false / undefined). */
+export declare function resolvePointMarkers(input: PointMarkers | undefined): ResolvedMarkerConfig | null;
+/** Internal floor - markers never render smaller than this. Mirrors the
+ *  cross-chart `minMarkSize` token (~1.5px). */
+export declare const MIN_MARKER_SIZE = 1.5;

package/dist/personalization/axes/point-opacity.d.ts

@@ -0,0 +1,6 @@
+export type PointOpacityInput = number | "auto";
+export declare const AUTO_OPACITY_THRESHOLDS: ReadonlyArray<{
+    readonly count: number;
+    readonly opacity: number;
+}>;
+export declare function resolvePointOpacity(input: PointOpacityInput | undefined, pointCount: number): number;

package/dist/personalization/axes/point-size.d.ts

@@ -0,0 +1,23 @@
+export type BubbleScale = "linear" | "sqrt";
+export interface PointSizeConfig {
+    /** `'linear'` (radius linear in value) or `'sqrt'` (area linear in value).
+     *  Default `'sqrt'` - perceptually correct for area-encoded bubbles. */
+    readonly scale?: BubbleScale;
+    /** `[minPx, maxPx]` - the rendered diameter range. Default [4, 32]. */
+    readonly range?: readonly [number, number];
+}
+export type PointSizeInput = number | "data-driven" | PointSizeConfig;
+export type ResolvedPointSize = {
+    readonly kind: "fixed";
+    readonly size: number;
+} | {
+    readonly kind: "data-driven";
+    readonly scale: BubbleScale;
+    readonly range: readonly [number, number];
+};
+export declare const DEFAULT_POINT_SIZE_PX = 9;
+export declare const DEFAULT_BUBBLE_RANGE_PX: readonly [number, number];
+export declare function resolvePointSize(input: PointSizeInput | undefined): ResolvedPointSize;
+/** Compute per-point bubble diameters into the caller-owned `out` buffer.
+ *  `out.length` must equal `sizes.length`. Zero-allocation on this path. */
+export declare function computeBubbleRadii(sizes: Float64Array, scale: BubbleScale, range: readonly [number, number], out: Float64Array): void;

package/dist/personalization/axes/price-range.d.ts

@@ -0,0 +1,9 @@
+export interface PriceRangeWindow {
+    /** Lower bound as fraction off mid (typically negative). */
+    readonly minPct: number;
+    /** Upper bound as fraction off mid (typically positive). */
+    readonly maxPct: number;
+}
+export type PriceRangeInput = "auto" | number | PriceRangeWindow;
+export declare const DEFAULT_PRICE_RANGE_PCT = 0.05;
+export declare function resolvePriceRange(input: PriceRangeInput | undefined): PriceRangeWindow;

package/dist/personalization/axes/radius-proportion.d.ts

@@ -0,0 +1,3 @@
+export type RadiusProportion = "uniform" | "value-weighted" | "sqrt-weighted";
+export declare const DEFAULT_RADIUS_PROPORTION: RadiusProportion;
+export declare function resolveRadiusProportion(input: RadiusProportion | undefined): RadiusProportion;

package/dist/personalization/axes/regression-line.d.ts

@@ -0,0 +1,36 @@
+export type RegressionType = "linear" | "polynomial" | "exponential" | "lowess";
+interface RegressionStyle {
+    /** `'auto'` resolves to `palette.neutral` at draw time. */
+    readonly color?: "auto" | string;
+    readonly lineWidth?: number;
+    readonly lineDash?: readonly number[];
+}
+export type RegressionLineInput = false | true | (RegressionStyle & {
+    readonly type: "linear";
+}) | (RegressionStyle & {
+    readonly type: "polynomial";
+    readonly degree?: number;
+}) | (RegressionStyle & {
+    readonly type: "exponential";
+}) | (RegressionStyle & {
+    readonly type: "lowess";
+    readonly bandwidth?: number;
+});
+interface ResolvedBase {
+    readonly color: "auto" | string;
+    readonly lineWidth: number;
+    readonly lineDash: readonly number[] | null;
+}
+export type ResolvedRegressionLine = (ResolvedBase & {
+    readonly type: "linear";
+}) | (ResolvedBase & {
+    readonly type: "polynomial";
+    readonly degree: number;
+}) | (ResolvedBase & {
+    readonly type: "exponential";
+}) | (ResolvedBase & {
+    readonly type: "lowess";
+    readonly bandwidth: number;
+});
+export declare function resolveRegressionLine(input: RegressionLineInput | undefined): ResolvedRegressionLine | null;
+export {};

package/dist/personalization/axes/sankey-link-color.d.ts

@@ -0,0 +1,10 @@
+export type SankeyLinkColorPreset = "source" | "target" | "gradient" | "neutral";
+export type SankeyLinkColorInput = SankeyLinkColorPreset | string;
+export type ResolvedSankeyLinkColor = {
+    readonly kind: SankeyLinkColorPreset;
+} | {
+    readonly kind: "literal";
+    readonly color: string;
+};
+export declare const DEFAULT_SANKEY_LINK_COLOR: SankeyLinkColorPreset;
+export declare function resolveSankeyLinkColor(input: SankeyLinkColorInput | undefined): ResolvedSankeyLinkColor;

package/dist/personalization/axes/sankey-value-display.d.ts

@@ -0,0 +1,4 @@
+export type SankeyValueDisplayInput = false | true | "on-link-hover";
+export type SankeyValueDisplayMode = "off" | "always" | "on-link-hover";
+export declare const DEFAULT_SANKEY_VALUE_DISPLAY: SankeyValueDisplayMode;
+export declare function resolveSankeyValueDisplay(input: SankeyValueDisplayInput | undefined): SankeyValueDisplayMode;

package/dist/personalization/axes/small-slice-threshold.d.ts

@@ -0,0 +1,15 @@
+interface SmallSliceConfig {
+    /** 0-1 fraction of total. */
+    readonly threshold: number;
+    readonly label?: string;
+    /** `'auto'` resolves to a darker neutral at draw time. */
+    readonly color?: "auto" | string;
+}
+export type SmallSliceThresholdInput = false | number | SmallSliceConfig;
+export interface ResolvedSmallSliceThreshold {
+    readonly threshold: number;
+    readonly label: string;
+    readonly color: "auto" | string;
+}
+export declare function resolveSmallSliceThreshold(input: SmallSliceThresholdInput | undefined): ResolvedSmallSliceThreshold | null;
+export {};

package/dist/personalization/axes/sort-order.d.ts

@@ -0,0 +1,3 @@
+export type SortOrder = "value-desc" | "value-asc" | "data-order" | "alphabetical";
+export declare const DEFAULT_SORT_ORDER: SortOrder;
+export declare function resolveSortOrder(input: SortOrder | undefined): SortOrder;

package/dist/personalization/axes/spread-display.d.ts

@@ -0,0 +1,4 @@
+export type SpreadDisplayMode = "off" | "pill" | "inline";
+export type SpreadDisplayInput = false | true | "pill" | "inline";
+export declare const DEFAULT_SPREAD_DISPLAY: SpreadDisplayMode;
+export declare function resolveSpreadDisplay(input: SpreadDisplayInput | undefined): SpreadDisplayMode;

package/dist/personalization/axes/stacking.d.ts

@@ -0,0 +1,17 @@
+export type StackingMode = false | true | "normalized";
+export declare const DEFAULT_STACKING: StackingMode;
+/** Result of `validateStackingAlignment`. */
+export interface StackingAlignmentError {
+    readonly kind: "length-mismatch" | "time-mismatch";
+    /** 0-based index of the offending series (the one that diverges from
+     *  series[0]); always > 0 when this returns non-null. */
+    readonly seriesIdx: number;
+    /** Bar index where the divergence occurs ('time-mismatch' only). */
+    readonly barIdx?: number;
+}
+/** Boundary check: every entry shares the same length and the same `times`
+ *  values as the first entry. Returns null when aligned. */
+export declare function validateStackingAlignment(series: readonly {
+    readonly times: Float64Array;
+    readonly length: number;
+}[]): StackingAlignmentError | null;

package/dist/personalization/axes/tile-layout.d.ts

@@ -0,0 +1,3 @@
+export type TileLayout = "squarify" | "slice-and-dice" | "strip" | "slice" | "dice" | "binary";
+export declare const DEFAULT_TILE_LAYOUT: TileLayout;
+export declare function resolveTileLayout(input: TileLayout | undefined): TileLayout;

package/dist/personalization/axes/time-off-axes.d.ts

@@ -0,0 +1,19 @@
+export type TimeOffSource = "close" | "high-low";
+export declare const DEFAULT_TIME_OFF_SOURCE: TimeOffSource;
+export declare function resolveTimeOffSource(input: TimeOffSource | undefined): TimeOffSource;
+export declare const DEFAULT_RENKO_REVERSAL = 2;
+export declare function resolveRenkoReversal(input: number | undefined): number;
+export declare const DEFAULT_BRICK_GAP = 0;
+export declare function resolveBrickGap(input: number | undefined): number;
+export type KagiThicknessRule = "shoulder-waist" | "previous-high-low";
+export declare const DEFAULT_KAGI_THICKNESS_RULE: KagiThicknessRule;
+export declare function resolveKagiThicknessRule(input: KagiThicknessRule | undefined): KagiThicknessRule;
+export declare const DEFAULT_KAGI_THICK_LINE_WIDTH = 3;
+export declare const DEFAULT_KAGI_THIN_LINE_WIDTH = 1.5;
+export declare const DEFAULT_PNF_REVERSAL_COUNT = 3;
+export declare function resolvePnFReversalCount(input: number | undefined): number;
+export type PnFSymbolStyle = "classic" | "filled";
+export declare const DEFAULT_PNF_SYMBOL_STYLE: PnFSymbolStyle;
+export declare function resolvePnFSymbolStyle(input: PnFSymbolStyle | undefined): PnFSymbolStyle;
+export declare const DEFAULT_PNF_SYMBOL_PADDING = 0.15;
+export declare function resolvePnFSymbolPadding(input: number | undefined): number;

package/dist/personalization/axes/treemap-color-scale.d.ts

@@ -0,0 +1,3 @@
+export type TreemapColorScale = "flat-categorical" | "depth-gradient" | "value-heat" | "directional";
+export declare const DEFAULT_TREEMAP_COLOR_SCALE: TreemapColorScale;
+export declare function resolveTreemapColorScale(input: TreemapColorScale | undefined): TreemapColorScale;

package/dist/personalization/axes/value-labels.d.ts

@@ -0,0 +1,21 @@
+export type ValueLabelPosition = "auto" | "inside" | "outside" | "top" | "bottom";
+export interface LabelConfig {
+    position?: ValueLabelPosition;
+    format?: "auto" | ((value: number) => string);
+    /** `'auto'` picks high-contrast based on fill (white on Fill mode,
+     *  theme primary text on Outline mode). Hex / rgba string overrides. */
+    color?: "auto" | string;
+    fontSize?: number;
+    fontWeight?: number | "normal" | "bold";
+}
+export type ValueLabels = false | true | LabelConfig;
+export interface ResolvedLabelConfig {
+    readonly position: ValueLabelPosition;
+    /** When 'auto', caller routes the value through the chart's
+     *  locale-aware formatter; when a function, that function is called. */
+    readonly format: "auto" | ((value: number) => string);
+    readonly color: "auto" | string;
+    readonly fontSize: number;
+    readonly fontWeight: number | "normal" | "bold";
+}
+export declare function resolveValueLabels(input: ValueLabels | undefined): ResolvedLabelConfig | null;

package/dist/personalization/axes/view-mode.d.ts

@@ -0,0 +1,3 @@
+export type ViewMode = "nested" | "drill-down";
+export declare const DEFAULT_VIEW_MODE: ViewMode;
+export declare function resolveViewMode(input: ViewMode | undefined): ViewMode;

package/dist/personalization/axes/volume-coloring.d.ts

@@ -0,0 +1,24 @@
+import { Palette, Theme } from '../palette/types';
+export type VolumeColoring = "by-direction" | "single" | "by-magnitude";
+export interface VolumeColorResolveArgs {
+    readonly mode: VolumeColoring;
+    /** Used only when mode='single'. `'auto'` derives from palette. */
+    readonly singleColor: "auto" | string;
+    readonly palette: Palette;
+    readonly theme: Theme;
+    /** Visible-window volumes (the same Float64Array CandleSeries owns;
+     *  zero-copy). */
+    readonly volumes: Float64Array;
+    /** Inclusive start index in `volumes`. */
+    readonly startIdx: number;
+    /** Inclusive end index in `volumes`. */
+    readonly endIdx: number;
+}
+export interface VolumeColorResolver {
+    /** Returns the CSS color (rgba / hex) for the bar at `idx`. `isUp`
+     *  indicates the candle direction; only `'by-direction'` mode uses
+     *  it. The returned string is interned for the resolver lifetime;
+     *  callers can compare references for equality (zero-alloc draw). */
+    resolveAt(idx: number, isUp: boolean): string;
+}
+export declare function resolveVolumeColoring(args: VolumeColorResolveArgs): VolumeColorResolver;

package/dist/personalization/axes/y-axis-mode.d.ts

@@ -0,0 +1,3 @@
+export type YAxisMode = "frequency" | "density" | "cumulative";
+export declare const DEFAULT_Y_AXIS_MODE: YAxisMode;
+export declare function resolveYAxisMode(input: YAxisMode | undefined): YAxisMode;

package/dist/personalization/index.d.ts

@@ -0,0 +1,38 @@
+export { type Personalization, type PersonalizationInput, type LiveBarIndicator, type ConnectionIndicator, type LegendPosition, type StaleVisualization, type LegendVisibility, resolvePersonalization, resolveTheme, effectiveOutlineAlpha, } from './personalization';
+export { type BarEntryAnimation, type BarUpdateAnimation, type ThemeSwitchTransition, type AnimationAxes, type AnimationInputs, resolveAnimation, ANIMATION_DEFAULTS, } from './axes/animation';
+export { type PointSizeInput, type ResolvedPointSize, type BubbleScale, resolvePointSize, computeBubbleRadii, DEFAULT_POINT_SIZE_PX, DEFAULT_BUBBLE_RANGE_PX, } from './axes/point-size';
+export { type PointOpacityInput, resolvePointOpacity, AUTO_OPACITY_THRESHOLDS, } from './axes/point-opacity';
+export { type DensityInput, type DensityRenderMode, resolveDensityMode, DENSITY_AUTO_THRESHOLD, } from './axes/density';
+export { type RegressionLineInput, type ResolvedRegressionLine, type RegressionType, resolveRegressionLine, } from './axes/regression-line';
+export { type BinAlgorithm, resolveBinAlgorithm, DEFAULT_BIN_ALGORITHM, } from './axes/bin-algorithm';
+export { type YAxisMode, resolveYAxisMode, DEFAULT_Y_AXIS_MODE, } from './axes/y-axis-mode';
+export { type HistogramOverlayInput, type HistogramOverlayType, type ResolvedHistogramOverlay, resolveHistogramOverlay, } from './axes/histogram-overlay';
+export { type HeatmapColorScaleInput, type HeatmapColorScaleType, type ResolvedHeatmapColorScale, resolveHeatmapColorScale, DEFAULT_HEATMAP_COLOR_SCALE, } from './axes/heatmap-color-scale';
+export { type CellShape, resolveCellShape, DEFAULT_CELL_SHAPE, } from './axes/cell-shape';
+export { type NullBehavior, resolveNullBehavior, DEFAULT_NULL_BEHAVIOR, } from './axes/null-behavior';
+export { type AxisLabelsMode, resolveAxisLabels, DEFAULT_AXIS_LABELS, } from './axes/axis-labels';
+export { type PriceRangeInput, type PriceRangeWindow, resolvePriceRange, DEFAULT_PRICE_RANGE_PCT, } from './axes/price-range';
+export { type MidLineInput, type MidLineStyle, type ResolvedMidLine, resolveMidLine, } from './axes/mid-line';
+export { type SpreadDisplayInput, type SpreadDisplayMode, resolveSpreadDisplay, DEFAULT_SPREAD_DISPLAY, } from './axes/spread-display';
+export { type DepthFillType, resolveDepthFillType, DEFAULT_DEPTH_FILL_TYPE, } from './axes/depth-fill-type';
+export { type LevelHighlightInput, type ResolvedLevelHighlight, resolveLevelHighlight, } from './axes/level-highlight';
+export { type LabelPlacement, resolveLabelPlacement, DEFAULT_LABEL_PLACEMENT, } from './axes/label-placement';
+export { type LabelContentInput, type LabelContentPreset, type ResolvedLabelContent, type SliceLabelData, resolveLabelContent, DEFAULT_LABEL_CONTENT, } from './axes/label-content';
+export { type SortOrder, resolveSortOrder, DEFAULT_SORT_ORDER, } from './axes/sort-order';
+export { type SmallSliceThresholdInput, type ResolvedSmallSliceThreshold, resolveSmallSliceThreshold, } from './axes/small-slice-threshold';
+export { type TileLayout, resolveTileLayout, DEFAULT_TILE_LAYOUT, } from './axes/tile-layout';
+export { type LabelBehavior, resolveLabelBehavior, DEFAULT_LABEL_BEHAVIOR, } from './axes/label-behavior';
+export { type DepthLimitInput, resolveDepthLimit, } from './axes/depth-limit';
+export { type TreemapColorScale, resolveTreemapColorScale, DEFAULT_TREEMAP_COLOR_SCALE, } from './axes/treemap-color-scale';
+export { type ViewMode, resolveViewMode, DEFAULT_VIEW_MODE, } from './axes/view-mode';
+export { type RadiusProportion, resolveRadiusProportion, DEFAULT_RADIUS_PROPORTION, } from './axes/radius-proportion';
+export { type LabelRotation, resolveLabelRotation, DEFAULT_LABEL_ROTATION, } from './axes/label-rotation';
+export { type BoxSizingInput, type ResolvedBoxSizing, resolveBoxSizing, DEFAULT_BOX_SIZING, } from './axes/box-sizing';
+export { type TimeOffSource, type KagiThicknessRule, type PnFSymbolStyle, resolveTimeOffSource, resolveRenkoReversal, resolveBrickGap, resolveKagiThicknessRule, resolvePnFReversalCount, resolvePnFSymbolStyle, resolvePnFSymbolPadding, DEFAULT_TIME_OFF_SOURCE, DEFAULT_RENKO_REVERSAL, DEFAULT_BRICK_GAP, DEFAULT_KAGI_THICKNESS_RULE, DEFAULT_KAGI_THICK_LINE_WIDTH, DEFAULT_KAGI_THIN_LINE_WIDTH, DEFAULT_PNF_REVERSAL_COUNT, } from './axes/time-off-axes';
+export { type NodeAlignment, resolveNodeAlignment, DEFAULT_NODE_ALIGNMENT, } from './axes/node-alignment';
+export { type SankeyLinkColorInput, type SankeyLinkColorPreset, type ResolvedSankeyLinkColor, resolveSankeyLinkColor, DEFAULT_SANKEY_LINK_COLOR, } from './axes/sankey-link-color';
+export { type SankeyValueDisplayInput, type SankeyValueDisplayMode, resolveSankeyValueDisplay, DEFAULT_SANKEY_VALUE_DISPLAY, } from './axes/sankey-value-display';
+export { DEFAULT_PNF_SYMBOL_STYLE, DEFAULT_PNF_SYMBOL_PADDING, } from './axes/time-off-axes';
+export { type ResolvedLocale, resolveLocale, registerLocale, isLocaleRegistered, listLocales, LocaleNotSupportedError, } from './locale/resolver';
+export { ChartFormatter, acquireChartFormatter, clearChartFormatterCache, chartFormatterCacheSize, type ChartFormatterOptions, type DigitGrouping, type NumberAbbreviation, type DecimalPlaces, type CurrencyDisplay, type PercentPrecision, type DateFormat, type TimeFormat, } from './locale/formatter';
+export { type Palette, type PaletteVariant, type Theme, type ThemeInput, type VisualStyle, type Oklch, type BuiltInPaletteName, type TonalSymmetrySide, type ResolvedTonalSymmetry, PaletteValidationError, validatePaletteOrThrow, registerPalette, getPalette, getPaletteOrThrow, listPalettes, isBuiltInPalette, resolveTonalSymmetry, isTonallyChosen, resolveDirectionalLineOklch, oklchToHex, oklchToPackedRgba, oklchToRgbF, BUILT_IN_PALETTES, MONOCHROME, CLASSIC, ACCESSIBLE, } from './palette';

package/dist/personalization/locale/formatter.d.ts

@@ -0,0 +1,45 @@
+import { ResolvedLocale } from './resolver';
+export type DigitGrouping = "international" | "lakh-crore" | "none";
+export type NumberAbbreviation = "off" | "compact" | "lakh-crore" | "auto";
+export type DecimalPlaces = "auto" | number;
+export type CurrencyDisplay = "none" | "symbol" | "code";
+export type PercentPrecision = "auto" | number;
+export type DateFormat = "auto" | "short" | "medium" | "iso";
+export type TimeFormat = "auto" | "24h" | "12h";
+export interface ChartFormatterOptions {
+    readonly locale: ResolvedLocale;
+    readonly digitGrouping: DigitGrouping;
+    readonly numberAbbreviation: NumberAbbreviation;
+    readonly decimalPlaces: DecimalPlaces;
+    readonly currency: string;
+    readonly currencyDisplay: CurrencyDisplay;
+    readonly percentPrecision: PercentPrecision;
+    readonly dateFormat: DateFormat;
+    readonly timeFormat: TimeFormat;
+    readonly timeZone?: string | undefined;
+}
+export declare class ChartFormatter {
+    private readonly opt;
+    private readonly resolvedAbbrev;
+    private readonly intlCache;
+    private readonly dateFmt;
+    private readonly timeFmt;
+    constructor(opt: ChartFormatterOptions);
+    private intlFor;
+    formatNumber(n: number, decimalsOverride?: number): string;
+    formatPrice(n: number, decimalsOverride?: number): string;
+    formatPercent(fraction: number, precisionOverride?: number): string;
+    formatDate(t: number): string;
+    formatTime(t: number): string;
+    private buildDateFmt;
+    private buildTimeFmt;
+}
+/** Acquire a ChartFormatter for the given options. Cached app-wide
+ *  using a 32-entry LRU. Move-to-front on hit so frequently-used
+ *  configs survive longest. Returns the same instance for identical
+ *  option tuples. */
+export declare function acquireChartFormatter(opt: ChartFormatterOptions): ChartFormatter;
+/** Empty the cache. Used by memory-pressure handlers + tests. */
+export declare function clearChartFormatterCache(): void;
+/** Test-only - current cache size. */
+export declare function chartFormatterCacheSize(): number;

package/dist/personalization/locale/resolver.d.ts

@@ -0,0 +1,22 @@
+export interface ResolvedLocale {
+    /** Uppercase ISO 3166-1 alpha-3 code. */
+    readonly country: string;
+    /** Platform-formatter locale for international grouping. */
+    readonly baseLocale: string;
+    /** Locale for lakh-crore (lakh/crore) grouping with Latin digits forced.
+     *  When undefined, the country has no native lakh-crore-grouping
+     *  locale; ChartFormatter falls back to its custom 5-line formatter
+     *  when the host opts into lakh-crore grouping. */
+    readonly lakhCroreLocale: string | undefined;
+    /** ISO 4217 currency code paired with this locale by default. */
+    readonly defaultCurrency: string;
+}
+export declare class LocaleNotSupportedError extends Error {
+    readonly name = "LocaleNotSupportedError";
+}
+type LocaleEntry = Omit<ResolvedLocale, "country">;
+export declare function resolveLocale(country: string): ResolvedLocale;
+export declare function registerLocale(country: string, entry: LocaleEntry): void;
+export declare function isLocaleRegistered(country: string): boolean;
+export declare function listLocales(): readonly string[];
+export {};

package/dist/personalization/palette/built-ins.d.ts

@@ -0,0 +1,10 @@
+import { Palette } from './types';
+export declare const MONOCHROME: Palette;
+export declare const CLASSIC: Palette;
+export declare const ACCESSIBLE: Palette;
+export declare const BUILT_IN_PALETTES: {
+    readonly Monochrome: Palette;
+    readonly Classic: Palette;
+    readonly Accessible: Palette;
+};
+export type BuiltInPaletteName = keyof typeof BUILT_IN_PALETTES;

package/dist/personalization/palette/derive.d.ts

@@ -0,0 +1,35 @@
+import { Oklch } from './oklch';
+import { PaletteVariant, Palette, TonalSymmetrySide } from './types';
+/** Convert a sRGB hex string (`#rrggbb` or `#rgb`) to OKLCH. */
+export declare function hexToOklch(hex: string): Oklch;
+/** Accept brand input as OKLCH or hex string. */
+export type BrandInput = Oklch | string;
+/** Generate `n` categorical colors by rotating hue around the brand.
+ *  The brand color sits at slot 0; subsequent slots step `360 / n`
+ *  degrees around the OKLCH hue wheel while preserving the brand's L
+ *  and C. Palettes are expected to define a usable
+ *  categorical array (used by multi-series, pie/donut, treemap, etc.).
+ *
+ *  Tunable count - defaults to 8 which matches the built-in palettes. */
+export declare function deriveCategoricalSet(brand: BrandInput, count?: number): readonly Oklch[];
+/** Generate the chart-chrome accent tint. Per the built-ins, the accent
+ *  is a desaturated version of the brand pulled toward neutral so it
+ *  reads as "muted ink" against the chart background while still
+ *  carrying the brand hue. */
+export declare function deriveAccentTint(brand: BrandInput): Oklch;
+/** Build a `PaletteVariant` (one of `light` or `dark`) from a brand
+ *  color. Uses opinionated L/C tuning matching the built-in
+ *  Monochrome / Classic / Accessible variants:
+ *    - Light theme - up/down at L ≈ 0.70, C ≈ 0.18.
+ *    - Dark theme  - brightened L ≈ 0.78, C ≈ 0.20 for AA contrast.
+ *  Hue derives from the brand. Categorical = 8-step hue rotation. */
+export declare function deriveVariant(brand: BrandInput, theme: "light" | "dark"): PaletteVariant;
+/** Build a complete `Palette` from a brand color. Generates both
+ *  `light` and `dark` variants by calling `deriveVariant` twice with
+ *  theme-tuned L/C. */
+export interface DeriveDefaultPaletteOptions {
+    readonly name: string;
+    readonly tonalSymmetrySide?: TonalSymmetrySide;
+    readonly tonalSymmetryFlipInDarkMode?: boolean;
+}
+export declare function deriveDefaultPalette(brand: BrandInput, opts: DeriveDefaultPaletteOptions): Palette;

package/dist/personalization/palette/index.d.ts

@@ -0,0 +1,6 @@
+export { type Oklch, type RgbF, oklchToHex, oklchToPackedRgba, oklchToRgbF, } from './oklch';
+export { type Theme, type ThemeInput, type VisualStyle, type Palette, type PaletteVariant, type TonalSymmetrySide, PaletteValidationError, validatePaletteOrThrow, } from './types';
+export { type ResolvedTonalSymmetry, resolveTonalSymmetry, isTonallyChosen, resolveDirectionalLineOklch, } from './tonal-symmetry';
+export { BUILT_IN_PALETTES, MONOCHROME, CLASSIC, ACCESSIBLE, type BuiltInPaletteName, } from './built-ins';
+export { registerPalette, getPalette, getPaletteOrThrow, listPalettes, isBuiltInPalette, } from './registry';
+export { type BrandInput, type DeriveDefaultPaletteOptions, deriveAccentTint, deriveCategoricalSet, deriveDefaultPalette, deriveVariant, hexToOklch, } from './derive';

package/dist/personalization/palette/oklch.d.ts

@@ -0,0 +1,19 @@
+export interface Oklch {
+    L: number;
+    C: number;
+    h: number;
+}
+export interface RgbF {
+    r: number;
+    g: number;
+    b: number;
+}
+export declare function oklchToOklab({ L, C, h }: Oklch): {
+    L: number;
+    a: number;
+    b: number;
+};
+export declare function oklabToLinearRgb(L: number, a: number, b: number): RgbF;
+export declare function oklchToRgbF(o: Oklch): RgbF;
+export declare function oklchToHex({ L, C, h }: Oklch, alpha?: number): string;
+export declare function oklchToPackedRgba(o: Oklch, alpha?: number): number;

package/dist/personalization/palette/registry.d.ts

@@ -0,0 +1,7 @@
+import { Palette } from './types';
+import { BuiltInPaletteName } from './built-ins';
+export declare function registerPalette(palette: Palette): void;
+export declare function getPalette(name: string): Palette | undefined;
+export declare function getPaletteOrThrow(name: string): Palette;
+export declare function listPalettes(): readonly string[];
+export declare function isBuiltInPalette(name: string): name is BuiltInPaletteName;

package/dist/personalization/palette/tonal-symmetry.d.ts

@@ -0,0 +1,32 @@
+import { Palette, Theme, TonalSymmetrySide } from './types';
+export interface ResolvedTonalSymmetry {
+    /** The effective chosen side for the active theme (after the
+     *  dark-mode flip). `'none'` → palette has no symmetry rule; bars
+     *  render normally per `visualStyle`. */
+    readonly chosen: TonalSymmetrySide;
+}
+export declare function resolveTonalSymmetry(palette: Palette, theme: Theme): ResolvedTonalSymmetry;
+/** True if the bar's direction (`positive`) matches the resolved
+ *  chosen side and should therefore render with the symmetric "hollow
+ *  w/ opposite-color stroke" treatment. False (and for `'none'`
+ *  palettes always false) means the bar renders normally per
+ *  `visualStyle`. */
+export declare function isTonallyChosen(symmetry: ResolvedTonalSymmetry, positive: boolean): boolean;
+/** Resolves the directional-line/area color for a non-threshold,
+ *  non-multi-series chart (LineChart standalone, AreaChart standalone,
+ *  Sparkline, etc.).
+ *
+ *  - `chosen === 'none'`: returns trend-aware color (`palette.up` if
+ *    `trendingUp`, else `palette.down`). Preserves the legacy
+ *    "color carries direction cue" behavior on Classic / Accessible.
+ *  - `chosen ≠ 'none'`: returns the OPPOSITE-of-chosen direction color
+ *    regardless of trend. Net effect on Monochrome: both trending-up
+ *    and trending-down lines use the contrasty shade against the chart
+ *    background (the chosen-side shade is the one that "blends" with
+ *    bg by palette design - using it consistently would make the line
+ *    invisible). The chart's shape (line going up vs. down) carries
+ *    the direction cue instead. */
+export declare function resolveDirectionalLineOklch<T>(symmetry: ResolvedTonalSymmetry, variant: {
+    up: T;
+    down: T;
+}, trendingUp: boolean): T;