@luigi-project/core-modular 0.0.1-dev.20260181313

package/services/routing.service.d.ts

@@ -0,0 +1,103 @@
+import { Luigi } from '../core-api/luigi';
+import { ModalSettings, Node, 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;
+    previousNode: Node | undefined;
+    currentRoute?: Route;
+    modalSettings?: ModalSettings;
+    constructor(luigi: Luigi);
+    private getNavigationService;
+    /**
+     * If the current route matches any of the defined patterns, it will be skipped.
+     * @returns {boolean} true if the current route matches any of the patterns, false otherwise
+     */
+    shouldSkipRoutingForUrlPatterns(): boolean;
+    /**
+     * Initializes the route change handler for the application.
+     *
+     * Depending on the Luigi configuration, this method sets up a listener for hash-based or path-based routing changes.
+     * When the URL changes, it:
+     * - Parses the current path and query parameters.
+     * - Filters node-specific parameters.
+     * - Checks if a redirect is necessary and navigates if so.
+     * - Retrieves and updates the current navigation node.
+     * - Notifies the navigation service of the node change.
+     * - Updates the top, left, and tab navigation UIs.
+     * - Updates the main content area based on the current node.
+     *
+     */
+    enableRouting(): void;
+    handleRouteChange(routeInfo: {
+        path: string;
+        query: string;
+    }): Promise<void>;
+    getCurrentRoute(): Route | undefined;
+    /**
+     * If `showModalPathInUrl` is provided, bookmarkable modal path will be triggered.
+     */
+    shouldShowModalPathInUrl(routeInfo: {
+        path: string;
+        query: string;
+    }): Promise<void>;
+    /**
+     * Handles opening a modal based on the current bookmarkable path.
+     *
+     * This method checks if there is an additional modal path present in the current Luigi path.
+     * If a modal path exists, it retrieves the corresponding modal parameters and node data,
+     * then opens the modal using the navigation service.
+     *
+     * @returns {Promise<void>} A promise that resolves when the modal handling is complete.
+     */
+    handleBookmarkableModalPath(routeInfo: {
+        path: string;
+        query: string;
+    }): Promise<void>;
+    /**
+     * Append modal data to url
+     * @param {string} modalPath path of the view which is displayed in the modal
+     * @param {Object} modalParams query parameter
+     */
+    appendModalDataToUrl(modalPath: string, modalParams: ModalSettings): void;
+    /**
+     * Remove modal data from url
+     * @param isClosedInternal flag if the modal is closed via close button or internal back navigation instead of changing browser URL manually or browser back button
+     */
+    removeModalDataFromUrl(isClosedInternal: boolean): void;
+    /**
+     * Set feature toggles if `queryStringParam` is provided at config file
+     * @param {string} path used for retrieving and appending the path parameters
+     */
+    setFeatureToggle(path: string): void;
+    /**
+     * Updates the current browser URL with modal-related routing information.
+     *
+     * Depending on the routing configuration (hash vs. standard), this method
+     * injects or updates two query parameters:
+     * - <modalParamName>: the modal's path identifier (modalPath)
+     * - <modalParamName>Params: a JSON-stringified object of additional modal parameters (modalParams)
+     *
+     * Behavior:
+     * - Determines the parameter base name via RoutingHelpers.getModalViewParamName.
+     * - Merges existing query parameters obtained through RoutingHelpers.getQueryParams, overwriting any previous modal values.
+     * - If hash routing is enabled (routing.useHashRouting = true):
+     *   - Strips any existing query segment after the hash before appending the new encoded parameters.
+     *   - Rebuilds the hash in the form: #<hashBase><separator><encodedParams>.
+     * - If hash routing is disabled:
+     *   - Replaces the entire search string (?...) with the newly encoded parameters.
+     * - Serializes modalParams only when it is a non-empty object; otherwise omits the "*Params" companion parameter.
+     * - Uses history.pushState when addHistoryEntry is true, otherwise history.replaceState to avoid adding a new history entry.
+     *
+     * @param modalPath A string identifying the modal view or route segment to encode into the URL.
+     * @param modalParams A record of additional parameters for the modal; only included if non-empty. Serialized via JSON.stringify.
+     * @param addHistoryEntry If true, a new history entry is pushed (allowing back navigation); if false, the current entry is replaced.
+  
+     */
+    updateModalDataInUrl(modalPath: string, modalParams: ModalSettings, addHistoryEntry: boolean): void;
+}

