@ojiepermana/angular 22.1.11 → 22.1.12

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

@@ -1 +1,13 @@
-export * from '@ojiepermana/angular-component/spinner';
+import * as _angular_core from '@angular/core';
+
+declare class SpinnerComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    readonly decorative: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpinnerComponent, "Spinner", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "decorative": { "alias": "decorative"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { SpinnerComponent };

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

@@ -1 +1,44 @@
-export * from '@ojiepermana/angular-component/switch';
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+type SwitchSize = 'default' | 'sm';
+/**
+ * Switch built on a native `<input type="checkbox" role="switch">` (shadcn
+ * pattern) — no Material dependency.
+ */
+declare class SwitchComponent implements ControlValueAccessor {
+    readonly id: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string | null>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaDescribedby: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly ariaInvalid: _angular_core.InputSignal<string | boolean | null>;
+    readonly size: _angular_core.InputSignal<SwitchSize>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly checkedChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly ref;
+    protected readonly checked: _angular_core.WritableSignal<boolean>;
+    protected readonly disabledState: _angular_core.WritableSignal<boolean>;
+    protected readonly ariaInvalidAttr: _angular_core.Signal<string | null>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected readonly labelClasses: _angular_core.Signal<string>;
+    protected readonly trackClasses: _angular_core.Signal<string>;
+    protected readonly thumbClasses: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    protected handleChange(event: Event): void;
+    protected handleBlur(): void;
+    focus(): void;
+    writeValue(v: boolean): void;
+    registerOnChange(fn: (v: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(d: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "Switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaDescribedby": { "alias": "aria-describedby"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "ariaInvalid": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, never, ["*"], true, never>;
+}
+
+export { SwitchComponent };
+export type { SwitchSize };

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

@@ -1 +1,57 @@
-export * from '@ojiepermana/angular-component/table';
+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 class TableComponent {
+    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 class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent, "Table", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+}
+declare class TableHeaderComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableHeaderComponent, "thead[TableHeader]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableBodyComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableBodyComponent, "tbody[TableBody]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableFooterComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableFooterComponent, "tfoot[TableFooter]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableRowComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableRowComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableRowComponent, "tr[TableRow]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableHeadComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableHeadComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableHeadComponent, "th[TableHead]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableCellComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableCellComponent, "td[TableCell]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TableCaptionComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCaptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableCaptionComponent, "caption[TableCaption]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { TableBodyComponent, TableCaptionComponent, TableCellComponent, TableComponent, TableFooterComponent, TableHeadComponent, TableHeaderComponent, TableRowComponent };

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

@@ -1 +1,124 @@
-export * from '@ojiepermana/angular-component/tabs';
+import * as _angular_core from '@angular/core';
+import { model, Signal, OnInit, OnDestroy } from '@angular/core';
+import * as i1 from '@ojiepermana/angular/component/utils/scale';
+import { ComponentScaleDirective } from '@ojiepermana/angular/component/utils/scale';
+
+type TabsListVariant = 'default' | 'line';
+/**
+ * Shared state for a tabs group. Children read the active value and register
+ * themselves so the group can drive roving-tabindex keyboard navigation.
+ */
+declare abstract class TabsContextBase {
+    abstract value: ReturnType<typeof model<string | null>>;
+    abstract effectiveValue: Signal<string | null>;
+    abstract register(element: HTMLElement, value: () => string, disabled: () => boolean): void;
+    abstract unregister(element: HTMLElement): void;
+    abstract activate(value: string, focus?: boolean): void;
+    abstract tabIndexFor(element: HTMLElement): number;
+    abstract focusNext(from: HTMLElement, offset: number): void;
+    abstract focusFirst(): void;
+    abstract focusLast(): void;
+    abstract triggerId(value: string): string;
+    abstract contentId(value: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsContextBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabsContextBase, never, never, {}, {}, never, never, true, never>;
+}
+declare abstract class TabsListContextBase {
+    abstract listVariant(): TabsListVariant;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsListContextBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TabsListContextBase, never, never, {}, {}, never, never, true, never>;
+}
+declare class TabsComponent extends TabsContextBase {
+    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 value: _angular_core.ModelSignal<string | null>;
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly idPrefix;
+    private readonly triggers;
+    /**
+     * The value the group actually renders.
+     *
+     * A group whose `value` is empty -- nothing bound at all, or a consumer signal
+     * that starts at null -- still has to show a tab, so the first enabled trigger
+     * stands in. Derived rather than written back: `value` is the consumer's
+     * two-way binding to own, and filling it in on their behalf reported a
+     * selection they never made, from inside a child's ngOnInit.
+     */
+    readonly effectiveValue: Signal<string>;
+    protected readonly classes: Signal<string>;
+    register(element: HTMLElement, value: () => string, disabled: () => boolean): void;
+    unregister(element: HTMLElement): void;
+    /**
+     * The roving `tabindex` for one trigger.
+     *
+     * Normally the selected trigger is the single tab stop. When the bound value
+     * matches no ENABLED trigger the first enabled one takes the tab stop instead.
+     * Without that fallback a value nothing answers to -- a typo, a tab removed
+     * from the DOM while it was selected, a selected tab that is disabled -- left
+     * every trigger at `tabindex=-1`, which drops the whole tablist out of the tab
+     * order and leaves a keyboard user with no way into it at all.
+     *
+     * The fallback is presentation only: it never rewrites `value`, because that
+     * is the consumer's two-way binding to own.
+     */
+    tabIndexFor(element: HTMLElement): number;
+    activate(value: string, focus?: boolean): void;
+    focusNext(from: HTMLElement, offset: number): void;
+    focusFirst(): void;
+    focusLast(): void;
+    triggerId(value: string): string;
+    contentId(value: string): string;
+    private enabledTriggers;
+    private triggerForValue;
+    private normalizeValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsComponent, "Tabs", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "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 TabsListComponent extends TabsListContextBase {
+    protected readonly ctx: TabsComponent;
+    readonly variant: _angular_core.InputSignal<TabsListVariant>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: Signal<string>;
+    listVariant(): TabsListVariant;
+    private variantClasses;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsListComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsListComponent, "TabsList", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TabsTriggerComponent implements OnInit, OnDestroy {
+    protected readonly ctx: TabsComponent;
+    private readonly list;
+    private readonly el;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly selected: Signal<boolean>;
+    protected readonly tabIndex: Signal<number>;
+    protected readonly triggerId: Signal<string>;
+    protected readonly contentId: Signal<string>;
+    protected readonly classes: Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onClick(): void;
+    protected onArrow(e: KeyboardEvent, delta: number, axis: 'horizontal' | 'vertical'): void;
+    protected onHome(e: KeyboardEvent): void;
+    protected onEnd(e: KeyboardEvent): void;
+    private variantClasses;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsTriggerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsTriggerComponent, "button[TabsTrigger]", 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 TabsContentComponent {
+    private readonly ctx;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly active: Signal<boolean>;
+    protected readonly triggerId: Signal<string>;
+    protected readonly contentId: Signal<string>;
+    protected readonly classes: Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsContentComponent, "TabsContent", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { TabsComponent, TabsContentComponent, TabsContextBase, TabsListComponent, TabsListContextBase, TabsTriggerComponent };
+export type { TabsListVariant };

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

@@ -1 +1,17 @@
-export * from '@ojiepermana/angular-component/textarea';
+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 class TextareaComponent {
+    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">;
+    private readonly el;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "textarea[Textarea]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+}
+
+export { TextareaComponent };

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

@@ -1 +1,64 @@
-export * from '@ojiepermana/angular-component/timeline';
+import * as _angular_core from '@angular/core';
+
+type TimelineAlign = 'start' | 'baseline' | 'center' | 'end';
+type TimelineSize = 'default' | 'lg';
+type TimelineStatus = 'complete' | 'current' | 'incomplete';
+type TimelineIndicatorVariant = 'default' | 'bare';
+type TimelineIndicatorColor = 'red' | 'orange' | 'amber' | 'yellow' | 'lime' | 'green' | 'emerald' | 'teal' | 'cyan' | 'sky' | 'blue' | 'indigo' | 'violet' | 'purple' | 'fuchsia' | 'pink' | 'rose';
+declare class TimelineComponent {
+    readonly horizontal: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly align: _angular_core.InputSignal<TimelineAlign>;
+    readonly size: _angular_core.InputSignal<TimelineSize>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineComponent, "Timeline", never, { "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineItemComponent {
+    private readonly timeline;
+    readonly status: _angular_core.InputSignal<TimelineStatus | null>;
+    readonly align: _angular_core.InputSignal<TimelineAlign | null>;
+    readonly size: _angular_core.InputSignal<TimelineSize | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly orientation: _angular_core.Signal<"horizontal" | "vertical">;
+    readonly resolvedAlign: _angular_core.Signal<TimelineAlign>;
+    readonly resolvedSize: _angular_core.Signal<TimelineSize>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineItemComponent, "TimelineItem", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineIndicatorComponent {
+    private readonly item;
+    readonly variant: _angular_core.InputSignal<TimelineIndicatorVariant>;
+    readonly status: _angular_core.InputSignal<TimelineStatus | null>;
+    readonly color: _angular_core.InputSignal<TimelineIndicatorColor | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly resolvedStatus: _angular_core.Signal<TimelineStatus>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineIndicatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineIndicatorComponent, "TimelineIndicator", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineContentComponent {
+    private readonly item;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineContentComponent, "TimelineContent", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineBlockComponent {
+    private readonly item;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineBlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineBlockComponent, "TimelineBlock", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class TimelineSubgridComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineSubgridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineSubgridComponent, "TimelineSubgrid", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { TimelineBlockComponent, TimelineComponent, TimelineContentComponent, TimelineIndicatorComponent, TimelineItemComponent, TimelineSubgridComponent };
+export type { TimelineAlign, TimelineIndicatorColor, TimelineIndicatorVariant, TimelineSize, TimelineStatus };

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

@@ -1 +1,64 @@
-export * from '@ojiepermana/angular-component/toast';
+import * as i0 from '@angular/core';
+
+type ToastVariant = 'default' | 'destructive' | 'success' | 'info' | 'warning';
+type ToastMessage<T> = string | ((value: T) => string);
+interface ToastPromiseMessages<T> {
+    readonly loading: string;
+    readonly success: ToastMessage<T>;
+    readonly error: ToastMessage<unknown>;
+}
+type ToastHorizontalPosition = 'start' | 'center' | 'end' | 'left' | 'right';
+type ToastVerticalPosition = 'top' | 'bottom';
+interface ToastOptions {
+    readonly title?: string;
+    readonly description?: string;
+    readonly action?: string;
+    /** Accessible label for the dismiss button. */
+    readonly dismissLabel?: string;
+    readonly variant?: ToastVariant;
+    readonly durationMs?: number | null;
+    /** Pause auto-dismiss while pointer or keyboard focus is inside the toast. */
+    readonly pauseOnInteraction?: boolean;
+    readonly horizontalPosition?: ToastHorizontalPosition;
+    readonly verticalPosition?: ToastVerticalPosition;
+}
+/** Handle for a shown toast. */
+interface ToastRef {
+    dismiss(): void;
+    /** Resolves with `true` when the action button dismissed the toast. */
+    readonly afterDismissed: Promise<{
+        dismissedByAction: boolean;
+    }>;
+}
+/**
+ * Signal-era toast tanpa dependensi Material: stack dirender ke sebuah live
+ * region (`role="status"`, `aria-live="polite"`) sehingga screen reader
+ * mengumumkan setiap toast.
+ */
+declare class ToastService {
+    private readonly documentRef;
+    private container;
+    private readonly active;
+    constructor();
+    show(options: ToastOptions): ToastRef;
+    success(opts: Omit<ToastOptions, 'variant'>): ToastRef;
+    info(opts: Omit<ToastOptions, 'variant'>): ToastRef;
+    warning(opts: Omit<ToastOptions, 'variant'>): ToastRef;
+    error(opts: Omit<ToastOptions, 'variant'>): ToastRef;
+    promise<T>(taskOrFactory: Promise<T> | (() => Promise<T>), messages: ToastPromiseMessages<T>): Promise<T>;
+    dismiss(): void;
+    private ensureContainer;
+    /**
+     * Position the persistent container for the toast being shown.
+     *
+     * Applied only when the stack is empty (see {@link show}), so a run of toasts
+     * shares one corner and nothing already visible jumps. The previous corner is
+     * cleared first, so switching corners between runs works.
+     */
+    private applyPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}
+
+export { ToastService };
+export type { ToastHorizontalPosition, ToastMessage, ToastOptions, ToastPromiseMessages, ToastRef, ToastVariant, ToastVerticalPosition };

package/types/ojiepermana-angular-component-toggle-group.d.ts

@@ -1 +1,90 @@
-export * from '@ojiepermana/angular-component/toggle-group';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy } from '@angular/core';
+import { ToggleVariant, ToggleSize } from '@ojiepermana/angular/component/toggle';
+
+type ToggleGroupType = 'single' | 'multiple';
+type ToggleGroupOrientation = 'horizontal' | 'vertical';
+type ToggleGroupVariant = ToggleVariant;
+type ToggleGroupSize = ToggleSize;
+declare abstract class ToggleGroupContextBase {
+    abstract groupType(): ToggleGroupType;
+    abstract groupOrientation(): ToggleGroupOrientation;
+    abstract groupVariant(): ToggleGroupVariant;
+    abstract groupSize(): ToggleGroupSize;
+    abstract groupDisabled(): boolean;
+    abstract isRtl(): boolean;
+    abstract register(element: HTMLElement, value: () => string, disabled: () => boolean): void;
+    abstract unregister(element: HTMLElement): void;
+    abstract isSelected(value: string): boolean;
+    abstract toggle(value: string): void;
+    abstract tabindexFor(value: string, disabled: boolean): number;
+    abstract markFocused(value: string): void;
+    abstract focusNext(from: HTMLElement, offset: number): void;
+    abstract focusFirst(): void;
+    abstract focusLast(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleGroupContextBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToggleGroupContextBase, never, never, {}, {}, never, never, true, never>;
+}
+declare class ToggleGroupComponent extends ToggleGroupContextBase {
+    readonly type: _angular_core.InputSignal<ToggleGroupType>;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly values: _angular_core.ModelSignal<string[]>;
+    readonly orientation: _angular_core.InputSignal<ToggleGroupOrientation>;
+    readonly variant: _angular_core.InputSignal<ToggleVariant>;
+    readonly size: _angular_core.InputSignal<ToggleSize>;
+    readonly spacing: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly loop: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly dir: _angular_core.InputSignal<"ltr" | "rtl" | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly host;
+    private readonly focusedValue;
+    private readonly registrationVersion;
+    private readonly items;
+    private readonly resolvedSpacing;
+    private readonly tabStopValue;
+    protected readonly classes: _angular_core.Signal<string>;
+    groupType(): ToggleGroupType;
+    groupOrientation(): ToggleGroupOrientation;
+    groupVariant(): ToggleGroupVariant;
+    groupSize(): ToggleGroupSize;
+    groupDisabled(): boolean;
+    isRtl(): boolean;
+    register(element: HTMLElement, value: () => string, disabled: () => boolean): void;
+    unregister(element: HTMLElement): void;
+    isSelected(value: string): boolean;
+    toggle(value: string): void;
+    tabindexFor(value: string, disabled: boolean): number;
+    markFocused(value: string): void;
+    focusNext(from: HTMLElement, offset: number): void;
+    focusFirst(): void;
+    focusLast(): void;
+    private enabledItems;
+    private itemForValue;
+    private bumpRegistrationVersion;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleGroupComponent, "ToggleGroup", never, { "type": { "alias": "type"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "spacing": { "alias": "spacing"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "values": "valuesChange"; }, never, ["*"], true, never>;
+}
+declare class ToggleGroupItemDirective implements OnInit, OnDestroy {
+    protected readonly ctx: ToggleGroupContextBase;
+    private readonly element;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly selected: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected isDisabled(): boolean;
+    protected onClick(): void;
+    protected onFocus(): void;
+    protected onArrow(event: KeyboardEvent, offset: number): void;
+    protected onHorizontalArrow(event: KeyboardEvent, offset: number): void;
+    protected onHome(event: KeyboardEvent): void;
+    protected onEnd(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleGroupItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToggleGroupItemDirective, "button[ToggleGroupItem]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ToggleGroupComponent, ToggleGroupContextBase, ToggleGroupItemDirective };
+export type { ToggleGroupOrientation, ToggleGroupSize, ToggleGroupType, ToggleGroupVariant };

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

@@ -1 +1,25 @@
-export * from '@ojiepermana/angular-component/toggle';
+import * as _angular_core from '@angular/core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ToggleVariant = NonNullable<VariantProps<typeof toggleVariants>['variant']>;
+type ToggleSize = NonNullable<VariantProps<typeof toggleVariants>['size']>;
+
+declare class ToggleComponent {
+    readonly pressed: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly variant: _angular_core.InputSignal<ToggleVariant>;
+    readonly size: _angular_core.InputSignal<ToggleSize>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleComponent, "button[Toggle]", never, { "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "pressed": "pressedChange"; }, never, ["*"], true, never>;
+}
+
+export { ToggleComponent, toggleVariants };
+export type { ToggleSize, ToggleVariant };