@luigi-project/core-modular 0.0.1

package/main.d.ts

@@ -0,0 +1 @@
+export {};

package/modules/communicaton-module.d.ts

@@ -0,0 +1,6 @@
+import { Luigi } from '../core-api/luigi';
+export declare const CommunicationModule: {
+    luigi: Luigi;
+    init: (luigi: Luigi) => void;
+    addListeners: (containerElement: any, luigi: Luigi) => void;
+};

package/modules/routing-module.d.ts

@@ -0,0 +1,18 @@
+import { ExternalLink, Node, PageErrorHandler } from '../services/navigation.service';
+import { Luigi } from '../core-api/luigi';
+export declare const RoutingModule: {
+    init: (luigi: Luigi) => void;
+    handlePageErrorHandler: (pageErrorHandler: PageErrorHandler, node: Node, luigi: Luigi) => void;
+    handleExternalLinkNavigation: (externalLink: ExternalLink) => void;
+    /**
+     * Adds search parameters to the URL based on client permissions defined in the current navigation node.
+     *
+     * Only parameters explicitly allowed (with `write: true` permission) in the current node's `clientPermissions.urlParameters`
+     * are added to the URL. Parameters without permission will trigger a warning in the console and will not be added.
+     *
+     * @param searchParams - An object containing key-value pairs of search parameters to be added to the URL.
+     * @param keepBrowserHistory - If `true`, the browser history will be preserved when updating the URL.
+     * @param luigi - The Luigi core instance used to interact with the routing API.
+     */
+    addSearchParamsFromClient(searchParams: Record<string, any>, keepBrowserHistory: boolean, luigi: Luigi): void;
+};

package/modules/ui-module.d.ts

@@ -0,0 +1,14 @@
+import { Luigi } from '../core-api/luigi';
+import { NavigationService, ModalSettings } from '../services/navigation.service';
+import { RoutingService } from '../services/routing.service';
+export declare const UIModule: {
+    navService: NavigationService;
+    routingService: RoutingService;
+    luigi: Luigi;
+    init: (luigi: Luigi) => void;
+    update: (scopes?: string[]) => void;
+    updateMainContent: (currentNode: any, luigi: Luigi) => Promise<void>;
+    openModal: (luigi: Luigi, node: any, 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>;
+};

package/modules/ux-module.d.ts

@@ -0,0 +1,49 @@
+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;
+}
+export interface AlertHandler {
+    openFromClient: boolean;
+    close(): void;
+    link(linkKey: string): boolean;
+}
+export interface ProcessedAlertSettings {
+    settings: AlertSettings;
+}
+export interface Link {
+    elemId: string;
+    url?: string;
+    dismissKey?: string;
+}
+export interface ProcessedTextAndLinks {
+    sanitizedText: string;
+    links: Link[];
+}
+export interface ConfirmationModalSettings {
+    icon?: string;
+    type?: string;
+    header?: string;
+    body?: string;
+    buttonConfirm?: string;
+    buttonDismiss?: string;
+}
+export interface ConfirmationModalHandler {
+    confirm(): void;
+    dismiss(): void;
+}
+export interface UserSettings {
+    [key: string]: number | string | boolean;
+}
+export declare const UXModule: {
+    luigi: Luigi | undefined;
+    documentTitle: any;
+    init: (luigi: Luigi) => void;
+    processAlert: (alertSettings: AlertSettings, openFromClient: boolean, containerElement: LuigiContainer | LuigiCompoundContainer) => void;
+    handleConfirmationModalRequest: (confirmationModalSettings: ConfirmationModalSettings, containerElement: LuigiContainer | LuigiCompoundContainer) => void;
+    handleDirtyStatusRequest: (isDirty: boolean, source: any) => void;
+};

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@luigi-project/core-modular",
+  "description": "Javascript library supporting consumers of the Luigi framework",
+  "license": "Apache-2.0",
+  "main": "luigi.js",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/SAP/luigi.git"
+  },
+  "publishConfig": {
+    "tag": "luigi"
+  },
+  "keywords": [
+    "luigi",
+    "core",
+    "UI",
+    "extensibility",
+    "micro-frontends",
+    "microfrontends"
+  ],
+  "version": "0.0.1"
+}

package/services/auth-layer.service.d.ts