package/services/service-registry.d.ts

@@ -0,0 +1,42 @@
+type ServiceFactory<T> = (...args: any[]) => T;
+/**
+ * Manages the registration and retrieval of services within the application.
+ *
+ * The `ServiceRegistry` allows services to be registered with a unique identifier and a factory function.
+ * Services can be registered as singletons (default) or as transient instances.
+ *
+ * - Use `register` to add a service to the registry.
+ * - Use `get` to retrieve an instance of a registered service.
+ *
+ * @example
+ * ```typescript
+ * registry.register('myService', () => new MyService(), true);
+ * const service = registry.get<T>('myService');
+ * ```
+ */
+declare class ServiceRegistry {
+    private services;
+    /**
+     * Registers a service with the service registry.
+     *
+     * @template T - The type of the service.
+     * @param name - The unique identifier for the service.
+     * @param factory - A factory function that creates an instance of the service.
+     * @param singleton - If true, the service will be treated as a singleton. Defaults to true.
+     */
+    register<T>(param: new (...args: any[]) => T, factory: ServiceFactory<T>, singleton?: boolean): void;
+    /**
+     * Retrieves an instance of the requested service by its identifier.
+     *
+     * If the service is registered as a singleton, returns the existing instance or creates one if it doesn't exist.
+     * If the service is not a singleton, returns a new instance each time.
+     *
+     * @typeParam T - The type of the service to retrieve.
+     * @param name - The identifier of the service to retrieve.
+     * @returns The instance of the requested service.
+     * @throws {Error} If the service is not registered.
+     */
+    get<T>(param: new (...args: any[]) => T): T;
+}
+export declare const serviceRegistry: ServiceRegistry;
+export {};

package/services/viewurl-decorator.d.ts

@@ -0,0 +1,7 @@
+export declare class ViewUrlDecoratorSvc {
+    decorators: any[];
+    constructor();
+    hasDecorators(): boolean;
+    add(decorator: any): void;
+    applyDecorators(url: string, decode: boolean): string;
+}

package/types/connector.d.ts

@@ -0,0 +1,26 @@
+import { ModalSettings, LeftNavData, Node, TopNavData, TabNavData } from '../services/navigation.service';
+import { AlertHandler, AlertSettings, ConfirmationModalHandler, ConfirmationModalSettings, UserSettings } from '../modules/ux-module';
+export interface LuigiConnector {
+    renderMainLayout(): void;
+    renderTopNav(data: TopNavData): void;
+    renderLeftNav(data: LeftNavData): void;
+    getContainerWrapper(): HTMLElement;
+    renderModal(content: HTMLElement, modalSettings: ModalSettings, onCloseCallback?: () => void, onCloseRequest?: () => void): any;
+    renderDrawer(content: HTMLElement, modalSettings: ModalSettings, onCloseCallback?: () => void): any;
+    renderTabNav(data: TabNavData): void;
+    renderAlert(alertSettings: AlertSettings, alertHandler: AlertHandler): void;
+    renderConfirmationModal(confirmationModalSettings: ConfirmationModalSettings, containerHandler: ConfirmationModalHandler): void;
+    setDocumentTitle(documentTitle: string): void;
+    getDocumentTitle(): string;
+    showLoadingIndicator(container?: HTMLElement): void;
+    hideLoadingIndicator(container?: HTMLElement): void;
+    addBackdrop(): void;
+    removeBackdrop(): void;
+    openUserSettings(settings: UserSettings): void;
+    closeUserSettings(): void;
+    setCurrentLocale(locale: string): void;
+    getCurrentLocale(): string;
+    updateModalSettings(modalSettings: ModalSettings): void;
+    showFatalError(error: string): void;
+}
+export type { Node };

package/utilities/defaultLuigiTranslationTable.d.ts

