@luigi-project/core-modular 0.0.7-dev.202605190111 → 0.0.7-dev.202605260713

package/package.json

@@ -18,5 +18,5 @@
     "micro-frontends",
     "microfrontends"
   ],
-  "version": "0.0.7-dev.202605190111"
+  "version": "0.0.7-dev.202605260713"
 }

package/types/navigation.d.ts

@@ -33,8 +33,13 @@ export interface ProfileSettings {
     items?: ProfileItem[];
     staticUserInfoFn?: () => Promise<UserInfo>;
     onUserInfoUpdate: (fn: (uInfo: UserInfo) => void) => void;
+    settings: UserSettingsProfileMenuEntry;
     itemClick: (item: ProfileItem) => void;
 }
+export interface UserSettingsProfileMenuEntry {
+    label?: string;
+    link?: string;
+}
 export interface ProfileLogout {
     label?: string;
     icon?: string;
@@ -102,6 +107,7 @@ export interface Node {
     isRootNode?: boolean;
     keepSelectedForChildren?: boolean;
     label?: string;
+    link?: string;
     loadingIndicator?: {
         enabled: boolean;
     };
@@ -129,6 +135,7 @@ export interface Node {
     _virtualTree?: Node;
     _virtualPathIndex?: number;
     _virtualViewUrl?: string;
+    _rawContext?: Record<string, any>;
 }
 export interface PageErrorHandler {
     timeout: number;
@@ -159,6 +166,7 @@ export interface BreadcrumbItem {
 export interface NavItem {
     altText?: string;
     category?: Category;
+    href?: string;
     icon?: string;
     node?: Node;
     label?: string;
@@ -230,6 +238,7 @@ export interface NavigationRequestBase {
 }
 export interface NavigationRequestParams extends NavigationRequestBase {
     drawerSettings?: any;
+    intent?: boolean;
     modalSettings?: any;
     newTab?: boolean;
     path: string;

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

@@ -8,10 +8,9 @@ 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>;
+    mergeContext(base: Record<string, any>, addition?: Record<string, any>, navigationContext?: string): Record<string, any>;
     prepareForTests(...parts: string[]): string;
     /**
      * Finds the virtual tree root node for a given node by traversing up the node hierarchy until it finds a node with the virtualTree property set to true. If no such node is found, it returns undefined.

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

@@ -80,19 +80,100 @@ export declare const RoutingHelpers: {
      * @returns An object containing only the permitted search parameters for the client.
      */
     prepareSearchParamsForClient(currentNode: Node, luigi: Luigi): {};
+    /**
+     * Checks if given path contains intent navigation special syntax
+     * @param {string} path - path to be checked
+     */
+    hasIntent(path: string): boolean;
+    /**
+     * This function takes an intentLink and parses it conforming certain limitations in characters usage.
+     * Limitations include:
+     *  - `semanticObject` allows only alphanumeric characters
+     *  - `action` allows alphanumeric characters and the '_' sign
+     *
+     * Example of resulting output:
+     * ```
+     *  {
+     *    semanticObject: "Sales",
+     *    action: "order",
+     *    params: {param1: "value1",param2: "value2"}
+     *  };
+     * ```
+     * @param {string} intentLink - the intent link represents the semantic intent defined by the user, i.e.: #?intent=semanticObject-action?param=value
+     */
+    getIntentObject(intentLink: string): Record<string, any> | undefined;
+    /**
+     * This function compares the intentLink parameter with the configuration intentMapping
+     * and returns the path segment that is matched together with the parameters, if any
+     *
+     * Example:
+     *
+     * For intentLink = `#?intent=Sales-order?foo=bar`
+     * and Luigi configuration:
+     * ```
+     * intentMapping: [{
+     *   semanticObject: 'Sales',
+     *   action: 'order',
+     *   pathSegment: '/projects/pr2/order'
+     * }]
+     *
+     * ```
+     * the given intentLink is matched with the configuration's same semanticObject and action,
+     * resulting in pathSegment `/projects/pr2/order` being returned. The parameter is also added in
+     * this case resulting in: `/projects/pr2/order?~foo=bar`
+     *
+     * Or for external intent links: intentLink = `#?intent=External-view`
+     * and Luigi configuration:
+     * ```
+     * intentMapping: [{
+     *   semanticObject: 'External',
+     *   action: 'view',
+     *   externalLink: { url: 'https://www.sap.com', openInNewTab: true }
+     * }]
+     * ```
+     * The resulting will be returned from this function:
+     * ```
+     * {
+     *   url: 'https://www.sap.com',
+     *   openInNewTab: true,
+     *   external: true
+     * }
+     * ```
+     * @param {string} intentLink - the intentLink represents the semantic intent defined by the user, i.e.: #?intent=semanticObject-action?param=value
+     * @param luigi - Luigi instance used to access configuration values
+     */
+    getIntentPath(intentLink: string, luigi: Luigi): boolean | string | Record<string, any>;
+    /**
+     * This function takes a path which contains dynamic parameters and a list parameters and replaces the dynamic parameters
+     * with the given parameters if any. The input path remains unchanged if the parameters list
+     * does not contain the respective dynamic parameter name.
+     * e.g.:
+     * Assume either of these two calls are made:
+     * 1. `LuigiClient.linkManager().navigateToIntent('Sales-settings', {project: 'pr2', user: 'john'})`
+     * 2. `LuigiClient.linkManager().navigate('/#?intent=Sales-settings?project=pr2&user=john')`
+     * For both 1. and 2., the following dynamic input path: `/projects/:project/details/:user`
+     * is resolved through this method to `/projects/pr2/details/john`
+     *
+     * @param {string} path - the path containing the potential dynamic parameter
+     * @param {Object} parameters - a list of objects consisting of passed parameters
+     */
+    resolveDynamicIntentPath(path: string, parameters: object): string;
     /**
      * Retrieves the current path and query string from the browser's location hash.
      *
+     * @param hashRouting - true if hash routing is active, false if path routing is active
+     * @param luigi - Luigi instance used to access configuration values
      * @returns An object containing the normalized path and the query string.
      * @remarks
      * - The path is normalized using `NavigationHelpers.normalizePath`.
      * - The query string is extracted from the portion after the '?' in the hash.
      * - If there is no query string, `query` will be `undefined`.
      */
-    getCurrentPath(hashRouting?: boolean): {
+    getCurrentPath(luigi: Luigi, hashRouting?: boolean, checkIntent?: boolean): {
         path: string;
         query: string;
     };
+    handleExternalIntentPath(intentPath: Record<string, any>): void;
     /**
      * Retrieves the modal path from the current URL's query parameters based on the provided Luigi instance.
      *
@@ -163,7 +244,7 @@ export declare const RoutingHelpers: {
     getModalParamsFromPath(luigi: Luigi): any;
     /**
      * Get the query param separator which is used with hashRouting
-     * Default: :
+     * Default:
      * @example /home?modal=(urlencoded)/some-modal?modalParams=(urlencoded){...}&otherParam=hmhm
      * @returns the first query param separator (like ? for path routing)
      */
@@ -367,4 +448,31 @@ export declare const RoutingHelpers: {
      * @returns A string representing the concatenated path, with exactly one '/' character between the base and relative paths.
      */
     concatenatePath(basePath: any, relativePath?: any): string;
+    /**
+     * Returns the resolved route link for a navigation node. If the node has an external link, its URL is returned directly.
+     * If the node has an internal link, the prefix is prepended. Otherwise, the full route is built from the node's path
+     * segments and path parameters are substituted.
+     * @param node - The navigation node to resolve the link for
+     * @param pathParams - Dynamic path parameters to substitute in the route
+     * @param relativePathPrefix - Prefix to prepend to relative paths (e.g. '#' for hash routing)
+     * @returns The resolved route link as a string
+     */
+    getRouteLink(node: Node, pathParams: Record<string, any>, relativePathPrefix: string): string;
+    /**
+     * Calculates the full href for a navigation node, taking hash routing and i18n view URLs into account.
+     * @param node - The navigation node to calculate the href for
+     * @param pathParams - Dynamic path parameters to substitute in the route
+     * @param luigi - The Luigi instance used to read routing configuration
+     * @returns The fully resolved href string for the node
+     */
+    calculateNodeHref(node: Node, pathParams: Record<string, any>, luigi: Luigi): string;
+    /**
+     * Returns the href for a navigation node if the `navigation.addNavHrefs` configuration is enabled.
+     * This is used to populate anchor `href` attributes for accessibility and native browser behavior.
+     * @param node - The navigation node to get the href for
+     * @param pathParams - Dynamic path parameters to substitute in the route
+     * @param luigi - The Luigi instance used to read configuration
+     * @returns The node href string if `addNavHrefs` is enabled, otherwise `undefined`
+     */
+    getNodeHref(node: Node, pathParams: Record<string, any>, luigi: Luigi): string | undefined;
 };