@ojiepermana/angular-component 22.0.27

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

@@ -0,0 +1,90 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+type ComposerVariant = 'default' | 'input';
+type ComposerSubmitBehavior = 'cmd-enter' | 'enter';
+declare class ComposerComponent {
+    readonly variant: _angular_core.InputSignal<ComposerVariant>;
+    readonly inline: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly submit: _angular_core.InputSignal<ComposerSubmitBehavior>;
+    readonly submitForm: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly submitRequested: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly shellClasses: _angular_core.Signal<string>;
+    protected readonly bodyClasses: _angular_core.Signal<string>;
+    handleInputKeydown(event: KeyboardEvent): void;
+    private requestNearestFormSubmit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComposerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComposerComponent, "Composer", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "submit": { "alias": "submit"; "required": false; "isSignal": true; }; "submitForm": { "alias": "submitForm"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "submitRequested": "submitRequested"; }, never, ["ComposerHeader", "ComposerActionsLeading", "textarea[ComposerInput], ComposerInput", "ComposerActionsTrailing", "ComposerFooter"], true, never>;
+}
+declare class ComposerHeaderComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComposerHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComposerHeaderComponent, "ComposerHeader", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ComposerFooterComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComposerFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComposerFooterComponent, "ComposerFooter", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ComposerActionsLeadingComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComposerActionsLeadingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComposerActionsLeadingComponent, "ComposerActionsLeading", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ComposerActionsTrailingComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComposerActionsTrailingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComposerActionsTrailingComponent, "ComposerActionsTrailing", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ComposerInputComponent {
+    private readonly composer;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalidInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly invalid: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComposerInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComposerInputComponent, "ComposerInput", never, { "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalidInput": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class ComposerTextareaComponent implements AfterViewInit, ControlValueAccessor {
+    private readonly el;
+    private readonly composer;
+    readonly rows: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly maxRows: _angular_core.InputSignalWithTransform<number | null, number | null>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalidInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly disabledState;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly invalid: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    ngAfterViewInit(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    resizeToContent(): void;
+    focus(): void;
+    protected handleInput(): void;
+    protected handleBlur(): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    private getLineHeight;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComposerTextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ComposerTextareaComponent, "textarea[ComposerInput]", never, { "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "maxRows": { "alias": "maxRows"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalidInput": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ComposerActionsLeadingComponent, ComposerActionsTrailingComponent, ComposerComponent, ComposerFooterComponent, ComposerHeaderComponent, ComposerInputComponent, ComposerTextareaComponent };
+export type { ComposerSubmitBehavior, ComposerVariant };

package/types/ojiepermana-angular-component-context-menu.d.ts

@@ -0,0 +1,36 @@
+import * as _angular_core from '@angular/core';
+import { MenuContentDirective } from '@ojiepermana/angular-component/dropdown-menu';
+
+/**
+ * Opens a menu anchored to the cursor when the host fires `contextmenu`.
+ * Reuses `<ng-template MenuContent>` from the dropdown-menu entry.
+ *
+ * @example
+ * <div [ContextMenuTrigger]="menu" class="p-12 border">Right-click me</div>
+ * <ng-template MenuContent #menu>
+ *   <MenuSurface>
+ *     <button MenuItem>Copy</button>
+ *     <button MenuItem>Paste</button>
+ *   </MenuSurface>
+ * </ng-template>
+ */
+declare class ContextMenuTriggerDirective {
+    private readonly overlay;
+    private readonly vcr;
+    private readonly el;
+    private readonly destroyRef;
+    readonly ContextMenuTrigger: _angular_core.InputSignal<MenuContentDirective>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    private overlayRef;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    constructor();
+    protected onContextMenu(event: MouseEvent): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    openAt(x: number, y: number): void;
+    close(emitOpenedChange?: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContextMenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ContextMenuTriggerDirective, "[ContextMenuTrigger]", ["ContextMenuTrigger"], { "ContextMenuTrigger": { "alias": "ContextMenuTrigger"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+export { ContextMenuTriggerDirective };

package/types/ojiepermana-angular-component-date-picker.d.ts

@@ -0,0 +1,48 @@
+import * as _angular_core from '@angular/core';
+import { MatCalendarView } from '@angular/material/datepicker';
+import { ControlValueAccessor, FormControl } from '@angular/forms';
+
+/**
+ * Popup date picker. The component self-provides a native `DateAdapter`, so it
+ * works in any consumer (host app, federated remote, or standalone) without the
+ * consumer wiring `provideNativeDateAdapter()`. The popup calendar is rendered
+ * in a CDK overlay whose portal uses this component's view container, so the
+ * component-level adapter reaches the overlay content too. A consumer can still
+ * override the adapter/locale at the application root.
+ */
+declare class DatePickerComponent implements ControlValueAccessor {
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    readonly id: _angular_core.InputSignal<string | null>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly min: _angular_core.InputSignal<Date | null>;
+    readonly max: _angular_core.InputSignal<Date | null>;
+    readonly startAt: _angular_core.InputSignal<Date | null>;
+    readonly startView: _angular_core.InputSignal<MatCalendarView>;
+    readonly touchUi: _angular_core.InputSignal<boolean>;
+    readonly dateFilter: _angular_core.InputSignal<((date: Date | null) => boolean) | null>;
+    readonly panelClass: _angular_core.InputSignal<string | string[]>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    /** Disabled state pushed by the Forms API; kept separate so it never clobbers the `disabled` binding. */
+    private readonly cvaDisabled;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    private readonly fallbackId;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly resolvedId: _angular_core.Signal<string>;
+    protected readonly control: FormControl<Date | null>;
+    private onChangeFn;
+    private onTouchedFn;
+    constructor();
+    protected handleTouched(): void;
+    writeValue(v: Date | null): void;
+    registerOnChange(fn: (v: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(state: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePickerComponent, "DatePicker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "startAt": { "alias": "startAt"; "required": false; "isSignal": true; }; "startView": { "alias": "startView"; "required": false; "isSignal": true; }; "touchUi": { "alias": "touchUi"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "disabled": "disabledChange"; }, never, never, true, never>;
+}
+
+export { DatePickerComponent };

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

@@ -0,0 +1,87 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Declarative modal dialog. Renders into the body via CDK overlay when
+ * `open` becomes `true`. Focus is trapped inside; restored to trigger on close.
+ *
+ * @example
+ * <button Button (click)="open.set(true)">Open</button>
+ * <Dialog [(open)]="open">
+ *   <DialogHeader>
+ *     <DialogTitle>Are you sure?</DialogTitle>
+ *     <DialogDescription>This action cannot be undone.</DialogDescription>
+ *   </DialogHeader>
+ *   <DialogFooter>
+ *     <button Button variant="outline" (click)="open.set(false)">Cancel</button>
+ *     <button Button variant="destructive" (click)="confirm()">Delete</button>
+ *   </DialogFooter>
+ * </Dialog>
+ */
+declare class DialogComponent {
+    private readonly overlay;
+    private readonly vcr;
+    private readonly trapFactory;
+    private readonly doc;
+    private readonly destroyRef;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    readonly closeOnBackdropClick: _angular_core.InputSignal<boolean>;
+    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>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    private readonly tpl;
+    private overlayRef;
+    private focusTrap;
+    private previousFocus;
+    protected readonly surfaceClasses: _angular_core.Signal<string>;
+    constructor();
+    private attach;
+    private detach;
+    private requestClose;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogComponent, "Dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "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; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "openedChange": "openedChange"; }, never, ["*"], true, never>;
+}
+
+declare class DialogCloseDirective {
+    private readonly dialog;
+    closeDialog(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogCloseDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DialogCloseDirective, "button[DialogClose], a[DialogClose]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DialogHeaderComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogHeaderComponent, "DialogHeader", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class DialogTitleComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogTitleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogTitleComponent, "DialogTitle, h2[DialogTitle]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class DialogDescriptionComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogDescriptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogDescriptionComponent, "DialogDescription, p[DialogDescription]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class DialogContentComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogContentComponent, "DialogContent", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class DialogFooterComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogFooterComponent, "DialogFooter", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { DialogCloseDirective, DialogComponent, DialogContentComponent, DialogDescriptionComponent, DialogFooterComponent, DialogHeaderComponent, DialogTitleComponent };

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

@@ -0,0 +1 @@
+export { SheetCloseDirective as DrawerCloseDirective, SheetComponent as DrawerComponent, SheetContentComponent as DrawerContentComponent, SheetDescriptionComponent as DrawerDescriptionComponent, SheetSide as DrawerDirection, SheetFooterComponent as DrawerFooterComponent, SheetHeaderComponent as DrawerHeaderComponent, SheetSide as DrawerSide, SheetTitleComponent as DrawerTitleComponent } from '@ojiepermana/angular-component/sheet';

package/types/ojiepermana-angular-component-dropdown-menu.d.ts

@@ -0,0 +1,140 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, AfterContentInit } from '@angular/core';
+import { OverlayAlign, OverlaySide } from '@ojiepermana/angular-component/utils';
+
+type MenuItemVariant = 'default' | 'destructive';
+declare abstract class MenuFocusableItem {
+    private readonly el;
+    readonly disabledInput: _angular_core.InputSignal<boolean>;
+    readonly inset: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly variant: _angular_core.InputSignal<MenuItemVariant>;
+    readonly selected: _angular_core.OutputEmitterRef<MouseEvent | KeyboardEvent>;
+    get disabled(): boolean;
+    focus(): void;
+    getLabel(): string;
+    protected buildItemClasses(extraClass?: string): string;
+    protected emitSelection(event: MouseEvent | KeyboardEvent): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuFocusableItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuFocusableItem, never, never, { "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, never, never, true, never>;
+}
+declare class MenuGroupComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuGroupComponent, "MenuGroup", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare abstract class MenuRadioGroupBase {
+    abstract isChecked(value: string): boolean;
+    abstract select(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioGroupBase, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuRadioGroupBase, never, never, {}, {}, never, never, true, never>;
+}
+declare class MenuRadioGroupComponent extends MenuRadioGroupBase {
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    isChecked(value: string): boolean;
+    select(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuRadioGroupComponent, "MenuRadioGroup", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, ["*"], true, never>;
+}
+declare class MenuItemComponent extends MenuFocusableItem {
+    protected readonly classes: _angular_core.Signal<string>;
+    protected handleClick(e: MouseEvent | KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemComponent, "MenuItem, button[MenuItem]", never, {}, {}, never, ["*"], true, never>;
+}
+declare class MenuCheckboxItemComponent extends MenuFocusableItem {
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected toggle(event: MouseEvent | KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuCheckboxItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuCheckboxItemComponent, "MenuCheckboxItem, button[MenuCheckboxItem]", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; }, never, ["*"], true, never>;
+}
+declare class MenuRadioItemComponent extends MenuFocusableItem {
+    private readonly group;
+    readonly value: _angular_core.InputSignal<string>;
+    protected readonly checked: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected select(event: MouseEvent | KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuRadioItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuRadioItemComponent, "MenuRadioItem, button[MenuRadioItem]", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class MenuSeparatorComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSeparatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuSeparatorComponent, "MenuSeparator", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class MenuLabelComponent {
+    readonly inset: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuLabelComponent, "MenuLabel", never, { "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class MenuShortcutComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuShortcutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuShortcutComponent, "MenuShortcut, span[MenuShortcut]", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Surface rendered inside the overlay. Hosts keyboard navigation for its items.
+ */
+declare class MenuSurfaceComponent implements AfterContentInit {
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly items;
+    readonly closeRequested: _angular_core.OutputEmitterRef<void>;
+    private keyManager;
+    protected readonly classes: _angular_core.Signal<string>;
+    ngAfterContentInit(): void;
+    protected onArrow(e: KeyboardEvent, delta: number): void;
+    protected onHome(e: KeyboardEvent): void;
+    protected onEnd(e: KeyboardEvent): void;
+    protected onTab(e: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuSurfaceComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuSurfaceComponent, "MenuSurface", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "closeRequested": "closeRequested"; }, ["items"], ["*"], true, never>;
+}
+/**
+ * Wraps an `<ng-template>` that holds `<MenuSurface>` + items.
+ */
+declare class MenuContentDirective {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuContentDirective, "ng-template[MenuContent]", ["MenuContent"], {}, {}, never, never, true, never>;
+}
+
+type MenuSide = OverlaySide;
+type MenuAlign = OverlayAlign;
+/**
+ * Opens an `<ng-template MenuContent>` anchored to the trigger element.
+ */
+declare class MenuTriggerDirective {
+    private readonly overlay;
+    private readonly vcr;
+    private readonly el;
+    private readonly destroyRef;
+    readonly MenuTrigger: _angular_core.InputSignal<MenuContentDirective>;
+    readonly side: _angular_core.InputSignal<OverlaySide>;
+    readonly align: _angular_core.InputSignal<OverlayAlign>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    private overlayRef;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    constructor();
+    toggle(): void;
+    protected openAndFocus(e: KeyboardEvent): void;
+    protected openForSide(e: KeyboardEvent, side: MenuSide): void;
+    open(): void;
+    close(options?: {
+        restoreFocus?: boolean;
+    }): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[MenuTrigger]", ["MenuTrigger"], { "MenuTrigger": { "alias": "MenuTrigger"; "required": true; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+export { MenuCheckboxItemComponent, MenuContentDirective, MenuFocusableItem, MenuGroupComponent, MenuItemComponent, MenuLabelComponent, MenuRadioGroupBase, MenuRadioGroupComponent, MenuRadioItemComponent, MenuSeparatorComponent, MenuShortcutComponent, MenuSurfaceComponent, MenuTriggerDirective };
+export type { MenuAlign, MenuItemVariant, MenuSide };

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

@@ -0,0 +1,126 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+type EditorCommand = 'paragraph' | 'heading-1' | 'heading-2' | 'heading-3' | 'bold' | 'italic' | 'underline' | 'strike' | 'bullet' | 'ordered' | 'blockquote' | 'subscript' | 'superscript' | 'highlight' | 'link' | 'code' | 'align-left' | 'align-center' | 'align-right' | 'undo' | 'redo';
+type EditorCommandSource = 'api' | 'toolbar' | 'shortcut';
+interface EditorCommandEvent {
+    readonly command: EditorCommand;
+    readonly source: EditorCommandSource;
+    readonly originalEvent?: Event;
+}
+type EditorToolbarPart = {
+    readonly type: 'button';
+    readonly command: EditorCommand;
+    readonly label: string;
+    readonly ariaLabel: string;
+} | {
+    readonly type: 'heading';
+    readonly track: string;
+} | {
+    readonly type: 'align';
+    readonly track: string;
+} | {
+    readonly type: 'separator';
+    readonly track: string;
+} | {
+    readonly type: 'spacer';
+    readonly track: string;
+};
+declare class EditorComponent {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly commandSelected: _angular_core.OutputEmitterRef<EditorCommandEvent>;
+    private content;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly shellClasses: _angular_core.Signal<string>;
+    execute(command: EditorCommand, source?: EditorCommandSource, originalEvent?: Event): void;
+    registerContent(content: EditorContentComponent): void;
+    unregisterContent(content: EditorContentComponent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorComponent, "Editor", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "commandSelected": "commandSelected"; }, never, ["EditorToolbar", "EditorContent"], true, never>;
+}
+declare class EditorToolbarComponent {
+    private readonly editor;
+    readonly items: _angular_core.InputSignal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly buttonClasses: string;
+    protected readonly selectClasses: string;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly parts: _angular_core.Signal<EditorToolbarPart[]>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected execute(command: EditorCommand, event: MouseEvent): void;
+    protected handleSelect(event: Event): void;
+    protected readonly preserveSelection: (event: MouseEvent) => void;
+    protected trackPart(part: EditorToolbarPart, index: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorToolbarComponent, "EditorToolbar", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class EditorButtonComponent {
+    private readonly editor;
+    readonly command: _angular_core.InputSignal<EditorCommand | null>;
+    readonly pressed: _angular_core.InputSignal<boolean | null>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly tooltip: _angular_core.InputSignal<string>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected handleClick(event: MouseEvent): void;
+    protected readonly preserveSelection: (event: MouseEvent) => void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorButtonComponent, "button[EditorButton]", never, { "command": { "alias": "command"; "required": false; "isSignal": true; }; "pressed": { "alias": "pressed"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class EditorSeparatorComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorSeparatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorSeparatorComponent, "EditorSeparator", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class EditorSpacerComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorSpacerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorSpacerComponent, "EditorSpacer", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class EditorContentComponent implements AfterViewInit, OnDestroy, ControlValueAccessor {
+    private readonly el;
+    private readonly editor;
+    private readonly document;
+    private readonly sanitizer;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalidInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly class: _angular_core.InputSignal<string>;
+    private readonly disabledState;
+    protected readonly empty: _angular_core.WritableSignal<boolean>;
+    protected readonly disabled: _angular_core.Signal<boolean>;
+    protected readonly invalid: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private lastKnownValue;
+    private onChange;
+    private onTouched;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    execute(command: EditorCommand): void;
+    focus(): void;
+    protected handleInput(): void;
+    protected handleBlur(): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    private exec;
+    private highlightColor;
+    private syncEmptyState;
+    private shortcutCommand;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditorContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditorContentComponent, "EditorContent", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalidInput": { "alias": "aria-invalid"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { EditorButtonComponent, EditorComponent, EditorContentComponent, EditorSeparatorComponent, EditorSpacerComponent, EditorToolbarComponent };
+export type { EditorCommand, EditorCommandEvent, EditorCommandSource };

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

@@ -0,0 +1,50 @@
+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 emptyVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type EmptyMediaVariant = NonNullable<VariantProps<typeof emptyMediaVariants>['variant']>;
+
+declare class EmptyComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyComponent, "Empty", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class EmptyHeaderComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyHeaderComponent, "EmptyHeader", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class EmptyMediaComponent {
+    readonly variant: _angular_core.InputSignal<EmptyMediaVariant>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyMediaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyMediaComponent, "EmptyMedia", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class EmptyTitleComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyTitleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyTitleComponent, "EmptyTitle", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class EmptyDescriptionComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyDescriptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyDescriptionComponent, "EmptyDescription", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+declare class EmptyContentComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyContentComponent, "EmptyContent", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { EmptyComponent, EmptyContentComponent, EmptyDescriptionComponent, EmptyHeaderComponent, EmptyMediaComponent, EmptyTitleComponent, emptyMediaVariants, emptyVariants };
+export type { EmptyMediaVariant };