@@ -0,0 +1 @@
+export declare const defaultLuigiTranslationTable: Record<string, any>;

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

@@ -0,0 +1,13 @@
+export declare const AsyncHelpers: {
+    wrapAsPromise: (value: any) => Promise<any>;
+    /**
+     * Executes a function with a set of parameters
+     * and returns its value as promise
+     *
+     * @param {function} fn a function
+     * @param {array} args an array of arguments
+     * @returns {promise}
+     */
+    applyFunctionPromisified: (fn: any, args: any) => Promise<any>;
+    getConfigValueFromObjectAsync: (object: Record<string, any>, property: string, ...parameters: any[]) => Promise<any>;
+};

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

@@ -0,0 +1,22 @@
+declare class AuthHelpersClass {
+    getStoredAuthData(): any;
+    isLoggedIn(): boolean;
+    /**
+     * Checks if there is a error parameter in the url
+     * and returns error and error description
+     */
+    parseUrlAuthErrors(): {
+        error: string;
+        errorDescription: string | null;
+    } | undefined;
+    /**
+     * Triggers onAuthError event with the found error
+     * and error parameters.
+     * @param {object} providerInstanceSettings
+     * @param {string} error
+     * @param {string} errorDescription
+     */
+    handleUrlAuthErrors(providerInstanceSettings: any, error?: string, errorDescription?: string): Promise<any>;
+}
+export declare const AuthHelpers: AuthHelpersClass;
+export {};

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

@@ -0,0 +1,19 @@
+import { Luigi } from '../../core-api/luigi';
+declare class ConfigHelpersClass {
+    setErrorMessage(errorMsg: string): void;
+    getLuigi(): Luigi;
+    getConfigValue(key: string): any;
+    getConfigValueAsync(key: string): any;
+    /**
+     * Executes the function of the given property on the Luigi config object.
+     * Fails if property is not a function.
+     *
+     * If the value is a Function it is called (with the given parameters) and the result of that call is the value.
+     * If the value is not a Promise it is wrapped to a Promise so that the returned value is definitely a Promise.
+     * @private
+     * @memberof Configuration
+     */
+    executeConfigFnAsync(property: string, throwError?: boolean, ...parameters: any): Promise<any>;
+}
+export declare const ConfigHelpers: ConfigHelpersClass;
+export {};

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

@@ -0,0 +1,10 @@
+import { Link, ProcessedTextAndLinks } from '../../modules/ux-module';
+export declare const EscapingHelpers: {
+    sanitizeHtml(text?: string): string;
+    restoreSanitizedBrs(text?: string): string;
+    restoreSanitizedElements(text?: string): string;
+    sanatizeHtmlExceptTextFormatting(text?: string): string;
+    sanitizeParam(param?: string): string;
+    escapeKeyForRegexp(str?: string): string;
+    processTextAndLinks(text: string | undefined, links: Link, uniqueID: any): ProcessedTextAndLinks;
+};

package/utilities/helpers/event-listener-helpers.d.ts

@@ -0,0 +1,7 @@
+export declare const EventListenerHelpers: {
+    listeners: any[];
+    hashChangeWithoutSync: boolean;
+    addEventListener(type: any, listenerFn: any): void;
+    removeEventListener(type: any, listenerFn: any): void;
+    removeAllEventListeners(): void;
+};

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

