@ojiepermana/angular 0.0.3 → 0.1.1

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

@@ -0,0 +1,81 @@
+import * as _angular_core from '@angular/core';
+import { NavigationItem, shouldRenderNavigationItem, hasNavigationChildren } from '@ojiepermana/angular/navigation';
+import { trackNavigationTreeItem, getNavigationTreePathKey } from '@ojiepermana/angular/internal';
+
+declare class HorizontalNavigationBranchItem {
+    private _menuTrigger?;
+    private _rootTrigger?;
+    private _activeChildBranch;
+    private readonly _document;
+    readonly isMenuOpen: _angular_core.WritableSignal<boolean>;
+    readonly expandedInlineBranchByParent: _angular_core.WritableSignal<Record<string, string>>;
+    item: _angular_core.InputSignal<NavigationItem>;
+    menuItem: _angular_core.InputSignal<boolean>;
+    nested: _angular_core.InputSignal<boolean>;
+    variant: _angular_core.InputSignal<HorizontalNavigationVariant>;
+    itemClicked: _angular_core.OutputEmitterRef<NavigationItem>;
+    branchOpened: _angular_core.OutputEmitterRef<HorizontalNavigationBranchItem>;
+    branchClosed: _angular_core.OutputEmitterRef<HorizontalNavigationBranchItem>;
+    readonly itemChildren: _angular_core.Signal<NavigationItem[]>;
+    readonly treeTemplateData: _angular_core.Signal<{
+        inlineBranch: boolean;
+    }>;
+    readonly treeTrackByFn: typeof trackNavigationTreeItem;
+    readonly treeShouldRenderItemFn: typeof shouldRenderNavigationItem;
+    readonly treeHasChildrenFn: typeof hasNavigationChildren;
+    readonly treeResolveParentKeyFn: typeof getNavigationTreePathKey;
+    readonly menuPanelClass: _angular_core.Signal<string>;
+    hasChildren(item: NavigationItem): boolean;
+    shouldRenderItem(item: NavigationItem): boolean;
+    trackByFn(index: number, item: NavigationItem): string | number;
+    onMenuItemTriggerClick(event: MouseEvent): void;
+    onChildItemClicked(child: NavigationItem): void;
+    isInlineBranchExpanded(item: NavigationItem, parentKey: string): boolean;
+    toggleInlineBranch(item: NavigationItem, parentKey: string): void;
+    onInlineBranchHeaderClick(event: MouseEvent, item: NavigationItem, parentKey: string): void;
+    getPathKey(parentKey: string, item: NavigationItem): string;
+    onChildBranchOpened(branch: HorizontalNavigationBranchItem): void;
+    onChildBranchClosed(branch: HorizontalNavigationBranchItem): void;
+    handleMenuOpened(): void;
+    handleMenuClosed(): void;
+    closeMenu(): void;
+    private _syncRootTriggerWidth;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HorizontalNavigationBranchItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HorizontalNavigationBranchItem, "horizontal-navigation-branch-item", never, { "item": { "alias": "item"; "required": true; "isSignal": true; }; "menuItem": { "alias": "menuItem"; "required": false; "isSignal": true; }; "nested": { "alias": "nested"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "itemClicked": "itemClicked"; "branchOpened": "branchOpened"; "branchClosed": "branchClosed"; }, never, never, true, never>;
+}
+
+type HorizontalNavigationVariant = 'default' | 'mega';
+declare abstract class HorizontalNavigationBaseComponent {
+    abstract readonly variant: HorizontalNavigationVariant;
+    private readonly _navigationService;
+    private _activeRootBranch;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly navigation: _angular_core.InputSignal<NavigationItem[]>;
+    readonly itemClicked: _angular_core.OutputEmitterRef<NavigationItem>;
+    readonly navigationData: _angular_core.Signal<NavigationItem[]>;
+    isMegaVariant(): boolean;
+    onItemClicked(item: NavigationItem): void;
+    onRootBranchOpened(branch: HorizontalNavigationBranchItem): void;
+    onRootBranchClosed(branch: HorizontalNavigationBranchItem): void;
+    shouldRenderItem(item: NavigationItem): boolean;
+    hasChildren(item: NavigationItem): boolean;
+    getFlatNavigation(): NavigationItem[];
+    getItem(id: string): NavigationItem | null;
+    getItemParent(id: string): NavigationItem[] | NavigationItem | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HorizontalNavigationBaseComponent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<HorizontalNavigationBaseComponent, never, never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "navigation": { "alias": "navigation"; "required": false; "isSignal": true; }; }, { "itemClicked": "itemClicked"; }, never, never, true, never>;
+}
+
+declare class HorizontalNavigation extends HorizontalNavigationBaseComponent {
+    readonly variant: "default";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HorizontalNavigation, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HorizontalNavigation, "horizontal-navigation", never, {}, {}, never, never, true, never>;
+}
+
+declare class HorizontalNavigationMegaComponent extends HorizontalNavigationBaseComponent {
+    readonly variant: "mega";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HorizontalNavigationMegaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HorizontalNavigationMegaComponent, "horizontal-navigation-mega", never, {}, {}, never, never, true, never>;
+}
+
+export { HorizontalNavigation, HorizontalNavigationBranchItem, HorizontalNavigationMegaComponent };

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

