@luigi-project/core-modular 0.0.1

package/App.svelte.d.ts

@@ -0,0 +1 @@
+export { SvelteComponent as default } from 'svelte';

package/README.md

@@ -0,0 +1,13 @@
+# Luigi Modular Core
+
+## Overview
+
+Luigi Core, headless, modular.
+
+This is an early version and not yet recommended for production use.
+
+For details on Luigi Core, see [this](https://github.com/luigi-project/luigi/tree/main/core) document.
+
+If you want to try Luigi out, see the [examples](https://github.com/luigi-project/luigi/tree/main/core/examples).
+
+For documentation on Luigi Core, see [Luigi documentation](https://docs.luigi-project.io).

package/core-api/auth.d.ts

@@ -0,0 +1,92 @@
+export declare class LuigiAuthClass {
+    /**
+     * Detects if authorization is enabled via configuration.
+     * Read more about [custom authorization providers](authorization-configuration.md).
+     * @memberof Authorization
+     * @returns {boolean} - `true` if authorization is enabled. Otherwise returns `false`.
+     * @example
+     * Luigi.auth().isAuthorizationEnabled();
+     */
+    isAuthorizationEnabled(): boolean;
+    /**
+     * Login the user dynamically.
+     * This will run the same functionality as though the user clicked the login button.
+     * @memberof Authorization
+     * @example
+     * Luigi.auth().login();
+     */
+    login(): void;
+    /**
+     * Logout the user dynamically.
+     * This will run the same functionality as though the user clicked the logout button.
+     * @memberof Authorization
+     * @example
+     * Luigi.auth().logout();
+     */
+    logout(): void;
+    /**
+     * @private
+     * @memberof Authorization
+     * @param {string} eventName
+     * @param {Object} providerInstanceSettings
+     * @param {AuthData} data
+     * @param {string} redirectUrl
+     */
+    handleAuthEvent(eventName: string, providerInstanceSettings: any, data?: any, redirectUrl?: string): Promise<any>;
+    /**
+     * Authorization Storage helpers, to be used in your custom authorization provider.
+     * Read more about custom authorization providers [here](authorization-configuration.md#implement-a-custom-authorization-provider).
+     * @name AuthorizationStore
+     */
+    /**
+     * Authorization object that is stored in auth store and used within Luigi. It is then available in [LuigiClient.addInitListener](luigi-client-api.md#addInitListener) and can also be used in the Core configuration.
+     * @typedef {Object} AuthData
+     * @property {string} accessToken - access token value
+     * @property {string} accessTokenExpirationDate - timestamp value
+     * @property {string} scope - scope, can be empty if it is not required
+     * @property {string} idToken - id token, used for renewing authentication
+     */
+    get store(): {
+        /**
+         * Retrieves the key name that is used to store the auth data.
+         * @memberof AuthorizationStore
+         * @returns {string} - name of the store key
+         * @example Luigi.auth().store.getStorageKey()
+         */
+        getStorageKey: () => any;
+        /**
+         * Retrieves the storage type that is used to store the auth data. To set it, use the `storage` property of the `auth` Luigi configuration object. Find out more [here](https://docs.luigi-project.io/docs/authorization-configuration?section=general-authorization-options).
+         * @memberof AuthorizationStore
+         * @returns {('localStorage'|'sessionStorage'|'none')} - storage type
+         * @example Luigi.auth().store.getStorageType()
+         */
+        getStorageType: () => string;
+        /**
+         * Retrieves the current auth object.
+         * @memberof AuthorizationStore
+         * @returns {AuthData} - the current auth data object
+         * @example Luigi.auth().store.getAuthData()
+         */
+        getAuthData: () => any;
+        /**
+         * Sets authorization data
+         * @memberof AuthorizationStore
+         * @param {AuthData} data - new auth data object
+         * @example Luigi.auth().store.setAuthData(data)
+         */
+        setAuthData: (data: any) => void;
+        /**
+         * Clears authorization data from store
+         * @memberof AuthorizationStore
+         * @example Luigi.auth().store.removeAuthData()
+         */
+        removeAuthData: () => void;
+        /**
+         * Defines a new authorization session. Must be triggered after initial `setAuthData()` in order to trigger **onAuthSuccessful** event after login.
+         * @memberof AuthorizationStore
+         * @example Luigi.auth().store.setNewlyAuthorized()
+         */
+        setNewlyAuthorized: () => void;
+    };
+}
+export declare const LuigiAuth: LuigiAuthClass;

package/core-api/feature-toggles.d.ts

@@ -0,0 +1,33 @@
+export declare class FeatureToggles {
+    featureToggleList: Set<string>;
+    constructor();
+    /**
+     * Add a feature toggle to an active feature toggles list
+     * @param {string} featureToggleName name of the feature toggle
+     */
+    setFeatureToggle(featureToggleName: string, fromUrlQuery?: boolean): void;
+    /**
+     * Remove a feature toggle from the list
+     * @param {string} featureToggleName name of the feature toggle
+     */
+    unsetFeatureToggle(featureToggleName: string): void;
+    /**
+     * Get a list of active feature toggles
+     * @return {Array} of active feature toggles
+     */
+    getActiveFeatureToggleList(): string[];
+    /**
+     * Check if it is a valid feature toggle
+     * @private
+     * @param {string} featureToggleName name of the feature toggle
+     * @return {boolean} of valid feature toggle name
+     */
+    private isValid;
+    /**
+     * Check if feature toggle is duplicated or already disabled
+     * @private
+     * @param {string} featureToggleName name of the feature toggle
+     * @return {boolean} of valid feature toggle name
+     */
+    private isDuplicatedOrDisabled;
+}

package/core-api/luigi.d.ts

@@ -0,0 +1,79 @@
+import { LuigiEngine } from '../luigi-engine';
+import { i18nService } from '../services/i18n.service';
+import { FeatureToggles } from './feature-toggles';
+import { Navigation } from './navigation';
+import { Routing } from './routing';
+import { Theming } from './theming';
+import { UX } from './ux';
+import { LuigiAuthClass } from './auth';
+export declare class Luigi {
+    private engine;
+    config: any;
+    _store: any;
+    _featureToggles?: FeatureToggles;
+    _i18n: i18nService;
+    _theming?: Theming;
+    _routing?: Routing;
+    __cssVars?: any;
+    preventLoadingModalData?: boolean;
+    initialized: boolean;
+    configReadyCallback: () => void;
+    private USER_SETTINGS_KEY;
+    constructor(engine: LuigiEngine);
+    getEngine(): LuigiEngine;
+    setConfig: (cfg: any) => void;
+    getConfig: () => any;
+    configChanged: (...scopes: string[]) => void;
+    /**
+     * Gets value of the given property on Luigi config object. Target can be a value or a synchronous function.
+     * @param {string} property the object traversal path
+     * @example
+     * Luigi.getConfigValue('auth.use')
+     * Luigi.getConfigValue('settings.sideNavFooterText')
+     */
+    getConfigValue(property: string): any;
+    /**
+     * Gets value of the given property on the Luigi config object.
+     * 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.
+     * @memberof Configuration
+     * @param {string} property the object traversal path
+     * @param {*} parameters optional parameters that are used if the target is a function
+     * @example
+     * Luigi.getConfigValueAsync('navigation.nodes')
+     * Luigi.getConfigValueAsync('navigation.profile.items')
+     * Luigi.getConfigValueAsync('navigation.contextSwitcher.options')
+     */
+    getConfigValueAsync(property: string, ...parameters: any[]): Promise<any>;
+    /**
+     * Reads the user settings object.
+     * You can choose a custom storage to read the user settings by implementing the `userSettings.readUserSettings` function in the settings section of the Luigi configuration.
+     * By default, the user settings will be read from the **localStorage**
+     * @returns {Promise} a promise when a custom `readUserSettings` function in the settings.userSettings section of the Luigi configuration is implemented. It resolves a stored user settings object. If the promise is rejected the user settings dialog will also closed if the error object has a `closeDialog` property, e.g `reject({ closeDialog: true, message: 'some error' })`. In addition a custom error message can be logged to the browser console.
+     * @example
+     * Luigi.readUserSettings();
+     */
+    readUserSettings(): Promise<any>;
+    /**
+     * Stores the user settings object.
+     * You can choose a custom storage to write the user settings by implementing the `userSetting.storeUserSettings` function in the settings section of the Luigi configuration
+     * By default, the user settings will be written from the **localStorage**
+     * @param {Object} userSettingsObj to store in the storage.
+     * @param {Object} previousUserSettingsObj the previous object from storage.
+     * @returns {Promise} a promise when a custom `storeUserSettings` function in the settings.userSettings section of the Luigi configuration is implemented. If it is resolved the user settings dialog will be closed. If the promise is rejected the user settings dialog will also closed if the error object has a `closeDialog` property, e.g `reject({ closeDialog: true, message: 'some error' })`. In addition a custom error message can be logged to the browser console.
+     * @example
+     * Luigi.storeUserSettings(userSettingsobject, previousUserSettingsObj);
+     */
+    storeUserSettings(userSettingsObj: Record<string, any>, previousUserSettingsObj: Record<string, any>): Promise<any>;
+    i18n: () => i18nService;
+    navigation: () => Navigation;
+    ux: () => UX;
+    featureToggles: () => FeatureToggles;
+    routing: () => Routing;
+    theming: () => Theming;
+    auth: () => LuigiAuthClass;
+    private luigiAfterInit;
+    private createConfigStore;
+    private getConfigReadyCallback;
+    private setConfigCallback;
+}

package/core-api/navigation.d.ts

@@ -0,0 +1,15 @@
+import { ModalService } from '../services/modal.service';
+import { ModalSettings, NavigationService } from '../services/navigation.service';
+import { RoutingService } from '../services/routing.service';
+import { Luigi } from './luigi';
+export declare class Navigation {
+    luigi: Luigi;
+    hashRouting: boolean;
+    navService: NavigationService;
+    routingService: RoutingService;
+    modalService: ModalService;
+    constructor(luigi: Luigi);
+    navigate: (path: string, preserveView?: string, modalSettings?: ModalSettings, callbackFn?: (val?: unknown) => void) => void;
+    openAsModal: (path: string, modalSettings: ModalSettings, onCloseCallback?: () => void) => Promise<void>;
+    openAsDrawer: (path: string, modalSettings: ModalSettings, onCloseCallback?: () => void) => void;
+}

package/core-api/routing.d.ts

@@ -0,0 +1,43 @@
+import { Luigi } from './luigi';
+export declare class Routing {
+    luigi: Luigi;
+    constructor(luigi: Luigi);
+    /**
+     * Adds or updates search parameters in the current URL.
+     *
+     * Depending on the routing configuration, this method will either update the hash fragment
+     * or the standard search parameters of the URL. It also manages browser history based on the
+     * `keepBrowserHistory` flag.
+     *
+     * @param params - An object containing key-value pairs to be added as search parameters.
+     * @param keepBrowserHistory - If `true`, a new entry is added to the browser's history; otherwise, the current entry is replaced. Defaults to `false`.
+     */
+    addSearchParams(params: object, keepBrowserHistory?: boolean): void;
+    /**
+     * Get search parameter from URL as an object.
+     * @memberof Routing
+     * @returns {Object}
+     * @example
+     * Luigi.routing().getSearchParams();
+     */
+    getSearchParams(): object;
+    /**
+     * Updates the browser's history stack with the provided URL.
+     *
+     * Depending on the `keepBrowserHistory` flag, this method either pushes a new entry
+     * onto the browser's history stack or replaces the current entry. The URL is sanitized
+     * before being used. If the sanitized URL is invalid, a warning is logged and no action is taken.
+     *
+     * @param keepBrowserHistory - If `true`, a new history entry is pushed; if `false`, the current entry is replaced.
+     * @param url - The URL object to be used for updating the browser history.
+     */
+    handleBrowserHistory(keepBrowserHistory: boolean, url: URL): void;
+    /**
+     * Sanitizes a given URL by ensuring it shares the same origin as the current page.
+     *
+     * @param url - The URL to be sanitized.
+     * @returns The original URL if it has the same origin as the current location; otherwise, returns `undefined`.
+     */
+    sanitizeUrl(url: string): string | undefined;
+    addNodeParams(params: Record<string, any>, keepBrowserHistory: boolean): void;
+}

package/core-api/theming.d.ts

@@ -0,0 +1,78 @@
+import { Luigi } from './luigi';
+declare global {
+    interface Window {
+        Luigi: any;
+        __luigiThemeVars?: string[];
+    }
+}
+export declare class Theming {
+    #private;
+    constructor(luigi: Luigi);
+    /**
+     * Retrieves the available themes
+     * @memberof Theming
+     * @returns {promise} resolves an array of theming objects
+     * @example
+     * Luigi
+     *  .theming()
+     *  .getAvailableThemes()
+     *  .then((themes) => {
+     *     // Logic to generate theme selector
+     *  });
+     */
+    getAvailableThemes(): Promise<any>;
+    /**
+     * Sets the current theme id
+     * @memberof Theming
+     * @param {string} id of a theme object
+     * @example
+     * Luigi.theming().setCurrentTheme('light')
+     */
+    setCurrentTheme(id: string): void;
+    /**
+     * Retrieves a theme object by name.
+     * @memberof Theming
+     * @param {string} id a theme id
+     * @returns {promise} resolves a theme object
+     * @example
+     * Luigi
+     *  .theming()
+     *  .getThemeObject('light')
+     *  .then((id => {
+     *    // Logic
+     *  }))
+     */
+    getThemeObject(id: string): Promise<any>;
+    /**
+     * Retrieves the current active theme. Falls back to **defaultTheme** if none explicitly specified before.
+     * @memberof Theming
+     * @returns {string} theme id
+     * @example
+     * Luigi.theming().getCurrentTheme()
+     */
+    getCurrentTheme(): any;
+    /**
+     * The general status about the Theming configuration.
+     * @memberof Theming
+     * @returns {boolean} `true` if **settings.theming** configuration object is defined
+     * @example
+     * Luigi.theming().isThemingAvailable()
+     */
+    isThemingAvailable(): boolean;
+    /**
+     * Returns CSS variables with key value from Luigi if `@luigi-project/core/luigi_theme-vars.js` is included in the `index.html` and `settings.theming.variables==='fiori'` is defined in the {@link general-settings.md settings} section.
+     * It's also possible to define your own variables file which can be declared in `settings.theming.variables.file` in the {@link general-settings.md settings} section.
+     * The variables should be defined in a JSON file which starts with a `root` key.
+     * When you configure you own file, you can also implement exception handling by using the function `settings.theming.variables.errorHandling` which gets the error object as argument.
+     * @memberof Theming
+     * @returns {Object} CSS variables with their value.
+     * @example Luigi.theming().getCSSVariables();
+     */
+    getCSSVariables(): Promise<any>;
+    /**
+     * Initialize Theming Core API
+     * @memberof Theming
+     * @private
+     */
+    _init(): void;
+}

package/core-api/ux.d.ts

@@ -0,0 +1,22 @@
+import { AlertSettings, ConfirmationModalSettings, UserSettings } from '../modules/ux-module';
+import { DirtyStatusService } from '../services/dirty-status.service';
+import { Luigi } from './luigi';
+export declare class UX {
+    luigi: Luigi;
+    dirtyStatusService: DirtyStatusService;
+    private appLoadingIndicatorSelector;
+    constructor(luigi: Luigi);
+    showAlert: (alertSettings: AlertSettings) => Promise<unknown>;
+    showConfirmationModal: (settings: ConfirmationModalSettings) => Promise<unknown>;
+    processUserSettingGroups: () => any[];
+    openUserSettings: (settings: UserSettings) => void;
+    closeUserSettings: () => void;
+    setDocumentTitle: (documentTitle: string) => void;
+    getDocumentTitle: () => string;
+    hideAppLoadingIndicator: () => void;
+    showLoadingIndicator: (containerWrapper: HTMLElement) => void | undefined;
+    hideLoadingIndicator: (containerWrapper: HTMLElement) => void | undefined;
+    addBackdrop: () => void | undefined;
+    removeBackdrop: () => void | undefined;
+    getDirtyStatus: () => boolean;
+}

package/luigi-engine.d.ts

@@ -0,0 +1,40 @@
+import { NavigationService } from './services/navigation.service';
+import { RoutingService } from './services/routing.service';
+import { LuigiConnector } from './types/connector';
+export declare class LuigiEngine {
+    config: any;
+    _connector: LuigiConnector | undefined;
+    _app: any;
+    _ui: {
+        navService: NavigationService;
+        routingService: RoutingService;
+        luigi: import('./core-api/luigi').Luigi;
+        init: (luigi: import('./core-api/luigi').Luigi) => void;
+        update: (scopes?: string[]) => void;
+        updateMainContent: (currentNode: any, luigi: import('./core-api/luigi').Luigi) => Promise<void>;
+        openModal: (luigi: import('./core-api/luigi').Luigi, node: any, modalSettings: import('./services/navigation.service').ModalSettings, onCloseCallback?: () => void) => Promise<void>;
+        updateModalSettings: (modalSettings: import('./services/navigation.service').ModalSettings, addHistoryEntry: boolean, luigi: import('./core-api/luigi').Luigi) => void;
+        openDrawer: (luigi: import('./core-api/luigi').Luigi, node: any, modalSettings: import('./services/navigation.service').ModalSettings, onCloseCallback?: () => void) => Promise<void>;
+    };
+    _comm: {
+        luigi: import('./core-api/luigi').Luigi;
+        init: (luigi: import('./core-api/luigi').Luigi) => void;
+        addListeners: (containerElement: any, luigi: import('./core-api/luigi').Luigi) => void;
+    };
+    _ux: {
+        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;
+        handleDirtyStatusRequest: (isDirty: boolean, source: any) => void;
+    };
+    _routing: {
+        init: (luigi: import('./core-api/luigi').Luigi) => void;
+        handlePageErrorHandler: (pageErrorHandler: import('./services/navigation.service').PageErrorHandler, node: import('./services/navigation.service').Node, luigi: import('./core-api/luigi').Luigi) => void;
+        handleExternalLinkNavigation: (externalLink: import('./services/navigation.service').ExternalLink) => void;
+        addSearchParamsFromClient(searchParams: Record<string, any>, keepBrowserHistory: boolean, luigi: import('./core-api/luigi').Luigi): void;
+    };
+    bootstrap(connector: LuigiConnector): void;
+    init(): void;
+}