@@ -0,0 +1,78 @@
+export declare const GenericHelpers: {
+    /**
+     * Creates a random Id
+     * @returns random numeric value {number}
+     * @private
+     */
+    getRandomId: () => number;
+    /**
+     * Checks if input is a promise.
+     * @param promiseToCheck mixed
+     * @returns {boolean}
+     */
+    isPromise: (promiseToCheck: any) => boolean;
+    /**
+     * Checks if input is a function.
+     * @param functionToCheck mixed
+     * @returns {boolean}
+     */
+    isFunction: (functionToCheck: any) => boolean;
+    /**
+     * Checks if input is a string.
+     * @param stringToCheck mixed
+     * @returns {boolean}
+     */
+    isString: (stringToCheck: string | any) => boolean;
+    /**
+     * Checks if input is an object.
+     * @param objectToCheck mixed
+     * @returns {boolean}
+     */
+    isObject: (objectToCheck: object | any) => boolean;
+    /**
+     * Removes leading slash of a string
+     * @param {str} string
+     * @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
+     * @returns {string} string without any trailing slash
+     */
+    trimTrailingSlash: (str: string) => string;
+    /**
+     * Checks if HTML element is visible
+     * @param {Element} element to be checked in DOM
+     * @returns {boolean} `true` if element is visible - otherwise `false`
+     */
+    isElementVisible: (element: Element) => boolean;
+    /**
+     * Gets collection of HTML elements
+     * @param {string} selector to be searched in DOM
+     * @param {boolean} onlyVisible elements should be included
+     * @returns {Array} collection of HTML elements
+     */
+    getNodeList: (selector: string, onlyVisible?: boolean) => Element[];
+    /**
+     * Prepend current url to redirect_uri, if it is a relative path
+     * @param {path} string full url, relative or absolute path
+     * @returns {string} window location origin
+     */
+    prependOrigin: (path: string) => string;
+    /**
+     * Gets value of the given property on the given object.
+     * @param object mixed
+     * @param property name of the given property
+     */
+    getConfigValueFromObject: (object: Record<string, any>, property: string) => any;
+    /**
+     * Gets boolean value of specified property on the given object.
+     * Function returns true if the property value is equal true or 'true'. Otherwise the function returns false.
+     * @param {Object} object mixed
+     * @param {string} property name of the given property
+     * @returns {boolean} boolean value
+     */
+    getConfigBooleanValue: (object: Record<string, any>, property: string) => boolean;
+    getUrlParameter: (key: string) => string | null;
+};

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

@@ -0,0 +1,15 @@
+import { FeatureToggles } from '../../core-api/feature-toggles';
+import { Luigi } from '../../core-api/luigi';
+import { AppSwitcher, Node, PathData } from '../../services/navigation.service';
+export declare const NavigationHelpers: {
+    normalizePath: (raw: string) => string;
+    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;
+    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;
+    mergeContext(...objs: Record<string, any>[]): Record<string, any>;
+    prepareForTests(...parts: string[]): string;
+};

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

