@luigi-project/core-modular 0.0.4-dev.202603120041 → 0.0.4-dev.202603131029

package/modules/ui-module.d.ts

@@ -1,15 +1,16 @@
 import { Luigi } from '../core-api/luigi';
 import { NavigationService } from '../services/navigation.service';
 import { RoutingService } from '../services/routing.service';
-import { ModalSettings } from '../types/navigation';
+import { ModalSettings, Node } from '../types/navigation';
+import { LuigiParams } from '../types/routing';
 export declare const UIModule: {
     navService: NavigationService;
     routingService: RoutingService;
     luigi: Luigi;
     init: (luigi: Luigi) => void;
     update: (scopes?: string[]) => Promise<void>;
-    updateMainContent: (currentNode: any, luigi: Luigi, withoutSync?: boolean, preventContextUpdate?: boolean) => Promise<void>;
-    openModal: (luigi: Luigi, node: any, modalSettings: ModalSettings, onCloseCallback?: () => void) => Promise<void>;
+    updateMainContent: (currentNode: Node, luigi: Luigi, luigiParams?: LuigiParams, withoutSync?: boolean, preventContextUpdate?: boolean) => Promise<void>;
+    openModal: (luigi: Luigi, node: Node, modalSettings: ModalSettings, onCloseCallback?: () => void) => Promise<void>;
     updateModalSettings: (modalSettings: ModalSettings, addHistoryEntry: boolean, luigi: Luigi) => void;
-    openDrawer: (luigi: Luigi, node: any, modalSettings: ModalSettings, onCloseCallback?: () => void) => Promise<void>;
+    openDrawer: (luigi: Luigi, node: Node, modalSettings: ModalSettings, onCloseCallback?: () => void) => Promise<void>;
 };

package/package.json

@@ -18,5 +18,5 @@
     "micro-frontends",
     "microfrontends"
   ],
-  "version": "0.0.4-dev.202603120041"
+  "version": "0.0.4-dev.202603131029"
 }

package/services/navigation.service.d.ts

