@luigi-project/core-modular 0.0.10 → 0.0.11-dev.20260720111

package/core-api/custom-messages.d.ts

@@ -2,6 +2,32 @@ import { Luigi } from './luigi';
 export declare class CustomMessages {
     luigi: Luigi;
     constructor(luigi: Luigi);
+    /**
+     * Sends a custom message to all opened micro frontends.
+     * @param {Object} message - an object containing data to be sent to the micro frontend to process it further. This object is set as an input parameter of the custom message listener on the micro frontend side.
+     * @param {string} message.id - the id of the message
+     * @param {*} message.MY_DATA_FIELD - any other message data field
+     * @example
+     * Luigi.customMessages().sendToAll({
+     *     id: 'myprefix.my-custom-message-for-client',
+     *     dataField1: 'here goes some data',
+     *     moreData: 'here goes some more'
+     * });
+     */
     sendToAll(message: Record<string, any>): void;
+    /**
+     * Sends a message to specific micro frontend identified with an id.
+     * Use Luigi.elements().getMicrofrontends() to get the iframe id.
+     * @param {string} microfrontendId - the id of the micro frontend
+     * @param {Object} message - an object containing data to be sent to the micro frontend to process it further. This object is set as an input parameter of the custom message listener on the micro frontend side
+     * @param {string} message.id - the id of the message
+     * @param {*} message.MY_DATA_FIELD - any other message data field
+     * @example
+     * Luigi.customMessages().send(microfrontend.id, {
+     *     id: 'myprefix.my-custom-message-for-client',
+     *     dataField1: 'here goes some data',
+     *     moreData: 'here goes some more'
+     * });
+     */
     send(microfrontendId: string, message: Record<string, any>): void;
 }

package/core-api/global-search.d.ts

@@ -0,0 +1,61 @@
+import { GlobalSearchService } from '../services/global-search.service';
+import { SearchResultItem } from '../types/global-search';
+import { Luigi } from './luigi';
+export declare class GlobalSearch {
+    luigi: Luigi;
+    globalSearchService: GlobalSearchService;
+    constructor(luigi: Luigi);
+    /**
+     * Opens the global search field.
+     * @example Luigi.globalSearch().openSearchField();
+     */
+    openSearchField(): void;
+    /**
+     * Closes the global search field.
+     * @example Luigi.globalSearch().closeSearchField();
+     */
+    closeSearchField(): void;
+    /**
+     * Clears the global search field.
+     * @example Luigi.globalSearch().clearSearchField();
+     */
+    clearSearchField(): void;
+    /**
+     * Opens the global search result. By standard it is a popover.
+     * @param {Array<SearchResultItem>} searchResultItems
+     * @example
+     * let searchResultItem = {
+     *   pathObject: {
+     *     link,
+     *     params: {}
+     *   },
+     *   label,
+     *   description
+     * }
+     *
+     * Luigi.globalSearch().showSearchResult([searchResultItem1, searchResultItem2]);
+     */
+    showSearchResult(searchResultItems: SearchResultItem[]): void;
+    /**
+     * Closes the global search result. By standard it is rendered as a popover.
+     * @example Luigi.globalSearch().closeSearchResult();
+     */
+    closeSearchResult(): void;
+    /**
+     * Gets the value of the search input field.
+     * @example Luigi.globalSearch().getSearchString();
+     */
+    getSearchString(): string;
+    /**
+     * Sets the value of the search input field.
+     * @param searchString search value
+     * @example Luigi.globalSearch().setSearchString('searchString');
+     */
+    setSearchString(searchString: string): void;
+    /**
+     * Sets the value of the Placeholder search input field.
+     * @param placeholder placeholder value
+     * @example Luigi.globalSearch().setSearchInputPlaceholder('HERE input Placeholder');
+     */
+    setSearchInputPlaceholder(placeholder: string): void;
+}

package/core-api/luigi.d.ts

@@ -3,6 +3,7 @@ import { i18nService } from '../services/i18n.service';
 import { Elements } from './dom-elements';
 import { LuigiAuthClass } from './auth';
 import { FeatureToggles } from './feature-toggles';