@@ -0,0 +1,254 @@
+import { FeatureToggles } from '../../core-api/feature-toggles';
+import { Luigi } from '../../core-api/luigi';
+import { Node, PathData } from '../../services/navigation.service';
+export declare const RoutingHelpers: {
+    defaultContentViewParamPrefix: string;
+    defaultQueryParamSeparator: string;
+    defaultModalViewParamName: string;
+    /**
+     * Adds or updates query parameters to a hash-based routing string.
+     *
+     * @param params - An object representing the parameters to add or update in the hash's query string.
+     * @param hash - The hash string (e.g., "#/path?foo=bar") to which the parameters will be added or updated.
+     * @param paramPrefix - (Optional) A prefix to apply to each parameter key when adding or updating.
+     * @returns The updated hash string with the new or modified query parameters.
+     */
+    addParamsOnHashRouting(params: Record<string, any>, hash: string, paramPrefix?: string): string;
+    /**
+     * Modifies the given `URLSearchParams` object by setting or deleting parameters based on the provided `params` object.
+     *
+     * For each key-value pair in `params`, the function sets the corresponding parameter in `searchParams`.
+     * If a `paramPrefix` is provided, it is prepended to each parameter key.
+     * If a value in `params` is `undefined`, the corresponding parameter is deleted from `searchParams`.
+     *
+     * @param params - An object containing key-value pairs to set or delete in the search parameters.
+     * @param searchParams - The `URLSearchParams` instance to modify.
+     * @param paramPrefix - (Optional) A string to prefix to each parameter key.
+     */
+    modifySearchParams(params: Record<string, any>, searchParams: URLSearchParams, paramPrefix?: string): void;
+    /**
+     * Extracts and sanitizes node-specific parameters from the provided params object.
+     *
+     * This method filters the input `params` to include only those keys that start with
+     * a specific prefix, determined by `getContentViewParamPrefix(luigi)`. The prefix is
+     * removed from the key names in the resulting object. The resulting map is then
+     * sanitized before being returned.
+     *
+     * @param params - An object containing key-value pairs of parameters.
+     * @param luigi - The Luigi instance used to determine the parameter prefix.
+     * @returns A sanitized map of node-specific parameters with the prefix removed from their keys.
+     */
+    filterNodeParams(params: Record<string, string>, luigi: Luigi): Record<string, string>;
+    /**
+     * Retrieves the content view parameter prefix from the Luigi configuration.
+     *
+     * This method attempts to obtain the prefix value from the Luigi configuration using the key
+     * `'routing.nodeParamPrefix'`. If the configuration value is explicitly set to `false`, it returns
+     * an empty string. If the value is not set or is falsy, it falls back to the default content view
+     * parameter prefix defined in the class.
+     *
+     * @param luigi - The Luigi instance used to access configuration values.
+     * @returns The content view parameter prefix as a string.
+     */
+    getContentViewParamPrefix(luigi: Luigi): any;
+    /**
+     * Sanitizes the keys and values of a parameter map by applying the `EscapingHelpers.sanitizeParam` function
+     * to each key-value pair. Returns a new object with sanitized keys and values.
+     *
+     * @param paramsMap - An object containing string keys and values to be sanitized.
+     * @returns A new object with both keys and values sanitized.
+     */
+    sanitizeParamsMap(paramsMap: Record<string, string>): Record<string, string>;
+    /**
+     * Prepares and filters the search parameters from the Luigi routing context
+     * based on the current node's client permissions. Only parameters explicitly
+     * allowed with `read: true` in the node's `clientPermissions.urlParameters`
+     * are included in the returned object.
+     *
+     * @param currentNode - The current navigation node containing client permissions.
+     * @param luigi - The Luigi instance providing access to routing and search parameters.
+     * @returns An object containing only the permitted search parameters for the client.
+     */
+    prepareSearchParamsForClient(currentNode: Node, luigi: Luigi): {};
+    /**
+     * Retrieves the current path and query string from the browser's location hash.
+     *
+     * @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): {
+        path: string;
+        query: string;
+    };
+    /**
+     * Retrieves the modal path from the current URL's query parameters based on the provided Luigi instance.
+     *
+     * @param luigi - The Luigi instance used to determine the query parameter name and value.
+     * @returns The modal path as a string if present in the query parameters; otherwise, `undefined`.
+     */
+    getModalPathFromPath(luigi: Luigi): string | undefined;
+    /**
+     * Retrieves the value of a specific query parameter from the current URL.
+     *
+     * @param paramName - The name of the query parameter to retrieve.
+     * @param luigi - The Luigi instance used to access routing information.
+     * @returns The value of the specified query parameter if present; otherwise, `undefined`.
+     */
+    getQueryParam(paramName: string, luigi: Luigi): string | undefined;
+    /**
+     * Retrieves the current query parameters from the URL as a key-value record.
+     *
+     * Depending on the Luigi configuration, this method will extract query parameters
+     * either from the URL hash (if hash routing is enabled) or from the standard search
+     * portion of the URL.
+     *
+     * @param luigi - The Luigi instance used to access configuration values.
+     * @returns A record containing query parameter names and their corresponding values.
+     */
+    getQueryParams(luigi: Luigi): Record<string, string>;
+    /**
+     * Retrieves the query parameters from the current location's search string as a key-value map.
+     *
+     * @returns {Record<string, string>} An object containing the query parameters as key-value pairs.
+     * If there are no query parameters, returns an empty object.
+     */
+    getLocationSearchQueryParams(): Record<string, string>;
+    /**
+     * Returns the current browser location object.
+     *
+     * @returns {Location} The current location object representing the URL of the document.
+     */
+    getLocation(): Location;
+    /**
+     * Extracts and parses query parameters from the current location's hash fragment.
+     *
+     * @returns {Record<string, string>} An object containing key-value pairs of query parameters
+     * extracted from the hash, or an empty object if no query parameters are present.
+     */
+    getLocationHashQueryParams(): Record<string, string>;
+    /**
+     * Retrieves the name of the URL parameter used for modal views in routing.
+     *
+     * This method attempts to obtain the parameter name from the Luigi configuration
+     * using the key `'routing.modalPathParam'`. If the configuration value is not set,
+     * it falls back to a default parameter name defined by `this.defaultModalViewParamName`.
+     *
+     * @param luigi - The Luigi instance used to access configuration values.
+     * @returns The name of the modal view parameter to be used in routing.
+     */
+    getModalViewParamName(luigi: Luigi): string;
+    /**
+     * Parses a URL query parameter string into an object mapping parameter names to values.
+     *
+     * Replaces '+' with spaces, splits the string by '&' to get key-value pairs,
+     * and decodes each component using `decodeURIComponent`.
+     *
+     * @param paramsString - The URL query parameter string to parse (e.g., "foo=bar&baz=qux").
+     * @returns An object where each key is a parameter name and each value is the corresponding decoded value.
+     */
+    parseParams(paramsString: string): Record<string, string>;
+    getModalParamsFromPath(luigi: Luigi): any;
+    /**
+     * Get the query param separator which is used with hashRouting
+     * Default: :
+     * @example /home?modal=(urlencoded)/some-modal?modalParams=(urlencoded){...}&otherParam=hmhm
+     * @returns the first query param separator (like ? for path routing)
+     */
+    getHashQueryParamSeparator(): string;
+    /**
+     * Get an url without modal data. It's necessary on page refresh or loading Luigi with modal data in a new tab
+     * @param {String} searchParamsString url search parameter as string
+     * @param {String} modalParamName  modalPathParam value defined in Luigi routing settings
+     * @returns {String} url search parameter as string without modal data
+     */
+    getURLWithoutModalData(searchParamsString: string, modalParamName: string): string;
+    /**
+     * Extending history state object for calculation how much history entries the browser have to go back when modal will be closed.
+     * @param {Object} historyState history.state object.
+     * @param {Number} historyState.modalHistoryLength will be increased when modals will be openend successively like e.g. stepping through a wizard.
+     * @param {Number} historyState.historygap is the history.length at the time when the modal will be opened. It's needed for calculating how much we have to go back in the browser history when the modal will be closed.
+     * @param {String} historyState.pathBeforeHistory path before modal will be opened. It's needed for calculating how much we have to go back in the browser history when the modal will be closed.
+     * @param {boolean} hashRoutingActive true if hash routing is active, false if path routing is active
+     * @param {URL} url url object to read hash value or pathname
+     * @returns {Object} history state object
+     */
+    handleHistoryState(historyState: any, path: string): any;
+    /**
+     * Encodes an object of key-value pairs into a URL query string.
+     *
+     * Each key and value in the input object is URI-encoded and joined with '='.
+     * The resulting pairs are concatenated with '&' to form a valid query string.
+     *
+     * @param dataObj - An object containing key-value pairs to encode.
+     * @returns A URL-encoded query string representing the input object.
+     */
+    encodeParams(dataObj: Record<string, any>): string;
+    /**
+     * Retrieves the last node object from the provided `PathData`'s `nodesInPath` array.
+     * If `nodesInPath` is empty or undefined, returns an empty object.
+     *
+     * @param pathData - The `PathData` object containing the `nodesInPath` array.
+     * @returns The last node object in the `nodesInPath` array, or an empty object if none exists.
+     */
+    getLastNodeObject(pathData: PathData): Node | {};
+    /**
+     * Checks if given URL is allowed to be included, based on 'navigation.validWebcomponentUrls' in Luigi config.
+     *
+     * @param {string} url the URL string to be checked
+     * @param {Luigi} luigi - the Luigi instance used to determine the parameter prefix
+     * @returns {boolean} `true` if allowed - `false` otherwise
+     */
+    checkWCUrl(url: string, luigi: Luigi): boolean;
+    /**
+     * Set feature toggles
+     * @param {string} featureToggleProperty used for identifying feature toggles
+     * @param {string} path used for retrieving and appending the path parameters
+     */
+    /**
+     * Set feature toggles
+     * @param {string} featureToggleProperty used for identifying feature toggles
+     * @param {string} path used for retrieving and appending the path parameters
+     */
+    setFeatureToggles(featureToggleProperty: string, path: string, featureToggles: FeatureToggles): void;
+    /**
+     * Replaces dynamic parameter placeholders in the values of the provided object
+     * using a mapping of parameter names to concrete values.
+     *
+     * A placeholder is defined as the concatenation of `paramPrefix` and a key from `paramMap`
+     * (e.g. ":id"). Depending on the `contains` flag, the replacement logic operates in:
+     * - Exact match mode (`contains = false`): a value is replaced only if it equals the full placeholder (e.g. value === ":id").
+     * - Containment mode (`contains = true`): a value is scanned and any single occurrence of a placeholder substring is replaced
+     *   (e.g. "/users/:id/details" becomes "/users/123/details"). Only the first matching key is replaced; subsequent occurrences
+     *   or multiple different placeholders in the same value are not handled by this implementation.
+     *
+     * The function returns a new plain object; the original `object` argument is not mutated.
+     *
+     * @param object A record whose string values may contain dynamic parameter placeholders to substitute.
+     * @param paramMap A mapping of parameter names (without prefix) to their substitution values.
+     * @param paramPrefix The prefix that denotes a placeholder in `object` values. Defaults to ":".
+     * @param contains If true, perform substring replacement; if false, only exact value matches are substituted.
+     * @returns A new object with substituted values where placeholders matched the provided `paramMap`.
+     *
+     * @example
+     * const obj = { userId: ':id', path: '/users/:id/details', untouched: 'static' };
+     * const paramMap = { id: '123' };
+     *
+     * // Exact match mode:
+     * substituteDynamicParamsInObject(obj, paramMap);
+     * // => { userId: '123', path: '/users/:id/details', untouched: 'static' }
+     *
+     * // Containment mode:
+     * substituteDynamicParamsInObject(obj, paramMap, ':', true);
+     * // => { userId: '123', path: '/users/123/details', untouched: 'static' }
+     *
+     * @remarks
+     * - Only the first matching parameter key is considered per value when `contains = true`.
+     * - Values that are undefined or null are returned as-is.
+     * - The return type is a generic object; if stronger typing is desired, consider overloading or
+     *   constraining `paramMap` and `object` to more specific record types.
+     */
+    substituteDynamicParamsInObject(object: Record<string, string>, paramMap: Record<any, any>, paramPrefix?: string, contains?: boolean): {};
+};

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

