@ojiepermana/angular 22.1.11 → 22.1.13

package/types/ojiepermana-angular-chart-line.d.ts

@@ -1 +1,75 @@
-export * from '@ojiepermana/angular-chart/line';
+import * as _ojiepermana_angular_chart_core from '@ojiepermana/angular/chart/core';
+import { ChartOrientation, LineCurve, ChartMargin, ChartPointClickEvent, LinePoint, LineSeriesPath } from '@ojiepermana/angular/chart/core';
+export { AreaLayoutInput, AreaLayoutResult, CartesianBase, LineCurve, LineLayoutResult, LinePoint, LineSeriesPath, buildCartesianScales, cloneLinear, computeAreaLayout, computeLineLayout, pointToBandAdapter, provideCartesianFromLineLayout } from '@ojiepermana/angular/chart/core';
+import * as _angular_core from '@angular/core';
+
+/** Emitted when a data point is activated (click or keyboard). */
+/**
+ * @deprecated Use `ChartPointClickEvent` from
+ * `@ojiepermana/angular/chart/core`. Kept so existing handlers keep compiling;
+ * the shape is identical.
+ */
+type LinePointClickEvent = ChartPointClickEvent;
+declare class LineChart {
+    private readonly root;
+    private readonly cart;
+    private readonly viewport;
+    readonly data: _angular_core.InputSignal<readonly Readonly<Record<string, unknown>>[]>;
+    readonly xKey: _angular_core.InputSignal<string>;
+    readonly orientation: _angular_core.InputSignal<ChartOrientation>;
+    /**
+     * Presentational style of the chart.
+     *
+     * Replaces `styles`, which read like a CSS styles bag rather than a single
+     * variant. Named `styleVariant` and not `variant` because `ChartBar` already
+     * publishes a `variant` input for its grouped versus stacked axis, and one
+     * name cannot mean two things across the family.
+     */
+    readonly styleVariant: _angular_core.InputSignal<"base" | undefined>;
+    /**
+     * @deprecated Use `styleVariant`. Still fully supported; when both are bound,
+     *   `styleVariant` wins. Due for removal in the next major.
+     */
+    readonly styles: _angular_core.InputSignal<"base">;
+    /** The style actually in effect. Bind this, never `styles()`. */
+    protected readonly chartStyle: _angular_core.Signal<"base">;
+    readonly curve: _angular_core.InputSignal<LineCurve>;
+    private readonly themeSpace;
+    /**
+     * Plot gutters. Leave it unset and they follow the theme-space density
+     * axis; set it and your numbers win, unchanged, whatever the axis says.
+     */
+    readonly margin: _angular_core.InputSignal<ChartMargin | null>;
+    /** The margin actually in effect. Bind this, never `margin()`. */
+    protected readonly plotMargin: _angular_core.Signal<ChartMargin>;
+    readonly strokeWidth: _angular_core.InputSignal<number>;
+    readonly showDots: _angular_core.InputSignal<boolean>;
+    readonly dotRadius: _angular_core.InputSignal<number>;
+    readonly dotColorKey: _angular_core.InputSignal<string | undefined>;
+    readonly dotStrokeColor: _angular_core.InputSignal<string | undefined>;
+    readonly dotStrokeWidth: _angular_core.InputSignal<number>;
+    readonly showValueLabels: _angular_core.InputSignal<boolean>;
+    readonly valueLabelFormat: _angular_core.InputSignal<(value: number) => string>;
+    readonly pointClick: _angular_core.OutputEmitterRef<LinePointClickEvent>;
+    /**
+     * The shared cartesian scaffolding: geometry, the index window, the layout
+     * effect, and the click plus active-point plus aria-label handlers.
+     *
+     * Declared before `layout` because the layout computed reads its geometry.
+     */
+    protected readonly cx: _ojiepermana_angular_chart_core.CartesianChartSetup<LinePoint>;
+    protected readonly layout: _angular_core.Signal<_ojiepermana_angular_chart_core.LineLayoutResult>;
+    protected readonly series: _angular_core.Signal<readonly LineSeriesPath[]>;
+    protected readonly ariaSummary: _angular_core.Signal<string>;
+    protected readonly dataColumns: _angular_core.Signal<string[]>;
+    protected dotFill(point: LinePoint, fallbackColor: string): string;
+    protected formatValueLabel(point: LinePoint): string;
+    protected labelX(point: LinePoint): number;
+    protected labelY(point: LinePoint): number;
+    protected labelAnchor(): 'middle' | 'start';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LineChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LineChart, "ChartLine", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "xKey": { "alias": "xKey"; "required": true; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "styleVariant": { "alias": "styleVariant"; "required": false; "isSignal": true; }; "styles": { "alias": "styles"; "required": false; "isSignal": true; }; "curve": { "alias": "curve"; "required": false; "isSignal": true; }; "margin": { "alias": "margin"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "dotRadius": { "alias": "dotRadius"; "required": false; "isSignal": true; }; "dotColorKey": { "alias": "dotColorKey"; "required": false; "isSignal": true; }; "dotStrokeColor": { "alias": "dotStrokeColor"; "required": false; "isSignal": true; }; "dotStrokeWidth": { "alias": "dotStrokeWidth"; "required": false; "isSignal": true; }; "showValueLabels": { "alias": "showValueLabels"; "required": false; "isSignal": true; }; "valueLabelFormat": { "alias": "valueLabelFormat"; "required": false; "isSignal": true; }; }, { "pointClick": "pointClick"; }, never, ["svg:g[ChartBrush]", "svg\\:g[ChartGrid]", "svg\\:g[ChartAxisX]", "svg\\:g[ChartAxisY]", "svg\\:g[ChartCrosshair]", "ChartTooltip", "ChartLegend", "ChartZoomControls"], true, never>;
+}
+
+export { LineChart };
+export type { LinePointClickEvent };

package/types/ojiepermana-angular-chart-pie.d.ts

@@ -1 +1,131 @@
-export * from '@ojiepermana/angular-chart/pie';
+import * as _ojiepermana_angular_chart_core from '@ojiepermana/angular/chart/core';
+import { ChartDatum, ChartMargin, ChartPointClickEvent } from '@ojiepermana/angular/chart/core';
+import * as _ojiepermana_angular_chart_pie from '@ojiepermana/angular/chart/pie';
+import * as _angular_core from '@angular/core';
+
+interface PieLayoutInput {
+    readonly data: readonly ChartDatum[];
+    /** Field on each datum whose value is the slice's numeric magnitude. */
+    readonly valueKey: string;
+    /** Field on each datum whose value is the slice's categorical label. */
+    readonly nameKey: string;
+    /**
+     * Ordered series keys used to resolve color (`var(--color-<key>)`).
+     * Must have the same length as `data`. If omitted, falls back to
+     * `nameKey` values.
+     */
+    readonly seriesKeys?: readonly string[];
+    /**
+     * Series keys the legend has toggled off. Their slices are dropped and the
+     * remainder re-totals, because a pie's angles are relative by construction.
+     */
+    readonly hiddenSeriesKeys?: ReadonlySet<string>;
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    /** Inner radius for donut-style charts (0 = full pie). */
+    readonly innerRadius: number;
+    /** Gap between slices, in radians. */
+    readonly padAngle: number;
+    /** Corner radius for slices (px). */
+    readonly cornerRadius: number;
+    /** Starting angle in radians (default −π/2 = 12 o'clock). */
+    readonly startAngle: number;
+    /** Ending angle in radians (default 3π/2). */
+    readonly endAngle: number;
+    readonly activeIndex?: number;
+    readonly activeOffset?: number;
+}
+interface PieSliceRect {
+    readonly seriesKey: string;
+    readonly name: string;
+    readonly value: number;
+    readonly datumIndex: number;
+    readonly color: string;
+    readonly arcPath: string;
+    readonly centroid: readonly [number, number];
+    readonly startAngle: number;
+    readonly endAngle: number;
+    readonly translateX: number;
+    readonly translateY: number;
+}
+interface PieLayout {
+    readonly slices: readonly PieSliceRect[];
+    readonly centerX: number;
+    readonly centerY: number;
+    readonly outerRadius: number;
+}
+declare function computePieLayout(input: PieLayoutInput): PieLayout;
+
+/**
+ * @deprecated Use `ChartPointClickEvent` from
+ * `@ojiepermana/angular/chart/core`. `name` is superseded by `category`, which
+ * carries the same value; `name` is still emitted so existing handlers keep
+ * working.
+ */
+type PieSliceClickEvent = ChartPointClickEvent & {
+    /** @deprecated Use `category`. */
+    readonly name: string;
+};
+declare class PieChart {
+    private readonly root;
+    readonly data: _angular_core.InputSignal<readonly Readonly<Record<string, unknown>>[]>;
+    readonly valueKey: _angular_core.InputSignal<string>;
+    readonly nameKey: _angular_core.InputSignal<string>;
+    readonly seriesKeys: _angular_core.InputSignal<readonly string[] | undefined>;
+    /**
+     * Presentational style of the chart.
+     *
+     * Replaces `styles`, which read like a CSS styles bag rather than a single
+     * variant. Named `styleVariant` and not `variant` because `ChartBar` already
+     * publishes a `variant` input for its grouped versus stacked axis, and one
+     * name cannot mean two things across the family.
+     */
+    readonly styleVariant: _angular_core.InputSignal<"base" | undefined>;
+    /**
+     * @deprecated Use `styleVariant`. Still fully supported; when both are bound,
+     *   `styleVariant` wins. Due for removal in the next major.
+     */
+    readonly styles: _angular_core.InputSignal<"base">;
+    /** The style actually in effect. Bind this, never `styles()`. */
+    protected readonly chartStyle: _angular_core.Signal<"base">;
+    private readonly themeRadius;
+    private readonly themeSpace;
+    /**
+     * Plot gutters. Leave it unset and they follow the theme-space density
+     * axis; set it and your numbers win, unchanged, whatever the axis says.
+     */
+    readonly margin: _angular_core.InputSignal<ChartMargin | null>;
+    /** The margin actually in effect. Bind this, never `margin()`. */
+    protected readonly plotMargin: _angular_core.Signal<ChartMargin>;
+    readonly innerRadius: _angular_core.InputSignal<number>;
+    readonly padAngle: _angular_core.InputSignal<number>;
+    /**
+     * Slice corner radius. Unset now means "follow the theme-radius axis", the
+     * same contract `ChartBar` already offers, so a pie picks up the app's shape
+     * language instead of being the one chart that stays sharp.
+     *
+     * Zero is still available, and still means square corners: it is a real value,
+     * not the absence of one, which is why the default moved to `null`.
+     */
+    readonly cornerRadius: _angular_core.InputSignal<number | null>;
+    /** The slice corner radius actually in effect. */
+    protected readonly sliceCornerRadius: _angular_core.Signal<number>;
+    readonly startAngle: _angular_core.InputSignal<number>;
+    readonly endAngle: _angular_core.InputSignal<number>;
+    readonly showLabels: _angular_core.InputSignal<boolean>;
+    readonly activeIndex: _angular_core.InputSignal<number | undefined>;
+    readonly activeOffset: _angular_core.InputSignal<number>;
+    readonly sliceClick: _angular_core.OutputEmitterRef<PieSliceClickEvent>;
+    protected readonly polar: _ojiepermana_angular_chart_core.PolarChartSetup;
+    protected readonly layout: _angular_core.Signal<_ojiepermana_angular_chart_pie.PieLayout>;
+    protected readonly ariaSummary: _angular_core.Signal<string>;
+    protected readonly dataColumns: _angular_core.Signal<string[]>;
+    protected sliceAriaLabel(s: PieSliceRect): string;
+    protected sliceTransform(s: PieSliceRect): string | null;
+    protected emitClick(s: PieSliceRect): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PieChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PieChart, "ChartPie", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "valueKey": { "alias": "valueKey"; "required": true; "isSignal": true; }; "nameKey": { "alias": "nameKey"; "required": true; "isSignal": true; }; "seriesKeys": { "alias": "seriesKeys"; "required": false; "isSignal": true; }; "styleVariant": { "alias": "styleVariant"; "required": false; "isSignal": true; }; "styles": { "alias": "styles"; "required": false; "isSignal": true; }; "margin": { "alias": "margin"; "required": false; "isSignal": true; }; "innerRadius": { "alias": "innerRadius"; "required": false; "isSignal": true; }; "padAngle": { "alias": "padAngle"; "required": false; "isSignal": true; }; "cornerRadius": { "alias": "cornerRadius"; "required": false; "isSignal": true; }; "startAngle": { "alias": "startAngle"; "required": false; "isSignal": true; }; "endAngle": { "alias": "endAngle"; "required": false; "isSignal": true; }; "showLabels": { "alias": "showLabels"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "activeOffset": { "alias": "activeOffset"; "required": false; "isSignal": true; }; }, { "sliceClick": "sliceClick"; }, never, ["ChartPieCenter", "ChartTooltip", "ChartLegend"], true, never>;
+}
+
+export { PieChart, computePieLayout };
+export type { PieLayout, PieLayoutInput, PieSliceClickEvent, PieSliceRect };

package/types/ojiepermana-angular-chart-primitives.d.ts

@@ -1 +1,291 @@
-export * from '@ojiepermana/angular-chart/primitives';
+import * as _angular_core from '@angular/core';
+import { Type, TemplateRef } from '@angular/core';
+import * as _ojiepermana_angular_chart_core from '@ojiepermana/angular/chart/core';
+import { ChartTick, ChartDatum } from '@ojiepermana/angular/chart/core';
+
+/**
+ * X axis for a cartesian chart. Reads scales from `CartesianContext`.
+ *
+ * Renders as `<svg:g>` — must be placed inside the owning chart's SVG.
+ */
+declare class ChartAxisX {
+    private readonly ctx;
+    /** Approximate tick count for linear (value) scales. */
+    readonly tickCount: _angular_core.InputSignal<number>;
+    /** Show 6-px tick marks between the axis line and the labels. */
+    readonly tickLine: _angular_core.InputSignal<boolean>;
+    /** Formatter for numeric tick labels. */
+    readonly tickFormat: _angular_core.InputSignal<(value: number) => string>;
+    protected readonly innerWidth: _angular_core.WritableSignal<number>;
+    protected readonly transform: _angular_core.Signal<string>;
+    protected readonly ticks: _angular_core.Signal<ChartTick[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartAxisX, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartAxisX, "svg:g[ChartAxisX]", never, { "tickCount": { "alias": "tickCount"; "required": false; "isSignal": true; }; "tickLine": { "alias": "tickLine"; "required": false; "isSignal": true; }; "tickFormat": { "alias": "tickFormat"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Y axis for a cartesian chart. Reads scales from `CartesianContext`.
+ *
+ * Renders as `<svg:g>` — must be placed inside the owning chart's SVG.
+ */
+declare class ChartAxisY {
+    private readonly ctx;
+    readonly tickCount: _angular_core.InputSignal<number>;
+    readonly tickLine: _angular_core.InputSignal<boolean>;
+    readonly tickFormat: _angular_core.InputSignal<(value: number) => string>;
+    protected readonly innerHeight: _angular_core.WritableSignal<number>;
+    protected readonly ticks: _angular_core.Signal<ChartTick[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartAxisY, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartAxisY, "svg:g[ChartAxisY]", never, { "tickCount": { "alias": "tickCount"; "required": false; "isSignal": true; }; "tickLine": { "alias": "tickLine"; "required": false; "isSignal": true; }; "tickFormat": { "alias": "tickFormat"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Horizontal / vertical grid lines for the cartesian plotting area.
+ *
+ * Reads tick positions from `CartesianContext.valueScale`. Direction of the
+ * grid lines follows `orientation`:
+ *  - vertical   → horizontal grid lines (one per y-tick)
+ *  - horizontal → vertical grid lines (one per x-tick)
+ */
+declare class ChartGrid {
+    private readonly ctx;
+    readonly tickCount: _angular_core.InputSignal<number>;
+    protected readonly ticks: _angular_core.Signal<_ojiepermana_angular_chart_core.ChartTick[]>;
+    protected readonly line: (offset: number) => {
+        x1: number;
+        x2: number;
+        y1: number;
+        y2: number;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartGrid, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartGrid, "svg:g[ChartGrid]", never, { "tickCount": { "alias": "tickCount"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Crosshair primitive — a line drawn through the currently active data point
+ * perpendicular to the categorical axis. Reads `activePoint` from
+ * `ChartContext` and the scales from `CartesianContext`.
+ *
+ * Place inside a cartesian chart's SVG inner group.
+ */
+declare class ChartCrosshair {
+    private readonly root;
+    private readonly cart;
+    protected readonly line: _angular_core.Signal<{
+        x1: number;
+        x2: number;
+        y1: number;
+        y2: number;
+    } | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartCrosshair, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartCrosshair, "svg:g[ChartCrosshair]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ChartBrush {
+    private readonly hitbox;
+    private readonly cart;
+    private readonly categorical;
+    private readonly scatter;
+    private readonly document;
+    /**
+     * Torn down the moment a drag ends. Permanent `window:` bindings marked the
+     * view dirty for every pointer move anywhere on the page, brush or no brush.
+     */
+    private detachDragListeners;
+    constructor();
+    private readonly mode;
+    private readonly activePointerId;
+    private readonly categoryStartIndex;
+    private readonly categoryPanStart;
+    private readonly scatterBrush;
+    private readonly scatterPan;
+    protected readonly width: _angular_core.Signal<number>;
+    protected readonly height: _angular_core.Signal<number>;
+    protected readonly categoryPreview: _angular_core.Signal<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    protected readonly scatterPreviewRect: _angular_core.Signal<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(event?: PointerEvent): void;
+    protected onPointerCancel(event: PointerEvent): void;
+    protected onWheel(event: WheelEvent): void;
+    protected resetZoom(): void;
+    private beginDrag;
+    private endDrag;
+    private onScatterPointerDown;
+    private localPoint;
+    private pointerAxis;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartBrush, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartBrush, "svg:g[ChartBrush]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Attach to a chart's `<svg:svg>` to publish pointer-driven active-point
+ * state into the surrounding `ChartContext`.
+ *
+ * Computes the local (x, y) of the pointer relative to the inner plotting
+ * area, resolves the nearest category, and updates
+ * `ChartContext.activePoint`. Clears it on `pointerleave`.
+ */
+declare class ChartPointerTracker {
+    private readonly root;
+    private readonly cart;
+    private readonly viewport;
+    protected onMove(event: PointerEvent): void;
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartPointerTracker, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ChartPointerTracker, "svg:svg[ChartPointerTracker]", never, {}, {}, never, never, true, never>;
+}
+
+/** Row of data fed to tooltip templates. */
+interface ChartTooltipRow {
+    readonly seriesKey: string;
+    readonly label: string;
+    readonly value: unknown;
+    readonly color: string;
+    readonly icon?: Type<unknown>;
+}
+/** Payload available to a user-supplied tooltip template. */
+interface ChartTooltipPayload {
+    readonly category: string;
+    readonly datum: ChartDatum;
+    readonly rows: readonly ChartTooltipRow[];
+}
+/** Indicator rendered beside each tooltip row. */
+type ChartTooltipIndicator = 'dot' | 'line' | 'dashed' | 'none';
+/** Signature for the per-row value formatter (string output). */
+type ChartTooltipValueFormatter = (value: unknown, row: ChartTooltipRow, payload: ChartTooltipPayload) => string;
+/** Signature for the tooltip header (label) formatter. */
+type ChartTooltipLabelFormatter = (label: string, payload: ChartTooltipPayload) => string;
+/**
+ * Tooltip overlay — renders the default tooltip card (or a user-supplied
+ * template) anchored to the currently active data point.
+ *
+ * Shadcn-compatible knobs:
+ * - `indicator="line"` / `"none"` / `"dashed"` — swap the row glyph
+ * - `hideLabel` — drop the header row
+ * - `label="Activities"` — override the header text
+ * - `labelKey="activities"` — resolve the header from `config[labelKey].label`
+ * - `labelFormatter` — transform the header (e.g. ISO date → long date)
+ * - `formatter` — format per-row values (e.g. `"380 kcal"`)
+ * - `valueKey` — for pie/radial/radar, read row value from a single field
+ * - Icons are picked up automatically from `config[key].icon`.
+ */
+declare class ChartTooltip {
+    private readonly root;
+    private readonly host;
+    private readonly zone;
+    private readonly platformId;
+    private readonly destroyRef;
+    /**
+     * The two measurements `position` needs, taken outside it.
+     *
+     * `position` used to call `getBoundingClientRect` and read `offsetWidth`
+     * while the template evaluated it, which forced layout on every tick and left
+     * the tooltip stale after a resize — a computed only re-runs for the signals
+     * it reads, and a DOM box is not one.
+     */
+    private readonly containerBox;
+    private readonly tooltipBox;
+    constructor();
+    /** Data key on each datum whose value is the category label (x-axis). */
+    readonly xKey: _angular_core.InputSignal<string | null>;
+    /** Data source (optional — if omitted tooltip reads from chart data via activePoint.datumIndex). */
+    readonly data: _angular_core.InputSignal<readonly Readonly<Record<string, unknown>>[] | null>;
+    /**
+     * Optional key for per-datum value lookup (pie / radial / radar datasets
+     * store values on a single field like `visitors` instead of one field per
+     * series). When set and `activePoint.seriesKey` is active, the tooltip row
+     * reads `datum[valueKey]` for its value.
+     */
+    readonly valueKey: _angular_core.InputSignal<string | null>;
+    /** Indicator variant next to each row. Default `'dot'`. */
+    readonly indicator: _angular_core.InputSignal<ChartTooltipIndicator>;
+    /** Hide the header label entirely. */
+    readonly hideLabel: _angular_core.InputSignal<boolean>;
+    /** Override the header label with a fixed string. Takes precedence over `labelKey`. */
+    readonly label: _angular_core.InputSignal<string | null>;
+    /**
+     * Resolve the header label from `config[labelKey].label`. Useful when the
+     * header should come from a config entry rather than the datum itself
+     * (shadcn's "Custom label" variant).
+     */
+    readonly labelKey: _angular_core.InputSignal<string | null>;
+    /** Transform the final header string (e.g. ISO date → long date). */
+    readonly labelFormatter: _angular_core.InputSignal<ChartTooltipLabelFormatter | null>;
+    /** Format each row's value (return string — HTML is not interpreted). */
+    readonly formatter: _angular_core.InputSignal<ChartTooltipValueFormatter | null>;
+    readonly customTpl: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly visible: _angular_core.Signal<boolean>;
+    protected readonly payload: _angular_core.Signal<ChartTooltipPayload | null>;
+    /** Resolve the header string honoring `label`, `labelKey`, then `labelFormatter`. */
+    protected headerText(p: ChartTooltipPayload): string | null;
+    /** Apply per-row value formatter (or stringify). */
+    protected formatRow(row: ChartTooltipRow, p: ChartTooltipPayload): string;
+    protected readonly position: _angular_core.Signal<{
+        x: number;
+        y: number;
+    }>;
+    private observeContainer;
+    private measure;
+    private measureContainer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartTooltip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartTooltip, "ChartTooltip", never, { "xKey": { "alias": "xKey"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "valueKey": { "alias": "valueKey"; "required": false; "isSignal": true; }; "indicator": { "alias": "indicator"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelKey": { "alias": "labelKey"; "required": false; "isSignal": true; }; "labelFormatter": { "alias": "labelFormatter"; "required": false; "isSignal": true; }; "formatter": { "alias": "formatter"; "required": false; "isSignal": true; }; }, {}, ["customTpl"], never, true, never>;
+}
+
+/**
+ * Legend — renders a list of series swatches. Clicking an item toggles
+ * visibility via `ChartContext.toggleSeries`.
+ *
+ * Place as a child of `<Chart>`:
+ * ```html
+ * <Chart [config]="cfg">
+ *   <ChartBar ... />
+ *   <ChartLegend />
+ * </Chart>
+ * ```
+ */
+declare class ChartLegend {
+    private readonly root;
+    protected readonly items: _angular_core.Signal<{
+        seriesKey: string;
+        label: string;
+        color: string;
+        hidden: boolean;
+    }[]>;
+    protected toggle(key: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartLegend, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartLegend, "ChartLegend", never, {}, {}, never, never, true, never>;
+}
+
+declare class ChartZoomControls {
+    private readonly categorical;
+    private readonly scatter;
+    protected readonly status: _angular_core.Signal<string | null>;
+    protected readonly hint: _angular_core.Signal<"Drag to brush a region. Use the wheel to zoom and one-finger touch drag to pan while zoomed." | "Drag to select a category range. Use the wheel to zoom and one-finger touch drag to pan while zoomed.">;
+    protected resetZoom(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartZoomControls, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartZoomControls, "ChartZoomControls", never, {}, {}, never, never, true, never>;
+}
+
+declare class PieCenter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PieCenter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PieCenter, "ChartPieCenter", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class RadialCenter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadialCenter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadialCenter, "ChartRadialCenter", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { ChartAxisX, ChartAxisY, ChartBrush, ChartCrosshair, ChartGrid, ChartLegend, ChartPointerTracker, ChartTooltip, ChartZoomControls, PieCenter, RadialCenter };
+export type { ChartTooltipIndicator, ChartTooltipLabelFormatter, ChartTooltipPayload, ChartTooltipRow, ChartTooltipValueFormatter };

package/types/ojiepermana-angular-chart-radar.d.ts

@@ -1 +1,116 @@
-export * from '@ojiepermana/angular-chart/radar';
+import * as _ojiepermana_angular_chart_core from '@ojiepermana/angular/chart/core';
+import { ChartDatum, ChartMargin, ChartPointClickEvent } from '@ojiepermana/angular/chart/core';
+import * as _ojiepermana_angular_chart_radar from '@ojiepermana/angular/chart/radar';
+import * as _angular_core from '@angular/core';
+
+type RadarCurve = 'linear' | 'cardinal';
+type RadarGrid = 'polygon' | 'circle' | 'none';
+interface RadarLayoutInput {
+    readonly data: readonly ChartDatum[];
+    readonly axisKey: string;
+    readonly seriesKeys: readonly string[];
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    readonly maxValue?: number;
+    readonly levels: number;
+    readonly curve: RadarCurve;
+    readonly grid: RadarGrid;
+}
+interface RadarAxisInfo {
+    readonly name: string;
+    readonly angle: number;
+    readonly x: number;
+    readonly y: number;
+}
+interface RadarSeries {
+    readonly seriesKey: string;
+    readonly color: string;
+    readonly path: string;
+    readonly points: readonly {
+        readonly x: number;
+        readonly y: number;
+        readonly value: number;
+        readonly axis: string;
+    }[];
+}
+interface RadarLevel {
+    readonly value: number;
+    readonly radius: number;
+    readonly path: string;
+}
+interface RadarLayout {
+    readonly centerX: number;
+    readonly centerY: number;
+    readonly radius: number;
+    readonly axes: readonly RadarAxisInfo[];
+    readonly levels: readonly RadarLevel[];
+    readonly maxValue: number;
+    readonly series: readonly RadarSeries[];
+    readonly grid: RadarGrid;
+}
+declare function computeRadarLayout(input: RadarLayoutInput): RadarLayout;
+
+/** One radar dot, resolved to the row and series it stands for. */
+type RadarPoint = RadarSeries['points'][number];
+declare class RadarChart {
+    private readonly root;
+    readonly data: _angular_core.InputSignal<readonly Readonly<Record<string, unknown>>[]>;
+    readonly axisKey: _angular_core.InputSignal<string>;
+    /**
+     * Presentational style of the chart.
+     *
+     * Replaces `styles`, which read like a CSS styles bag rather than a single
+     * variant. Named `styleVariant` and not `variant` because `ChartBar` already
+     * publishes a `variant` input for its grouped versus stacked axis, and one
+     * name cannot mean two things across the family.
+     */
+    readonly styleVariant: _angular_core.InputSignal<"base" | undefined>;
+    /**
+     * @deprecated Use `styleVariant`. Still fully supported; when both are bound,
+     *   `styleVariant` wins. Due for removal in the next major.
+     */
+    readonly styles: _angular_core.InputSignal<"base">;
+    /** The style actually in effect. Bind this, never `styles()`. */
+    protected readonly chartStyle: _angular_core.Signal<"base">;
+    private readonly themeSpace;
+    /**
+     * Plot gutters. Leave it unset and they follow the theme-space density
+     * axis; set it and your numbers win, unchanged, whatever the axis says.
+     */
+    readonly margin: _angular_core.InputSignal<ChartMargin | null>;
+    /** The margin actually in effect. Bind this, never `margin()`. */
+    protected readonly plotMargin: _angular_core.Signal<ChartMargin>;
+    readonly curve: _angular_core.InputSignal<RadarCurve>;
+    readonly levels: _angular_core.InputSignal<number>;
+    readonly maxValue: _angular_core.InputSignal<number | undefined>;
+    readonly strokeWidth: _angular_core.InputSignal<number>;
+    readonly fillOpacity: _angular_core.InputSignal<number>;
+    readonly showLabels: _angular_core.InputSignal<boolean>;
+    readonly showDots: _angular_core.InputSignal<boolean>;
+    readonly dotRadius: _angular_core.InputSignal<number>;
+    readonly grid: _angular_core.InputSignal<RadarGrid>;
+    readonly gridFilled: _angular_core.InputSignal<boolean>;
+    readonly showAxes: _angular_core.InputSignal<boolean>;
+    readonly linesOnly: _angular_core.InputSignal<boolean>;
+    /**
+     * Emitted when a dot is activated by pointer or keyboard. Radar was the one
+     * chart family a keyboard user could focus but never operate.
+     */
+    readonly pointClick: _angular_core.OutputEmitterRef<ChartPointClickEvent<Readonly<Record<string, unknown>>>>;
+    protected readonly polar: _ojiepermana_angular_chart_core.PolarChartSetup;
+    protected readonly layout: _angular_core.Signal<_ojiepermana_angular_chart_radar.RadarLayout>;
+    protected readonly ariaSummary: _angular_core.Signal<string>;
+    protected readonly dataColumns: _angular_core.Signal<string[]>;
+    protected gridFill(): string;
+    protected gridFillOpacity(levelIndex: number): number | null;
+    protected dotAriaLabel(seriesKey: string, p: {
+        axis: string;
+        value: number;
+    }): string;
+    protected emitClick(seriesKey: string, point: RadarPoint, datumIndex: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadarChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadarChart, "ChartRadar", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "axisKey": { "alias": "axisKey"; "required": true; "isSignal": true; }; "styleVariant": { "alias": "styleVariant"; "required": false; "isSignal": true; }; "styles": { "alias": "styles"; "required": false; "isSignal": true; }; "margin": { "alias": "margin"; "required": false; "isSignal": true; }; "curve": { "alias": "curve"; "required": false; "isSignal": true; }; "levels": { "alias": "levels"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "fillOpacity": { "alias": "fillOpacity"; "required": false; "isSignal": true; }; "showLabels": { "alias": "showLabels"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "dotRadius": { "alias": "dotRadius"; "required": false; "isSignal": true; }; "grid": { "alias": "grid"; "required": false; "isSignal": true; }; "gridFilled": { "alias": "gridFilled"; "required": false; "isSignal": true; }; "showAxes": { "alias": "showAxes"; "required": false; "isSignal": true; }; "linesOnly": { "alias": "linesOnly"; "required": false; "isSignal": true; }; }, { "pointClick": "pointClick"; }, never, ["*", "ChartTooltip", "ChartLegend"], true, never>;
+}
+
+export { RadarChart, computeRadarLayout };
+export type { RadarAxisInfo, RadarCurve, RadarGrid, RadarLayout, RadarLayoutInput, RadarLevel, RadarSeries };