@edsis/ui 0.0.2 → 0.0.3

package/types/edsis-ui-command.d.ts

@@ -11,6 +11,7 @@ declare abstract class CommandContextBase {
     abstract focusFirst(): void;
     abstract hasVisibleItems(): boolean;
     abstract activateOnly(item: CommandItemComponent): void;
+    abstract activeDescendantId(): string | null;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandContextBase, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CommandContextBase, never, never, {}, {}, never, never, true, never>;
 }
@@ -18,7 +19,6 @@ declare class CommandComponent extends CommandContextBase {
     readonly query: _angular_core.ModelSignal<string>;
     readonly class: _angular_core.InputSignal<string>;
     private readonly items;
-    private readonly activeIndex;
     protected readonly classes: _angular_core.Signal<string>;
     matches(text: string): boolean;
     registerItem(item: CommandItemComponent): void;
@@ -29,8 +29,10 @@ declare class CommandComponent extends CommandContextBase {
     focusFirst(): void;
     hasVisibleItems(): boolean;
     activateOnly(item: CommandItemComponent): void;
+    activeDescendantId(): string | null;
     /** Returns the first visible item's text if any. Used when user hits Enter with no active. */
     getActive(): CommandItemComponent | null;
+    private setActiveItem;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommandComponent, "ui-command", never, { "query": { "alias": "query"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, { "query": "queryChange"; }, never, ["*"], true, never>;
 }
@@ -74,6 +76,7 @@ declare class CommandSeparatorComponent {
 declare class CommandItemComponent {
     protected readonly ctx: CommandComponent;
     private readonly el;
+    readonly itemId: string;
     readonly value: _angular_core.InputSignal<string>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly class: _angular_core.InputSignal<string>;

package/types/edsis-ui-context-menu.d.ts

@@ -24,10 +24,11 @@ declare class ContextMenuTriggerDirective {
     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(): void;
+    close(emitOpenedChange?: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContextMenuTriggerDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ContextMenuTriggerDirective, "[uiContextMenuTrigger]", ["uiContextMenuTrigger"], { "uiContextMenuTrigger": { "alias": "uiContextMenuTrigger"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
 }

package/types/edsis-ui-dropdown-menu.d.ts

@@ -8,7 +8,7 @@ declare abstract class MenuFocusableItem {
     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>;
+    readonly selected: _angular_core.OutputEmitterRef<KeyboardEvent | MouseEvent>;
     get disabled(): boolean;
     focus(): void;
     getLabel(): string;
@@ -123,11 +123,14 @@ declare class MenuTriggerDirective {
     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(): void;
+    close(options?: {
+        restoreFocus?: boolean;
+    }): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[uiMenuTrigger]", ["uiMenuTrigger"], { "uiMenuTrigger": { "alias": "uiMenuTrigger"; "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>;
 }

package/types/edsis-ui-editor.d.ts

@@ -89,6 +89,7 @@ declare class EditorContentComponent implements AfterViewInit, OnDestroy, Contro
     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>;

package/types/edsis-ui-hover-card.d.ts

@@ -49,13 +49,15 @@ declare class HoverCardTriggerDirective {
     private isContentHovered;
     private isTriggerFocused;
     private isContentFocused;
+    constructor();
     handleTriggerPointerEnter(): void;
     handleTriggerPointerLeave(event: PointerEvent): void;
     handleTriggerFocusIn(): void;
     handleTriggerFocusOut(event: FocusEvent): void;
     open(): void;
-    close(): void;
+    close(emitOpenedChange?: boolean): void;
     private bindOverlayInteractions;
+    private unbindOverlayInteractions;
     private readonly onContentPointerEnter;
     private readonly onContentPointerLeave;
     private readonly onContentFocusIn;

package/types/edsis-ui-layout-services.d.ts

@@ -0,0 +1 @@
+export { LayoutService } from '@edsis/ui/layout';

package/types/edsis-ui-layout-types.d.ts

@@ -0,0 +1 @@
+export { UI_LAYOUT_APPEARANCE_STORAGE_KEY, UI_LAYOUT_DEFAULT_STYLE, UI_LAYOUT_DEFAULT_SURFACE, UI_LAYOUT_DEFAULT_TYPE, UI_LAYOUT_DEFAULT_WIDTH, UI_LAYOUT_STYLES, UI_LAYOUT_STYLE_STORAGE_KEY, UI_LAYOUT_SURFACES, UI_LAYOUT_SURFACE_STORAGE_KEY, UI_LAYOUT_TYPES, UI_LAYOUT_TYPE_STORAGE_KEY, UI_LAYOUT_WIDTHS, UI_LAYOUT_WIDTH_STORAGE_KEY, UiLayoutContextValue, UiLayoutStyle, UiLayoutSurface, UiLayoutType, UiLayoutWidth, isUiLayoutStyle, isUiLayoutSurface, isUiLayoutType, isUiLayoutWidth } from '@edsis/ui/layout';

package/types/edsis-ui-layout.d.ts

@@ -0,0 +1,153 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+import { UiNavComponent } from '@edsis/ui/nav';
+
+declare const UI_LAYOUT_TYPES: readonly ["vertical", "horizontal", "empty"];
+declare const UI_LAYOUT_SURFACES: readonly ["flat", "grid", "honeycome", "line-vertical", "line-horizontal"];
+declare const UI_LAYOUT_STYLES: readonly ["flat", "border-rail"];
+declare const UI_LAYOUT_WIDTHS: readonly ["full", "wide", "container"];
+type UiLayoutType = (typeof UI_LAYOUT_TYPES)[number];
+type UiLayoutSurface = (typeof UI_LAYOUT_SURFACES)[number];
+type UiLayoutStyle = (typeof UI_LAYOUT_STYLES)[number];
+type UiLayoutWidth = (typeof UI_LAYOUT_WIDTHS)[number];
+declare const UI_LAYOUT_DEFAULT_SURFACE: UiLayoutSurface;
+declare const UI_LAYOUT_DEFAULT_TYPE: UiLayoutType;
+declare const UI_LAYOUT_DEFAULT_STYLE: UiLayoutStyle;
+declare const UI_LAYOUT_DEFAULT_WIDTH: UiLayoutWidth;
+declare const UI_LAYOUT_SURFACE_STORAGE_KEY = "layout-surface";
+declare const UI_LAYOUT_APPEARANCE_STORAGE_KEY = "layout-appearance";
+declare const UI_LAYOUT_TYPE_STORAGE_KEY = "layout-type";
+declare const UI_LAYOUT_STYLE_STORAGE_KEY = "layout-style";
+declare const UI_LAYOUT_WIDTH_STORAGE_KEY = "layout-width";
+interface UiLayoutContextValue {
+    surface: Signal<UiLayoutSurface>;
+    type: Signal<UiLayoutType>;
+    appearance: Signal<UiLayoutStyle>;
+    style: Signal<UiLayoutStyle>;
+    width: Signal<UiLayoutWidth>;
+}
+declare function isUiLayoutSurface(value: string | null): value is UiLayoutSurface;
+declare function isUiLayoutType(value: string | null): value is UiLayoutType;
+declare function isUiLayoutStyle(value: string | null): value is UiLayoutStyle;
+declare function isUiLayoutWidth(value: string | null): value is UiLayoutWidth;
+
+declare class LayoutService {
+    private readonly platformId;
+    private readonly surfaceState;
+    private readonly typeState;
+    private readonly styleState;
+    private readonly widthState;
+    readonly surface: _angular_core.Signal<"flat" | "grid" | "honeycome" | "line-vertical" | "line-horizontal">;
+    readonly type: _angular_core.Signal<"vertical" | "horizontal" | "empty">;
+    readonly appearance: _angular_core.Signal<"flat" | "border-rail">;
+    readonly style: _angular_core.Signal<"flat" | "border-rail">;
+    readonly width: _angular_core.Signal<"full" | "wide" | "container">;
+    registerDefaults(defaults: {
+        surface?: UiLayoutSurface;
+        appearance?: UiLayoutStyle;
+        type?: UiLayoutType;
+        width?: UiLayoutWidth;
+    }): this;
+    registerSurface(surface: UiLayoutSurface): void;
+    registerType(type: UiLayoutType): void;
+    registerAppearance(appearance: UiLayoutStyle): void;
+    registerStyle(style: UiLayoutStyle): void;
+    registerWidth(width: UiLayoutWidth): void;
+    setSurface(surface: UiLayoutSurface): void;
+    setType(type: UiLayoutType): void;
+    setAppearance(appearance: UiLayoutStyle): void;
+    setStyle(style: UiLayoutStyle): void;
+    setWidth(width: UiLayoutWidth): void;
+    getStoredSurface(): UiLayoutSurface;
+    getStoredType(): UiLayoutType;
+    getStoredAppearance(): UiLayoutStyle;
+    getStoredStyle(): UiLayoutStyle;
+    getStoredWidth(): UiLayoutWidth;
+    private readStorage;
+    private removeStorage;
+    private writeStorage;
+    private getStorage;
+    private readStoredAppearance;
+    private getStoredAppearanceOrDefault;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LayoutService>;
+}
+
+declare class UiLayoutComponent {
+    protected readonly layout: LayoutService;
+    readonly surface: _angular_core.InputSignal<"flat" | "grid" | "honeycome" | "line-vertical" | "line-horizontal" | null>;
+    readonly appearance: _angular_core.InputSignal<"flat" | "border-rail" | null>;
+    readonly layoutStyleAttribute: _angular_core.InputSignal<"flat" | "border-rail" | null>;
+    readonly width: _angular_core.InputSignal<"full" | "wide" | "container" | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly appearanceInput: _angular_core.Signal<"flat" | "border-rail" | null>;
+    protected readonly resolvedSurface: _angular_core.Signal<"flat" | "grid" | "honeycome" | "line-vertical" | "line-horizontal">;
+    protected readonly resolvedAppearance: _angular_core.Signal<"flat" | "border-rail">;
+    protected readonly resolvedStyle: _angular_core.Signal<"flat" | "border-rail">;
+    protected readonly resolvedWidth: _angular_core.Signal<"full" | "wide" | "container">;
+    protected readonly isBorderRail: _angular_core.Signal<boolean>;
+    protected readonly showsHorizontalInsetRails: _angular_core.Signal<boolean>;
+    protected readonly railPaddingClasses: _angular_core.Signal<string>;
+    protected readonly railAnchorClasses: _angular_core.Signal<string>;
+    protected readonly contentShellClasses: _angular_core.Signal<string>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected readonly frameClasses: _angular_core.Signal<string>;
+    constructor();
+    private surfaceClasses;
+    private widthClasses;
+    private frameWidthClasses;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiLayoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiLayoutComponent, "ui-layout", never, { "surface": { "alias": "surface"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "layoutStyleAttribute": { "alias": "layout-style"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class UiLayoutVerticalComponent {
+    private readonly layout;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiLayoutVerticalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiLayoutVerticalComponent, "ui-layout-vertical", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class UiLayoutHorizontalComponent {
+    private readonly layout;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiLayoutHorizontalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiLayoutHorizontalComponent, "ui-layout-horizontal", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class UiLayoutEmptyComponent {
+    private readonly layout;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiLayoutEmptyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiLayoutEmptyComponent, "ui-layout-empty", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class UiLayoutNavComponent {
+    protected readonly layout: LayoutService;
+    protected readonly projectedNav: _angular_core.Signal<UiNavComponent | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly railOffset: _angular_core.InputSignal<string | null>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly showsVerticalRail: _angular_core.Signal<boolean>;
+    protected readonly resolvedRailOffset: _angular_core.Signal<string>;
+    protected readonly railTransform: _angular_core.Signal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiLayoutNavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiLayoutNavComponent, "ui-layout-nav", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "railOffset": { "alias": "railOffset"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["projectedNav"], ["*"], true, never>;
+}
+
+declare class UiLayoutContentComponent {
+    protected readonly layout: LayoutService;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiLayoutContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiLayoutContentComponent, "ui-layout-content", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { LayoutService, UI_LAYOUT_APPEARANCE_STORAGE_KEY, UI_LAYOUT_DEFAULT_STYLE, UI_LAYOUT_DEFAULT_SURFACE, UI_LAYOUT_DEFAULT_TYPE, UI_LAYOUT_DEFAULT_WIDTH, UI_LAYOUT_STYLES, UI_LAYOUT_STYLE_STORAGE_KEY, UI_LAYOUT_SURFACES, UI_LAYOUT_SURFACE_STORAGE_KEY, UI_LAYOUT_TYPES, UI_LAYOUT_TYPE_STORAGE_KEY, UI_LAYOUT_WIDTHS, UI_LAYOUT_WIDTH_STORAGE_KEY, UiLayoutComponent, UiLayoutContentComponent, UiLayoutEmptyComponent, UiLayoutHorizontalComponent, UiLayoutNavComponent, UiLayoutVerticalComponent, isUiLayoutStyle, isUiLayoutSurface, isUiLayoutType, isUiLayoutWidth };
+export type { UiLayoutContextValue, UiLayoutStyle, UiLayoutSurface, UiLayoutType, UiLayoutWidth };

package/types/edsis-ui-menubar.d.ts

@@ -45,12 +45,14 @@ declare class MenubarTriggerDirective {
     private readonly menubar;
     private readonly destroyRef;
     private overlayRef;
+    constructor();
     toggle(): void;
     open(options?: {
         focusFirstItem?: boolean;
     }): void;
     close(options?: {
         restoreFocus?: boolean;
+        emitOpenedChange?: boolean;
     }): void;
     focus(): void;
     containsTarget(target: EventTarget | null): boolean;

package/types/edsis-ui-nav-service.d.ts

@@ -0,0 +1,138 @@
+import * as i0 from '@angular/core';
+import { Signal } from '@angular/core';
+import { UrlTree, Params, QueryParamsHandling, IsActiveMatchOptions } from '@angular/router';
+
+type UiNavOrientation = 'vertical' | 'horizontal';
+type UiNavVerticalAppearance = 'sidebar' | 'dockbar';
+type UiNavHorizontalAppearance = 'navbar' | 'flyout';
+type UiNavAppearance = UiNavVerticalAppearance | UiNavHorizontalAppearance;
+type UiNavPosition = 'left' | 'right';
+type UiNavDockbarMode = 'drawer' | 'sticky';
+type UiNavLink = string | readonly unknown[] | UrlTree;
+interface UiNavItem {
+    readonly id?: string;
+    readonly title?: string;
+    readonly subtitle?: string;
+    readonly active?: boolean;
+    readonly disabled?: boolean;
+    readonly tooltip?: string;
+    readonly classes?: {
+        readonly title?: string;
+        readonly subtitle?: string;
+        readonly icon?: string;
+        readonly wrapper?: string;
+    };
+    readonly icon?: string;
+    readonly link?: UiNavLink;
+    readonly href?: string;
+    readonly fragment?: string;
+    readonly preserveFragment?: boolean;
+    readonly queryParams?: Params | null;
+    readonly queryParamsHandling?: QueryParamsHandling | null;
+    readonly externalLink?: boolean;
+    readonly target?: '_blank' | '_self' | '_parent' | '_top' | string;
+    readonly rel?: string;
+    readonly exactMatch?: boolean;
+    readonly isActiveMatchOptions?: IsActiveMatchOptions;
+    readonly children?: readonly UiNavItem[];
+}
+interface UiNavNormalizedItem extends Omit<UiNavItem, 'children'> {
+    readonly key: string;
+    readonly stateId: string;
+    readonly panelId: string;
+    readonly type: 'item' | 'group' | 'collapsible' | 'mega' | 'divider' | 'spacer';
+    readonly source: UiNavItem;
+    readonly children: readonly UiNavNormalizedItem[];
+}
+interface UiNavRegisterInput {
+    readonly id: string;
+    readonly orientation: UiNavOrientation;
+    readonly appearance?: UiNavAppearance | null;
+    readonly position?: UiNavPosition | null;
+    readonly collapsed?: boolean | null;
+    readonly dockbarMode?: UiNavDockbarMode | null;
+}
+interface UiNavState {
+    readonly id: string;
+    readonly orientation: UiNavOrientation;
+    readonly appearance: UiNavAppearance;
+    readonly position: UiNavPosition;
+    readonly collapsed: boolean;
+    readonly dockbarMode: UiNavDockbarMode;
+}
+interface UiNavIconContext {
+    readonly $implicit: string;
+    readonly icon: string;
+    readonly item: UiNavItem;
+    readonly active: boolean;
+    readonly orientation: UiNavOrientation;
+    readonly level: number;
+}
+
+declare class NavService {
+    private readonly documentRef;
+    private readonly router;
+    private readonly routerUrl;
+    private readonly states;
+    private readonly openPanelKeys;
+    private readonly drawerOpenState;
+    readonly openPanelKey: Signal<string | null>;
+    readonly exactMatchOptions: IsActiveMatchOptions;
+    readonly subsetMatchOptions: IsActiveMatchOptions;
+    constructor();
+    register(input: UiNavRegisterInput): UiNavState;
+    unregister(id: string): void;
+    state(id: string): Signal<UiNavState | null>;
+    currentState(id: string): UiNavState | null;
+    currentPanelKey(id: string): string | null;
+    update(id: string, patch: Partial<UiNavRegisterInput>): UiNavState;
+    setAppearance(id: string, appearance: UiNavAppearance): UiNavState;
+    setPosition(id: string, position: UiNavPosition): UiNavState;
+    setCollapsed(id: string, collapsed: boolean): UiNavState;
+    toggleCollapsed(id: string): UiNavState;
+    setDockbarMode(id: string, mode: UiNavDockbarMode): UiNavState;
+    isRouterItem(item: UiNavNormalizedItem): boolean;
+    hrefFor(item: UiNavNormalizedItem): string | null;
+    relFor(item: UiNavNormalizedItem): string | null;
+    routerLinkActiveOptions(item: UiNavNormalizedItem): IsActiveMatchOptions;
+    itemRole(orientation: UiNavOrientation, level: number): 'menuitem' | null;
+    compactLabel(item: UiNavNormalizedItem, compact: boolean): string | null;
+    titleFor(item: UiNavNormalizedItem, compact: boolean): string | null;
+    compactFallback(item: UiNavNormalizedItem): string;
+    iconContext(item: UiNavNormalizedItem, active: boolean, level: number, orientation: UiNavOrientation): UiNavIconContext;
+    isItemActive(item: UiNavNormalizedItem, activeIds: ReadonlySet<string>, explicitActiveUrl: string | null): boolean;
+    isPanelOpen(navIdOrItem: string | UiNavNormalizedItem, item?: UiNavNormalizedItem): boolean;
+    openPanel(navIdOrItem: string | UiNavNormalizedItem, item?: UiNavNormalizedItem): void;
+    togglePanel(navIdOrItem: string | UiNavNormalizedItem, item?: UiNavNormalizedItem): void;
+    closePanel(id?: string): void;
+    isDrawerOpen(id: string): boolean;
+    openDrawer(id: string): void;
+    toggleDrawer(id: string): void;
+    closeDrawer(id: string): void;
+    private matchesActiveUrl;
+    private resolveState;
+    private resolveAppearance;
+    private resolvePosition;
+    private resolveCollapsed;
+    private resolveDockbarMode;
+    private persistState;
+    private readOrientationAppearance;
+    private ensureAppearanceDefaults;
+    private storage;
+    private readStorage;
+    private writeStorage;
+    private instanceStorageKey;
+    private normalizeId;
+    private withoutKey;
+    private resolvePanelArgs;
+    private isAppearanceForOrientation;
+    private isVerticalAppearance;
+    private isHorizontalAppearance;
+    private isPosition;
+    private isDockbarMode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavService>;
+}
+
+export { NavService };
+export type { UiNavAppearance, UiNavDockbarMode, UiNavHorizontalAppearance, UiNavIconContext, UiNavItem, UiNavLink, UiNavNormalizedItem, UiNavOrientation, UiNavPosition, UiNavRegisterInput, UiNavState, UiNavVerticalAppearance };

package/types/edsis-ui-nav.d.ts

@@ -0,0 +1,205 @@
+import * as _edsis_ui_nav from '@edsis/ui/nav';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, Signal } from '@angular/core';
+import { UrlTree, Params, QueryParamsHandling, IsActiveMatchOptions } from '@angular/router';
+
+type UiNavOrientation = 'vertical' | 'horizontal';
+type UiNavVerticalAppearance = 'sidebar' | 'dockbar';
+type UiNavHorizontalAppearance = 'navbar' | 'flyout';
+type UiNavAppearance = UiNavVerticalAppearance | UiNavHorizontalAppearance;
+type UiNavCollapseTree = 'stairs' | 'straight';
+type UiNavPosition = 'left' | 'right';
+type UiNavDockbarMode = 'drawer' | 'sticky';
+interface UiNavRegisterInput {
+    readonly id: string;
+    readonly orientation: UiNavOrientation;
+    readonly appearance?: UiNavAppearance | null;
+    readonly position?: UiNavPosition | null;
+    readonly collapsed?: boolean | null;
+    readonly dockbarMode?: UiNavDockbarMode | null;
+}
+interface UiNavState {
+    readonly id: string;
+    readonly orientation: UiNavOrientation;
+    readonly appearance: UiNavAppearance;
+    readonly position: UiNavPosition;
+    readonly collapsed: boolean;
+    readonly dockbarMode: UiNavDockbarMode;
+}
+type UiNavItemType = 'item' | 'basic' | 'aside' | 'group' | 'collapsible' | 'collapsable' | 'mega' | 'divider' | 'spacer';
+type UiNavNormalizedItemType = 'item' | 'group' | 'collapsible' | 'mega' | 'divider' | 'spacer';
+type UiNavLink = string | readonly unknown[] | UrlTree;
+interface UiNavItemClasses {
+    readonly title?: string;
+    readonly subtitle?: string;
+    readonly icon?: string;
+    readonly wrapper?: string;
+}
+interface UiNavItemBadge {
+    readonly title?: string;
+    readonly classes?: string;
+}
+type UiNavVisibilityHandler = (item: UiNavItem) => boolean;
+type UiNavActionHandler = (item: UiNavItem) => void;
+interface UiNavItem {
+    readonly id?: string;
+    readonly type?: UiNavItemType;
+    readonly title?: string;
+    readonly subtitle?: string;
+    readonly active?: boolean;
+    readonly disabled?: boolean;
+    readonly tooltip?: string;
+    readonly classes?: UiNavItemClasses;
+    readonly icon?: string;
+    readonly badge?: UiNavItemBadge;
+    readonly meta?: Record<string, unknown>;
+    readonly isHidden?: UiNavVisibilityHandler;
+    readonly link?: UiNavLink;
+    readonly href?: string;
+    readonly fragment?: string;
+    readonly preserveFragment?: boolean;
+    readonly queryParams?: Params | null;
+    readonly queryParamsHandling?: QueryParamsHandling | null;
+    readonly externalLink?: boolean;
+    readonly target?: '_blank' | '_self' | '_parent' | '_top' | string;
+    readonly rel?: string;
+    readonly exactMatch?: boolean;
+    readonly isActiveMatchOptions?: IsActiveMatchOptions;
+    readonly action?: UiNavActionHandler;
+    readonly columns?: number;
+    readonly children?: readonly UiNavItem[];
+}
+interface UiNavNormalizedItem extends Omit<UiNavItem, 'children' | 'type'> {
+    readonly key: string;
+    readonly stateId: string;
+    readonly panelId: string;
+    readonly type: UiNavNormalizedItemType;
+    readonly source: UiNavItem;
+    readonly children: readonly UiNavNormalizedItem[];
+}
+interface UiNavSelection {
+    readonly item: UiNavItem;
+    readonly key: string;
+    readonly type: UiNavNormalizedItemType;
+    readonly link?: UiNavLink;
+    readonly external: boolean;
+}
+interface UiNavIconContext {
+    readonly $implicit: string;
+    readonly icon: string;
+    readonly item: UiNavItem;
+    readonly active: boolean;
+    readonly orientation: UiNavOrientation;
+    readonly level: number;
+}
+declare function normalizeUiNavItems(items: readonly UiNavItem[]): readonly UiNavNormalizedItem[];
+
+declare class NavIconDirective {
+    readonly template: TemplateRef<UiNavIconContext>;
+    static ngTemplateContextGuard(_directive: NavIconDirective, context: unknown): context is UiNavIconContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavIconDirective, "ng-template[uiNavIcon]", never, {}, {}, never, never, true, never>;
+}
+
+declare class UiNavFooterComponent {
+    private readonly shell;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly isHorizontal: _angular_core.Signal<boolean>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiNavFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiNavFooterComponent, "ui-nav-footer", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class UiNavHeaderComponent {
+    private readonly shell;
+    readonly toggle: _angular_core.InputSignal<boolean>;
+    readonly class: _angular_core.InputSignal<string>;
+    protected readonly collapsed: _angular_core.Signal<boolean>;
+    protected readonly displayCollapsed: _angular_core.Signal<boolean>;
+    protected readonly isHorizontal: _angular_core.Signal<boolean>;
+    protected readonly showToggle: _angular_core.Signal<boolean>;
+    protected readonly toggleAriaLabel: _angular_core.Signal<"Expand navigation" | "Collapse navigation">;
+    protected readonly toggleIconName: _angular_core.Signal<"left_panel_open" | "left_panel_close">;
+    protected readonly contentClasses: _angular_core.Signal<"min-w-0" | "min-w-0 flex-1">;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    protected toggleCollapsed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiNavHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiNavHeaderComponent, "ui-nav-header", never, { "toggle": { "alias": "toggle"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface UiNavShellContext {
+    readonly state: Signal<UiNavState>;
+    readonly displayState: Signal<UiNavState>;
+    readonly collapseEnabled: Signal<boolean>;
+    toggleCollapsed(): void;
+}
+
+declare class UiNavComponent implements UiNavShellContext {
+    readonly navId: _angular_core.InputSignal<string>;
+    readonly data: _angular_core.InputSignal<readonly UiNavItem[]>;
+    readonly items: _angular_core.InputSignal<readonly UiNavItem[]>;
+    readonly orientation: _angular_core.InputSignal<UiNavOrientation>;
+    readonly appearance: _angular_core.InputSignal<UiNavAppearance | null>;
+    readonly position: _angular_core.InputSignal<UiNavPosition | null>;
+    readonly collapsed: _angular_core.InputSignal<boolean | null>;
+    readonly dockbarMode: _angular_core.InputSignal<UiNavDockbarMode | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly compact: _angular_core.InputSignal<boolean>;
+    readonly previewExpanded: _angular_core.InputSignal<boolean>;
+    readonly sidebarCollapse: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collapseTree: _angular_core.InputSignal<UiNavCollapseTree>;
+    readonly class: _angular_core.InputSignal<string>;
+    readonly itemClass: _angular_core.InputSignal<string>;
+    readonly activeIds: _angular_core.InputSignal<ReadonlySet<string> | readonly string[] | null>;
+    readonly activeUrl: _angular_core.InputSignal<string | null>;
+    readonly openedIds: _angular_core.ModelSignal<readonly string[]>;
+    readonly itemSelected: _angular_core.OutputEmitterRef<UiNavSelection>;
+    private readonly hoverPreviewExpanded;
+    private readonly controller;
+    protected readonly headerSlot: _angular_core.Signal<UiNavHeaderComponent | undefined>;
+    protected readonly footerSlot: _angular_core.Signal<UiNavFooterComponent | undefined>;
+    protected readonly iconTemplate: _angular_core.Signal<NavIconDirective | undefined>;
+    protected readonly normalizedItems: _angular_core.Signal<readonly _edsis_ui_nav.UiNavNormalizedItem[]>;
+    protected readonly resolvedState: _angular_core.Signal<_edsis_ui_nav.UiNavState>;
+    protected readonly activeIdSet: _angular_core.Signal<ReadonlySet<string>>;
+    readonly previewRailExpanded: _angular_core.Signal<boolean>;
+    readonly previewRailOffset: _angular_core.Signal<"15rem" | "0px">;
+    readonly displayState: _angular_core.Signal<_edsis_ui_nav.UiNavState>;
+    readonly collapseEnabled: _angular_core.Signal<boolean>;
+    protected readonly shellClasses: _angular_core.Signal<string>;
+    readonly state: _angular_core.Signal<_edsis_ui_nav.UiNavState>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    toggleCollapsed(): void;
+    protected setHoverPreview(value: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiNavComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiNavComponent, "ui-nav", never, { "navId": { "alias": "id"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "dockbarMode": { "alias": "dockbarMode"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "previewExpanded": { "alias": "previewExpanded"; "required": false; "isSignal": true; }; "sidebarCollapse": { "alias": "nav-sidebar-collapse"; "required": false; "isSignal": true; }; "collapseTree": { "alias": "collapse-tree"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "itemClass": { "alias": "itemClass"; "required": false; "isSignal": true; }; "activeIds": { "alias": "activeIds"; "required": false; "isSignal": true; }; "activeUrl": { "alias": "activeUrl"; "required": false; "isSignal": true; }; "openedIds": { "alias": "openedIds"; "required": false; "isSignal": true; }; }, { "openedIds": "openedIdsChange"; "itemSelected": "itemSelected"; }, ["headerSlot", "footerSlot", "iconTemplate"], ["ui-nav-header", "ui-nav-footer"], true, never>;
+}
+
+declare class UiNavCollapseRootDirective {
+    private readonly shell;
+    protected readonly collapseEnabled: _angular_core.Signal<boolean>;
+    protected readonly displayCollapsed: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiNavCollapseRootDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UiNavCollapseRootDirective, "[uiNavCollapseRoot]", never, {}, {}, never, never, true, never>;
+}
+declare class UiNavCollapseExpandedDirective {
+    private readonly shell;
+    private readonly templateRef;
+    private readonly viewContainer;
+    private hasView;
+    private readonly shouldRender;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiNavCollapseExpandedDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<UiNavCollapseExpandedDirective, "[uiNavCollapseExpanded]", never, {}, {}, never, never, true, never>;
+}
+
+declare class UiNavMainComponent {
+    readonly class: _angular_core.InputSignal<string>;
+    readonly orientation: _angular_core.InputSignal<UiNavOrientation>;
+    protected readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiNavMainComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UiNavMainComponent, "ui-nav-main", never, { "class": { "alias": "class"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { NavIconDirective, UiNavCollapseExpandedDirective, UiNavCollapseRootDirective, UiNavComponent, UiNavFooterComponent, UiNavHeaderComponent, UiNavMainComponent, normalizeUiNavItems };
+export type { UiNavActionHandler, UiNavAppearance, UiNavCollapseTree, UiNavDockbarMode, UiNavHorizontalAppearance, UiNavIconContext, UiNavItem, UiNavItemBadge, UiNavItemClasses, UiNavItemType, UiNavLink, UiNavNormalizedItem, UiNavNormalizedItemType, UiNavOrientation, UiNavPosition, UiNavRegisterInput, UiNavSelection, UiNavState, UiNavVerticalAppearance, UiNavVisibilityHandler };

package/types/edsis-ui-navigation-menu.d.ts

@@ -63,6 +63,7 @@ declare class NavigationMenuTriggerDirective extends NavigationMenuRootItem {
     private readonly navigationMenu;
     private readonly destroyRef;
     private overlayRef;
+    constructor();
     protected readonly classes: _angular_core.Signal<string>;
     toggle(): void;
     open(options?: {
@@ -70,6 +71,7 @@ declare class NavigationMenuTriggerDirective extends NavigationMenuRootItem {
     }): void;
     close(options?: {
         restoreFocus?: boolean;
+        emitOpenedChange?: boolean;
     }): void;
     protected tabIndex(): number;
     protected openFromKeyboard(event: KeyboardEvent, focusFirstItem: boolean): void;