@@ -0,0 +1,24 @@
+import { LuigiStore } from '../utilities/store';
+declare class AuthLayerSvcClass {
+    idpProviderInstance: any;
+    private _userInfoStore;
+    private _loggedInStore;
+    constructor();
+    setUserInfo(uInfo: any): void;
+    setLoggedIn(loggedIn: boolean): void;
+    getUserInfoStore(): LuigiStore;
+    getLoggedInStore(): LuigiStore;
+    init(): Promise<any>;
+    checkAuth(idpProviderSettings: any): Promise<any>;
+    startAuthorization(): Promise<any>;
+    logout(): void;
+    createIdpProviderException(message: string): {
+        message: string;
+        name: string;
+    };
+    getIdpProviderInstance(idpProviderName: string, idpProviderSettings: any): Promise<any>;
+    unload(): void;
+    resetExpirationChecks(): void;
+}
+export declare const AuthLayerSvc: AuthLayerSvcClass;
+export {};

package/services/auth-store.service.d.ts

@@ -0,0 +1,23 @@
+declare class AuthStoreSvcClass {
+    private _authKey;
+    private _storageType;
+    private _defaultStorage;
+    private _newlyAuthorizedKey;
+    private _invalidStorageMsg;
+    private _internalStorage;
+    constructor();
+    reset(): void;
+    getStorageKey(): any;
+    getStorageType(): string;
+    getAuthData(): any;
+    setAuthData(values: any): void;
+    removeAuthData(): void;
+    isNewlyAuthorized(): boolean;
+    setNewlyAuthorized(): void;
+    removeNewlyAuthorized(): void;
+    _getWebStorage(sType: string): Storage;
+    _setStore(key: string, data: any): void;
+    _getStore(key: string): any;
+}
+export declare const AuthStoreSvc: AuthStoreSvcClass;
+export {};

package/services/dirty-status.service.d.ts

@@ -0,0 +1,41 @@
+export declare class DirtyStatusService {
+    unsavedChanges: {
+        isDirty?: boolean;
+        persistUrl?: string | null;
+        dirtySet?: Set<any>;
+    };
+    /**
+     * Initializes the `unsavedChanges` property with default values.
+     * Sets `isDirty` to `false` and `persistUrl` to `null`, indicating that there are no unsaved changes initially.
+     */
+    constructor();
+    /**
+     * Updates the dirty status of a given source and manages the set of unsaved changes.
+     *
+     * If the dirty set does not exist or is not a `Set`, it initializes a new `Set` and adds the source to it.
+     * The current URL is persisted in the `unsavedChanges` object.
+     * If `isDirty` is `true`, the source is added to the dirty set; otherwise, it is removed.
+     *
+     * @param isDirty - Indicates whether the source has unsaved changes.
+     * @param source - The source object to be marked as dirty or clean.
+     */
+    updateDirtyStatus(isDirty: boolean, source: any): void;
+    /**
+     * Clears the dirty state for a given source or all sources.
+     *
+     * If a source is provided, removes it from the set of unsaved changes.
+     * If no source is provided, clears all unsaved changes.
+     *
+     * @param source - The source to clear from the dirty set. If omitted, all sources are cleared.
+     */
+    clearDirtyState(source?: any): void;
+    /**
+     * Determines whether there are unsaved changes.
+     *
+     * Checks if the `dirtySet` exists and contains any items, indicating unsaved changes.
+     * If `dirtySet` is not present, falls back to the `isDirty` flag.
+     *
+     * @returns {boolean} `true` if there are unsaved changes, otherwise `false`.
+     */
+    readDirtyStatus(): boolean;
+}

package/services/i18n.service.d.ts

