@luigi-project/core-modular 0.0.4-dev.20260490045 → 0.0.5-dev.202604160059

package/modules/ui-module.d.ts

@@ -7,10 +7,12 @@ export declare const UIModule: {
     navService: NavigationService;
     routingService: RoutingService;
     luigi: Luigi;
+    modalContainer: any;
+    drawerContainer: any;
     init: (luigi: Luigi) => void;
     update: (scopes?: string[]) => 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: Node, modalSettings: ModalSettings, onCloseCallback?: () => void) => Promise<void>;
+    openDrawer: (luigi: Luigi, node: Node, drawerSettings: ModalSettings, onCloseCallback?: () => void) => Promise<void>;
 };

package/modules/ux-module.d.ts

@@ -1,11 +1,12 @@
 import { LuigiCompoundContainer, LuigiContainer } from '@luigi-project/container';
 import { Luigi } from '../core-api/luigi';
 export interface AlertSettings {
-    text?: string;
-    type?: string;
-    links?: Record<string, Link>;
     closeAfter?: number;
     id?: string;
+    links?: Record<string, Link>;
+    text?: string;
+    ttl?: number;
+    type?: string;
 }
 export interface AlertHandler {
     openFromClient: boolean;

package/package.json

@@ -18,5 +18,5 @@
     "micro-frontends",
     "microfrontends"
   ],
-  "version": "0.0.4-dev.20260490045"
+  "version": "0.0.5-dev.202604160059"
 }

package/services/navigation.service.d.ts

