@ojiepermana/angular 22.1.10 → 22.1.12

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

@@ -1 +1,116 @@
-export * from '@ojiepermana/angular-chart/radial';
+import * as _ojiepermana_angular_chart_core from '@ojiepermana/angular/chart/core';
+import { ChartDatum, ChartPointClickEvent, ChartMargin } from '@ojiepermana/angular/chart/core';
+import * as _ojiepermana_angular_chart_radial from '@ojiepermana/angular/chart/radial';
+import * as _angular_core from '@angular/core';
+
+interface RadialLayoutInput {
+    readonly data: readonly ChartDatum[];
+    readonly nameKey: string;
+    readonly valueKey: string;
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    /** Optional explicit series-key list (same length as data). */
+    readonly seriesKeys?: readonly string[];
+    /**
+     * Series keys the legend has toggled off. Their tracks are dropped and the
+     * remaining ones share the radius; the value scale is unaffected, so a track
+     * that stays keeps the sweep it had.
+     */
+    readonly hiddenSeriesKeys?: ReadonlySet<string>;
+    /** Gap between concentric tracks (px). */
+    readonly trackPadding: number;
+    /** Start / end angle (radians). */
+    readonly startAngle: number;
+    readonly endAngle: number;
+    readonly cornerRadius: number;
+    readonly maxValue?: number;
+}
+interface RadialBarRect {
+    readonly seriesKey: string;
+    readonly name: string;
+    readonly value: number;
+    readonly datumIndex: number;
+    readonly color: string;
+    readonly arcPath: string;
+    readonly backgroundPath: string;
+    readonly innerRadius: number;
+    readonly outerRadius: number;
+    readonly endAngle: number;
+}
+interface RadialLayout {
+    readonly centerX: number;
+    readonly centerY: number;
+    readonly outerRadius: number;
+    readonly bars: readonly RadialBarRect[];
+    readonly maxValue: number;
+}
+declare function computeRadialLayout(input: RadialLayoutInput): RadialLayout;
+
+type RadialValueLabelFormatter = (value: number, name: string) => string;
+/**
+ * @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 RadialBarClickEvent = ChartPointClickEvent & {
+    /** @deprecated Use `category`. */
+    readonly name: string;
+};
+declare class RadialChart {
+    private readonly root;
+    private readonly themeRadius;
+    readonly data: _angular_core.InputSignal<readonly Readonly<Record<string, unknown>>[]>;
+    readonly nameKey: _angular_core.InputSignal<string>;
+    readonly valueKey: _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 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 trackPadding: _angular_core.InputSignal<number>;
+    readonly cornerRadius: _angular_core.InputSignal<number | null>;
+    readonly startAngle: _angular_core.InputSignal<number>;
+    readonly endAngle: _angular_core.InputSignal<number>;
+    readonly maxValue: _angular_core.InputSignal<number | undefined>;
+    readonly showTrack: _angular_core.InputSignal<boolean>;
+    readonly showValueLabels: _angular_core.InputSignal<boolean>;
+    readonly valueLabelFormat: _angular_core.InputSignal<RadialValueLabelFormatter>;
+    readonly barClick: _angular_core.OutputEmitterRef<RadialBarClickEvent>;
+    protected readonly resolvedCornerRadius: _angular_core.Signal<number>;
+    protected readonly polar: _ojiepermana_angular_chart_core.PolarChartSetup;
+    protected readonly layout: _angular_core.Signal<_ojiepermana_angular_chart_radial.RadialLayout>;
+    protected readonly ariaSummary: _angular_core.Signal<string>;
+    protected readonly dataColumns: _angular_core.Signal<string[]>;
+    protected barAriaLabel(b: RadialBarRect): string;
+    protected formatValueLabel(b: RadialBarRect): string;
+    protected barLabelX(b: RadialBarRect): number;
+    protected barLabelY(b: RadialBarRect): number;
+    protected barLabelAnchor(b: RadialBarRect): 'start' | 'end';
+    protected emitClick(b: RadialBarRect): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadialChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadialChart, "ChartRadial", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "nameKey": { "alias": "nameKey"; "required": true; "isSignal": true; }; "valueKey": { "alias": "valueKey"; "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; }; "trackPadding": { "alias": "trackPadding"; "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; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "showTrack": { "alias": "showTrack"; "required": false; "isSignal": true; }; "showValueLabels": { "alias": "showValueLabels"; "required": false; "isSignal": true; }; "valueLabelFormat": { "alias": "valueLabelFormat"; "required": false; "isSignal": true; }; }, { "barClick": "barClick"; }, never, ["ChartRadialCenter", "ChartTooltip", "ChartLegend"], true, never>;
+}
+
+export { RadialChart, computeRadialLayout };
+export type { RadialBarClickEvent, RadialBarRect, RadialLayout, RadialLayoutInput, RadialValueLabelFormatter };

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