@@ -0,0 +1,81 @@
+import { LuigiContainer, LuigiCompoundContainer } from '@luigi-project/container';
+import { Luigi } from '../core-api/luigi';
+/**
+ * Localization-related functions
+ */
+export declare class i18nService {
+    private luigi;
+    currentLocaleStorageKey: string;
+    defaultLocale: string;
+    listeners: Record<number, (locale: string) => void>;
+    translationImpl: any;
+    translationTable: Record<string, any>;
+    constructor(luigi: Luigi);
+    _init(): void;
+    /**
+     * Gets the current locale.
+     * @returns {string} current locale
+     */
+    getCurrentLocale(): string;
+    /**
+     * Sets current locale to the specified one.
+     * @param {string} locale locale to be set as the current locale
+     */
+    setCurrentLocale(locale: string, containerElement?: LuigiContainer | LuigiCompoundContainer): void;
+    /**
+     * Registers a listener for locale changes.
+     * @param {Function} listener function called on every locale change with the new locale as argument
+     * @returns {number | null} listener ID associated with the given listener; use it when removing the listener
+     */
+    addCurrentLocaleChangeListener(listener: (locale: string) => void): number | null;
+    /**
+     * Unregisters a listener for locale changes.
+     * @param {number} listenerId listener ID associated with the listener to be removed, returned by addCurrentLocaleChangeListener
+     */
+    removeCurrentLocaleChangeListener(listenerId: number): void;
+    /**
+     * Gets translated text for the specified key in the current locale or in the specified one.
+     * Property values for token replacement in the localization key will be taken from the specified interpolations object.
+     *
+     * <!-- add-attribute:class:success -->
+     * > **TIP**: Be aware that this function is not asynchronous and therefore the translation table must be existing already at initialization. Take a look at our [i18n](i18n.md) section for an implementation suggestion.
+     *
+     * @param {string} key key to be translated
+     * @param {Object} interpolations object with properties that will be used for token replacements in the localization key
+     * @param {string} locale optional locale to get the translation for; default is the current locale
+     * @returns {string} translated text for the specified key
+     */
+    getTranslation(key: string, interpolations?: undefined, locale?: undefined): string;
+    /**
+     * @private
+     */
+    private _notifyLocaleChange;
+    /**
+     * @private
+     */
+    private _initCustomImplementation;
+    /**
+     * @private
+     * Sets locale to all Luigi containers
+     */
+    private broadcastLocaleToAllContainers;
+    /**
+     * @private
+     * Finds the translated value based on given key.
+     * @param {string} key key to be translated
+     * @param {*} obj translation table
+     * @param {Object | undefined} interpolations object with properties that will be used for token replacements in the localization key
+     * @returns {string | undefined} current locale
+     */
+    private findTranslation;
+    /**
+     * @private
+     * Replaces values that are defiend in translation strings
+     * @param {string} value string to be translated
+     * @param {Object} interpolations translation table
+     * @returns {string} current locale
+     * @example
+     * findInterpolations('Environment {num}', {num: 1})
+     */
+    private findInterpolations;
+}

package/services/modal.service.d.ts

@@ -0,0 +1,52 @@
+import { Luigi } from '../core-api/luigi';
+import { ModalSettings } from './navigation.service';
+export interface ModalPromiseObject {
+    closePromise?: Promise<void>;
+    resolveFn?: () => void;
+    onCloseRequestHandler?: () => void;
+    onInternalClose?: () => void;
+    modalsettings?: ModalSettings;
+}
+export declare class ModalService {
+    private luigi;
+    _modalStack: ModalPromiseObject[];
+    modalSettings: ModalSettings;
+    constructor(luigi: Luigi);
+    /**
+     * Closes the topmost modal in the stack.
+     */
+    closeModals(): Promise<void>;
+    /**
+     * Adds a modal promise object to the internal modal stack.
+     *
+     * This method is used to track active modals in a last-in-first-out (LIFO) stack,
+     * enabling the service to manage and resolve/dismiss modals in the correct order.
+     *
+     * @param modalObj - The modal promise object to register on the stack.
+     * @returns {void}
+     */
+    registerModal(modalObj: ModalPromiseObject): void;
+    /**
+     * Gets the settings of the first modal in the stack.
+     * @returns The settings of the first modal in the stack, or an empty object if the stack is empty.
+     */
+    getModalSettings(): ModalSettings | {};
+    /**
+     * Gets the current number of modals in the stack.
+     * @returns number The current number of modals in the stack.
+     */
+    getModalStackLength(): number;
+    /**
+     * Updates the settings of the first modal in the stack.
+     * @param settings modal settings to update the first modal with
+     */
+    updateFirstModalSettings(settings: ModalSettings): void;
+    /**
+     * Clears the entire modal stack.
+     */
+    clearModalStack(): void;
+    /**
+     * Removes the last modal from the stack.
+     */
+    removeLastModalFromStack(): void;
+}

package/services/navigation.service.d.ts

