@ojiepermana/angular-chart 22.0.27

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

@@ -0,0 +1,369 @@
+import * as _angular_core from '@angular/core';
+import { Type, Signal } from '@angular/core';
+import * as _ojiepermana_angular_chart_core from '@ojiepermana/angular-chart/core';
+import { ScaleBand, ScaleLinear, scalePoint, scaleLinear, ScalePoint, scaleBand } from 'd3-scale';
+
+/**
+ * Theme-aware color definition for a chart series.
+ *
+ * Either:
+ * - a single `color` string (raw CSS color — hex, hsl, oklch, CSS var ref), or
+ * - a `theme` map whose keys match the document color scheme (`light` / `dark`).
+ *
+ * Values are injected verbatim into a scoped `<style>` block as
+ * `--color-<key>: <value>;`, so any valid CSS color works.
+ *
+ * Defaults reference the theme tokens from `@ojiepermana/angular-theme/styles`
+ * (e.g. `'hsl(var(--chart-1))'`).
+ */
+interface ChartSeriesConfig {
+    /** Human-readable label (shown in legend, tooltip). */
+    readonly label?: string;
+    /** Optional icon component rendered next to the label. */
+    readonly icon?: Type<unknown>;
+    /** Raw color. Mutually exclusive with `theme`. */
+    readonly color?: string;
+    /** Theme-aware colors — keyed by color scheme. */
+    readonly theme?: Readonly<Record<ChartThemeKey, string>>;
+}
+/** Supported color scheme keys. */
+type ChartThemeKey = 'light' | 'dark';
+/** Map of series-key → config. */
+type ChartConfig = Readonly<Record<string, ChartSeriesConfig>>;
+/** CSS selector under which a chart instance is scoped. */
+declare const CHART_DATA_ATTRIBUTE = "data-chart";
+/** Default color schemes supported by the generated `<style>` block. */
+declare const CHART_THEMES: ReadonlyArray<{
+    readonly key: ChartThemeKey;
+    readonly selector: string;
+}>;
+/**
+ * Generate the CSS rule-set for a chart instance: one `--color-<key>` per
+ * series, scoped to the owning `[data-chart]` element, with optional dark
+ * variant via `[data-mode="dark"] [data-chart="…"]`.
+ *
+ * Series without any color are skipped (consumer can fall back to a default).
+ *
+ * @param chartId  Unique chart id (used as attribute value).
+ * @param config   Series configuration map.
+ */
+declare function buildChartCss(chartId: string, config: ChartConfig): string;
+/** Resolve the `var(--color-<key>)` reference for a given series. */
+declare function seriesColorVar(seriesKey: string): string;
+
+/** Pixel dimensions of the chart render area. */
+interface ChartDimensions {
+    readonly width: number;
+    readonly height: number;
+}
+/** Active data point (for tooltip / crosshair) shared across primitives. */
+interface ChartActivePoint {
+    readonly index: number;
+    readonly datumIndex?: number;
+    readonly seriesKey?: string;
+    readonly clientX?: number;
+    readonly clientY?: number;
+}
+/**
+ * Shared chart state provided by `ChartContainer` to all nested chart
+ * components (axes, grid, tooltip, legend, chart types).
+ *
+ * All state is exposed as signals so consumers can derive computed state
+ * (scales, visible series, tooltip position) without manual subscriptions.
+ */
+declare class ChartContext {
+    /** Stable instance id — used in the `data-chart` attribute and CSS scope. */
+    readonly id: _angular_core.WritableSignal<string>;
+    /** User-provided series config. */
+    readonly config: _angular_core.WritableSignal<Readonly<Record<string, _ojiepermana_angular_chart_core.ChartSeriesConfig>>>;
+    /** Measured render-area dimensions (ResizeObserver-driven). */
+    readonly dimensions: _angular_core.WritableSignal<ChartDimensions>;
+    /** Currently highlighted data point (tooltip / crosshair). */
+    readonly activePoint: _angular_core.WritableSignal<ChartActivePoint | null>;
+    /** Series keys the user has toggled off via legend. */
+    readonly hiddenSeries: _angular_core.WritableSignal<ReadonlySet<string>>;
+    /** Ordered list of series keys (from `config`). */
+    readonly seriesKeys: Signal<readonly string[]>;
+    /** Series keys currently visible (config order minus `hiddenSeries`). */
+    readonly visibleSeriesKeys: Signal<readonly string[]>;
+    /** Toggle visibility of a series. */
+    toggleSeries(key: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartContext, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChartContext>;
+}
+
+/**
+ * Emits a scoped `<style>` block mapping every series key in the current
+ * `ChartConfig` to a `--color-<key>` CSS custom property, scoped to
+ * `[data-chart="<id>"]`. Dark-mode values are scoped under `[data-mode="dark"]`.
+ *
+ * Implemented as an empty component that injects a real `<style>` element
+ * into its host via `Renderer2`. We avoid rendering `<style>` directly in a
+ * template — Angular hoists those into component CSS and strips
+ * interpolations from them.
+ *
+ * Consumers never instantiate this directly — `ChartContainer` renders it.
+ */
+declare class ChartStyle {
+    private readonly ctx;
+    private readonly host;
+    private readonly renderer;
+    private styleEl;
+    protected readonly css: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartStyle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartStyle, "ChartStyle", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Presentational style of a chart family.
+ *
+ * Every chart component exposes a `styles` input that defaults to `'base'`
+ * (the classic look). Families may widen this union with their own custom
+ * styles — e.g. the bar family adds `'dot'` for a dot-matrix rendering.
+ *
+ * Custom styles are implemented inside each chart family (not in the theme
+ * library) but must only use theme CSS variables (`--muted`, `--color-<key>`,
+ * …) so they follow the active theme automatically.
+ */
+type ChartStyleVariant = 'base';
+
+/**
+ * Root of every chart. Provides `ChartContext` to descendants, reflects the
+ * chart id via `data-chart`, injects the per-instance CSS-variable
+ * `<style>` block, and tracks its render-area dimensions via
+ * `ResizeObserver`.
+ *
+ * Usage:
+ * ```html
+ * <Chart [config]="cfg">
+ *   <ChartBar [data]="data" />
+ *   <ChartLegend />
+ * </Chart>
+ * ```
+ *
+ * The chart render area is laid out on top; any projected `<ChartLegend>` is
+ * rendered as a centered row beneath it. Render-area dimensions are measured on
+ * the chart area only, so the legend never shrinks the chart.
+ */
+declare class ChartContainer {
+    protected readonly ctx: ChartContext;
+    private readonly zone;
+    private readonly platformId;
+    private readonly destroyRef;
+    private readonly areaRef;
+    /** Series configuration. Required for color / label resolution. */
+    readonly config: _angular_core.InputSignal<Readonly<Record<string, _ojiepermana_angular_chart_core.ChartSeriesConfig>>>;
+    /**
+     * Tailwind aspect-ratio utility for the chart render area. Defaults to
+     * `aspect-video` for cartesian charts; override with `aspect-square` for
+     * radial / pie layouts, or e.g. `aspect-auto h-[320px]` for a fixed height.
+     */
+    readonly aspect: _angular_core.InputSignal<string>;
+    protected readonly areaClass: _angular_core.Signal<string>;
+    /**
+     * Optional explicit id override. When omitted, a stable auto-id is
+     * generated (`chart-<n>`), unique across the document.
+     */
+    readonly chartId: _angular_core.InputSignal<string | null>;
+    constructor();
+    private observeSize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartContainer, "Chart", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "aspect": { "alias": "aspect"; "required": false; "isSignal": true; }; "chartId": { "alias": "chartId"; "required": false; "isSignal": true; }; }, {}, never, ["*", "ChartLegend"], true, never>;
+}
+
+/** A single row of chart data — one categorical key + N numeric series. */
+type ChartDatum = Readonly<Record<string, unknown>>;
+/** Render-area margins inside the chart's SVG (px). */
+interface ChartMargin {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}
+/** Axis orientation for cartesian charts. */
+type ChartOrientation = 'vertical' | 'horizontal';
+/** Primary axis scale — band for categorical, linear for numeric. */
+type CategoryScale = ScaleBand<string>;
+type ValueScale = ScaleLinear<number, number>;
+/**
+ * Cartesian plotting frame shared between a chart type (Bar, Line, Area…)
+ * and its axis / grid primitives.
+ *
+ * The owning chart component provides an instance and publishes its scales;
+ * descendants read them via signals and re-render when dimensions or data
+ * change.
+ */
+declare class CartesianContext {
+    /** Inner width (outer width − margin.left − margin.right). */
+    readonly innerWidth: _angular_core.WritableSignal<number>;
+    /** Inner height (outer height − margin.top − margin.bottom). */
+    readonly innerHeight: _angular_core.WritableSignal<number>;
+    /** Margins around the plotting area. */
+    readonly margin: _angular_core.WritableSignal<ChartMargin>;
+    /** Layout orientation (drives which axis holds the band scale). */
+    readonly orientation: _angular_core.WritableSignal<ChartOrientation>;
+    /** Band (categorical) scale. */
+    readonly categoryScale: _angular_core.WritableSignal<CategoryScale | null>;
+    /** Linear (numeric) scale. */
+    readonly valueScale: _angular_core.WritableSignal<ValueScale | null>;
+    /** Ordered category domain (e.g. x labels for vertical, y labels for horizontal). */
+    readonly categories: _angular_core.WritableSignal<readonly string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CartesianContext, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CartesianContext>;
+}
+/** Resolve the scale that maps to the X axis for a given orientation. */
+declare function xScale(ctx: Pick<CartesianContext, 'orientation' | 'categoryScale' | 'valueScale'>): Signal<CategoryScale | ValueScale | null>;
+/** Resolve the scale that maps to the Y axis for a given orientation. */
+declare function yScale(ctx: Pick<CartesianContext, 'orientation' | 'categoryScale' | 'valueScale'>): Signal<CategoryScale | ValueScale | null>;
+
+interface ChartIndexRange {
+    readonly startIndex: number;
+    readonly endIndex: number;
+}
+type NumericDomain = readonly [number, number];
+declare function normalizeIndexRange(start: number, end: number, maxCount: number): ChartIndexRange | null;
+declare function effectiveIndexRange(range: ChartIndexRange | null, maxCount: number): ChartIndexRange | null;
+declare function indexRangeSize(range: ChartIndexRange | null, maxCount: number): number;
+declare function sliceByIndexRange<T>(data: readonly T[], range: ChartIndexRange | null): readonly T[];
+declare function zoomIndexRange(current: ChartIndexRange | null, maxCount: number, anchorIndex: number, factor: number): ChartIndexRange | null;
+declare function panIndexRange(current: ChartIndexRange | null, maxCount: number, deltaSteps: number): ChartIndexRange | null;
+declare function normalizeNumericDomain(a: number, b: number): NumericDomain;
+declare function zoomNumericDomain(current: NumericDomain, full: NumericDomain, anchor: number, factor: number): NumericDomain;
+declare function panNumericDomain(current: NumericDomain, full: NumericDomain, delta: number): NumericDomain;
+
+declare class CategoricalViewportContext {
+    readonly dataCount: _angular_core.WritableSignal<number>;
+    readonly brushRange: _angular_core.WritableSignal<ChartIndexRange | null>;
+    readonly zoomRange: _angular_core.WritableSignal<ChartIndexRange | null>;
+    readonly hasZoom: _angular_core.Signal<boolean>;
+    resetZoom(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CategoricalViewportContext, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CategoricalViewportContext>;
+}
+
+declare class ScatterViewportContext {
+    readonly innerWidth: _angular_core.WritableSignal<number>;
+    readonly innerHeight: _angular_core.WritableSignal<number>;
+    readonly fullXDomain: _angular_core.WritableSignal<NumericDomain | null>;
+    readonly fullYDomain: _angular_core.WritableSignal<NumericDomain | null>;
+    readonly zoomXDomain: _angular_core.WritableSignal<NumericDomain | null>;
+    readonly zoomYDomain: _angular_core.WritableSignal<NumericDomain | null>;
+    readonly xScale: _angular_core.WritableSignal<ScaleLinear<number, number, never> | null>;
+    readonly yScale: _angular_core.WritableSignal<ScaleLinear<number, number, never> | null>;
+    readonly hasZoom: _angular_core.Signal<boolean>;
+    resetZoom(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScatterViewportContext, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ScatterViewportContext>;
+}
+
+/** A tick descriptor for rendering axes. */
+interface ChartTick {
+    readonly value: string | number;
+    /** Offset (px) along the axis. For band scales this is the band center. */
+    readonly offset: number;
+    /** Display label. */
+    readonly label: string;
+}
+/** Produce evenly-spaced ticks for a band (categorical) scale. */
+declare function bandTicks(scale: ScaleBand<string>): ChartTick[];
+/**
+ * Produce ticks for a linear scale.
+ *
+ * @param scale      The linear scale.
+ * @param count      Approximate number of ticks (hint, d3 may return fewer/more).
+ * @param formatter  Label formatter.
+ */
+declare function linearTicks(scale: ScaleLinear<number, number>, count?: number, formatter?: (value: number) => string): ChartTick[];
+
+interface ClientPoint {
+    readonly clientX: number;
+    readonly clientY: number;
+}
+/**
+ * Given a pointer event's local (x, y) relative to the chart's inner group,
+ * resolve the nearest category index along the categorical axis.
+ *
+ * @returns index into `ctx.categories()` (or −1 if no scale / no data).
+ */
+declare function nearestCategoryIndex(ctx: Pick<CartesianContext, 'categoryScale' | 'categories' | 'orientation'>, localX: number, localY: number): number;
+/** Resolve the client-space center point of a focused or clicked SVG/HTML element. */
+declare function elementClientCenter(target: EventTarget | null): ClientPoint | null;
+
+/** Curve type shared by line & area charts. */
+type LineCurve = 'linear' | 'monotone' | 'step';
+/** A single series ready to render as either a line or an area. */
+interface LineSeriesPath {
+    readonly seriesKey: string;
+    readonly color: string;
+    readonly linePath: string;
+    /** Optional area path — only populated when `computeAreaLayout` is used. */
+    readonly areaPath?: string;
+    /** Raw points for dots / active markers. */
+    readonly points: readonly LinePoint[];
+}
+/** One resolved (x, y) point for a series. */
+interface LinePoint {
+    readonly seriesKey: string;
+    readonly datumIndex: number;
+    readonly category: string;
+    readonly value: number;
+    readonly x: number;
+    readonly y: number;
+}
+interface CartesianBase {
+    readonly data: readonly ChartDatum[];
+    readonly xKey: string;
+    readonly seriesKeys: readonly string[];
+    readonly orientation: ChartOrientation;
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    readonly curve: LineCurve;
+}
+interface LineLayoutResult {
+    readonly series: readonly LineSeriesPath[];
+    readonly points: readonly LinePoint[];
+    readonly categoryScale: ReturnType<typeof scalePoint<string>>;
+    readonly valueScale: ReturnType<typeof scaleLinear<number, number>>;
+    readonly categories: readonly string[];
+}
+interface AreaLayoutResult extends LineLayoutResult {
+    readonly stacked: boolean;
+}
+/** Build category + value scales for point-based charts (line / area). */
+declare function buildCartesianScales(input: CartesianBase): {
+    categories: readonly string[];
+    categoryScale: ReturnType<typeof scalePoint<string>>;
+    valueScale: ReturnType<typeof scaleLinear<number, number>>;
+};
+/** Compute line-chart geometry. */
+declare function computeLineLayout(input: CartesianBase): LineLayoutResult;
+interface AreaLayoutInput extends CartesianBase {
+    readonly stacked: boolean;
+    readonly expanded?: boolean;
+}
+/** Compute area-chart geometry (single or stacked). */
+declare function computeAreaLayout(input: AreaLayoutInput): AreaLayoutResult;
+
+/**
+ * Publish a `scalePoint` from line/area layouts to the `CartesianContext`,
+ * which expects a `scaleBand`. Line/area points sit on the range edges (the
+ * point scale has zero padding, so the first point touches the y-axis and the
+ * last touches the right edge). We extend the band range by half a step on
+ * each side so band centers — used to position axis ticks — line up exactly
+ * with those edge-touching points.
+ *
+ * This keeps axes/grid primitives agnostic to whether the underlying chart
+ * uses `scaleBand` (bar) or `scalePoint` (line/area).
+ */
+declare function pointToBandAdapter(pointScale: ScalePoint<string>, range: [number, number]): ReturnType<typeof scaleBand<string>>;
+/** Recreate a linear scale with the same domain/range (handy for effects). */
+declare function cloneLinear(scale: ReturnType<typeof scaleLinear<number, number>>): ReturnType<typeof scaleLinear<number, number>>;
+declare function provideCartesianFromLineLayout(ctx: CartesianContext, layout: {
+    categoryScale: ScalePoint<string>;
+    valueScale: ReturnType<typeof scaleLinear<number, number>>;
+    categories: readonly string[];
+}, orientation: 'vertical' | 'horizontal', innerWidth: number, innerHeight: number): void;
+
+export { CHART_DATA_ATTRIBUTE, CHART_THEMES, CartesianContext, CategoricalViewportContext, ChartContainer, ChartContext, ChartStyle, ScatterViewportContext, bandTicks, buildCartesianScales, buildChartCss, cloneLinear, computeAreaLayout, computeLineLayout, effectiveIndexRange, elementClientCenter, indexRangeSize, linearTicks, nearestCategoryIndex, normalizeIndexRange, normalizeNumericDomain, panIndexRange, panNumericDomain, pointToBandAdapter, provideCartesianFromLineLayout, seriesColorVar, sliceByIndexRange, xScale, yScale, zoomIndexRange, zoomNumericDomain };
+export type { AreaLayoutInput, AreaLayoutResult, CartesianBase, CategoryScale, ChartActivePoint, ChartConfig, ChartDatum, ChartDimensions, ChartIndexRange, ChartMargin, ChartOrientation, ChartSeriesConfig, ChartStyleVariant, ChartThemeKey, ChartTick, ClientPoint, LineCurve, LineLayoutResult, LinePoint, LineSeriesPath, NumericDomain, ValueScale };

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

@@ -0,0 +1,57 @@
+import * as _ojiepermana_angular_chart_core from '@ojiepermana/angular-chart/core';
+import { ChartOrientation, LineCurve, ChartMargin, ChartDatum, LineSeriesPath, LinePoint } 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). */
+interface LinePointClickEvent {
+    readonly seriesKey: string;
+    readonly datumIndex: number;
+    readonly category: string;
+    readonly value: number;
+    readonly datum: ChartDatum;
+}
+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>;
+    readonly styles: _angular_core.InputSignal<"base">;
+    readonly curve: _angular_core.InputSignal<LineCurve>;
+    readonly margin: _angular_core.InputSignal<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>;
+    protected readonly innerWidth: _angular_core.Signal<number>;
+    protected readonly innerHeight: _angular_core.Signal<number>;
+    protected readonly visibleStartIndex: _angular_core.Signal<number>;
+    protected readonly visibleData: _angular_core.Signal<readonly Readonly<Record<string, unknown>>[]>;
+    protected readonly layout: _angular_core.Signal<_ojiepermana_angular_chart_core.LineLayoutResult>;
+    protected readonly series: _angular_core.Signal<readonly LineSeriesPath[]>;
+    protected readonly viewBox: _angular_core.Signal<string>;
+    protected readonly innerTransform: _angular_core.Signal<string>;
+    protected readonly ariaSummary: _angular_core.Signal<string>;
+    constructor();
+    protected emitClick(p: LinePoint): void;
+    protected setActivePoint(event: FocusEvent, p: LinePoint): void;
+    protected clearActivePoint(): void;
+    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';
+    protected pointAriaLabel(p: LinePoint): string;
+    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; }; "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[ChartGrid]", "svg\\:g[ChartAxisX]", "svg\\:g[ChartAxisY]", "svg\\:g[ChartCrosshair]", "svg:g[ChartBrush]", "ChartTooltip", "ChartLegend", "ChartZoomControls"], true, never>;
+}
+
+export { LineChart };
+export type { LinePointClickEvent };

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