@@ -1 +1,125 @@
-export * from '@ojiepermana/angular-chart/scatter';
+import { ScaleLinear } from 'd3-scale';
+import * as _ojiepermana_angular_chart_core from '@ojiepermana/angular/chart/core';
+import { NumericDomain, ChartDatum, ChartMargin, ChartPointClickEvent } from '@ojiepermana/angular/chart/core';
+import * as _ojiepermana_angular_chart_scatter from '@ojiepermana/angular/chart/scatter';
+import * as _angular_core from '@angular/core';
+
+interface ScatterLayoutInput {
+    readonly data: readonly ChartDatum[];
+    readonly xKey: string;
+    readonly yKey: string;
+    readonly sizeKey?: string;
+    readonly seriesKey?: string;
+    readonly seriesKeys: readonly string[];
+    readonly innerWidth: number;
+    readonly innerHeight: number;
+    readonly minPointRadius: number;
+    readonly maxPointRadius: number;
+    readonly xDomain?: readonly [number, number];
+    readonly yDomain?: readonly [number, number];
+}
+interface ScatterPoint {
+    readonly seriesKey: string;
+    readonly color: string;
+    readonly x: number;
+    readonly y: number;
+    readonly radius: number;
+    readonly datumIndex: number;
+    readonly rawX: number;
+    readonly rawY: number;
+    readonly rawSize: number;
+}
+interface ScatterLayout {
+    readonly points: readonly ScatterPoint[];
+    readonly xScale: ScaleLinear<number, number>;
+    readonly yScale: ScaleLinear<number, number>;
+    readonly xDomain: NumericDomain;
+    readonly yDomain: NumericDomain;
+}
+declare function resolveScatterDomains(input: Pick<ScatterLayoutInput, 'data' | 'xKey' | 'yKey' | 'xDomain' | 'yDomain'>): {
+    xDomain: NumericDomain;
+    yDomain: NumericDomain;
+};
+declare function computeScatterLayout(input: ScatterLayoutInput): ScatterLayout;
+
+/**
+ * @deprecated Use `ChartPointClickEvent` from `@ojiepermana/angular/chart/core`.
+ * `x` and `y` stay scatter-only and are still emitted; the shared `category` and
+ * `value` carry the same pair (`category` is the x value as text, `value` is y).
+ */
+type ScatterPointClickEvent = ChartPointClickEvent & {
+    /** Raw x value. Also surfaced as `category`. */
+    readonly x: number;
+    /** Raw y value. Also surfaced as `value`. */
+    readonly y: number;
+};
+/**
+ * Scatter chart — one dot per datum. Both axes are linear; color can
+ * come from a fixed series key or per-row via `seriesKey` field. Point
+ * radius optionally scales with `sizeKey`.
+ */
+declare class ScatterChart {
+    private readonly root;
+    private readonly viewport;
+    readonly data: _angular_core.InputSignal<readonly Readonly<Record<string, unknown>>[]>;
+    readonly xKey: _angular_core.InputSignal<string>;
+    readonly yKey: _angular_core.InputSignal<string>;
+    /** Optional numeric field to drive point radius. */
+    readonly sizeKey: _angular_core.InputSignal<string | undefined>;
+    /** Optional field on each datum used as color key. */
+    readonly seriesKey: _angular_core.InputSignal<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 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 minPointRadius: _angular_core.InputSignal<number>;
+    readonly maxPointRadius: _angular_core.InputSignal<number>;
+    readonly xDomain: _angular_core.InputSignal<readonly [number, number] | undefined>;
+    readonly yDomain: _angular_core.InputSignal<readonly [number, number] | undefined>;
+    readonly pointClick: _angular_core.OutputEmitterRef<ScatterPointClickEvent>;
+    /**
+     * The shared cartesian scaffolding. Scatter uses the geometry, the layout
+     * effect, and the click plus active-point plus aria-label handlers; it has no
+     * `CartesianContext` of its own (it publishes to a `ScatterViewportContext`
+     * instead) and no index window, so it passes neither `cartesian` nor
+     * `viewport`.
+     *
+     * Declared before `layout` because the layout computed reads its geometry.
+     */
+    protected readonly cx: _ojiepermana_angular_chart_core.CartesianChartSetup<ScatterPoint>;
+    protected readonly resolvedDomains: _angular_core.Signal<{
+        xDomain: _ojiepermana_angular_chart_core.NumericDomain;
+        yDomain: _ojiepermana_angular_chart_core.NumericDomain;
+    }>;
+    protected readonly currentXDomain: _angular_core.Signal<_ojiepermana_angular_chart_core.NumericDomain>;
+    protected readonly currentYDomain: _angular_core.Signal<_ojiepermana_angular_chart_core.NumericDomain>;
+    protected readonly layout: _angular_core.Signal<_ojiepermana_angular_chart_scatter.ScatterLayout>;
+    protected readonly clipPathId: _angular_core.Signal<string>;
+    protected readonly ariaSummary: _angular_core.Signal<string>;
+    protected readonly dataColumns: _angular_core.Signal<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScatterChart, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScatterChart, "ChartScatter", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "xKey": { "alias": "xKey"; "required": true; "isSignal": true; }; "yKey": { "alias": "yKey"; "required": true; "isSignal": true; }; "sizeKey": { "alias": "sizeKey"; "required": false; "isSignal": true; }; "seriesKey": { "alias": "seriesKey"; "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; }; "minPointRadius": { "alias": "minPointRadius"; "required": false; "isSignal": true; }; "maxPointRadius": { "alias": "maxPointRadius"; "required": false; "isSignal": true; }; "xDomain": { "alias": "xDomain"; "required": false; "isSignal": true; }; "yDomain": { "alias": "yDomain"; "required": false; "isSignal": true; }; }, { "pointClick": "pointClick"; }, never, ["svg:g[ChartBrush]", "ChartTooltip", "ChartLegend", "ChartZoomControls"], true, never>;
+}
+
+export { ScatterChart, computeScatterLayout, resolveScatterDomains };
+export type { ScatterLayout, ScatterLayoutInput, ScatterPoint, ScatterPointClickEvent };

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

@@ -1 +1,2 @@
-export * from '@ojiepermana/angular-chart';
+export { AreaLayoutInput, AreaLayoutResult, CHART_DATA_ATTRIBUTE, CHART_THEMES, CartesianBase, CartesianChartOptions, CartesianChartSetup, CartesianContext, CartesianMark, CategoricalViewportContext, CategoryScale, ChartActivePoint, ChartConfig, ChartContainer, ChartContext, ChartDatum, ChartDimensions, ChartIndexRange, ChartMargin, ChartOrientation, ChartPointClickEvent, ChartSeriesConfig, ChartStyle, ChartStyleVariant, ChartThemeKey, ChartTick, ClientPoint, DEFAULT_CARTESIAN_MARGIN, DEFAULT_POLAR_MARGIN, DEFAULT_RADAR_MARGIN, LineCurve, LineLayoutResult, LinePoint, LineSeriesPath, NumericDomain, ScatterViewportContext, ValueScale, bandTicks, buildCartesianScales, buildChartCss, cloneLinear, computeAreaLayout, computeLineLayout, effectiveIndexRange, elementClientCenter, escapeCssIdent, indexRangeSize, isSafeCssColorValue, linearTicks, nearestCategoryIndex, normalizeIndexRange, normalizeNumericDomain, panIndexRange, panNumericDomain, pointToBandAdapter, provideCartesianFromLineLayout, resolveChartStyle, resolveSeriesColor, seriesColorVar, setupCartesianChart, sliceByIndexRange, xScale, yScale, zoomIndexRange, zoomNumericDomain } from '@ojiepermana/angular/chart/core';
+export { ChartAxisX, ChartAxisY, ChartBrush, ChartCrosshair, ChartGrid, ChartLegend, ChartPointerTracker, ChartTooltip, ChartTooltipIndicator, ChartTooltipLabelFormatter, ChartTooltipPayload, ChartTooltipRow, ChartTooltipValueFormatter, ChartZoomControls, PieCenter, RadialCenter } from '@ojiepermana/angular/chart/primitives';

package/types/ojiepermana-angular-component-accordion.d.ts

@@ -1 +1,85 @@
-export * from '@ojiepermana/angular-component/accordion';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
+import * as i1 from '@ojiepermana/angular/component/utils/scale';
+import { ComponentScaleDirective } from '@ojiepermana/angular/component/utils/scale';
+
+type AccordionType = 'single' | 'multiple';
+declare abstract class AccordionContextBase {
+    abstract isOpen(value: string): boolean;
+    abstract toggle(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionContextBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionContextBase, never, never, {}, {}, never, never, true, never>;
+}
+declare class AccordionComponent extends AccordionContextBase {
+    protected readonly componentScale: ComponentScaleDirective;
+    readonly radius: _angular_core.InputSignal<"inherit" | "none" | "xs" | "sm" | "md" | "xl" | "full">;
+    readonly density: _angular_core.InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
+    readonly type: _angular_core.InputSignal<AccordionType>;
+    readonly collapsible: _angular_core.InputSignal<boolean>;
+    readonly value: _angular_core.ModelSignal<string | string[] | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private readonly openSet;
+    isOpen(value: string): boolean;
+    /**
+     * Header elements, so arrow keys can move between them.
+     *
+     * Kept as a set of elements rather than an ordered list: registration order
+     * follows creation order, which is not the reading order once items are added,
+     * removed, or reordered. {@link orderedTriggers} sorts by document position so
+     * the keyboard always follows what the user sees.
+     */
+    private readonly triggers;
+    registerTrigger(element: HTMLElement): void;
+    unregisterTrigger(element: HTMLElement): void;
+    /** Move focus between headers, wrapping around, the way Tabs does. */
+    moveTriggerFocus(from: HTMLElement, offset: number): void;
+    focusFirstTrigger(): void;
+    focusLastTrigger(): void;
+    private orderedTriggers;
+    toggle(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionComponent, "Accordion", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "collapsible": { "alias": "collapsible"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+}
+declare class AccordionItemComponent {
+    protected readonly ctx: AccordionContextBase;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly triggerId: string;
+    readonly contentId: string;
+    protected readonly classes: _angular_core.Signal<string>;
+    readonly open: _angular_core.Signal<boolean>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionItemComponent, "AccordionItem", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AccordionTriggerComponent implements OnInit, OnDestroy {
+    protected readonly item: AccordionItemComponent;
+    private readonly accordion;
+    private readonly el;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Arrow keys move focus between headers; they never open or close a section.
+     * Enter and Space still do the toggling, which is the accordion pattern and
+     * matches how Tabs moves between its triggers.
+     */
+    protected onArrow(event: KeyboardEvent, offset: number): void;
+    protected onHome(event: KeyboardEvent): void;
+    protected onEnd(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionTriggerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionTriggerComponent, "button[AccordionTrigger]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AccordionContentComponent {
+    protected readonly item: AccordionItemComponent;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionContentComponent, "AccordionContent", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { AccordionComponent, AccordionContentComponent, AccordionContextBase, AccordionItemComponent, AccordionTriggerComponent };
+export type { AccordionType };

package/types/ojiepermana-angular-component-alert-dialog.d.ts

@@ -1 +1,140 @@
-export * from '@ojiepermana/angular-component/alert-dialog';
+import * as _angular_core from '@angular/core';
+import * as i1 from '@ojiepermana/angular/component/utils/scale';
+import { ComponentScaleDirective } from '@ojiepermana/angular/component/utils/scale';
+import { DialogBackdrop } from '@ojiepermana/angular/component/dialog';
+import { ButtonVariant, ButtonSize } from '@ojiepermana/angular/component/button';
+
+type AlertDialogSize = 'default' | 'sm';
+
+/**
+ * Confirmation dialog with `role="alertdialog"`.
+ *
+ * For the accessible name/description to wire up automatically, project the
+ * matching `AlertDialogTitle` / `AlertDialogDescription` parts (they register
+ * their ids with this component). Plain `DialogTitle` / `DialogDescription` will
+ * not auto-wire here — pass `aria-labelledby` / `aria-describedby` explicitly if
+ * you use custom markup.
+ */
+declare class AlertDialogComponent {
+    protected readonly componentScale: ComponentScaleDirective;
+    readonly radius: _angular_core.InputSignal<"sm" | "inherit" | "none" | "xs" | "md" | "xl" | "full">;
+    readonly density: _angular_core.InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    readonly closeOnBackdropClick: _angular_core.InputSignal<boolean>;
+    /** Appearance of the area outside the surface. Defaults to a dimmed overlay. */
+    readonly backdrop: _angular_core.InputSignal<DialogBackdrop>;
+    readonly showCloseButton: _angular_core.InputSignal<boolean>;
+    readonly closeButtonLabel: _angular_core.InputSignal<string>;
+    readonly labelledBy: _angular_core.InputSignal<string | null>;
+    readonly describedBy: _angular_core.InputSignal<string | null>;
+    /** ARIA role passed to the underlying dialog surface. `'alertdialog'` by default. */
+    readonly role: _angular_core.InputSignal<string>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly contentSize;
+    private readonly registeredTitleId;
+    private readonly registeredDescriptionId;
+    readonly resolvedSize: _angular_core.Signal<AlertDialogSize>;
+    protected readonly surfaceClasses: _angular_core.Signal<string>;
+    /** Explicit `aria-labelledby` wins; otherwise a projected `AlertDialogTitle` supplies the id. */
+    protected readonly resolvedLabelledBy: _angular_core.Signal<string | null>;
+    /** Explicit `aria-describedby` wins; otherwise a projected `AlertDialogDescription` supplies the id. */
+    protected readonly resolvedDescribedBy: _angular_core.Signal<string | null>;
+    setContentSize(size: AlertDialogSize): void;
+    /** Called by a projected `AlertDialogTitle` so default usage has an accessible name (AXE-safe). */
+    registerTitleId(id: string | null): void;
+    /** Cleared by an `AlertDialogTitle` on destroy so a reopened alert never points at a stale id. */
+    unregisterTitleId(id: string): void;
+    /** Called by a projected `AlertDialogDescription`. */
+    registerDescriptionId(id: string | null): void;
+    /** Cleared by an `AlertDialogDescription` on destroy. */
+    unregisterDescriptionId(id: string): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogComponent, "AlertDialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "backdrop": { "alias": "backdrop"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; "closeButtonLabel": { "alias": "closeButtonLabel"; "required": false; "isSignal": true; }; "labelledBy": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "describedBy": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "openedChange": "openedChange"; }, never, ["*"], true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+}
+
+declare class AlertDialogContentComponent {
+    readonly size: _angular_core.InputSignal<AlertDialogSize>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly alertDialog;
+    protected readonly classes: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogContentComponent, "AlertDialogContent", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AlertDialogHeaderComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogHeaderComponent, "AlertDialogHeader", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AlertDialogTitleComponent {
+    /** Explicit id override; when omitted a document-unique id is generated. */
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly autoId;
+    private readonly alertDialog;
+    /** The id rendered on the element, used by the parent alert dialog for aria-labelledby. */
+    readonly resolvedId: _angular_core.Signal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogTitleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogTitleComponent, "AlertDialogTitle, h2[AlertDialogTitle]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AlertDialogDescriptionComponent {
+    /** Explicit id override; when omitted a document-unique id is generated. */
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly autoId;
+    private readonly alertDialog;
+    /** The id rendered on the element, used by the parent alert dialog for aria-describedby. */
+    readonly resolvedId: _angular_core.Signal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogDescriptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogDescriptionComponent, "AlertDialogDescription, p[AlertDialogDescription]", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AlertDialogMediaComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly alertDialog;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogMediaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogMediaComponent, "AlertDialogMedia", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AlertDialogFooterComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogFooterComponent, "AlertDialogFooter", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AlertDialogCancelComponent {
+    readonly variant: _angular_core.InputSignal<ButtonVariant>;
+    readonly size: _angular_core.InputSignal<ButtonSize>;
+    readonly closeOnClick: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly host;
+    private readonly alertDialog;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly buttonType: _angular_core.Signal<"button" | null>;
+    protected handleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogCancelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogCancelComponent, "button[AlertDialogCancel], a[AlertDialogCancel]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AlertDialogActionComponent {
+    readonly variant: _angular_core.InputSignal<ButtonVariant>;
+    readonly size: _angular_core.InputSignal<ButtonSize>;
+    readonly closeOnClick: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly host;
+    private readonly alertDialog;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly buttonType: _angular_core.Signal<"button" | null>;
+    protected handleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDialogActionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDialogActionComponent, "button[AlertDialogAction], a[AlertDialogAction]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { AlertDialogActionComponent, AlertDialogCancelComponent, AlertDialogComponent, AlertDialogContentComponent, AlertDialogDescriptionComponent, AlertDialogFooterComponent, AlertDialogHeaderComponent, AlertDialogMediaComponent, AlertDialogTitleComponent };
+export type { AlertDialogSize };

package/types/ojiepermana-angular-component-alert.d.ts

@@ -1 +1,42 @@
-export * from '@ojiepermana/angular-component/alert';
+import * as _angular_core from '@angular/core';
+import * as i1 from '@ojiepermana/angular/component/utils/scale';
+import { ComponentScaleDirective } from '@ojiepermana/angular/component/utils/scale';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AlertVariant = NonNullable<VariantProps<typeof alertVariants>['variant']>;
+
+declare class AlertComponent {
+    protected readonly componentScale: ComponentScaleDirective;
+    readonly radius: _angular_core.InputSignal<"inherit" | "none" | "xs" | "sm" | "md" | "xl" | "full">;
+    readonly density: _angular_core.InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
+    readonly variant: _angular_core.InputSignal<AlertVariant>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertComponent, "Alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+}
+declare class AlertTitleComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertTitleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertTitleComponent, "AlertTitle, h5[AlertTitle]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AlertDescriptionComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertDescriptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertDescriptionComponent, "AlertDescription", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AlertActionComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertActionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertActionComponent, "AlertAction", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { AlertActionComponent, AlertComponent, AlertDescriptionComponent, AlertTitleComponent, alertVariants };
+export type { AlertVariant };

package/types/ojiepermana-angular-component-aspect-ratio.d.ts

@@ -1 +1,12 @@
-export * from '@ojiepermana/angular-component/aspect-ratio';
+import * as _angular_core from '@angular/core';
+
+declare class AspectRatioComponent {
+    readonly ratio: _angular_core.InputSignal<number>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly paddingBottom: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AspectRatioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AspectRatioComponent, "AspectRatio", never, { "ratio": { "alias": "ratio"; "required": true; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { AspectRatioComponent };

package/types/ojiepermana-angular-component-avatar.d.ts

@@ -1 +1,56 @@
-export * from '@ojiepermana/angular-component/avatar';
+import * as _angular_core from '@angular/core';
+import * as i1 from '@ojiepermana/angular/component/utils/scale';
+import { ComponentScaleDirective } from '@ojiepermana/angular/component/utils/scale';
+
+declare const avatarSizeClasses: {
+    readonly default: "h-10 w-10";
+    readonly sm: "h-8 w-8";
+    readonly lg: "h-12 w-12";
+};
+type AvatarSize = keyof typeof avatarSizeClasses;
+declare class AvatarComponent {
+    protected readonly componentScale: ComponentScaleDirective;
+    readonly radius: _angular_core.InputSignal<"inherit" | "none" | "xs" | "sm" | "md" | "xl" | "full">;
+    readonly density: _angular_core.InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
+    readonly size: _angular_core.InputSignal<"sm" | "default" | "lg">;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "Avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+}
+declare class AvatarImageComponent {
+    readonly src: _angular_core.InputSignal<string>;
+    readonly alt: _angular_core.InputSignal<string>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly failed: _angular_core.WritableSignal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarImageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarImageComponent, "AvatarImage", never, { "src": { "alias": "src"; "required": true; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class AvatarFallbackComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarFallbackComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarFallbackComponent, "AvatarFallback", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AvatarBadgeComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarBadgeComponent, "AvatarBadge", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AvatarGroupComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarGroupComponent, "AvatarGroup", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class AvatarGroupCountComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarGroupCountComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarGroupCountComponent, "AvatarGroupCount", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { AvatarBadgeComponent, AvatarComponent, AvatarFallbackComponent, AvatarGroupComponent, AvatarGroupCountComponent, AvatarImageComponent };
+export type { AvatarSize };

package/types/ojiepermana-angular-component-badge.d.ts

@@ -1 +1,24 @@
-export * from '@ojiepermana/angular-component/badge';
+import * as _angular_core from '@angular/core';
+import * as i1 from '@ojiepermana/angular/component/utils/scale';
+import { ComponentScaleDirective } from '@ojiepermana/angular/component/utils/scale';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "destructive" | "outline" | "ghost" | "link" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BadgeVariant = NonNullable<VariantProps<typeof badgeVariants>['variant']>;
+
+declare class BadgeComponent {
+    protected readonly componentScale: ComponentScaleDirective;
+    readonly radius: _angular_core.InputSignal<"inherit" | "none" | "xs" | "sm" | "md" | "xl" | "full">;
+    readonly density: _angular_core.InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
+    readonly variant: _angular_core.InputSignal<BadgeVariant>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BadgeComponent, "Badge, [Badge]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+}
+
+export { BadgeComponent, badgeVariants };
+export type { BadgeVariant };