@@ -0,0 +1,213 @@
+import { Luigi } from '../core-api/luigi';
+export interface TopNavData {
+    appTitle: string;
+    logo: string;
+    topNodes: NavItem[];
+    productSwitcher?: ProductSwitcher;
+    profile?: ProfileSettings;
+    appSwitcher?: AppSwitcher;
+    navClick?: (item: NavItem) => void;
+}
+export interface AppSwitcher {
+    showMainAppEntry?: boolean;
+    items?: AppSwitcherItem[];
+    itemRenderer?: (item: AppSwitcherItem, slot: HTMLElement, appSwitcherApiObj?: any) => void;
+}
+export interface AppSwitcherItem {
+    title?: string;
+    subtitle?: string;
+    link?: string;
+    selectionConditions?: selectionConditions;
+}
+export interface selectionConditions {
+    route?: string;
+    contextCriteria?: ContextCriteria[];
+}
+export interface ContextCriteria {
+    key: string;
+    value: string;
+}
+export interface ProfileSettings {
+    authEnabled: boolean;
+    signedIn: boolean;
+    logout: ProfileLogout;
+    items?: ProfileItem[];
+    staticUserInfoFn?: () => Promise<UserInfo>;
+    onUserInfoUpdate: (fn: (uInfo: UserInfo) => void) => void;
+    itemClick: (item: ProfileItem) => void;
+}
+export interface ProfileLogout {
+    label?: string;
+    icon?: string;
+    testId?: string;
+    altText?: string;
+    doLogout: () => void;
+}
+export interface ProfileItem {
+    label?: string;
+    link?: string;
+    externalLink?: ExternalLink;
+    icon?: string;
+    testId?: string;
+    altText?: string;
+    openNodeAsModal?: boolean | ModalSettings;
+}
+export interface UserInfo {
+    name?: string;
+    initials?: string;
+    email?: string;
+    picture?: string;
+    description?: string;
+}
+export interface LeftNavData {
+    selectedNode: any;
+    items: NavItem[];
+    basePath: string;
+    sideNavFooterText?: string;
+    navClick?: (item: NavItem) => void;
+}
+export interface PathData {
+    selectedNode?: Node;
+    selectedNodeChildren?: Node[];
+    nodesInPath?: Node[];
+    rootNodes: Node[];
+    pathParams: Record<string, any>;
+}
+export interface Node {
+    visibleForFeatureToggles?: string[];
+    anonymousAccess?: any;
+    category?: any;
+    children?: Node[];
+    clientPermissions?: {
+        changeCurrentLocale?: boolean;
+        urlParameters?: Record<string, any>;
+    };
+    context?: Record<string, any>;
+    drawer?: ModalSettings;
+    externalLink?: ExternalLink;
+    hideFromNav?: boolean;
+    hideSideNav?: boolean;
+    icon?: string;
+    keepSelectedForChildren?: boolean;
+    label?: string;
+    onNodeActivation?: (node: Node) => boolean | void;
+    openNodeInModal?: boolean;
+    pageErrorHandler?: PageErrorHandler;
+    pathSegment?: string;
+    tabNav?: boolean;
+    tooltip?: string;
+    viewUrl?: string;
+    isRootNode?: boolean;
+}
+export interface PageErrorHandler {
+    timeout: number;
+    viewUrl?: string;
+    redirectPath?: string;
+    errorFn?: (node?: Node) => void;
+}
+export interface Category {
+    collabsible?: boolean;
+    icon?: string;
+    id: string;
+    isGroup?: boolean;
+    label?: string;
+    nodes?: NavItem[];
+    tooltip?: string;
+}
+export interface NavItem {
+    node?: Node;
+    category?: Category;
+    selected?: boolean;
+}
+export interface TabNavData {
+    selectedNode?: any;
+    items?: NavItem[];
+    basePath?: string;
+    navClick?: (item: NavItem) => void;
+}
+export interface ModalSettings {
+    size?: 'fullscreen' | 'l' | 'm' | 's';
+    width?: string;
+    height?: string;
+    title?: string;
+    closebtn_data_testid?: string;
+    keepPrevious?: boolean;
+}
+export interface ProductSwitcher {
+    altText?: string;
+    columns?: number;
+    icon?: string;
+    items?: [ProductSwitcherItem];
+    label?: string;
+    testId?: string;
+}
+export interface ProductSwitcherItem {
+    altText?: string;
+    externalLink?: ExternalLink;
+    icon?: string;
+    label?: string;
+    link?: string;
+    selected?: boolean;
+    subTitle?: string;
+    testId?: string;
+}
+export interface ExternalLink {
+    url?: string;
+    sameWindow?: boolean;
+}
+export declare class NavigationService {
+    private luigi;
+    constructor(luigi: Luigi);
+    getPathData(path: string): PathData;
+    findMatchingNode(urlPathElement: string, nodes: Node[]): Node | undefined;
+    buildNavItems(nodes: Node[], selectedNode: Node | undefined, pathData: PathData): NavItem[];
+    shouldRedirect(path: string, pData?: PathData): string | undefined;
+    getCurrentNode(path: string): any;
+    getPathParams(path: string): Record<string, any>;
+    /**
+     * getTruncatedChildren
+     *
+     * Returns an array of children without the childs below
+     * last node that has keepSelectedForChildren or tabnav enabled
+     * @param array children
+     * @returns array children
+     */
+    getTruncatedChildren(children: any): any[];
+    applyNavGroups(items: NavItem[]): NavItem[];
+    getLeftNavData(path: string, pData?: PathData): LeftNavData;
+    navItemClick(item: Node, parentPath: string): void;
+    getTopNavData(path: string, pData?: PathData): TopNavData;
+    getParentNode(node: Node | undefined, pathData: PathData): Node | undefined;
+    getAppSwitcherData(appSwitcherData: AppSwitcher, headerSettings: any): AppSwitcher | undefined;
+    getTabNavData(path: string, pData?: PathData): TabNavData;
+    /**
+     * Handles changes between navigation nodes by invoking a configured hook function.
+     *
+     * This method retrieves the `navigation.nodeChangeHook` function from the Luigi configuration.
+     * If the hook is defined and is a function, it is called with the previous and next node as arguments.
+     * If the hook is defined but not a function, a warning is logged to the console.
+     *
+     * @param prevNode - The previous navigation node, or `undefined` if there was no previous node.
+     * @param nextNode - The new navigation node that is being navigated to.
+     */
+    onNodeChange(prevNode: Node | undefined, nextNode: Node): void;
+    /**
+     * Extracts navigation data from the provided path string.
+     *
+     * This method parses the given path to retrieve structured path data and the last node object
+     * in the navigation hierarchy. It utilizes internal helpers to process the path and extract
+     * relevant navigation information.
+     *
+     * @param path - The navigation path string to extract data from.
+     * @returns A promise that resolves to an object containing:
+     *   - `nodeObject`: The last node object in the navigation path.
+     *   - `pathData`: The structured data representation of the path.
+     */
+    extractDataFromPath(path: string): Promise<{
+        nodeObject: Node;
+        pathData: PathData;
+    }>;
+    private resolveTooltipText;
+    private prepareRootNodes;
+    private getAccessibleNodes;
+}

