@ojiepermana/angular-component 22.0.27

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

@@ -0,0 +1,63 @@
+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 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; }; "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

@@ -0,0 +1,51 @@
+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;
+    readonly variant?: ToastVariant;
+    readonly durationMs?: number | null;
+    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;
+    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;
+    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

@@ -0,0 +1,89 @@
+import * as _angular_core 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 {
+    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

@@ -0,0 +1,25 @@
+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 };

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

@@ -0,0 +1,101 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, TemplateRef } from '@angular/core';
+
+type TooltipSide = 'top' | 'right' | 'bottom' | 'left';
+type TooltipAlign = 'start' | 'center' | 'end';
+interface TooltipDefaults {
+    readonly side: Signal<TooltipSide>;
+    readonly align: Signal<TooltipAlign>;
+    readonly sideOffset: Signal<number>;
+    readonly openDelay: Signal<number>;
+    readonly closeDelay: Signal<number>;
+}
+declare const TOOLTIP_DEFAULTS: InjectionToken<TooltipDefaults>;
+declare class TooltipComponent implements TooltipDefaults {
+    readonly side: _angular_core.InputSignal<TooltipSide>;
+    readonly align: _angular_core.InputSignal<TooltipAlign>;
+    readonly sideOffset: _angular_core.InputSignal<number>;
+    readonly openDelay: _angular_core.InputSignal<number>;
+    readonly closeDelay: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "Tooltip", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TooltipContentDirective {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipContentDirective, "ng-template[TooltipContent]", ["TooltipContent"], {}, {}, never, never, true, never>;
+}
+
+declare class TooltipTriggerDirective {
+    private readonly overlay;
+    private readonly vcr;
+    private readonly el;
+    private readonly destroyRef;
+    private readonly defaults;
+    readonly TooltipTrigger: _angular_core.InputSignal<TooltipContentDirective>;
+    readonly side: _angular_core.InputSignal<TooltipSide | undefined>;
+    readonly align: _angular_core.InputSignal<TooltipAlign | undefined>;
+    readonly sideOffset: _angular_core.InputSignal<number | undefined>;
+    readonly openDelay: _angular_core.InputSignal<number | undefined>;
+    readonly closeDelay: _angular_core.InputSignal<number | undefined>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly contentId: _angular_core.WritableSignal<string | null>;
+    private overlayRef;
+    private openTimeoutId;
+    private closeTimeoutId;
+    private isPointerInsideTrigger;
+    private isTriggerFocused;
+    private isDestroying;
+    constructor();
+    handlePointerEnter(): void;
+    handlePointerLeave(event: PointerEvent): void;
+    handleFocusIn(): void;
+    handleFocusOut(event: FocusEvent): void;
+    open(): void;
+    close(): void;
+    private bindOverlayLifecycle;
+    private scheduleOpen;
+    private scheduleClose;
+    private clearOpenTimeout;
+    private clearCloseTimeout;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipTriggerDirective, "[TooltipTrigger]", ["TooltipTrigger"], { "TooltipTrigger": { "alias": "TooltipTrigger"; "required": true; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+}
+
+/** Posisi tooltip; kompatibel dengan nilai `matTooltipPosition` lama. */
+type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
+/**
+ * Shadcn-styled text tooltip — CDK overlay, tanpa dependensi Material.
+ *
+ * @example
+ * <button Button [Tooltip]="'Save changes'" TooltipPosition="above">Save</button>
+ */
+declare class TooltipDirective {
+    private readonly overlay;
+    private readonly el;
+    private readonly destroyRef;
+    readonly Tooltip: _angular_core.InputSignal<string>;
+    readonly TooltipPosition: _angular_core.InputSignal<TooltipPosition>;
+    readonly TooltipDisabled: _angular_core.InputSignal<boolean>;
+    readonly TooltipShowDelay: _angular_core.InputSignal<number>;
+    readonly TooltipHideDelay: _angular_core.InputSignal<number>;
+    private overlayRef;
+    private contentRef;
+    private showTimeoutId;
+    private hideTimeoutId;
+    private readonly side;
+    constructor();
+    show(): void;
+    hide(): void;
+    protected scheduleShow(): void;
+    protected scheduleHide(): void;
+    private clearTimers;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[Tooltip]", ["Tooltip"], { "Tooltip": { "alias": "Tooltip"; "required": false; "isSignal": true; }; "TooltipPosition": { "alias": "TooltipPosition"; "required": false; "isSignal": true; }; "TooltipDisabled": { "alias": "TooltipDisabled"; "required": false; "isSignal": true; }; "TooltipShowDelay": { "alias": "TooltipShowDelay"; "required": false; "isSignal": true; }; "TooltipHideDelay": { "alias": "TooltipHideDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { TOOLTIP_DEFAULTS, TooltipComponent, TooltipContentDirective, TooltipDirective, TooltipTriggerDirective };
+export type { TooltipAlign, TooltipDefaults, TooltipPosition, TooltipSide };

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

@@ -0,0 +1,30 @@
+import { ClassValue } from 'clsx';
+import { ConnectedPosition, OverlayRef } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+type OverlaySide = 'top' | 'right' | 'bottom' | 'left';
+type OverlayAlign = 'start' | 'center' | 'end';
+/**
+ * Builds the CDK `ConnectedPosition` for a shadcn-style `side`/`align`/`sideOffset`
+ * triple. Shared by every anchored overlay in the library (popover, tooltip,
+ * hover-card, menus, combobox).
+ */
+declare function connectedPositionFor(side: OverlaySide, align: OverlayAlign, sideOffset: number): ConnectedPosition;
+declare function oppositeSide(side: OverlaySide): OverlaySide;
+/**
+ * Emits whenever the user dismisses the overlay: pointer down outside (ignoring
+ * the origin element so trigger clicks keep toggling), Escape, or detachment.
+ * Subscribers decide how to close.
+ */
+declare function overlayDismissals(overlayRef: OverlayRef, origin?: HTMLElement): Observable<unknown>;
+
+/**
+ * Returns a document-unique id with the given prefix, e.g. `uniqueId('Checkbox')`
+ * → `"checkbox-1"`. Single shared counter for every component in the library.
+ */
+declare function uniqueId(prefix: string): string;
+
+export { cn, connectedPositionFor, oppositeSide, overlayDismissals, uniqueId };
+export type { OverlayAlign, OverlaySide };

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

@@ -0,0 +1,2 @@
+
+export { };