@@ -23,7 +23,7 @@ export declare class NavigationService {
      * @param array children
      * @returns array children
      */
-    getTruncatedChildren(children: any): any[];
+    getTruncatedChildren(children: Node[]): Node[];
     applyNavGroups(items: NavItem[]): NavItem[];
     getLeftNavData(path: string, pData?: PathData): Promise<LeftNavData>;
     navItemClick(node: Node, pathData?: PathData): void;

package/services/routing.service.d.ts

@@ -1,12 +1,7 @@
 import { Luigi } from '../core-api/luigi';
+import { Route } from '../types/routing';
 import { ModalSettings, Node, PathData } from '../types/navigation';
 import { NavigationService } from './navigation.service';
-export interface Route {
-    raw: string;
-    node?: Node;
-    path: string;
-    nodeParams?: Record<string, string>;
-}
 export declare class RoutingService {
     private luigi;
     navigationService?: NavigationService;

package/types/navigation.d.ts

@@ -59,7 +59,7 @@ export interface UserInfo {
     description?: string;
 }
 export interface LeftNavData {
-    selectedNode: any;
+    selectedNode: Node;
     items: NavItem[];
     basePath: string;
     sideNavFooterText?: string;
@@ -88,8 +88,10 @@ export interface Node {
         changeCurrentLocale?: boolean;
         urlParameters?: Record<string, any>;
     };
+    compound?: CompoundConfig;
     context?: Record<string, any>;
     drawer?: ModalSettings;
+    decodeViewUrl?: boolean;
     externalLink?: ExternalLink;
     hideFromNav?: boolean;
     hideSideNav?: boolean;
@@ -97,6 +99,9 @@ export interface Node {
     isRootNode?: boolean;
     keepSelectedForChildren?: boolean;
     label?: string;
+    loadingIndicator?: {
+        enabled: boolean;
+    };
     navigationContext?: string;
     onNodeActivation?: (node: Node) => boolean | void;
     openNodeInModal?: boolean;
@@ -106,9 +111,16 @@ export interface Node {
     runTimeErrorHandler?: RunTimeErrorHandler;
     tabNav?: boolean;
     tooltipText?: string;
+    userSettingsGroup?: string;
     viewUrl?: string;
     visibleForFeatureToggles?: string[];
     virtualTree?: boolean;
+    viewGroup?: string;
+    webcomponent?: boolean | {
+        type?: string;
+        selfRegistered?: boolean;
+        tagName?: string;
+    };
     _virtualTree?: Node;
     _virtualPathIndex?: number;
     _virtualViewUrl?: string;
@@ -198,4 +210,208 @@ export interface NavigationRequestParams extends NavigationRequestBase {
 export interface NavigationRequestEvent {
     detail: NavigationRequestBase;
 }
+/**
+ * Configuration for compound web components in Luigi.
+ * Compound allows you to layout multiple web components in one micro frontend.
+ */
+export interface CompoundConfig {
+    /**
+     * Renderer configuration for the compound layout
+     */
+    renderer?: {
+        /**
+         * The renderer to use - can be 'grid', a custom renderer object, or undefined for default
+         */
+        use?: 'grid' | string | {
+            /**
+             * Base renderer to extend (e.g., 'grid')
+             */
+            extends?: string;
+            /**
+             * Custom function to create the compound container
+             * @param config - The renderer configuration
+             * @param renderer - The parent/super renderer (if extending)
+             */
+            createCompoundContainer?: (config: RendererConfig, renderer?: any) => HTMLDivElement;
+            /**
+             * Custom function to create individual compound item containers
+             * @param layoutConfig - Layout configuration for the item
+             * @param config - The overall renderer configuration
+             * @param renderer - The parent/super renderer (if extending)
+             */
+            createCompoundItemContainer?: (layoutConfig?: LayoutConfig, config?: RendererConfig, renderer?: any) => HTMLDivElement;
+            /**
+             * Custom function to attach an item to the compound container
+             * @param compoundCnt - The compound container element
+             * @param compoundItemCnt - The item container to attach
+             * @param renderer - The parent/super renderer (if extending)
+             */
+            attachCompoundItem?: (compoundCnt: HTMLElement, compoundItemCnt: HTMLElement, renderer?: any) => void;
+        };
+        /**
+         * Configuration for the grid layout
+         */
+        config?: {
+            /**
+             * CSS grid-template-columns value (e.g., '1fr 2fr')
+             */
+            columns?: string;
+            /**
+             * CSS grid-template-rows value (e.g., '150px 150px')
+             */
+            rows?: string;
+            /**
+             * CSS grid-gap value (e.g., 'auto', '10px')
+             */
+            gap?: string;
+            /**
+             * Minimum height for the grid container
+             */
+            minHeight?: string;
+            /**
+             * Responsive layout configurations for different viewport sizes
+             */
+            layouts?: Array<{
+                /**
+                 * CSS grid-template-columns for this breakpoint
+                 */
+                columns?: string | number;
+                /**
+                 * CSS grid-template-rows for this breakpoint
+                 */
+                rows?: string | number;
+                /**
+                 * CSS grid-gap for this breakpoint
+                 */
+                gap?: string | number;
+                /**
+                 * Minimum viewport width for this layout (in pixels)
+                 */
+                minWidth?: number;
+                /**
+                 * Maximum viewport width for this layout (in pixels)
+                 */
+                maxWidth?: number;
+            }>;
+        };
+    };
+    /**
+     * Lazy loading configuration for compound children
+     */
+    lazyLoadingOptions?: {
+        /**
+         * Enable lazy loading using IntersectionObserver
+         * @default false
+         */
+        enabled?: boolean;
+        /**
+         * IntersectionObserver rootMargin option
+         * Controls when children are loaded relative to viewport visibility
+         * @default "0px"
+         */
+        intersectionRootMargin?: string;
+        /**
+         * Default temporary height for child containers before they load
+         * @default "500px"
+         */
+        temporaryContainerHeight?: string;
+        /**
+         * Disable automatic temporary container heights
+         * Useful for custom renderers that manage heights themselves
+         * @default false
+         */
+        noTemporaryContainerHeight?: boolean;
+    };
+    /**
+     * Array of child web component configurations
+     */
+    children?: Array<{
+        /**
+         * Unique identifier for this child web component
+         */
+        id: string;
+        /**
+         * URL pointing to the web component JavaScript file
+         * Supports {i18n.currentLocale} placeholder for localization
+         */
+        viewUrl: string;
+        /**
+         * Context object passed to the web component
+         */
+        context?: Record<string, any>;
+        /**
+         * Layout configuration for positioning this child
+         */
+        layoutConfig?: {
+            /**
+             * CSS grid-row value (e.g., '1 / 3', 'auto')
+             * @default "auto"
+             */
+            row?: string;
+            /**
+             * CSS grid-column value (e.g., '1 / -1', 'auto')
+             * @default "auto"
+             */
+            column?: string;
+            /**
+             * Slot name for nested web components
+             * Use this instead of row/column to plug into a parent's slot
+             */
+            slot?: string;
+            /**
+             * Override the default temporary container height for this specific child
+             * Only used when lazy loading is enabled
+             * * @default undefined
+             */
+            temporaryContainerHeight?: string;
+        };
+        /**
+         * Event listeners for cross-component communication via event bus
+         */
+        eventListeners?: Array<{
+            /**
+             * ID of the source web component (use '*' for any source)
+             */
+            source: string;
+            /**
+             * Name of the event to listen for
+             */
+            name: string;
+            /**
+             * Type of action to perform (e.g., 'update')
+             */
+            action: string;
+            /**
+             * Optional function to convert event data before passing to listener
+             * @param data - The event data
+             */
+            dataConverter?: (data: any) => any;
+        }>;
+    }>;
+}
+/**
+ * Supporting type for layout configuration
+ */
+export interface LayoutConfig {
+    column?: string;
+    row?: string;
+    slot?: string;
+    temporaryContainerHeight?: string;
+}
+/**
+ * Supporting type for renderer configuration
+ */
+export interface RendererConfig {
+    columns?: string;
+    rows?: string;
+    gap?: string;
+    minHeight?: string;
+    layouts?: Array<{
+        columns?: string;
+        rows?: string;
+        gap?: string | number;
+        minWidth?: number;
+        maxWidth?: number;
+    }>;
+}
 export type HistoryMethod = 'pushState' | 'replaceState';

package/types/routing.d.ts

@@ -0,0 +1,12 @@
+import { Node } from './navigation';
+export interface Route {
+    raw: string;
+    node?: Node;
+    path: string;
+    nodeParams?: Record<string, string>;
+}
+export interface LuigiParams {
+    nodeParams: Record<string, any> | {};
+    pathParams: Record<string, any> | {};
+    searchParams: Record<string, any> | {};
+}

package/utilities/helpers/navigation-helpers.d.ts

@@ -6,7 +6,7 @@ export declare const NavigationHelpers: {
     segmentMatches: (linkSegment: string, pathSegment: string, pathParams: Record<string, any>) => boolean;
     checkMatch: (route: string, nodesInPath: Array<any>, pathParams?: Record<string, any>) => boolean;
     checkVisibleForFeatureToggles: (nodeToCheckPermission: any, featureToggles: FeatureToggles) => boolean;
-    generateTooltipText: (node: any, translation: string, luigi: Luigi) => string;
+    generateTooltipText: (node: Node, translation: string, luigi: Luigi) => string;
     isNodeAccessPermitted: (nodeToCheckPermissionFor: Node, parentNode: Node | undefined, currentContext: Record<string, any>, luigi: Luigi) => boolean;
     updateHeaderTitle: (appSwitcherData: AppSwitcher, pathData: PathData) => string | undefined;
     buildPath(pathToLeftNavParent: Node[], pathData?: PathData): string;