@@ -12,8 +12,7 @@ export declare class NavigationService {
     getPathData(path: string): Promise<PathData>;
     findMatchingNode(urlPathElement: string, nodes: Node[]): Node | undefined;
     buildNavItems(nodes: Node[], selectedNode: Node | undefined, pathData: PathData): NavItem[];
-    shouldRedirect(path: string, pData?: PathData): Promise<string | undefined>;
-    getCurrentNode(path: string): Promise<any>;
+    getCurrentNode(path: string): Promise<Node | undefined>;
     getPathParams(path: string): Promise<Record<string, any>>;
     /**
      * getTruncatedChildren
@@ -103,7 +102,7 @@ export declare class NavigationService {
      * Builds a path string by concatenating path segments from the virtual tree root or the incoming path.
      *
      * @param incomingPath - The incoming path segment to be appended.
-     * @param fromVirtualTreeRoot - A boolean indicating whether to build the path from the virtual tree root.
+     * @param options - The set of params related to navigation.
      * @returns The constructed path string.
      */
     buildPath(incomingPath: string, options: NavigationOptions): Promise<string>;

package/services/routing.service.d.ts

@@ -105,4 +105,22 @@ export declare class RoutingService {
      */
     updateModalDataInUrl(modalPath: string, modalParams: ModalSettings, addHistoryEntry: boolean): void;
     checkInvalidateCache(previousPathData: PathData | undefined, newPath: string): void;
+    /**
+     * Deal with page not found scenario.
+     * @param {Object} nodeObject - the data of node
+     * @param {string} viewUrl - the url of the current mf view
+     * @param {Object} pathData - the information of current path
+     * @param {string} path - the path of the view to open
+     * @param {string} pathUrlRaw - path url without hash
+     * @returns {Promise<boolean>} A promise that resolves when page not found handling is complete.
+     */
+    handlePageNotFound(nodeObject: any, viewUrl: string, pathData: PathData, path: string, pathUrlRaw: string): Promise<boolean>;
+    /**
+     * Handle error for page not found scenario.
+     * @param {string} pathToRedirect - fallback path for redirection
+     * @param {string} notFoundPath - the path which cannot be found
+     * @param {boolean} isAnyPathMatched - is any path matched or not
+     * @returns {Promise<void>} A promise that resolves when error handling is complete.
+     */
+    showPageNotFoundError(pathToRedirect: string, notFoundPath: string, isAnyPathMatched?: boolean): Promise<void>;
 }

package/types/navigation.d.ts

@@ -66,11 +66,13 @@ export interface LeftNavData {
     navClick?: (item: NavItem) => void;
 }
 export interface PathData {
+    context?: Record<string, any>;
     selectedNode?: Node;
     selectedNodeChildren?: Node[];
     nodesInPath?: Node[];
     rootNodes: Node[];
     pathParams: Record<string, any>;
+    matchedPath: string;
 }
 export interface RootNode {
     node: Node;
@@ -204,6 +206,7 @@ export interface NavigationRequestBase {
     options?: NavigationOptions;
 }
 export interface NavigationRequestParams extends NavigationRequestBase {
+    drawerSettings?: any;
     modalSettings?: any;
     newTab?: boolean;
     path: string;

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

@@ -35,15 +35,39 @@ export declare const GenericHelpers: {
      * @returns {boolean}
      */
     isObject: (objectToCheck: object | any) => boolean;
+    /**
+     * Checks if a given input string begins a hash with slash
+     * @param {string} path
+     * @returns {boolean}
+     */
+    hasHash: (path: string) => boolean;
+    /**
+     * Removes leading hash of a string
+     * @param {string} path
+     * @returns {string}
+     */
+    getPathWithoutHash: (path: string) => string;
+    /**
+     * Removes any trailing slash of a string
+     * @param {string} path
+     * @returns {string}
+     */
+    getTrimmedUrl: (path: string) => string;
+    /**
+     * Adds a leading slash to a string if it has none
+     * @param {string} str string to be checked
+     * @returns {string} string with a leading slash
+     */
+    addLeadingSlash: (str: string) => string;
     /**
      * Removes leading slash of a string
-     * @param {str} string
+     * @param {string} str string to be checked
      * @returns {string} string without leading slash
      */
     trimLeadingSlash: (str: string) => string;
     /**
      * Prepend current url to redirect_uri, if it is a relative path
-     * @param {str} string from which any number of trailing slashes should be removed
+     * @param {string} str string from which any number of trailing slashes should be removed
      * @returns {string} string without any trailing slash
      */
     trimTrailingSlash: (str: string) => string;

package/utilities/helpers/luigi-container-helpers.d.ts

@@ -0,0 +1,18 @@
+import { Luigi } from '../../core-api/luigi';
+export type MicrofrontendEntry = {
+    iframe: HTMLElement;
+    id: string;
+    active: boolean;
+};
+export type MicrofrontendInDom = {
+    container: HTMLElement;
+    active: boolean;
+    type: 'main' | 'modal' | 'drawer';
+    id: string;
+};
+export declare const LuigiContainerHelpers: {
+    getMicrofrontendsInDom(luigi: Luigi): MicrofrontendInDom[];
+    getMainMicrofrontends(luigi: Luigi): MicrofrontendEntry[];
+    getModalMicrofrontends(): MicrofrontendEntry[];
+    getDrawerMicrofrontends(): MicrofrontendEntry;
+};

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

@@ -8,6 +8,7 @@ export declare const NavigationHelpers: {
     checkVisibleForFeatureToggles: (nodeToCheckPermission: any, featureToggles: FeatureToggles) => boolean;
     generateTooltipText: (node: Node, translation: string, luigi: Luigi) => string;
     isNodeAccessPermitted: (nodeToCheckPermissionFor: Node, parentNode: Node | undefined, currentContext: Record<string, any>, luigi: Luigi) => boolean;
+    applyContext: (context: Record<string, any>, addition: Record<string, any>, navigationContext: any) => Record<string, any>;
     updateHeaderTitle: (appSwitcherData: AppSwitcher, pathData: PathData) => string | undefined;
     buildPath(pathToLeftNavParent: Node[], pathData?: PathData): string;
     mergeContext(...objs: Record<string, any>[]): Record<string, any>;
@@ -18,4 +19,12 @@ export declare const NavigationHelpers: {
      * @returns The virtual tree root node if found, otherwise undefined.
      */
     findVirtualTreeRootNode(node: Node): Node | undefined;
+    /**
+     * Validates if a path exists and handles page not found cases.
+     * Returns the redirect path if valid, or undefined if the path should not be followed.
+     * @param path The path to validate
+     * @param luigi The Luigi instance
+     * @returns The redirect path if valid, undefined otherwise
+     */
+    validatePathAndGetRedirect: (path: string, luigi: Luigi) => Promise<string | undefined>;
 };

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

@@ -262,6 +262,41 @@ export declare const RoutingHelpers: {
      * @param {*} pathParams
      */
     getDynamicNodeValue(node: Node, pathParams: Record<string, string>): string | undefined;
+    /**
+     * Checks if given path is an existing route or not
+     * @param {string} activePath - path to be checked
+     * @param {PathData} pathData - related path data
+     * @returns {boolean} the result of path checking as boolean value
+     */
+    isExistingRoute(activePath: string, pathData: PathData): boolean;
+    /**
+     * Handles case if path exists or not.
+     * @param {string} path - the path to be checked
+     * @param {Luigi} luigi - the Luigi instance used to access configuration values
+     * @returns {Promise<boolean>} the result of path checking as async boolean value
+     */
+    pathExists(path: string, luigi: Luigi): Promise<boolean>;
+    showRouteNotFoundAlert(path: string, isAnyPathMatched: boolean | undefined, luigi: Luigi): void;
+    /**
+     * Queries the pageNotFoundHandler configuration and returns redirect path if it exists
+     * If the there is no `pageNotFoundHandler` defined we return undefined.
+     * @param {string} notFoundPath - the path to be checked
+     * @param {boolean} isAnyPathMatched - is any path matched or not
+     * @param {Luigi} luigi - the Luigi instance used to access config value
+     * @returns {Object} an object optionally containing the path to redirect, the keepURL option or an empty object if handler is undefined
+     */
+    getPageNotFoundRedirectResult(notFoundPath: string, isAnyPathMatched: boolean | undefined, luigi: Luigi): object;
+    /**
+     * Handles pageNotFound situation depending if path exists or not.
+     * If path exists simply return the given path, else fetch the pageNotFound redirect path and return it.
+     * In case there was no pageNotFound handler defined it shows an alert and returns undefined.
+     * @param {string} path - the path to check for
+     * @param {boolean} pathExists - defines if path exists or not
+     * @param {Luigi} luigi - the Luigi instance used to access configuration values
+     * @returns {} the path to redirect to or undefined if path doesn't exist and no redirect path is defined
+     */
+    handlePageNotFoundAndRetrieveRedirectPath(path: string, pathExists: boolean, luigi: Luigi): Promise<string | undefined>;
+    getDefaultChildNode(pathData: PathData, childrenResolverFn?: (lastElement: object, pathContext: object) => any): Promise<string>;
     /**
      *  Recursively constructs the full path for a given node by concatenating its path segment with those of its ancestors.
      *  If `params` are provided, they are appended as query parameters to the final path.