@@ -0,0 +1,25 @@
+declare class StorageHelpersClass {
+    init: boolean;
+    storage: Storage;
+    browseSupported: boolean | undefined;
+    constructor();
+    checkInit(): void;
+    supportLocalStorage(): boolean;
+    checkStorageBrowserSupport(): void;
+    process(microfrontendId: string, hostname: string, id: string, operation: string, params: object): void;
+    cleanHostname(hostname: string): string;
+    setItem(hostname: string, params: Record<string, string>): void;
+    getItem(hostname: string, params: Record<string, string>): any;
+    buildKey(hostname: string, subKey: string): string;
+    buildPrefix(hostname: string): string;
+    removeItem(hostname: string, params: Record<string, string>): string | undefined;
+    clear(hostname: string, params: Record<string, string>): void;
+    has(hostname: string, params: Record<string, string>): boolean;
+    getAllKeys(hostname: string, params: Record<string, string>): string[];
+    checkKey(params: Record<string, string>): void;
+    parseJsonIfPossible(text: string): any;
+    stringifyValue(value: any): string;
+    sendBackOperation(microfrontendId: string, id: string, status: 'OK' | 'ERROR', result: any): any;
+}
+export declare const StorageHelpers: StorageHelpersClass;
+export {};

package/utilities/helpers/usersetting-dialog-helpers.d.ts

@@ -0,0 +1,8 @@
+declare class UserSettingsHelperClass {
+    processUserSettingGroups(userSettings: any, storedSettings: any): any[];
+    getUserSettingsIframesInDom(): HTMLElement[];
+    hideUserSettingsIframe(): void;
+    findActiveCustomUserSettingsIframe(eventSource: any): any;
+}
+export declare const UserSettingsHelper: UserSettingsHelperClass;
+export {};