@@ -0,0 +1,93 @@
+import { ChartDatum, ChartMargin } 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[];
+    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;
+
+interface PieSliceClickEvent {
+    readonly seriesKey: string;
+    readonly name: string;
+    readonly value: number;
+    readonly datumIndex: number;
+    readonly datum: ChartDatum;
+}
+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>;
+    readonly styles: _angular_core.InputSignal<"base">;
+    readonly margin: _angular_core.InputSignal<ChartMargin>;
+    readonly innerRadius: _angular_core.InputSignal<number>;
+    readonly padAngle: _angular_core.InputSignal<number>;
+    readonly cornerRadius: _angular_core.InputSignal<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 innerWidth: _angular_core.Signal<number>;
+    protected readonly innerHeight: _angular_core.Signal<number>;
+    protected readonly layout: _angular_core.Signal<_ojiepermana_angular_chart_pie.PieLayout>;
+    protected readonly viewBox: _angular_core.Signal<string>;
+    protected readonly innerTransform: _angular_core.Signal<string>;
+    protected readonly ariaSummary: _angular_core.Signal<string>;
+    protected sliceAriaLabel(s: PieSliceRect): string;
+    protected sliceTransform(s: PieSliceRect): string | null;
+    protected emitClick(s: PieSliceRect): void;
+    protected setActive(event: PointerEvent | FocusEvent, s: PieSliceRect): void;
+    protected clearActive(): 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; }; "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 };