@filip.mazev/blocks 1.4.17 → 1.4.18

package/fesm2022/filip.mazev-blocks.mjs

@@ -1,4 +1,4 @@
-const BLOCKS_VERSION = "1.4.17";
+const BLOCKS_VERSION = "1.4.18";
 export { BLOCKS_VERSION };
 
 //# sourceMappingURL=filip.mazev-blocks.mjs.map

package/fesm2022/filip.mazev-blocks.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"filip.mazev-blocks.mjs","names":[],"sources":["../../../projects/blocks/src/public-api.ts"],"sourcesContent":["/* * Public API Surface of blocks\n * This file is auto-generated. Do not edit directly.\n */\n\nexport const BLOCKS_VERSION = '1.4.17';\n"],"mappings":"AAIA,MAAa,iBAAiB"}
+{"version":3,"file":"filip.mazev-blocks.mjs","names":[],"sources":["../../../projects/blocks/src/public-api.ts"],"sourcesContent":["/* * Public API Surface of blocks\n * This file is auto-generated. Do not edit directly.\n */\n\nexport const BLOCKS_VERSION = '1.4.18';\n"],"mappings":"AAIA,MAAa,iBAAiB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@filip.mazev/blocks",
-  "version": "1.4.17",
+  "version": "1.4.18",
   "license": "MIT",
   "schematics": "./schematics/collection.json",
   "exports": {

package/types/filip.mazev-blocks-core.d.ts

@@ -204,6 +204,7 @@ export declare class BxA11yService {
 export declare class BxOverlayPositionService {
   private readonly overlay;
   getElementStrategy(element: HTMLElement, placement: BxPlacement, offset?: number): FlexibleConnectedPositionStrategy;
+  getSubmenuStrategy(element: HTMLElement, side: 'left' | 'right', offset?: number): FlexibleConnectedPositionStrategy;
   getCoordinateStrategy(x: number, y: number): FlexibleConnectedPositionStrategy;
   private getPositions;
   static ɵfac: i0.ɵɵFactoryDeclaration<BxOverlayPositionService, never>;
@@ -371,6 +372,22 @@ export declare function invertPaletteToken(token: Color): Color;
 export declare function resolveThemeId(value: string | null | undefined): BxThemeId | undefined;
 export declare function uuidv4(): string;
 export declare function inheritOverlayTheme(source: HTMLElement, pane: HTMLElement): () => void;
-export declare function trackOverlayOrigin(overlay: OverlayRef, origin: HTMLElement): () => void;
+/** Callable tracking teardown with an explicit refresh for coordinated child overlays. */
+export type OverlayOriginTracker = (() => void) & {
+  /** Re-measure the source and refresh its native anchor offset or fallback position. */
+  reposition: () => void;
+};
+/** Optional coordination for overlays whose origins can move inside other overlays or clipped scrollers. */
+export interface IOverlayOriginOptions {
+  /** Allow native CSS anchor tracking. Defaults to true; coordinated cascades use measured positioning. */
+  nativeAnchoring?: boolean;
+  /** Optional callback after the overlay is positioned. Use it to update dependent child overlays in order. */
+  onPosition?: () => void;
+  /** Optional callback when the origin leaves the viewport or a clipping ancestor. Defaults to leaving visibility to the owner. */
+  onOriginHidden?: () => void;
+}
+export declare function trackOverlayOrigin(overlay: OverlayRef, origin: HTMLElement, options?: IOverlayOriginOptions): OverlayOriginTracker;
 /** Resolves text and tracks the adapter's language signal in the calling computation. */
-export declare function resolveText(text: ResolvableText | undefined, adapter: IBxI18nAdapter | null, params?: Record<string, unknown>): string;
+export declare function resolveText(text: ResolvableText | undefined, adapter: IBxI18nAdapter | null, params?: Record<string, unknown>): string;
+/** Whether an overlay origin still intersects the viewport and every ancestor that clips its contents. */
+export declare function isOverlayOriginVisible(origin: HTMLElement): boolean;

package/types/filip.mazev-blocks-navigation.d.ts

@@ -1,8 +1,10 @@
 import * as i0 from "@angular/core";
-import { InjectionToken, Signal } from "@angular/core";
+import { InjectionToken, Signal, TemplateRef } from "@angular/core";
 import { ActivatedRouteSnapshot, Data, Route } from "@angular/router";
 import { IconData } from "@filip.mazev/blocks/icons";
-import { ResolvableText, Strict } from "@filip.mazev/blocks/core";
+import { ResolvableText, Strict, WindowDimensionsService } from "@filip.mazev/blocks/core";
+import { ITagConfig } from "@filip.mazev/blocks/primitives";
+import { Subject } from "rxjs";
 export declare class Breadcrumbs {
   private readonly navigationService;
   private readonly a11y;
@@ -34,15 +36,42 @@ export interface INavContext {
   snapshot?: ActivatedRouteSnapshot;
 }
 export type NavText = ResolvableText | ((ctx: INavContext) => ResolvableText);
+/** A noninteractive badge displayed beside a navigation label. */
+export interface INavTag {
+  /** Optional translated text; number-only tags can omit it. */
+  text?: ResolvableText;
+  /** Optional Blocks tag appearance. Defaults to a small tonal tag. */
+  config?: ITagConfig;
+}
+/** Route UI metadata. TSection restricts section IDs when used with defineNavigation. */
 export interface INavMeta<TSection extends string = string> {
+  /** Optional translated menu label, resolved again when the language changes. */
   label?: NavText;
+  /** Optional breadcrumb label; defaults to label. */
   breadcrumb?: NavText;
+  /** Optional leading icon. */
   icon?: IconData;
+  /** Optional trailing icon, independent of the submenu disclosure. */
+  endIcon?: IconData;
+  /** Optional noninteractive Blocks tags. Defaults to no tags. */
+  tags?: readonly INavTag[];
+  /** Optional additional translated terms used by side-nav search. */
+  keywords?: readonly NavText[];
+  /** Optional disabled state. Prevents navigation and opening descendants. Defaults to false. */
+  disabled?: boolean;
+  /** Optional breadcrumb inclusion. Defaults to the section setting, then true. */
+  showInBreadcrumbs?: boolean;
+  /** Optional section ID. Nested entries inherit their parent's section. */
   section?: TSection;
+  /** Whether to render this route in menus. Defaults to true; false promotes visible descendants. */
   menu?: boolean;
+  /** Hides this route and its descendants from menus. Defaults to false. */
   hidden?: boolean;
+  /** Optional ascending display order; unordered items sort by label. */
   order?: number;
+  /** Marks the application's home route. Defaults to false. */
   root?: boolean;
+  /** Optional reactive visibility predicate. False hides this route and its descendants. */
   visible?: () => boolean;
 }
 export interface INavRouteData {
@@ -59,18 +88,94 @@ export interface INavigationItem {
   icon?: IconData;
   section?: string;
   visible: boolean;
+  /** Optional breadcrumb inclusion from route metadata. Defaults to the section setting, then true. */
+  showInBreadcrumbs?: boolean;
   children?: INavigationItem[];
   data?: INavMeta;
 }
+/** Shared configuration for a named navigation section. */
 export interface INavigationSectionConfig {
+  /** Required unique ID referenced by withNav metadata. */
   id: string;
-  title?: string;
+  /** Optional translated heading. Defaults to id. */
+  title?: ResolvableText;
+  /** Optional ascending section order. Defaults to declaration order. */
   order?: number;
+  /** Optional section icon; the side-nav falls back to folder. */
+  icon?: IconData;
+  /** Whether users may collapse the section. Defaults to false. */
+  collapsible?: boolean;
+  /** Initial section state when no saved state exists. Defaults to false. */
+  collapsed?: boolean;
+  /** Default breadcrumb inclusion for this section's routes. Defaults to true. */
+  showInBreadcrumbs?: boolean;
+}
+export type SideNavSide = 'left' | 'right';
+/** Short public alias for the fully documented configuration interface. */
+export type SideNavConfig = ISideNavConfig;
+/** NavigationService's resolved route contract. Supply route metadata through withNav. */
+export type NavItem = INavigationItem;
+/** Shared or per-instance side-nav configuration. Instance values override application defaults. */
+export interface ISideNavConfig {
+  /** Physical viewport side. Defaults to left, including in RTL. */
+  side?: SideNavSide;
+  /** Fixed application rail or inline panel. Inline mobile drawers fill their positioned containing shell without locking page scroll. Defaults to fixed. */
+  position?: 'fixed' | 'inline';
+  /** Expanded width, as a CSS length. Defaults to 17rem; constrained to the viewport. */
+  width?: string;
+  /** Icon rail width, as a CSS length. Defaults to 4.5rem. */
+  collapsedWidth?: string;
+  /** Optional search field. Defaults to true; searches all visible loaded descendants. */
+  searchable?: boolean;
+  /** Show leading icons in expanded item rows. Defaults to true; compact rows always retain an icon. */
+  showItemIcons?: boolean;
+  /** Show icons beside expanded section headings. Defaults to true; compact section triggers always retain an icon. */
+  showSectionIcons?: boolean;
+  /** Show the desktop collapse action. Defaults to true. */
+  collapsible?: boolean;
+  /** Initial desktop collapse state. Defaults to false; saved state wins unless the model is bound. */
+  collapsed?: boolean;
+  /** Optional localStorage key. Persists panel and section states; mobile openness and search are never saved. */
+  persistenceKey?: string;
+  /** Automatic mobile breakpoint from Blocks dimensions. Defaults to lg. */
+  mobileBreakpoint?: keyof WindowDimensionsService['breakpoints'];
+  /** Optional mobile override for embedded layouts and demos. Omit for automatic viewport detection. */
+  mobile?: boolean;
+  /** Show the built-in mobile hamburger. Defaults to true; false requires an application trigger calling open/toggle. */
+  showMobileTrigger?: boolean;
+  /** Optional accessible navigation name. Defaults to Main navigation. */
+  ariaLabel?: ResolvableText;
+  /** Optional search placeholder. Defaults to Search navigation…. */
+  searchPlaceholder?: ResolvableText;
+  /** Optional accessible search name. Defaults to Search navigation. */
+  searchLabel?: ResolvableText;
+  /** Optional accessible clear-search action. Defaults to Clear search. */
+  clearSearchLabel?: ResolvableText;
+  /** Optional no-results message. Defaults to No matching pages. */
+  emptyText?: ResolvableText;
+  /** Optional mobile open action name. Defaults to Open navigation. */
+  openLabel?: ResolvableText;
+  /** Optional mobile close/backdrop action name. Defaults to Close navigation. */
+  closeLabel?: ResolvableText;
+  /** Optional collapse action name. Defaults to Collapse navigation. */
+  collapseLabel?: ResolvableText;
+  /** Optional expand action name. Defaults to Expand navigation. */
+  expandLabel?: ResolvableText;
+  /** Optional submenu action prefix. Defaults to Open submenu; the item label is appended. */
+  submenuLabel?: ResolvableText;
+  /** Optional search target announcement prefix. Defaults to Search result; the target label is appended. */
+  resultLabel?: ResolvableText;
 }
+/** Application-wide navigation defaults supplied with provideNavigation. */
 export interface INavigationConfig {
+  /** Optional ordered sections. Unlisted section IDs are appended automatically. */
   sections?: readonly INavigationSectionConfig[];
+  /** Include hidden routes in breadcrumbs. Defaults to false. */
   includeHiddenInBreadcrumbs?: boolean;
+  /** Optional custom sibling ordering; defaults to metadata order, then label. */
   sortItems?: (a: INavigationItem, b: INavigationItem) => number;
+  /** Optional shared side-nav defaults, overridden by an instance's config. */
+  sideNav?: ISideNavConfig;
 }
 /** A UI section containing flat, visible menu entries. */
 export interface INavigationGroup {
@@ -112,6 +217,13 @@ export declare function provideNavigation(config: INavigationConfig): {
  * This allows you to easily associate navigation information with your routes, which can then be used by navigation components to generate menus, breadcrumbs, etc.
  */
 export declare function withNav<T extends INavMeta>(route: Route, nav: Strict<T, INavMeta>): Route;
+/** A resolved section retaining nested items for hierarchical navigation. */
+export interface INavigationTreeGroup extends Omit<INavigationSectionConfig, 'title'> {
+  /** Translated heading. */
+  title: string;
+  /** Visible roots in this section; same-section descendants remain nested. */
+  items: INavigationItem[];
+}
 export declare class NavigationService {
   private readonly router;
   private readonly config;
@@ -124,7 +236,11 @@ export declare class NavigationService {
   readonly baseRoute: Signal<string | undefined>;
   readonly menu: Signal<INavigationItem[]>;
   readonly menuGroups: Signal<INavigationGroup[]>;
+  /** Hierarchical sections; menuGroups retains its existing flat contract. */
+  readonly menuTreeGroups: Signal<INavigationTreeGroup[]>;
   navigateBack(): void;
+  private groupTree;
+  private includeBreadcrumb;
   private extractRoutes;
   private resolveCurrent;
   private buildMenu;
@@ -136,4 +252,232 @@ export declare class NavigationService {
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 export declare const NAVIGATION_ACCESS_ADAPTER: InjectionToken<INavigationAccessAdapter>;
-export declare const NAVIGATION_CONFIG: InjectionToken<INavigationConfig>;
+export declare const NAVIGATION_CONFIG: InjectionToken<INavigationConfig>;
+/** Context supplied to header and footer templates. */
+export interface ISideNavSlotContext {
+  /** True when presenting the desktop icon rail. Search temporarily expands the rail. */
+  $implicit: boolean;
+  /** Named equivalent of $implicit. */
+  collapsed: boolean;
+  /** True while using the mobile drawer. */
+  mobile: boolean;
+}
+/** Item presentation context. The surrounding link/button retains routing, semantics and keyboard behavior. */
+export interface ISideNavItemContext {
+  /** Resolved navigation item. */
+  $implicit: INavigationItem;
+  /** Whether this is the active Angular route. */
+  active: boolean;
+  /** Whether only the item's icon should be displayed. */
+  collapsed: boolean;
+}
+/** Resolved layout state for application shells and future top-bar integration. */
+export interface ISideNavLayout {
+  /** Physical panel edge. */
+  side: SideNavSide;
+  /** Space to reserve beside the application content; 0px for a mobile drawer. */
+  offset: string;
+  /** Whether the desktop panel is currently presented as an icon rail. */
+  collapsed: boolean;
+  /** Whether responsive drawer behavior is active. */
+  mobile: boolean;
+  /** Whether the mobile drawer is open. Desktop panels remain visible. */
+  open: boolean;
+}
+/** Internal search derivation; all paths contain stable navigation item IDs. */
+interface ISideNavSearchResult {
+  groups: readonly INavigationTreeGroup[];
+  path: readonly string[];
+  target?: string;
+  label?: string;
+}
+/** One instance per side-nav; coordinates its recursive branch presentations. */
+declare class SideNavStateService {
+  private readonly router;
+  private readonly activeRoute;
+  private readonly i18n;
+  private readonly lastSelected;
+  private readonly rememberedPath;
+  private readonly searchSelected;
+  readonly config: import("@angular/core").WritableSignal<ISideNavConfig>;
+  readonly sourceGroups: import("@angular/core").WritableSignal<readonly INavigationTreeGroup[]>;
+  readonly query: import("@angular/core").WritableSignal<string>;
+  readonly itemTemplate: import("@angular/core").WritableSignal<TemplateRef<ISideNavItemContext> | undefined>;
+  readonly activated: Subject<INavigationItem>;
+  readonly groups: import("@angular/core").Signal<{
+    items: INavigationItem[];
+    title: string;
+    id: string;
+    order?: number | undefined;
+    icon?: import("@filip.mazev/blocks/icons").IconData | undefined;
+    collapsible?: boolean | undefined;
+    collapsed?: boolean | undefined;
+    showInBreadcrumbs?: boolean | undefined;
+  }[]>;
+  /** Select the most specific visible route, rather than every matching URL prefix. */
+  readonly activeItem: import("@angular/core").Signal<INavigationItem | undefined>;
+  readonly activeIds: import("@angular/core").Signal<Set<string>>;
+  readonly searchResult: import("@angular/core").Signal<ISideNavSearchResult>;
+  readonly revealPath: import("@angular/core").Signal<readonly string[]>;
+  readonly target: import("@angular/core").Signal<string | undefined>;
+  readonly text: import("@angular/core").Signal<{
+    ariaLabel: string;
+    searchPlaceholder: string;
+    searchLabel: string;
+    clearSearchLabel: string;
+    emptyText: string;
+    openLabel: string;
+    closeLabel: string;
+    collapseLabel: string;
+    expandLabel: string;
+    submenuLabel: string;
+    resultLabel: string;
+  }>;
+  constructor();
+  isCurrent(item: INavigationItem): boolean;
+  search(query: string): void;
+  select(item: INavigationItem): void;
+  private findActiveItem;
+  private routeSpecificity;
+  private resolveNav;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SideNavStateService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class SideNav {
+  private readonly document;
+  private readonly router;
+  private readonly destroyRef;
+  private readonly dimensions;
+  private readonly navigation;
+  private readonly defaults;
+  private readonly scrollLock;
+  private readonly cascade;
+  private readonly a11y;
+  private readonly injector;
+  private readonly focusMonitor;
+  private readonly toggleElement;
+  private readonly saved;
+  private readonly loadedKey;
+  private readonly lockId;
+  private readonly presentation;
+  protected readonly drawerAnimated: import("@angular/core").WritableSignal<boolean>;
+  protected readonly state: SideNavStateService;
+  protected readonly id: string;
+  protected readonly headerTemplate: import("@angular/core").WritableSignal<TemplateRef<ISideNavSlotContext> | null>;
+  protected readonly footerTemplate: import("@angular/core").WritableSignal<TemplateRef<ISideNavSlotContext> | null>;
+  protected readonly reducedMotion: import("@angular/core").Signal<boolean>;
+  protected readonly visibleGroups: import("@angular/core").Signal<readonly INavigationTreeGroup[]>;
+  protected readonly slotContext: import("@angular/core").Signal<ISideNavSlotContext>;
+  readonly config: import("@angular/core").InputSignal<ISideNavConfig>;
+  /** Omit to use NavigationService's hierarchical route sections. */
+  readonly groups: import("@angular/core").InputSignal<readonly INavigationTreeGroup[] | undefined>;
+  /** Optional presentation template; routing and menu semantics remain on the component's surrounding control. */
+  readonly itemTemplate: import("@angular/core").InputSignal<TemplateRef<ISideNavItemContext> | undefined>;
+  /** Optional controlled desktop state. Without a binding, persisted state and configuration determine the initial value. */
+  readonly collapsed: import("@angular/core").InputSignal<boolean | undefined>;
+  readonly collapsedChange: import("@angular/core").OutputEmitterRef<boolean>;
+  readonly mobileOpen: import("@angular/core").ModelSignal<boolean>;
+  readonly itemSelected: import("@angular/core").OutputEmitterRef<INavigationItem>;
+  readonly layoutChange: import("@angular/core").OutputEmitterRef<ISideNavLayout>;
+  readonly resolvedConfig: import("@angular/core").Signal<{
+    side: import("@filip.mazev/blocks/navigation").SideNavSide;
+    position: "fixed" | "inline";
+    width: string;
+    collapsedWidth: string;
+    searchable: boolean;
+    showItemIcons: boolean;
+    showSectionIcons: boolean;
+    collapsible: boolean;
+    collapsed: boolean;
+    persistenceKey?: string;
+    mobileBreakpoint: keyof WindowDimensionsService["breakpoints"];
+    mobile?: boolean;
+    showMobileTrigger: boolean;
+    ariaLabel: import("@filip.mazev/blocks/core").ResolvableText;
+    searchPlaceholder: import("@filip.mazev/blocks/core").ResolvableText;
+    searchLabel: import("@filip.mazev/blocks/core").ResolvableText;
+    clearSearchLabel: import("@filip.mazev/blocks/core").ResolvableText;
+    emptyText: import("@filip.mazev/blocks/core").ResolvableText;
+    openLabel: import("@filip.mazev/blocks/core").ResolvableText;
+    closeLabel: import("@filip.mazev/blocks/core").ResolvableText;
+    collapseLabel: import("@filip.mazev/blocks/core").ResolvableText;
+    expandLabel: import("@filip.mazev/blocks/core").ResolvableText;
+    submenuLabel: import("@filip.mazev/blocks/core").ResolvableText;
+    resultLabel: import("@filip.mazev/blocks/core").ResolvableText;
+  }>;
+  readonly isMobile: import("@angular/core").Signal<boolean>;
+  readonly isCollapsed: import("@angular/core").Signal<boolean>;
+  readonly query: import("@angular/core").Signal<string>;
+  readonly layout: import("@angular/core").Signal<ISideNavLayout>;
+  private restoreFocus?;
+  private focusReturnOrigin;
+  private focusRevision;
+  constructor();
+  setHeaderTemplate(template: TemplateRef<ISideNavSlotContext> | null): void;
+  setFooterTemplate(template: TemplateRef<ISideNavSlotContext> | null): void;
+  toggle(origin?: HTMLElement | Event): void;
+  open(origin?: HTMLElement | Event): void;
+  close(): void;
+  toggleCollapsed(): void;
+  search(query: string): void;
+  protected closeFromControl(event: MouseEvent): void;
+  protected sectionActive(group: INavigationTreeGroup): boolean;
+  protected sectionHighlighted(group: INavigationTreeGroup): boolean;
+  protected sectionCollapsed(group: INavigationTreeGroup): boolean;
+  protected toggleSection(group: INavigationTreeGroup): void;
+  protected menuKey(event: KeyboardEvent): void;
+  protected panelKey(event: KeyboardEvent): void;
+  private readSavedState;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SideNav, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SideNav, "bx-side-nav", ["bxSideNav"], {
+    "config": {
+      "alias": "config";
+      "required": false;
+      "isSignal": true;
+    };
+    "groups": {
+      "alias": "groups";
+      "required": false;
+      "isSignal": true;
+    };
+    "itemTemplate": {
+      "alias": "itemTemplate";
+      "required": false;
+      "isSignal": true;
+    };
+    "collapsed": {
+      "alias": "collapsed";
+      "required": false;
+      "isSignal": true;
+    };
+    "mobileOpen": {
+      "alias": "mobileOpen";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "collapsedChange": "collapsedChange";
+    "mobileOpen": "mobileOpenChange";
+    "itemSelected": "itemSelected";
+    "layoutChange": "layoutChange";
+  }, never, never, true, never>;
+}
+/** Registers an ng-template with the containing side-nav, following the modal slot contract. */
+export declare class SideNavHeaderDirective {
+  private readonly template;
+  private readonly nav;
+  constructor();
+  static ngTemplateContextGuard(_directive: SideNavHeaderDirective, _context: unknown): _context is ISideNavSlotContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SideNavHeaderDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SideNavHeaderDirective, "[bxSideNavHeader]", never, {}, {}, never, never, true, never>;
+}
+/** Registers an ng-template with the containing side-nav, following the modal slot contract. */
+export declare class SideNavFooterDirective {
+  private readonly template;
+  private readonly nav;
+  constructor();
+  static ngTemplateContextGuard(_directive: SideNavFooterDirective, _context: unknown): _context is ISideNavSlotContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SideNavFooterDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<SideNavFooterDirective, "[bxSideNavFooter]", never, {}, {}, never, never, true, never>;
+}
+export {};

package/types/filip.mazev-blocks-primitives.d.ts

@@ -532,6 +532,8 @@ export type TagVariant = 'filled' | 'tonal' | 'outlined';
 export type TagSize = 'small' | 'medium';
 /** Reusable tag appearance; direct component inputs override these optional values. */
 export interface ITagConfig {
+  /** Optional opaque surface. True removes translucency and backdrop blur; otherwise follows application appearance. */
+  opaque?: boolean;
   /** Semantic color role. Defaults to accent. */
   color?: TagColor;
   /** Filled, tonal, or outlined treatment. Defaults to tonal. */
@@ -568,6 +570,8 @@ export declare class Tag {
   protected readonly resolvedTrailingNumber: import("@angular/core").Signal<string>;
   protected readonly palette: import("@angular/core").Signal<ITagPalette>;
   protected readonly isNumberOnly: import("@angular/core").Signal<boolean>;
+  /** Optional opaque surface; true removes translucency and blur. False or absent follows application appearance. */
+  readonly opaque: import("@angular/core").InputSignal<boolean | undefined>;
   readonly text: import("@angular/core").InputSignal<ResolvableText | undefined>;
   readonly config: import("@angular/core").InputSignal<ITagConfig>;
   readonly color: import("@angular/core").InputSignal<TagColor | undefined>;
@@ -588,6 +592,11 @@ export declare class Tag {
   readonly focusable: import("@angular/core").InputSignal<boolean>;
   static ɵfac: i0.ɵɵFactoryDeclaration<Tag, never>;
   static ɵcmp: i0.ɵɵComponentDeclaration<Tag, "bx-tag", never, {
+    "opaque": {
+      "alias": "opaque";
+      "required": false;
+      "isSignal": true;
+    };
     "text": {
       "alias": "text";
       "required": false;
@@ -675,4 +684,107 @@ export declare class Tag {
     };
   }, {}, never, never, true, never>;
 }
+/** Hover, click, touch and keyboard trigger for nested, opaque bx-menu surfaces. */
+export declare class MenuTriggerDirective {
+  private readonly source;
+  private readonly overlay;
+  private readonly overlayContext;
+  private readonly zone;
+  private readonly positions;
+  private readonly cascade;
+  private readonly vcr;
+  private readonly traps;
+  private readonly opened;
+  protected readonly overlayId: import("@angular/core").WritableSignal<string | null>;
+  readonly isOpen: import("@angular/core").Signal<boolean>;
+  readonly bxMenuTrigger: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+  /** The enclosing trigger, when this is a submenu. */
+  /** Optional positioning origin when a disclosure button belongs to a wider row. Defaults to the trigger element. */
+  readonly menuOrigin: import("@angular/core").InputSignal<HTMLElement | undefined>;
+  readonly menuParent: import("@angular/core").InputSignal<MenuTriggerDirective | undefined>;
+  /** Physical preferred side; viewport collision handling can flip the menu. Defaults to right. */
+  readonly menuSide: import("@angular/core").InputSignal<"left" | "right">;
+  /** Allows hover opening. Click and keyboard access always remain available. Defaults to true. */
+  readonly menuHover: import("@angular/core").InputSignal<boolean>;
+  /** Accessible menu name, normally the trigger's resolved label. */
+  readonly menuLabel: import("@angular/core").InputSignal<string>;
+  /** Keep a revealed search path open during pointer movement; Escape still dismisses it. */
+  readonly menuPinned: import("@angular/core").InputSignal<boolean>;
+  readonly menuOpened: import("@angular/core").OutputEmitterRef<void>;
+  readonly menuClosed: import("@angular/core").OutputEmitterRef<void>;
+  private overlayRef?;
+  private trap?;
+  private subscriptions;
+  private disconnectTheme?;
+  private hoverTimer?;
+  private positionTracker?;
+  constructor();
+  toggle(event: MouseEvent): void;
+  open(focus?: boolean): void;
+  close(restoreFocus?: boolean): void;
+  reposition(): void;
+  contains(target: Node): boolean;
+  scheduleClose(): void;
+  protected onPointerEnter(event: PointerEvent): void;
+  protected onKey(event: KeyboardEvent): void;
+  private cancelClose;
+  private focusFirst;
+  private onMenuKey;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[bxMenuTrigger]", ["bxMenuTrigger"], {
+    "bxMenuTrigger": {
+      "alias": "bxMenuTrigger";
+      "required": true;
+      "isSignal": true;
+    };
+    "menuOrigin": {
+      "alias": "menuOrigin";
+      "required": false;
+      "isSignal": true;
+    };
+    "menuParent": {
+      "alias": "menuParent";
+      "required": false;
+      "isSignal": true;
+    };
+    "menuSide": {
+      "alias": "menuSide";
+      "required": false;
+      "isSignal": true;
+    };
+    "menuHover": {
+      "alias": "menuHover";
+      "required": false;
+      "isSignal": true;
+    };
+    "menuLabel": {
+      "alias": "menuLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "menuPinned": {
+      "alias": "menuPinned";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "menuOpened": "menuOpened";
+    "menuClosed": "menuClosed";
+  }, never, never, true, never>;
+}
+/** Coordinates a single open menu path, allowing arbitrary nesting without sibling overlays accumulating. */
+export declare class MenuCascadeService {
+  private readonly entries;
+  activate(trigger: MenuTriggerDirective): void;
+  remove(trigger: MenuTriggerDirective): void;
+  closeChildren(trigger: MenuTriggerDirective): void;
+  contains(trigger: MenuTriggerDirective, target: Node): boolean;
+  hasOpenMenus(): boolean;
+  repositionChildren(trigger: MenuTriggerDirective): void;
+  closeAll(restoreFocus?: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MenuCascadeService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** Move focus among visible, enabled items in one menu, including wrapped item components. */
+export declare function navigateMenuKey(event: KeyboardEvent, menu: HTMLElement): boolean;
 export {};

package/types/filip.mazev-blocks.d.ts

@@ -1 +1 @@
-export declare const BLOCKS_VERSION = "1.4.17";
+export declare const BLOCKS_VERSION = "1.4.18";