+import { GlobalSearch } from './global-search';
 import { Navigation } from './navigation';
 import { Routing } from './routing';
 import { Theming } from './theming';
@@ -14,6 +15,7 @@ export declare class Luigi {
     _customMessages?: CustomMessages;
     _store: any;
     _featureToggles?: FeatureToggles;
+    _globalSearch?: GlobalSearch;
     _i18n: i18nService;
     _theming?: Theming;
     _routing?: Routing;
@@ -111,6 +113,7 @@ export declare class Luigi {
     navigation: () => Navigation;
     ux: () => UX;
     featureToggles: () => FeatureToggles;
+    globalSearch: () => GlobalSearch;
     routing: () => Routing;
     theming: () => Theming;
     auth: () => LuigiAuthClass;

package/core-api/navigation.d.ts

@@ -62,4 +62,10 @@ export declare class Navigation {
      */
     fromParent(): Navigation;
     withParams(nodeParams: Record<string, any>): Navigation;
+    /**
+     * Refreshes top navigation badge counters by rendering the navigation again.
+     * @example
+     * Luigi.navigation().updateTopNavigation();
+     */
+    updateTopNavigation(): Promise<void>;
 }

package/core-api/ux.d.ts

@@ -1,4 +1,4 @@
-import { AlertSettings, ConfirmationModalSettings } from '../modules/ux-module';
+import { AlertSettings, ConfirmationModalSettings } from '../types/ux';
 import { DirtyStatusService } from '../services/dirty-status.service';
 import { Luigi } from './luigi';
 export declare class UX {
@@ -6,16 +6,109 @@ export declare class UX {
     dirtyStatusService: DirtyStatusService;
     private appLoadingIndicatorSelector;
     constructor(luigi: Luigi);
+    /**
+     * Shows an alert.
+     * @param {Object} settings - the settings for the alert
+     * @param {string} settings.text - the content of the alert. To add a link to the content, you have to set up the link in the `links` object. The key(s) in the `links` object must be used in the text to reference the links, wrapped in curly brackets with no spaces. If you do not specify any text, the alert is not displayed
+     * @param {('info'|'success'|'warning'|'error')} settings.type - sets the type of alert
+     * @param {Object} settings.links - provides links data
+     * @param {Object} settings.links.LINK_KEY - object containing the data for a particular link. To properly render the link in the alert message refer to the description of the **settings.text** parameter
+     * @param {string} settings.links.LINK_KEY.text - text which replaces the link identifier in the alert content
+     * @param {string} settings.links.LINK_KEY.url - URL to navigate when you click the link. Currently, only internal links are supported in the form of relative or absolute paths
+     * @param {string} settings.links.LINK_KEY.dismissKey - dismissKey which represents the key of the link.
+     * @param {number} settings.closeAfter - (optional) time in milliseconds that tells Luigi when to close the Alert automatically. If not provided, the Alert will stay on until closed manually. It has to be greater than `100`
+     * @returns {promise} which is resolved when the alert is dismissed
+     * @example
+     * const settings = {
+     *  text: "Ut enim ad minim veniam, {goToHome} quis nostrud exercitation ullamco {relativePath}. Duis aute irure dolor {goToOtherProject} or {neverShowItAgain}",
+     *  type: 'info',
+     *  links: {
+     *    goToHome: { text: 'homepage', url: '/overview' },
+     *    goToOtherProject: { text: 'other project', url: '/projects/pr2' },
+     *    relativePath: { text: 'relative hide side nav', url: 'hideSideNav' },
+     *    neverShowItAgain: { text: 'Never show it again', dismissKey: 'neverShowItAgain' }
+     *  },
+     *  closeAfter: 3000
+     * }
+     * Luigi
+     *  .ux()
+     *  .showAlert(settings)
+     *  .then(() => {
+     *     // Logic to execute when the alert is dismissed
+     *  });
+     */
     showAlert: (alertSettings: AlertSettings) => Promise<unknown>;
+    /**
+     * Shows a confirmation modal.
+     * @param {Object} settings - the settings of the confirmation modal. If you do not provide any value for any of the fields, a default value is used
+     * @param {('confirmation'|'success'|'warning'|'error'|'information')} settings.type - the content of the modal type. (Optional)
+     * @param {string} [settings.header="Confirmation"] - the content of the modal header
+     * @param {string} [settings.body="Are you sure you want to do this?"] - the content of the modal body. It supports HTML formatting elements such as `<br>`, `<b>`, `<strong>`, `<i>`, `<em>`, `<mark>`, `<small>`, `<del>`, `<ins>`, `<sub>`, `<sup>`.
+     * @param {string|false} [settings.buttonConfirm="Yes"] - the label for the modal confirmation button. If set to `false`, the button will not be shown.
+     * @param {string} [settings.buttonDismiss="No"] - the label for the modal dismiss button
+     * @returns {promise} which is resolved when accepting the confirmation modal and rejected when dismissing it
+     * @example
+     * const settings = {
+     *  header: "Confirmation",
+     *  body: "Are you sure you want to do this?",
+     *  buttonConfirm: "Yes",
+     *  buttonDismiss: "No"
+     * }
+     * Luigi
+     *  .ux()
+     *  .showConfirmationModal(settings)
+     *  .then(() => {
+     *     // Logic to execute when the confirmation modal is dismissed
+     *  });
+     */
     showConfirmationModal: (settings: ConfirmationModalSettings) => Promise<unknown>;
+    /**
+     * Open user settings dialog
+     */
     openUserSettings: () => Promise<void>;
+    /**
+     * Close user settings dialog
+     */
     closeUserSettings: () => void;
+    /**
+     * Set the document title
+     * @param {string} documentTitle
+     * @example Luigi.ux().setDocumentTitle('Luigi');
+     */
     setDocumentTitle: (documentTitle: string) => void;
+    /**
+     * Get the document title
+     * @returns {string} a string, which is displayed in the tab.
+     * @example Luigi.ux().getDocumentTitle();
+     */
     getDocumentTitle: () => string;
+    /**
+     * Hides the app loading indicator.
+     */
     hideAppLoadingIndicator: () => void;
+    /**
+     * Sends message to show loading indicator
+     * @ignore
+     */
     showLoadingIndicator: (containerWrapper: HTMLElement) => void | undefined;
+    /**
+     * Sends message to hide loading indicator
+     * @ignore
+     */
     hideLoadingIndicator: (containerWrapper: HTMLElement) => void | undefined;
+    /**
+     * Adds backdrop. Function only used internally
+     * @private
+     */
     addBackdrop: () => void | undefined;
+    /**
+     * Removes backdrop. Function only used internally
+     * @private
+     */
     removeBackdrop: () => void | undefined;
+    /**
+     * Returns the dirty status, which is set by the Client via [setDirtyStatus](luigi-client-api.md#setdirtystatus). By default, the dirty status is `false`.
+     * @returns {boolean}
+     */
     getDirtyStatus: () => boolean;
 }

package/luigi-engine.d.ts

@@ -28,8 +28,8 @@ export declare class LuigiEngine {
         luigi: import('./core-api/luigi').Luigi | undefined;
         documentTitle: any;
         init: (luigi: import('./core-api/luigi').Luigi) => void;
-        processAlert: (alertSettings: import('./modules/ux-module').AlertSettings, openFromClient: boolean, containerElement: import('@luigi-project/container').LuigiContainer | import('@luigi-project/container').LuigiCompoundContainer) => void;
-        handleConfirmationModalRequest: (confirmationModalSettings: import('./modules/ux-module').ConfirmationModalSettings, containerElement: import('@luigi-project/container').LuigiContainer | import('@luigi-project/container').LuigiCompoundContainer) => void;
+        processAlert: (alertSettings: import('./types/ux').AlertSettings, openFromClient: boolean, containerElement: import('@luigi-project/container').LuigiContainer | import('@luigi-project/container').LuigiCompoundContainer) => void;
+        handleConfirmationModalRequest: (confirmationModalSettings: import('./types/ux').ConfirmationModalSettings, containerElement: import('@luigi-project/container').LuigiContainer | import('@luigi-project/container').LuigiCompoundContainer) => void;
         handleDirtyStatusRequest: (isDirty: boolean, source: any) => void;
     };
     _routing: {