package/services/node-data-management.service.d.ts

@@ -0,0 +1,45 @@
+import { Node } from './navigation.service';
+export declare class NodeDataManagementService {
+    dataManagement: Map<any, any>;
+    navPath: string;
+    constructor();
+    /**
+     * Stores node as key and value as value
+     * @param {Node} node
+     * @param {any} value
+     */
+    setChildren(node: Node, value: any): void;
+    /**
+     * Returns the map entry which belongs to the node, stored as key
+     * @param {Node} node
+     * @returns {any} map entry
+     */
+    getChildren(node: Node): any;
+    /**
+     * Checks if there is an entry of given node
+     * @param {Node} node
+     * @returns {boolean} true or false
+     */
+    hasChildren(node: Node): boolean;
+    /**
+     * Stores root node as object with key '_luigiRootNode'
+     * @param {Node} node
+     */
+    setRootNode(node: Node): void;
+    /**
+     * Returns the root node
+     * @returns {Node} root node
+     */
+    getRootNode(): Node;
+    /**
+     * Checks if root node exists
+     * @returns {boolean} true or false
+     */
+    hasRootNode(): boolean;
+    deleteCache(): void;
+    /**
+     * Deletes node from cache and its children recursively
+     * @param {Node} node
+     */
+    deleteNodesRecursively(node: Node): void;
+}