@@ -0,0 +1,262 @@
+import * as i0 from '@angular/core';
+import { OnChanges, OnInit, AfterViewInit, OnDestroy, ChangeDetectorRef, ElementRef, Renderer2, EventEmitter, SimpleChanges } from '@angular/core';
+import { NavigationService, VerticalNavigationMode, NavigationItem, VerticalNavigationPosition, VerticalNavigationAppearance, NavigationAsideItem, shouldRenderNavigationItem, NavigationBasicItem, NavigationCollapsableItem, NavigationGroupItem } from '@ojiepermana/angular/navigation';
+import { Router, IsActiveMatchOptions } from '@angular/router';
+import { ReplaySubject, Subject } from 'rxjs';
+import { trackNavigationTreeItem } from '@ojiepermana/angular/internal';
+
+declare abstract class VerticalNavigationBaseComponent implements OnChanges, OnInit, AfterViewInit, OnDestroy {
+    protected _changeDetectorRef: ChangeDetectorRef;
+    protected _document: Document;
+    protected _elementRef: ElementRef<any>;
+    protected _renderer2: Renderer2;
+    protected _router: Router;
+    protected _navigationService: NavigationService;
+    autoCollapse: boolean;
+    inner: boolean;
+    mode: VerticalNavigationMode;
+    navigation: NavigationItem[];
+    opened: boolean;
+    position: VerticalNavigationPosition;
+    transparentOverlay: boolean;
+    readonly appearanceChanged: EventEmitter<VerticalNavigationAppearance>;
+    readonly modeChanged: EventEmitter<VerticalNavigationMode>;
+    readonly openedChanged: EventEmitter<boolean>;
+    readonly positionChanged: EventEmitter<VerticalNavigationPosition>;
+    protected _navigationContentEl?: ElementRef;
+    activeAsideItemId: string | null;
+    onCollapsableItemCollapsed: ReplaySubject<NavigationItem>;
+    onCollapsableItemExpanded: ReplaySubject<NavigationItem>;
+    onRefreshed: ReplaySubject<boolean>;
+    protected _animationsEnabled: boolean;
+    protected _asideOverlay: HTMLElement | null;
+    protected _hovered: boolean;
+    protected _mutationObserver?: MutationObserver;
+    protected _overlay: HTMLElement | null;
+    protected _pendingTimeouts: ReturnType<typeof setTimeout>[];
+    protected _unsubscribeAll: Subject<void>;
+    protected abstract _componentPrefix: string;
+    protected abstract _asideWrapperClass: string;
+    private readonly _overlayClickHandler;
+    private readonly _asideOverlayClickHandler;
+    abstract appearance: VerticalNavigationAppearance;
+    get hostClasses(): Record<string, boolean>;
+    get asideWrapperClass(): string;
+    activeAsideNavigationItem(): NavigationAsideItem | null;
+    shouldRenderItem(item: NavigationItem): boolean;
+    onMouseenter(): void;
+    onMouseleave(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    refresh(): void;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    openAside(item: NavigationItem): void;
+    closeAside(): void;
+    toggleAside(item: NavigationItem): void;
+    trackByFn(index: number, item: NavigationItem): string | number | undefined;
+    protected _enableAnimations(): void;
+    protected _disableAnimations(): void;
+    protected _showOverlay(): void;
+    protected _hideOverlay(): void;
+    protected _showAsideOverlay(): void;
+    protected _hideAsideOverlay(): void;
+    protected _setTimeout(fn: () => void, delay?: number): void;
+    private _removeOverlayElement;
+    protected _toggleOpened(open: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavigationBaseComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VerticalNavigationBaseComponent, never, never, { "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "inner": { "alias": "inner"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "position": { "alias": "position"; "required": false; }; "transparentOverlay": { "alias": "transparentOverlay"; "required": false; }; }, { "appearanceChanged": "appearanceChanged"; "modeChanged": "modeChanged"; "openedChanged": "openedChanged"; "positionChanged": "positionChanged"; }, never, never, true, never>;
+}
+
+declare class VerticalNavigationDefaultComponent extends VerticalNavigationBaseComponent implements OnChanges, OnInit, AfterViewInit, OnDestroy {
+    protected _componentPrefix: string;
+    protected _asideWrapperClass: string;
+    appearance: VerticalNavigationAppearance;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavigationDefaultComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VerticalNavigationDefaultComponent, "vertical-navigation", ["verticalNavigationDefault"], { "appearance": { "alias": "appearance"; "required": false; }; }, {}, never, ["[verticalNavigationHeader]", "[verticalNavigationContentHeader]", "[verticalNavigationContentFooter]", "[verticalNavigationFooter]"], true, never>;
+}
+
+declare class VerticalNavigationCollapsibleComponent {
+    private navigationComponent?;
+    autoCollapse: boolean;
+    appearance: VerticalNavigationAppearance;
+    inner: boolean;
+    mode: VerticalNavigationMode;
+    navigation: NavigationItem[];
+    opened: boolean;
+    position: VerticalNavigationPosition;
+    transparentOverlay: boolean;
+    readonly appearanceChanged: EventEmitter<VerticalNavigationAppearance>;
+    readonly modeChanged: EventEmitter<VerticalNavigationMode>;
+    readonly openedChanged: EventEmitter<boolean>;
+    readonly positionChanged: EventEmitter<VerticalNavigationPosition>;
+    protected readonly renderedAppearance: VerticalNavigationAppearance;
+    refresh(): void;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavigationCollapsibleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VerticalNavigationCollapsibleComponent, "vertical-navigation-collapsible", ["verticalNavigationCollapsible"], { "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "inner": { "alias": "inner"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "navigation": { "alias": "navigation"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "position": { "alias": "position"; "required": false; }; "transparentOverlay": { "alias": "transparentOverlay"; "required": false; }; }, { "appearanceChanged": "appearanceChanged"; "modeChanged": "modeChanged"; "openedChanged": "openedChanged"; "positionChanged": "positionChanged"; }, never, ["[verticalNavigationHeader]", "[verticalNavigationContentHeader]", "[verticalNavigationContentFooter]", "[verticalNavigationFooter]"], true, never>;
+}
+
+declare class VerticalNavigationAsideItemComponent implements OnChanges, OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _navigationComponent;
+    private _router;
+    activeItemId?: string | null;
+    autoCollapse: boolean;
+    item: NavigationAsideItem;
+    skipChildren: boolean;
+    active: boolean;
+    readonly treeTrackByFn: typeof trackNavigationTreeItem;
+    readonly treeShouldRenderItemFn: typeof shouldRenderNavigationItem;
+    private _unsubscribeAll;
+    /**
+     * On changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Track by function for ngFor loops
+     */
+    trackByFn(index: number, item: NavigationItem): string | number | undefined;
+    shouldRenderItem(item: NavigationItem): boolean;
+    get treeTemplateData(): {
+        autoCollapse: boolean;
+    };
+    /**
+     * Check if the given item has the given url in one of its children
+     */
+    private _hasActiveChild;
+    /**
+     * Decide and mark if the item is active
+     */
+    private _markIfActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavigationAsideItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VerticalNavigationAsideItemComponent, "vertical-navigation-aside-item", never, { "activeItemId": { "alias": "activeItemId"; "required": false; }; "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "item": { "alias": "item"; "required": false; }; "skipChildren": { "alias": "skipChildren"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class VerticalNavigationBasicItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _navigationComponent;
+    private _navigationService;
+    item: NavigationBasicItem;
+    isActiveMatchOptions: IsActiveMatchOptions;
+    private _unsubscribeAll;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    hasAction(): boolean;
+    markActive(): void;
+    triggerAction(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavigationBasicItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VerticalNavigationBasicItemComponent, "vertical-navigation-basic-item", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class VerticalNavigationCollapsableItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _navigationComponent;
+    private _navigationService;
+    private _router;
+    autoCollapse: boolean;
+    item: NavigationCollapsableItem;
+    isCollapsed: boolean;
+    readonly treeTrackByFn: typeof trackNavigationTreeItem;
+    readonly treeShouldRenderItemFn: typeof shouldRenderNavigationItem;
+    get isExpanded(): boolean;
+    private _unsubscribeAll;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Collapse
+     */
+    collapse(): void;
+    /**
+     * Expand
+     */
+    expand(): void;
+    /**
+     * Toggle collapsable
+     */
+    toggleCollapsable(): void;
+    /**
+     * Track by function for ngFor loops
+     */
+    trackByFn(index: number, item: NavigationItem): string | number | undefined;
+    shouldRenderItem(item: NavigationItem): boolean;
+    get treeTemplateData(): {
+        autoCollapse: boolean;
+    };
+    /**
+     * Check if the given item has the given url in one of its children
+     */
+    private _hasActiveChild;
+    private _shouldExpand;
+    /**
+     * Check if this is a children of the given item
+     */
+    private _isChildrenOf;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavigationCollapsableItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VerticalNavigationCollapsableItemComponent, "vertical-navigation-collapsable-item", never, { "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class VerticalNavigationDividerItemComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavigationDividerItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VerticalNavigationDividerItemComponent, "vertical-navigation-divider-item", never, {}, {}, never, never, true, never>;
+}
+
+declare class VerticalNavigationGroupItemComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private _navigationComponent;
+    autoCollapse: boolean;
+    item: NavigationGroupItem;
+    private _unsubscribeAll;
+    readonly treeTrackByFn: typeof trackNavigationTreeItem;
+    readonly treeShouldRenderItemFn: typeof shouldRenderNavigationItem;
+    /**
+     * On init
+     */
+    ngOnInit(): void;
+    /**
+     * On destroy
+     */
+    ngOnDestroy(): void;
+    /**
+     * Track by function for ngFor loops
+     */
+    trackByFn(index: number, item: NavigationItem): string | number | undefined;
+    shouldRenderItem(item: NavigationItem): boolean;
+    get treeTemplateData(): {
+        autoCollapse: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavigationGroupItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VerticalNavigationGroupItemComponent, "vertical-navigation-group-item", never, { "autoCollapse": { "alias": "autoCollapse"; "required": false; }; "item": { "alias": "item"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class VerticalNavigationSpacerItemComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<VerticalNavigationSpacerItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VerticalNavigationSpacerItemComponent, "vertical-navigation-spacer-item", never, {}, {}, never, never, true, never>;
+}
+
+export { VerticalNavigationAsideItemComponent, VerticalNavigationBasicItemComponent, VerticalNavigationCollapsableItemComponent, VerticalNavigationCollapsibleComponent, VerticalNavigationDefaultComponent, VerticalNavigationDividerItemComponent, VerticalNavigationGroupItemComponent, VerticalNavigationSpacerItemComponent };

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

@@ -0,0 +1,228 @@
+import * as _angular_core from '@angular/core';
+import { EnvironmentProviders, InjectionToken } from '@angular/core';
+import { Params, QueryParamsHandling, IsActiveMatchOptions } from '@angular/router';
+
+type NavigationItemType = 'aside' | 'basic' | 'collapsable' | 'divider' | 'group' | 'spacer';
+interface NavigationItemClasses {
+    title?: string;
+    subtitle?: string;
+    icon?: string;
+    wrapper?: string;
+}
+interface NavigationItemBadge {
+    title?: string;
+    classes?: string;
+}
+type NavigationVisibilityHandler = (item: NavigationItem) => boolean;
+type NavigationActionHandler = (item: NavigationItem) => void;
+interface NavigationItemBase {
+    /** Unique identifier untuk item navigasi */
+    id?: string;
+    /** Judul/label yang ditampilkan */
+    title?: string;
+    /** Subtitle/deskripsi tambahan */
+    subtitle?: string;
+    /** Status aktif item */
+    active?: boolean;
+    /** Status disabled item */
+    disabled?: boolean;
+    /** Tooltip text saat hover */
+    tooltip?: string;
+    /** Custom CSS classes */
+    classes?: NavigationItemClasses;
+    /** Material icon name */
+    icon?: string;
+    /** Badge configuration */
+    badge?: NavigationItemBadge;
+    /** Additional metadata */
+    meta?: Record<string, unknown>;
+    /** Function untuk hide/show item secara dinamis */
+    isHidden?: NavigationVisibilityHandler;
+}
+interface NavigationRoutableItemBase extends NavigationItemBase {
+    /** Angular router link */
+    link?: string;
+    /** URL fragment (#anchor) */
+    fragment?: string;
+    /** Preserve fragment saat navigasi */
+    preserveFragment?: boolean;
+    /** Query parameters untuk routing */
+    queryParams?: Params | null;
+    /** Cara handle query params */
+    queryParamsHandling?: QueryParamsHandling | null;
+    /** Flag untuk external link */
+    externalLink?: boolean;
+    /** Target untuk external link */
+    target?: '_blank' | '_self' | '_parent' | '_top' | string;
+    /** Exact match untuk active route */
+    exactMatch?: boolean;
+    /** Options untuk active match detection */
+    isActiveMatchOptions?: IsActiveMatchOptions;
+    /** Custom action yang dipanggil saat item diklik */
+    action?: NavigationActionHandler;
+}
+interface NavigationBasicItem extends NavigationRoutableItemBase {
+    type: 'basic';
+    children?: never;
+}
+interface NavigationAsideItem extends NavigationRoutableItemBase {
+    type: 'aside';
+    children: NavigationItem[];
+}
+interface NavigationCollapsableItem extends NavigationRoutableItemBase {
+    type: 'collapsable';
+    children: NavigationItem[];
+}
+interface NavigationGroupItem extends NavigationItemBase {
+    type: 'group';
+    children: NavigationItem[];
+}
+interface NavigationDividerItem extends NavigationItemBase {
+    type: 'divider';
+    children?: never;
+}
+interface NavigationSpacerItem extends NavigationItemBase {
+    type: 'spacer';
+    children?: never;
+}
+type NavigationBranchItem = NavigationAsideItem | NavigationCollapsableItem | NavigationGroupItem;
+type NavigationLeafItem = NavigationBasicItem | NavigationDividerItem | NavigationSpacerItem;
+type NavigationItem = NavigationBranchItem | NavigationLeafItem;
+/**
+ * Navigation Item Interface
+ *
+ * Interface ini mendefinisikan struktur data untuk setiap item navigasi
+ * Mendukung berbagai tipe item dan konfigurasi routing Angular
+ */
+type NavigationStructuredItem = NavigationItem;
+/**
+ * Horizontal Navigation Variants
+ * - default: standard top navigation treatment
+ * - mega: roomier top navigation with larger dropdown treatment
+ */
+type HorizontalNavigationVariant = 'default' | 'mega';
+/**
+ * Vertical Navigation Appearances
+ * - default: 280px width, full labels & icons
+ * - collapsible: alias variant that currently reuses the default layout
+ */
+type VerticalNavigationAppearance = 'default' | 'collapsible';
+/**
+ * Vertical Navigation Modes
+ * - over: Overlay mode (fixed position, z-index tinggi)
+ * - side: Side mode (relative position, push content)
+ */
+type VerticalNavigationMode = 'over' | 'side';
+/**
+ * Vertical Navigation Position
+ */
+type VerticalNavigationPosition = 'left' | 'right';
+
+interface NgNavigationConfig {
+    defaultHorizontalVariant: HorizontalNavigationVariant;
+    defaultVerticalVariant: VerticalNavigationAppearance;
+}
+
+declare function provideNgNavigation(config?: Partial<NgNavigationConfig>): EnvironmentProviders;
+
+declare class NavigationPreferencesService {
+    private readonly config;
+    private readonly document;
+    private readonly isBrowser;
+    private readonly storage;
+    private readonly _horizontalVariant;
+    private readonly _verticalAppearance;
+    private readonly _activeItemId;
+    private readonly _expandedItemIds;
+    readonly horizontalVariant: _angular_core.Signal<HorizontalNavigationVariant>;
+    readonly verticalAppearance: _angular_core.Signal<VerticalNavigationAppearance>;
+    readonly activeItemId: _angular_core.Signal<string | null>;
+    readonly expandedItemIds: _angular_core.Signal<string[]>;
+    setHorizontalVariant(value: HorizontalNavigationVariant): void;
+    setVerticalAppearance(value: VerticalNavigationAppearance): void;
+    setActiveItem(id: string | null): void;
+    clearActiveItem(): void;
+    setExpandedItemIds(ids: readonly string[]): void;
+    expandItem(id: string): void;
+    collapseItem(id: string): void;
+    toggleExpandedItem(id: string): void;
+    clearExpandedItems(): void;
+    reset(): void;
+    syncWithNavigation(navigation: readonly NavigationItem[]): void;
+    private readActiveItemId;
+    private readExpandedItemIds;
+    private readHorizontalVariant;
+    private readVerticalAppearance;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationPreferencesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NavigationPreferencesService>;
+}
+
+declare const DEFAULT_NG_NAVIGATION_CONFIG: NgNavigationConfig;
+declare const NG_NAVIGATION_CONFIG: InjectionToken<NgNavigationConfig>;
+
+declare function getNavigationItemAction(item: NavigationItem): NavigationActionHandler | undefined;
+declare function getNavigationItemVisibilityHandler(item: NavigationItem): NavigationVisibilityHandler | undefined;
+declare function isNavigationItemHidden(item: NavigationItem): boolean;
+declare function shouldRenderNavigationItem(item: NavigationItem): boolean;
+declare function hasNavigationChildren(item: NavigationItem): item is NavigationBranchItem;
+declare function getNavigationChildren(item: NavigationItem): NavigationItem[];
+declare function isNavigationRoutableItem(item: NavigationItem): item is NavigationItem & NavigationRoutableItemBase;
+
+/**
+ * Navigation Service
+ *
+ * Service ini bertanggung jawab untuk:
+ * 1. Store dan retrieve navigation data
+ * 2. Menyediakan state aktif dan expanded item
+ * 3. Utility functions untuk navigation operations
+ */
+declare class NavigationService {
+    private readonly preferences;
+    private _navigation;
+    readonly navigationItems: _angular_core.Signal<NavigationItem[]>;
+    readonly activeItemId: _angular_core.Signal<string | null>;
+    readonly flatNavigation: _angular_core.Signal<NavigationItem[]>;
+    readonly expandedItemIds: _angular_core.Signal<string[]>;
+    /**
+     * Store navigation data
+     * Biasanya dipanggil saat app initialization
+     */
+    storeNavigation(navigation: NavigationItem[]): void;
+    /**
+     * Get navigation data dari storage
+     */
+    getNavigation(): NavigationItem[];
+    /**
+     * Delete navigation data dari storage
+     */
+    deleteNavigation(): void;
+    setActiveItem(id: string | null): void;
+    clearActiveItem(): void;
+    getActiveItem(navigation?: NavigationItem[]): NavigationItem | null;
+    expandItem(id: string): void;
+    collapseItem(id: string): void;
+    toggleItemExpanded(id: string): void;
+    isItemExpanded(id: string): boolean;
+    clearExpandedItems(): void;
+    /**
+     * Flatten navigation array
+     * Convert nested structure menjadi flat array (hanya basic items)
+     * Berguna untuk search, analytics, atau operations lainnya
+     */
+    getFlatNavigation(navigation: NavigationItem[], flatNavigation?: NavigationItem[]): NavigationItem[];
+    /**
+     * Get item by ID dari navigation tree
+     * Recursive search untuk find item dengan id tertentu
+     */
+    getItem(id: string, navigation: NavigationItem[]): NavigationItem | null;
+    /**
+     * Get parent dari item dengan id tertentu
+     * Berguna untuk breadcrumb atau navigation path
+     */
+    getItemParent(id: string, navigation: NavigationItem[], parent: NavigationItem[] | NavigationItem): NavigationItem[] | NavigationItem | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NavigationService>;
+}
+
+export { DEFAULT_NG_NAVIGATION_CONFIG, NG_NAVIGATION_CONFIG, NavigationPreferencesService, NavigationService, getNavigationChildren, getNavigationItemAction, getNavigationItemVisibilityHandler, hasNavigationChildren, isNavigationItemHidden, isNavigationRoutableItem, provideNgNavigation, shouldRenderNavigationItem };
+export type { HorizontalNavigationVariant, NavigationActionHandler, NavigationAsideItem, NavigationBasicItem, NavigationBranchItem, NavigationCollapsableItem, NavigationDividerItem, NavigationGroupItem, NavigationItem, NavigationItemBadge, NavigationItemBase, NavigationItemClasses, NavigationItemType, NavigationLeafItem, NavigationRoutableItemBase, NavigationSpacerItem, NavigationStructuredItem, NavigationVisibilityHandler, NgNavigationConfig, VerticalNavigationAppearance, VerticalNavigationMode, VerticalNavigationPosition };

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

@@ -1,10 +1,12 @@
 import { EnvironmentProviders } from '@angular/core';
 import { NgLayoutConfig } from '@ojiepermana/angular/layout';
+import { NgNavigationConfig } from '@ojiepermana/angular/navigation';
 import { NgThemeConfig } from '@ojiepermana/angular/theme/service';
 
 interface NgShellConfig {
     readonly theme?: Partial<NgThemeConfig>;
     readonly layout?: Partial<NgLayoutConfig>;
+    readonly navigation?: Partial<NgNavigationConfig>;
 }
 declare function provideNgShell(config?: NgShellConfig): EnvironmentProviders;