@ojiepermana/angular 22.1.11 → 22.1.12

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

@@ -1 +1,143 @@
-export * from '@ojiepermana/angular-component/tooltip';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, TemplateRef } from '@angular/core';
+import * as i1 from '@ojiepermana/angular/component/utils/scale';
+import { ComponentScaleDirective } from '@ojiepermana/angular/component/utils/scale';
+
+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>;
+    /**
+     * Delay before the tooltip hides after the pointer leaves.
+     *
+     * It matches `openDelay` rather than being zero so the pointer has time to
+     * cross the `sideOffset` gap and land on the panel. That is what makes the
+     * panel reachable, which WCAG 1.4.13 (hoverable) asks for. Set it to `0` for
+     * an instant hide, accepting that the panel then cannot be hovered.
+     */
+    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 {
+    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 template: TemplateRef<unknown>;
+    /**
+     * Resolved `--radius-base` / `--spacing-base` knob values (or `null` to
+     * inherit the global axis). Public so {@link TooltipTriggerDirective} can mirror
+     * them onto the CDK overlay panel — the element that actually paints the rounded
+     * background + padding — since this directive sits on an `<ng-template>` whose
+     * host bindings never reach the imperatively-created overlay subtree.
+     */
+    readonly radiusBase: _angular_core.Signal<string | null>;
+    readonly densityBase: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipContentDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipContentDirective, "ng-template[TooltipContent]", ["TooltipContent"], {}, {}, never, never, true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+}
+
+declare class TooltipTriggerDirective {
+    private readonly overlay;
+    private readonly vcr;
+    private readonly el;
+    private readonly destroyRef;
+    private readonly defaults;
+    private readonly idGenerator;
+    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 isPointerInsidePanel;
+    private isTriggerFocused;
+    private isDestroying;
+    /**
+     * Holds the tooltip open while the pointer rests on the panel, so a user can
+     * move onto it to read or copy the content (WCAG 1.4.13, hoverable).
+     */
+    private readonly onPanelPointerEnter;
+    private readonly onPanelPointerLeave;
+    constructor();
+    handlePointerEnter(): void;
+    handlePointerLeave(event: PointerEvent): void;
+    handleFocusIn(): void;
+    handleFocusOut(event: FocusEvent): void;
+    open(): void;
+    close(): void;
+    private applySurfaceVars;
+    private bindOverlayLifecycle;
+    private scheduleOpen;
+    private scheduleClose;
+    private releasePanel;
+    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;
+    private readonly idGenerator;
+    readonly Tooltip: _angular_core.InputSignal<string>;
+    readonly TooltipPosition: _angular_core.InputSignal<TooltipPosition>;
+    readonly TooltipDisabled: _angular_core.InputSignal<boolean>;
+    readonly TooltipShowDelay: _angular_core.InputSignal<number>;
+    /**
+     * Delay before hiding. It matches the show delay rather than being zero so the
+     * pointer can cross the offset gap and land on the panel, which is what makes
+     * the panel reachable (WCAG 1.4.13, hoverable). Set `0` for an instant hide,
+     * accepting that the panel then cannot be hovered.
+     */
+    readonly TooltipHideDelay: _angular_core.InputSignal<number>;
+    private overlayRef;
+    private contentRef;
+    private showTimeoutId;
+    private hideTimeoutId;
+    private isPointerInsidePanel;
+    private readonly onPanelPointerEnter;
+    private readonly onPanelPointerLeave;
+    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-core.d.ts

@@ -1 +1,184 @@
-export * from '@ojiepermana/angular-component/utils/core';
+import { ClassValue } from 'clsx';
+import { InjectionToken } from '@angular/core';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+/** Request/application-scoped DOM id generator with deterministic sequencing. */
+declare class UiIdGenerator {
+    private counter;
+    private readonly appInfix;
+    constructor(appId?: string);
+    next(prefix: string): string;
+}
+/**
+ * One generator per Angular application injector. Separate SSR requests and a
+ * hydrating browser application therefore start from the same deterministic
+ * sequence instead of sharing process-global state.
+ */
+declare const UI_ID_GENERATOR: InjectionToken<UiIdGenerator>;
+/** Generates an id during component/directive construction. */
+declare function injectUniqueId(prefix: string): string;
+
+/**
+ * One item of a horizontal roving row: a trigger that discloses an overlay, or
+ * a plain link sitting beside one. The row only ever asks an item whether it is
+ * disabled, moves focus to it, and matches it against an event target -- it
+ * never touches roles or ARIA, so a real `menubar` and a disclosure navigation
+ * can share it without either inheriting the other's semantics.
+ */
+interface RovingRowItem {
+    disabled(): boolean;
+    focus(): void;
+    containsTarget(target: EventTarget | null): boolean;
+}
+/** The subset of a disclosure trigger the row needs to hand one panel over. */
+interface RovingRowTrigger extends RovingRowItem {
+    close(options: {
+        restoreFocus: boolean;
+    }): void;
+}
+type RovingRowDirection = 'previous' | 'next' | 'start' | 'end';
+/** Which items answer for a keyboard event: every one, or only the enabled ones. */
+type RovingRowScope = 'all' | 'enabled';
+interface RovingRowConfig<TItem extends RovingRowItem> {
+    /** Every row item in DOM order, disabled ones included. */
+    items: () => readonly TItem[];
+    /** The row element; its resolved writing direction decides which way an arrow steps. */
+    host: () => HTMLElement;
+    /** Whether arrows wrap around at the ends instead of clamping. */
+    loop: () => boolean;
+    /**
+     * Commits a resolved move. The row has already picked the neighbour and
+     * ruled out the no-op cases; what focusing it means for an open panel is the
+     * owning component's decision, so it lands here.
+     */
+    enter: (item: TItem) => void;
+}
+/**
+ * Roving focus across one horizontal row of items, with at most one open
+ * disclosure among them.
+ *
+ * Shared by `Menubar` and `NavigationMenu`: both walk a single row with the
+ * arrow keys plus Home/End, hold exactly one tab stop, and keep at most one
+ * panel open. Everything that differs between the two -- roles, ARIA, and what
+ * happens to an open panel when focus moves on -- stays in the components.
+ */
+declare class RovingRow<TItem extends RovingRowItem, TTrigger extends TItem & RovingRowTrigger> {
+    private readonly config;
+    private readonly activeItem;
+    private readonly open;
+    constructor(config: RovingRowConfig<TItem>);
+    items(): readonly TItem[];
+    enabledItems(): TItem[];
+    setActive(item: TItem): void;
+    /**
+     * The roving `tabindex` for one row item.
+     *
+     * A composite widget carries exactly one tab stop: normally the active item
+     * owns it, falling back to the first enabled one. When EVERY item is disabled
+     * there is no enabled candidate, and leaving them all at `-1` drops the whole
+     * widget out of the tab order -- it becomes unreachable and a keyboard user
+     * cannot even discover that it is there. The first item keeps the tab stop
+     * instead and announces its state through `aria-disabled`, which is the APG
+     * focusable-disabled-item approach.
+     */
+    tabIndexFor(item: TItem): number;
+    openTrigger(): TTrigger | null;
+    hasOpenTrigger(except?: TTrigger): boolean;
+    notifyOpen(trigger: TTrigger): void;
+    notifyClosed(trigger: TTrigger): void;
+    /** The row item an event came from, or `null` when it came from outside the row. */
+    itemFrom(target: EventTarget | null, scope: RovingRowScope): TItem | null;
+    /**
+     * Handles the keys that walk the row itself -- Home, End and the horizontal
+     * arrows -- and reports whether it claimed the event, so a component can add
+     * its own keys around this without restating the row model.
+     */
+    handleNavigationKey(item: TItem, event: KeyboardEvent): boolean;
+    move(currentItem: TItem, direction: RovingRowDirection): void;
+    private nextIndex;
+    private horizontalStep;
+}
+
+/**
+ * Per-component corner-radius / spacing-density override helpers.
+ *
+ * These mirror the global `theme-radius` / `theme-space` preset values from
+ * `@ojiepermana/angular/theme` — kept as a local copy so this package stays
+ * decoupled from the theme package (see its empty peer/deps on -theme).
+ *
+ * A component that accepts a `radius` / `density` input binds the resolved value
+ * onto its surface element via `[style.--radius-base]` / `[style.--spacing-base]`.
+ * Tailwind's `rounded-*` utilities resolve `calc(var(--radius-base) * n)` and the
+ * spacing utilities resolve `calc(var(--spacing-base) * n)` (see the theme's
+ * `base/tailwind.css` `@theme inline` mapping), so the override rescales that
+ * subtree and shadows the global `<html theme-radius|theme-space>` axis. The
+ * `'inherit'` preset binds nothing, so the component keeps following the axis.
+ */
+/** Corner-radius presets for a per-component `radius` input. */
+declare const COMPONENT_RADII: readonly ["inherit", "none", "xs", "sm", "md", "xl", "full"];
+type ComponentRadius = (typeof COMPONENT_RADII)[number];
+/** Spacing-density presets for a per-component `density` input. */
+declare const COMPONENT_DENSITIES: readonly ["inherit", "compact", "normal", "relaxed", "spacious"];
+type ComponentDensity = (typeof COMPONENT_DENSITIES)[number];
+/**
+ * Resolves a `radius` input to a `--radius-base` value, or `null` to inherit the
+ * global axis. Bind the result to the surface host: `[style.--radius-base]`.
+ */
+declare function radiusBaseValue(radius: ComponentRadius): string | null;
+/**
+ * Resolves a `density` input to a `--spacing-base` value, or `null` to inherit
+ * the global axis. Bind the result to the surface host: `[style.--spacing-base]`.
+ */
+declare function densityBaseValue(density: ComponentDensity): string | null;
+
+/**
+ * Returns a document-unique id with the given prefix, e.g. `uniqueId('Checkbox')`
+ * → `"checkbox-1"`. Single shared counter for every component in the library.
+ *
+ * @deprecated Use `injectUniqueId` or inject `UI_ID_GENERATOR`. This legacy
+ * function cannot isolate concurrent server-rendering requests.
+ */
+declare function uniqueId(prefix: string): string;
+
+/**
+ * One safe way to touch `localStorage`, for every library that persists a
+ * preference.
+ *
+ * The same "reach localStorage through the document's window, wrap everything in
+ * try/catch" block was hand-copied across the theme axes and the navigation
+ * persistence unit. Every copy had to get three things right:
+ *
+ *  1. there may be no document at all (server side rendering),
+ *  2. `window.localStorage` can THROW on property access, not just on `getItem`
+ *     (a blocked or partitioned storage), so the getter itself needs guarding,
+ *  3. a quota error on write must never break the caller.
+ *
+ * This lives in `component/utils/core` rather than in the theme package on
+ * purpose: `navigation` also needs it, and navigation must not depend on
+ * `theme`, which already depends on navigation. Both already depend on this
+ * entry point.
+ */
+/** A storage that never throws. Missing storage reads as `null` and writes are dropped. */
+interface WebStorageRef {
+    read(key: string): string | null;
+    write(key: string, value: string): void;
+    remove(key: string): void;
+}
+/**
+ * `localStorage` reached through a document's own window.
+ *
+ * Resolved lazily on every call and never cached: the property access is the
+ * part that can throw, and a storage that is blocked now may be available later
+ * (or the other way round).
+ */
+declare function documentLocalStorage(documentRef: Document | null | undefined): WebStorageRef;
+/**
+ * `localStorage` from the global scope, for callers that only know whether they
+ * are in a browser (the `isPlatformBrowser` flavour) rather than holding a
+ * `Document`.
+ */
+declare function globalLocalStorage(isBrowser: boolean): WebStorageRef;
+
+export { COMPONENT_DENSITIES, COMPONENT_RADII, RovingRow, UI_ID_GENERATOR, UiIdGenerator, cn, densityBaseValue, documentLocalStorage, globalLocalStorage, injectUniqueId, radiusBaseValue, uniqueId };
+export type { ComponentDensity, ComponentRadius, RovingRowConfig, RovingRowDirection, RovingRowItem, RovingRowScope, RovingRowTrigger, WebStorageRef };

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

@@ -1 +1,21 @@
-export * from '@ojiepermana/angular-component/utils/overlay';
+import { ConnectedPosition, OverlayRef } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+
+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>;
+
+export { connectedPositionFor, oppositeSide, overlayDismissals };
+export type { OverlayAlign, OverlaySide };

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

@@ -1 +1,19 @@
-export * from '@ojiepermana/angular-component/utils/scale';
+import * as _angular_core from '@angular/core';
+
+/**
+ * Shared host behavior for the per-component radius and density axes.
+ *
+ * Components expose the directive inputs through `hostDirectives`, preserving
+ * their public `radius`/`density` API while keeping the CSS-variable mapping in
+ * one implementation.
+ */
+declare class ComponentScaleDirective {
+    readonly radius: _angular_core.InputSignal<"inherit" | "none" | "xs" | "sm" | "md" | "xl" | "full">;
+    readonly density: _angular_core.InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
+    readonly radiusBase: _angular_core.Signal<string | null>;
+    readonly densityBase: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComponentScaleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ComponentScaleDirective, never, never, { "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ComponentScaleDirective };

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

@@ -1 +1,2 @@
-export * from '@ojiepermana/angular-component/utils';
+export * from '@ojiepermana/angular/component/utils/core';
+export * from '@ojiepermana/angular/component/utils/overlay';

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

@@ -1 +1,2 @@
-export * from '@ojiepermana/angular-component';
+
+export { };

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

@@ -1 +1,59 @@
-export * from '@ojiepermana/angular-navigation/core';
+import { InjectionToken, Signal } from '@angular/core';
+import { IsActiveMatchOptions, ActivatedRoute } from '@angular/router';
+import { NavigationRegisterInput, NavigationState, NavigationItem, NavigationType, NavigationPosition, NavigationDockbarMode, NavigationNormalizedItem, NavigationOrientation, NavigationIconContext, NavigationResolvedRouteContext } from '@ojiepermana/angular/navigation/types';
+
+/** Stable contract consumed by navigation UI, independently of its state implementation. */
+interface NavigationAdapter {
+    register(input: NavigationRegisterInput, owner?: object): NavigationState;
+    unregister(id: string, owner?: object): void;
+    state(id: string): Signal<NavigationState | null>;
+    currentState(id: string): NavigationState | null;
+    data(id: string): Signal<readonly NavigationItem[]>;
+    publishData(id: string, data: readonly NavigationItem[], owner?: object): void;
+    clearData(id: string, owner?: object): void;
+    currentPanelKey(id: string): string | null;
+    update(id: string, patch: Partial<NavigationRegisterInput>): NavigationState;
+    setType(id: string, type: NavigationType): NavigationState;
+    setPosition(id: string, position: NavigationPosition): NavigationState;
+    setCollapsed(id: string, collapsed: boolean): NavigationState;
+    toggleCollapsed(id: string): NavigationState;
+    setDockbarMode(id: string, mode: NavigationDockbarMode): NavigationState;
+    isRouterItem(item: NavigationNormalizedItem): boolean;
+    hrefFor(item: NavigationNormalizedItem): string | null;
+    relFor(item: NavigationNormalizedItem): string | null;
+    routerLinkActiveOptions(item: NavigationNormalizedItem): IsActiveMatchOptions;
+    itemRole(orientation: NavigationOrientation, level: number): 'menuitem' | null;
+    compactLabel(item: NavigationNormalizedItem, compact: boolean): string | null;
+    titleFor(item: NavigationNormalizedItem, compact: boolean): string | null;
+    compactFallback(item: NavigationNormalizedItem): string;
+    iconContext(item: NavigationNormalizedItem, active: boolean, level: number, orientation: NavigationOrientation): NavigationIconContext;
+    isItemActive(item: NavigationNormalizedItem, activeIds: ReadonlySet<string>, explicitActiveUrl: string | null): boolean;
+    isPanelOpen(item: NavigationNormalizedItem): boolean;
+    isPanelOpen(navId: string, item: NavigationNormalizedItem): boolean;
+    openPanel(item: NavigationNormalizedItem): void;
+    openPanel(navId: string, item: NavigationNormalizedItem): void;
+    togglePanel(item: NavigationNormalizedItem): void;
+    togglePanel(navId: string, item: NavigationNormalizedItem): void;
+    closePanel(id?: string): void;
+    dockbarGroups(items: readonly NavigationNormalizedItem[]): readonly NavigationNormalizedItem[];
+    resolveDockbarGroup(id: string, items: readonly NavigationNormalizedItem[], mode: NavigationDockbarMode, activeIds: ReadonlySet<string>, activeUrl: string | null): NavigationNormalizedItem | null;
+    isDrawerOpen(id: string): boolean;
+    openDrawer(id: string): void;
+    toggleDrawer(id: string): void;
+    closeDrawer(id: string): void;
+}
+/**
+ * Kontrak terpisah untuk Router context agar custom `NavigationAdapter` lama
+ * tidak perlu mengimplementasikan method baru.
+ */
+interface NavigationRouteContextAdapter {
+    readonly routeContext: Signal<NavigationResolvedRouteContext>;
+    isItemRouteActive(item: NavigationNormalizedItem, explicitActiveUrl: string | null, relativeTo?: ActivatedRoute | null): boolean;
+}
+/** Override this token to supply a custom state/persistence adapter. */
+declare const NAVIGATION_ADAPTER: InjectionToken<NavigationAdapter>;
+/** Override token ini untuk memasok route context dari router/state host lain. */
+declare const NAVIGATION_ROUTE_CONTEXT_ADAPTER: InjectionToken<NavigationRouteContextAdapter>;
+
+export { NAVIGATION_ADAPTER, NAVIGATION_ROUTE_CONTEXT_ADAPTER };
+export type { NavigationAdapter, NavigationRouteContextAdapter };

package/types/ojiepermana-angular-navigation-icon.d.ts

@@ -1 +1,12 @@
-export * from '@ojiepermana/angular-navigation/icon';
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { NavigationIconContext } from '@ojiepermana/angular/navigation/types';
+
+declare class NavigationIconDirective {
+    readonly template: TemplateRef<NavigationIconContext>;
+    static ngTemplateContextGuard(_directive: NavigationIconDirective, context: unknown): context is NavigationIconContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavigationIconDirective, "ng-template[NavigationIcon]", never, {}, {}, never, never, true, never>;
+}
+
+export { NavigationIconDirective };

package/types/ojiepermana-angular-navigation-service.d.ts

@@ -1 +1,116 @@
-export * from '@ojiepermana/angular-navigation/service';
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { IsActiveMatchOptions, ActivatedRoute } from '@angular/router';
+import { NavigationResolvedRouteContext, NavigationRegisterInput, NavigationState, NavigationItem, NavigationType, NavigationPosition, NavigationDockbarMode, NavigationNormalizedItem, NavigationOrientation, NavigationIconContext } from '@ojiepermana/angular/navigation/types';
+export { NavigationDockbarMode, NavigationIconContext, NavigationItem, NavigationLink, NavigationNormalizedItem, NavigationOrientation, NavigationPosition, NavigationRegisterInput, NavigationState, NavigationType } from '@ojiepermana/angular/navigation/types';
+
+declare class NavigationService {
+    private readonly documentRef;
+    private readonly persistence;
+    private readonly router;
+    private readonly urlResolver;
+    private readonly routerUrl;
+    private readonly states;
+    private readonly openPanelKeys;
+    private readonly drawerOpenState;
+    /** Data mentah per id, dipublikasikan oleh `<Navigation>` agar surface lain (mis. apps-launcher di `Page`) bisa membaca nav by id tanpa mendaftarkan ulang id yang sama. */
+    private readonly dataById;
+    /** Semua publisher hidup per data id. Publisher terakhir menjadi sumber aktif; cleanup owner lama tidak boleh menghapus publisher baru. */
+    private readonly dataPublishers;
+    /** Token stabil untuk pemanggil legacy yang tidak mengirim owner. */
+    private readonly ownerlessDataPublisher;
+    /** id navigasi → token owner instance, untuk menjaga setiap id hanya dipakai satu <Navigation> hidup. */
+    private readonly idOwners;
+    readonly openPanelKey: Signal<string | null>;
+    /** Route aktif yang sudah dinormalisasi untuk consumer dockbar route-aware. */
+    readonly routeContext: Signal<NavigationResolvedRouteContext>;
+    readonly exactMatchOptions: IsActiveMatchOptions;
+    readonly subsetMatchOptions: IsActiveMatchOptions;
+    constructor();
+    /**
+     * Panel eksplisit (klik trigger rail/navbar) adalah state telusur sementara.
+     * Perpindahan path harus mengembalikan panel ke resolusi URL: tanpa pelepasan
+     * ini, dockbar sticky terkunci pada group lama sampai browser di-refresh,
+     * karena `resolveDockbarGroup` memprioritaskan panel key di atas pencocokan
+     * URL. Navigasi yang hanya mengubah query/fragment tidak melepas panel agar
+     * penelusuran group lain tidak tersentak oleh update background (mis. sort
+     * state yang ditulis ke query params).
+     */
+    private releasePanelsAfterNavigation;
+    private urlPath;
+    private readRouteContext;
+    private optionalString;
+    register(input: NavigationRegisterInput, owner?: object): NavigationState;
+    unregister(id: string, owner?: object): void;
+    /**
+     * Validasi keunikan id navigasi: setiap instance `<Navigation>` wajib memakai id unik.
+     * `owner` adalah token unik per instance — klaim ulang oleh owner yang sama (mis. perubahan
+     * input) diizinkan, tetapi dua instance hidup dengan id sama dianggap salah konfigurasi dan
+     * melempar error di mode dev. Pemanggil tanpa owner (akses langsung service) dilewati.
+     */
+    private claimId;
+    private releaseId;
+    state(id: string): Signal<NavigationState | null>;
+    currentState(id: string): NavigationState | null;
+    /** Data terdaftar untuk sebuah id sebagai signal; `[]` bila belum ada `<Navigation>` dengan id tersebut. */
+    data(id: string): Signal<readonly NavigationItem[]>;
+    /** Dipanggil `<Navigation>` untuk mempublikasikan datanya ke registry by id. */
+    publishData(id: string, data: readonly NavigationItem[], owner?: object): void;
+    /** Dipanggil `<Navigation>` saat destroy untuk melepas datanya dari registry. */
+    clearData(id: string, owner?: object): void;
+    currentPanelKey(id: string): string | null;
+    update(id: string, patch: Partial<NavigationRegisterInput>): NavigationState;
+    setType(id: string, type: NavigationType): NavigationState;
+    setPosition(id: string, position: NavigationPosition): NavigationState;
+    setCollapsed(id: string, collapsed: boolean): NavigationState;
+    toggleCollapsed(id: string): NavigationState;
+    setDockbarMode(id: string, mode: NavigationDockbarMode): NavigationState;
+    isRouterItem(item: NavigationNormalizedItem): boolean;
+    hrefFor(item: NavigationNormalizedItem): string | null;
+    /**
+     * A consumer `rel` is unioned with the safe default rather than replacing it:
+     * returning `rel="external"` verbatim on a `_blank` link dropped `noopener`
+     * and handed the opened page a live `window.opener`.
+     */
+    relFor(item: NavigationNormalizedItem): string | null;
+    routerLinkActiveOptions(item: NavigationNormalizedItem): IsActiveMatchOptions;
+    itemRole(orientation: NavigationOrientation, level: number): 'menuitem' | null;
+    compactLabel(item: NavigationNormalizedItem, compact: boolean): string | null;
+    titleFor(item: NavigationNormalizedItem, compact: boolean): string | null;
+    compactFallback(item: NavigationNormalizedItem): string;
+    iconContext(item: NavigationNormalizedItem, active: boolean, level: number, orientation: NavigationOrientation): NavigationIconContext;
+    isItemActive(item: NavigationNormalizedItem, activeIds: ReadonlySet<string>, explicitActiveUrl: string | null): boolean;
+    /**
+     * Pencocokan route murni untuk state dockbar berbasis Router. Berbeda dari
+     * `isItemActive`, konfigurasi legacy `item.active` dan `activeIds` sengaja
+     * tidak ikut menentukan group route aktif.
+     */
+    isItemRouteActive(item: NavigationNormalizedItem, explicitActiveUrl: string | null, relativeTo?: ActivatedRoute | null): boolean;
+    private matchesActiveTreeDeep;
+    /**
+     * The active URL is parsed once per top-level call and handed down the
+     * recursion; re-parsing it at every node turned one navigation into hundreds
+     * of identical `parseUrl` calls.
+     */
+    private activeMatch;
+    isPanelOpen(item: NavigationNormalizedItem): boolean;
+    isPanelOpen(navId: string, item: NavigationNormalizedItem): boolean;
+    openPanel(item: NavigationNormalizedItem): void;
+    openPanel(navId: string, item: NavigationNormalizedItem): void;
+    togglePanel(item: NavigationNormalizedItem): void;
+    togglePanel(navId: string, item: NavigationNormalizedItem): void;
+    closePanel(id?: string): void;
+    dockbarGroups(items: readonly NavigationNormalizedItem[]): readonly NavigationNormalizedItem[];
+    resolveDockbarGroup(id: string, items: readonly NavigationNormalizedItem[], mode: NavigationDockbarMode, activeIds: ReadonlySet<string>, activeUrl: string | null): NavigationNormalizedItem | null;
+    isDrawerOpen(id: string): boolean;
+    openDrawer(id: string): void;
+    toggleDrawer(id: string): void;
+    closeDrawer(id: string): void;
+    private matchesActiveTree;
+    private withoutKey;
+    private resolvePanelArgs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
+}
+
+export { NavigationService };