@bluealba/pae-ui-react-core 3.0.2-develop-1171

package/dist/src/hooks/customizations/useDynamicStyleSheet.d.ts

@@ -0,0 +1 @@
+export declare const useDynamicStyleSheet: (styleSheet?: string) => void;

package/dist/src/hooks/customizations/useGetPlatformTheme.d.ts

@@ -0,0 +1,3 @@
+type ThemeType = 'light' | 'dark';
+export declare const useGetPlatformTheme: () => ThemeType;
+export {};

package/dist/src/hooks/customizations/usePAECustomizationsLoadingState.d.ts

@@ -0,0 +1,2 @@
+export declare const usePAECustomizationsLoadingState: () => [boolean | undefined, import('../../utils/immutable').SetOrUpdateFn<boolean | undefined>];
+export default usePAECustomizationsLoadingState;

package/dist/src/hooks/customizations/usePlatformCustomization.d.ts

@@ -0,0 +1,8 @@
+import { FontDefinition } from './useDynamicFonts';
+
+type PlatformCustomization = {
+    fonts?: FontDefinition[];
+    styleSheet?: string;
+};
+export declare const usePlatformCustomization: (customizations: PlatformCustomization) => void;
+export {};

package/dist/src/hooks/customizations/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const platformHaveAnyCustomization: (loading: boolean | undefined) => loading is boolean;
+export declare const isPlatformCustomizationCompleted: (loading: boolean | undefined) => loading is false | undefined;

package/dist/src/hooks/events/usePlatformEventListener.d.ts

@@ -0,0 +1,2 @@
+export declare const usePlatformEventListener: (eventName: string, listener: (e: Event) => void) => void;
+export default usePlatformEventListener;

package/dist/src/hooks/extensions/useExtendExtensionPoint.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Hook used by micro-frontend modules that want to "extend" an extension point defined by another MF module.
+ * For example to replace a React Component from the shell like the applications selector menu you would the following
+ *
+ *    useExtendExtensionPoint('@bluealba/pae-shell-ui', 'ApplicationSelector', MyComponent)
+ *
+ * Where the first parameter is the name of the source module you want to extend.
+ * The second parameter
+ */
+export declare const useExtendExtensionPoint: <T>(moduleName: string, extensionPointName: string, value: T) => void;
+export default useExtendExtensionPoint;

package/dist/src/hooks/extensions/useExtensionPoint.d.ts

@@ -0,0 +1,16 @@
+import { ElementType, ReactNode } from 'react';
+
+/**
+ * The value of this extension point is either
+ * - ElementType: a react component (functional or class)
+ * - ReactElement: a straight react virtual DOM in case you are plugin a children prop directly.
+ */
+type ExtensionPointValueType = ElementType | Exclude<ReactNode, undefined | null>;
+/**
+ * Resolves an extension point to any actual extension that might have been defined by another
+ * micro-frontend.
+ *
+ * This is one of the React APIs to the core pure JS PAE API @ExtensionPointsRegistry.
+ */
+export declare const useExtensionPoint: (extensionPointName: string) => ExtensionPointValueType | null;
+export default useExtensionPoint;

package/dist/src/hooks/habits/ApplicationEvent.d.ts

@@ -0,0 +1,4 @@
+export type ApplicationEvent = {
+    name: string;
+    data?: object;
+};

package/dist/src/hooks/habits/mapEvent.d.ts

@@ -0,0 +1,17 @@
+import { ModuleMetadata, AuthUserWithApplications } from '@bluealba/pae-core';
+import { ApplicationEvent } from './ApplicationEvent';
+
+/**
+ * Map an ApplicationEvent to a Habits expected Event input body.
+ * It full-fills all the contextual data (user, module, app)
+ */
+declare const mapEvent: (user: AuthUserWithApplications, module: ModuleMetadata) => (event: ApplicationEvent) => {
+    name: string;
+    data?: object;
+    timestamp: string;
+    module: string;
+    moduleVersion: string | undefined;
+    application: string | undefined;
+    user: string;
+};
+export default mapEvent;

package/dist/src/hooks/habits/trackEvents.d.ts

@@ -0,0 +1,9 @@
+import { ModuleMetadata, AuthUserWithApplications } from '@bluealba/pae-core';
+import { ServiceInvoker } from '../useServiceInvoker';
+import { ApplicationEvent } from './ApplicationEvent';
+
+/**
+ * Posts an array of application events to be tracked by PAE (habits).
+ */
+declare const trackEvents: (invoker: ServiceInvoker, user: AuthUserWithApplications, module: ModuleMetadata) => (events: ApplicationEvent[]) => Promise<void>;
+export default trackEvents;

package/dist/src/hooks/habits/useTrackEvent.d.ts

@@ -0,0 +1,5 @@
+export type TrackEventFn<D> = (name: string, data?: D) => Promise<void>;
+/**
+ * Shortcut for useTrackEvents() for a function to publish a single ApplicationEvent.
+ */
+export declare const useTrackEvent: <D extends object>() => TrackEventFn<D>;

package/dist/src/hooks/habits/useTrackEvents.d.ts

@@ -0,0 +1,9 @@
+export declare const HABITS_SERVICE_NAME = "@bluealba/pae-habits-service";
+/**
+ * Provides a function to publish PAE Habit ApplicationEvent's from the current module.
+ * If the module is associated with a PAE Application then it will be emitting application events.
+ * Otherwise they will be global events.
+ * This allows to publish many events in a single call. It is the most basic form of the hook.
+ * If you want a shortcut to publish a single event the use `useTrackEvent()` instead.
+ */
+export declare const useTrackEvents: () => (events: import('./ApplicationEvent').ApplicationEvent[]) => Promise<void>;

package/dist/src/hooks/habits/useTrackEvents.test.d.ts

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

package/dist/src/hooks/index.d.ts

@@ -0,0 +1,42 @@
+export { usePAEState } from './usePAEState';
+export { useCatalog } from './catalog/useCatalog';
+export { useMutableCatalog } from './catalog/useMutableCatalog';
+export { useLocation } from './routing/useLocation';
+export { useHasNoSession } from './useHasNoSession';
+export { useModuleMetadata } from './module/useModuleMetadata';
+export { useModuleConfig } from './module/useModuleConfig';
+export { useModule } from './module/useModule';
+export { useModuleConfigByName } from './module/useModuleConfigByName';
+export { useModuleCommonPaths } from './module/useModuleCommonPaths';
+export { useApplications } from './applications/useApplications';
+export { useUIApplications } from './useUIApplications';
+export { useApplicationUIModule } from './applications/useApplicationUIModule';
+export { useApplicationIcon } from './applications/useApplicationIcon';
+export { useApplicationMenu } from './applications/useApplicationMenu';
+export { useCurrentApplicationName } from './applications/useCurrentApplicationName';
+export { useApplicationJSModule } from './applications/useApplicationJSModule';
+export { useCurrentApplication } from './applications/useCurrentApplication';
+export { useCurrentJSModule } from './applications/useCurrentJSModule';
+export { type ApplicationMenu, type ApplicationMenuItem } from './applications/ApplicationMenu';
+export { type PlatformApplication } from './applications/PlatformApplication';
+export { useAuth } from './useAuth';
+export { useOperations } from './useOperations';
+export { useServiceInvoker, type ServiceInvoker } from './useServiceInvoker';
+export { useServiceBaseURL } from './useServiceBaseURL';
+export { useTrackEvent } from './habits/useTrackEvent';
+export { useTrackEvents } from './habits/useTrackEvents';
+export { type ApplicationEvent } from './habits/ApplicationEvent';
+export { useExtensionPoint } from './extensions/useExtensionPoint';
+export { useExtendExtensionPoint } from './extensions/useExtendExtensionPoint';
+export { usePlatformEventListener } from './events/usePlatformEventListener';
+export { useDynamicStyleSheet } from './customizations/useDynamicStyleSheet';
+export { useDynamicFonts } from './customizations/useDynamicFonts';
+export { usePlatformCustomization } from './customizations/usePlatformCustomization';
+export { usePAECustomizationsLoadingState } from './customizations/usePAECustomizationsLoadingState';
+export { useGetPlatformTheme } from './customizations/useGetPlatformTheme';
+export * from './customizations/utils';
+export { useNotifications } from './useNotifications';
+export { useResourceActions } from './commons/useResourceActions';
+export { useResource } from './commons/useResource';
+export { useTenants } from './tenants/useTenants';
+export { useUserState } from './userState/useUserState';

package/dist/src/hooks/module/useModule.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Gives access to the given module (by name) definition (aka ModuleMetadata)
+ * This uses the client-side catalog (see useCatalog)
+ */
+export declare const useModule: (name: string) => import('@bluealba/pae-core').ModuleMetadata;
+export default useModule;

package/dist/src/hooks/module/useModuleCommonPaths.d.ts

@@ -0,0 +1,9 @@
+import { ModuleMetadata } from '@bluealba/pae-core';
+
+export type UrlType = 'only-base-path' | 'with-module-base' | 'full-path';
+export declare const useModuleCommonPaths: (module: ModuleMetadata, type?: UrlType) => {
+    apiDocsPath: string | undefined;
+    healthPath: string | undefined;
+    versionPath: string | undefined;
+    changelogPath: string | undefined;
+};

package/dist/src/hooks/module/useModuleConfig.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns this module's custom props (aka configuration from the catalog -currently-).
+ */
+export declare const useModuleConfig: () => import('@bluealba/pae-core').ModuleProps;
+export default useModuleConfig;

package/dist/src/hooks/module/useModuleConfigByName.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the module's custom props (aka configuration from the catalog -currently-) using module name.
+ */
+export declare const useModuleConfigByName: (name: string) => import('@bluealba/pae-core').ModuleProps;
+export default useModuleConfigByName;

package/dist/src/hooks/module/useModuleMetadata.d.ts

@@ -0,0 +1,8 @@
+import { ModuleMetadata } from '@bluealba/pae-core';
+
+/**
+ * Provides access to the current module's metadata from the catalog.
+ * This is based on PAE microfrontend's context.
+ */
+export declare const useModuleMetadata: () => ModuleMetadata;
+export default useModuleMetadata;

package/dist/src/hooks/routing/useLocation.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the current location path.
+ * This can be replaced by a router framework but we want to keep it vanilla JS
+ * for start.
+ */
+export declare const useLocation: () => string;
+export default useLocation;

package/dist/src/hooks/tenants/constants.d.ts

@@ -0,0 +1,21 @@
+import { TenantClientSideMode, TenantConfig, TenantMode } from '@bluealba/pae-core';
+
+export declare const TENANT_MODES: {
+    readonly SINGLE_TENANT: "single-tenant";
+    readonly MULTI_TENANT: "multi-tenant";
+};
+export declare const CLIENT_SIDE_TENANT_MODES: {
+    readonly QUERY_PARAM: "queryParams";
+    readonly SESSION_STORAGE: "sessionStorage";
+    readonly COOKIE: "cookie";
+};
+export declare const TENANT_VISIBILITY: {
+    readonly RESTRICTED: "restricted";
+    readonly OPEN: "open";
+};
+export declare const TENANT_REQUEST_COOKIE_KEY = "tenant";
+export declare const TENANT_REQUEST_QUERY_KEY = "tenant";
+export declare const TENANT_SESSION_STORAGE_KEY = "tenant";
+export declare const DEFAULT_TENANT_MODE: TenantMode;
+export declare const DEFAULT_CLIENT_SIDE_TENANT_MODE: TenantClientSideMode;
+export declare const DEFAULT_TENANT_CONFIG: TenantConfig;

package/dist/src/hooks/tenants/getClientTenantStrategy.d.ts

@@ -0,0 +1,4 @@
+import { TenantConfig } from '@bluealba/pae-core';
+import { TenantStrategy } from './strategies/tenantStrategy.interface';
+
+export declare const getClientTenantStrategy: (tenantConfig: TenantConfig) => TenantStrategy;

package/dist/src/hooks/tenants/strategies/cookie.d.ts

@@ -0,0 +1,7 @@
+import { TenantStrategy } from './tenantStrategy.interface';
+import { Tenant, TenantConfig } from '@bluealba/pae-core';
+
+export declare class CookieStrategy implements TenantStrategy {
+    setTenant(tenant: Tenant, tenantConfig: TenantConfig): void;
+    getCurrentTenantName(): string | undefined;
+}

package/dist/src/hooks/tenants/strategies/queryParams.d.ts

@@ -0,0 +1,7 @@
+import { Tenant, TenantConfig } from '@bluealba/pae-core';
+import { TenantStrategy } from './tenantStrategy.interface';
+
+export declare class QueryParamStrategy implements TenantStrategy {
+    setTenant(tenant: Tenant, tenantConfig: TenantConfig): void;
+    getCurrentTenantName(): string | null;
+}

package/dist/src/hooks/tenants/strategies/sessionStorage.d.ts

@@ -0,0 +1,7 @@
+import { Tenant, TenantConfig } from '@bluealba/pae-core';
+import { TenantStrategy } from './tenantStrategy.interface';
+
+export declare class SessionStorageStrategy implements TenantStrategy {
+    setTenant(tenant: Tenant, tenantConfig: TenantConfig): void;
+    getCurrentTenantName(): string | null;
+}

package/dist/src/hooks/tenants/strategies/subdomain.d.ts

@@ -0,0 +1,9 @@
+import { Tenant, TenantConfig } from '@bluealba/pae-core';
+import { TenantStrategy } from './tenantStrategy.interface';
+
+export declare class SubdomainStrategy implements TenantStrategy {
+    private extractSubdomain;
+    private getBaseDomain;
+    setTenant(tenant: Tenant, tenantConfig: TenantConfig): void;
+    getCurrentTenantName(): string | null;
+}

package/dist/src/hooks/tenants/strategies/tenantStrategy.interface.d.ts

@@ -0,0 +1,6 @@
+import { Tenant, TenantConfig } from '@bluealba/pae-core';
+
+export interface TenantStrategy {
+    setTenant: (tenant: Tenant, tenantConfig: TenantConfig) => void;
+    getCurrentTenantName: () => string | undefined | null;
+}

package/dist/src/hooks/tenants/useTenants.d.ts

@@ -0,0 +1,8 @@
+import { Tenant, TenantConfig } from '@bluealba/pae-core';
+
+export declare const useTenants: () => {
+    tenants: Tenant[];
+    currentTenant: Tenant | undefined;
+    tenantConfig: TenantConfig;
+    selectTenant: (tenantName: string) => void;
+};

package/dist/src/hooks/useAppStatus.d.ts

@@ -0,0 +1,6 @@
+export declare function useAppStatus(appName: string): {
+    statusName: "NOT_LOADED" | "LOADING_SOURCE_CODE" | "NOT_BOOTSTRAPPED" | "BOOTSTRAPPING" | "NOT_MOUNTED" | "MOUNTING" | "MOUNTED" | "UNMOUNTING" | "UNLOADING" | "SKIP_BECAUSE_BROKEN" | "LOAD_ERROR";
+    isLoading: boolean;
+    isMounted: boolean;
+    isBroken: boolean;
+};

package/dist/src/hooks/useAppsState.d.ts

@@ -0,0 +1,18 @@
+/**
+- NOT_LOADED: app has been registered with single-spa but has not yet been loaded.
+- LOADING_SOURCE_CODE: app's source code is being fetched.
+- NOT_BOOTSTRAPPED: app has been loaded but not bootstrapped.
+- BOOTSTRAPPING: the bootstrap lifecycle function has been called but has not finished.
+- NOT_MOUNTED: app has been loaded and bootstrapped but not yet mounted.
+- MOUNTING: app is being mounted but not finished.
+- MOUNTED: app is currently active and is mounted to the DOM.
+- UNMOUNTING: app is currently being unmounted but has not finished.
+- UNLOADING: app is currently being unloaded but has not finished.
+- SKIP_BECAUSE_BROKEN: app threw an error during load, bootstrap, mount, or unmount and has been siloed because it is misbehaving and has been skipped. Other apps will continue on normally.
+- LOAD_ERROR: The app's loading function returned a promise that rejected. This is often due to a network error attempting to download the JavaScript bundle for the application. Single-spa will retry loading the application after the user navigates away from the current route and then comes back to it.
+ */
+type AppStatus = 'NOT_LOADED' | 'LOADING_SOURCE_CODE' | 'NOT_BOOTSTRAPPED' | 'BOOTSTRAPPING' | 'NOT_MOUNTED' | 'MOUNTING' | 'MOUNTED' | 'UNMOUNTING' | 'UNLOADING' | 'SKIP_BECAUSE_BROKEN' | 'LOAD_ERROR';
+interface AppsState extends Record<string, AppStatus> {
+}
+export declare function useAppsState(): AppsState;
+export {};

package/dist/src/hooks/useAuth.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Custom hook to provide authentication and authorization information.
+ *
+ * @returns An object containing:
+ * - `authUser`: The currently authenticated user.
+ * - `hasAccess`: A memoized function indicating access permissions based on authorized operations.
+ *
+ * @remarks
+ * This hook relies on `usePAEState` to retrieve the authenticated user and `useOperations` to determine authorized operations.
+ */
+export declare const useAuth: () => {
+    authUser: import('@bluealba/pae-core').AuthUserWithApplications;
+    hasAccess: (...operations: string[]) => boolean;
+};

package/dist/src/hooks/useAuth.test.d.ts

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

package/dist/src/hooks/useHasNoSession.d.ts

@@ -0,0 +1,2 @@
+export declare const useHasNoSession: () => boolean;
+export default useHasNoSession;

package/dist/src/hooks/useNotifications.d.ts

@@ -0,0 +1,4 @@
+export type NotificationType = 'success' | 'error' | 'warning' | 'info';
+export declare const useNotifications: () => {
+    notify: (message: string, type: NotificationType, error?: Error) => void;
+};

package/dist/src/hooks/useOperations.d.ts

@@ -0,0 +1 @@
+export declare const useOperations: () => import('@bluealba/pae-core').Operation[];

package/dist/src/hooks/usePAEState.d.ts

@@ -0,0 +1,7 @@
+import { PAEState } from '../types';
+
+/**
+ * Returns the PAE client state
+ */
+export declare const usePAEState: () => [PAEState, import('../utils/immutable').SetOrUpdateFn<PAEState>];
+export default usePAEState;

package/dist/src/hooks/useServiceBaseURL.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Given a serviceName it returns its baseURL resolved via the PAE Catalog.
+ * Fails if the service is unknown.
+ */
+export declare const useServiceBaseURL: (serviceName: string, skipThrow?: boolean) => string | null;
+export default useServiceBaseURL;

package/dist/src/hooks/useServiceInvoker.d.ts

@@ -0,0 +1,20 @@
+type RequestInit = Parameters<typeof fetch>[1];
+export type ServiceInvoker = (path: string, init?: RequestInit) => Promise<Response>;
+/**
+ * Returns a function that can be used to call a PAE service endpoint.
+ * It is (almost) fully compatible with the Fetch function.
+ * The only difference is that you don't need to provide the service's base path. Just any following path.
+ * For example instead of doing this
+ *
+ *    fetch('/my-service/items', { ... })
+ *
+ * You just need to do
+ *
+ *    invoker('/items', { ... })
+ *
+ * This abstracts the caller from knowing the base path of the service and instead we refer to services
+ * through their names. Since the baseURL is a gateway/routing configuration which might be dynamically
+ * changed in PAE Applications Catalog.
+ */
+export declare const useServiceInvoker: (serviceName: string, serviceBaseUrl?: string) => ServiceInvoker;
+export default useServiceInvoker;

package/dist/src/hooks/useServiceInvoker.test.d.ts

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

package/dist/src/hooks/useUIApplications.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Gives the list of PlatformApplication that have an UI module.
+ */
+export declare const useUIApplications: () => import('.').PlatformApplication[];
+export default useUIApplications;

package/dist/src/hooks/userState/UserState.d.ts

@@ -0,0 +1,7 @@
+export interface UserState<T = any> {
+    id: number;
+    user: string;
+    application: string;
+    name: string;
+    value: T;
+}

package/dist/src/hooks/userState/UserStateApiClient.d.ts

@@ -0,0 +1,9 @@
+import { ServiceInvoker } from '../useServiceInvoker';
+import { UserState } from './UserState';
+
+export declare class UserStateApiClient {
+    static get<T extends UserState>(invoker: ServiceInvoker, application: string, name: string): Promise<T | null>;
+    static create<T extends UserState>(invoker: ServiceInvoker, application: string, name: string, value: T["value"]): Promise<T>;
+    static update<T extends UserState>(invoker: ServiceInvoker, application: string, name: string, value: T["value"]): Promise<T>;
+    static delete(invoker: ServiceInvoker, application: string, name: string): Promise<null>;
+}

package/dist/src/hooks/userState/useUserState.d.ts

@@ -0,0 +1,24 @@
+export type UserStateOperationParams<T> = {
+    newValue?: T;
+    shouldThrowError?: boolean;
+};
+export type UserStateHook<T> = {
+    value: T | null;
+    loading: boolean;
+    error: null;
+    hasFetched: boolean;
+    setValue: (newValue: T, shouldThrowError?: boolean) => Promise<T | null>;
+    createValue: (params?: UserStateOperationParams<T>) => Promise<T | null>;
+    updateValue: (params?: UserStateOperationParams<T>) => Promise<T | null>;
+    deleteValue: (params?: Pick<UserStateOperationParams<T>, "shouldThrowError">) => Promise<T | null>;
+};
+/**
+ * Provides UserState management with automatic persistence.
+ *
+ * **Primary Usage**: This hook exposes `value` and `setValue` properties that just works like `useState`,
+ * but automatically persist changes to the UserState server-side, handling all API calls behind the scenes.
+ *
+ * **Secondary Usage**: For advanced scenarios, explicit CRUD methods (`createValue`, `updateValue`,
+ * `deleteValue`) are available when you need precise control over which API operation to perform.
+ */
+export declare const useUserState: <T>(name: string) => UserStateHook<T>;

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+
+export type { ModuleMetadata, AuthUser, AuthUserWithApplications, BaseUser } from '@bluealba/pae-core';
+export * from './core';
+export * from './hooks';
+export * from './hocs';
+export * from './utils';
+export * from './components';
+export * from './components/common';
+export { default as initializeMicroFrontend } from './utils/initializeMicroFrontend';
+export * from './MicrofrontendProps';
+export { setupTestEnvironment } from './test-utils/setupTestEnvironment';

package/dist/src/model/ModuleMetadata.d.ts

@@ -0,0 +1,6 @@
+import { ModuleMetadata } from '@bluealba/pae-core';
+import { PlatformApplication } from '../hooks';
+
+export declare const isUIModule: (module: ModuleMetadata) => boolean;
+export declare const isShellUIModule: (module: ModuleMetadata) => boolean;
+export declare const isUIApplication: (app: PlatformApplication) => boolean | "" | undefined;

package/dist/src/test-utils/setupTestEnvironment.d.ts

@@ -0,0 +1,15 @@
+import { getGlobalState } from '../getGlobalState';
+
+/**
+ * Recursively make all properties of T optional
+ * https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript
+ */
+type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object | undefined ? RecursivePartial<T[P]> : T[P];
+};
+interface GlobalState extends ReturnType<typeof getGlobalState> {
+}
+interface GlobalStateOverrides extends RecursivePartial<GlobalState> {
+}
+export declare const setupTestEnvironment: (overrides?: GlobalStateOverrides) => void;
+export {};

package/dist/src/types.d.ts

@@ -0,0 +1,37 @@
+// TODO: these types are repeated between pae-ui-react-core and orchestrator's main.ts
+
+import { BehaviorSubject, Subject } from "rxjs";
+import type {
+  AuthUserWithApplications,
+  ModuleMetadata,
+  ExtensionPointsRegistry,
+  AuthenticationConfig,
+  Tenant,
+  TenantConfig,
+} from '@bluealba/pae-core';
+
+import { EXTENSION_POINTS_REGISTRY, GLOBAL_REACTIVE_STATE_KEY, PAE_CUSTOMIZATIONS_LOADING_STATE_KEY, PAE_GLOBAL_STATE_KEY } from './constants';
+
+export type PAEReactiveState = Subject<PAEState>;
+
+export type PAEState = {
+  authUser: AuthUserWithApplications;
+  catalog: ModuleMetadata[];
+  authentication: AuthenticationConfig;
+  tenants?: Tenant[];
+  currentTenant?: Tenant;
+  tenantConfig?: TenantConfig;
+  platformVersion: string;
+}
+
+export type PAECustomizationsLoadingState = BehaviorSubject<boolean | undefined>;
+
+
+declare global {
+  interface Window {
+    [PAE_GLOBAL_STATE_KEY]: PAEState;
+    [GLOBAL_REACTIVE_STATE_KEY]: PAEReactiveState;
+    [EXTENSION_POINTS_REGISTRY]: ExtensionPointsRegistry;
+    [PAE_CUSTOMIZATIONS_LOADING_STATE_KEY]: PAECustomizationsLoadingState;
+  }
+}

package/dist/src/utils/Request.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a new RequestInit which contains the original data + the given headers appended.
+ * Pure function
+ */
+export declare const appendHeadersToRequestInit: (init: RequestInit, headersToAppend: Record<string, string>) => RequestInit;
+export declare const appendHeaderToHeadersInit: (headers: HeadersInit, headersToAppend: Record<string, string>) => HeadersInit;
+export declare const isHeadersObjectInstance: (headers: HeadersInit) => boolean;

package/dist/src/utils/URL.d.ts

@@ -0,0 +1,6 @@
+export declare const requestInfoToURL: (info: RequestInfo | URL) => URL;
+/**
+ * Tells whether the given url string is a relative one (iex /blah)
+ * or an absolute one (http://example.com)
+ */
+export declare const isRelativeURL: (url: string | URL) => boolean;

package/dist/src/utils/alphaColor.d.ts

@@ -0,0 +1 @@
+export declare const alphaColor: (color: string, alpha: number) => string;

package/dist/src/utils/createRootComponent.d.ts

@@ -0,0 +1,9 @@
+import { FC } from 'react';
+import { RootComponentProps } from '../MicrofrontendProps';
+
+/**
+ * Creates the root component. Wrapping the MF's root component with a PAEModule
+ * in charge of setting the context for the module.
+ */
+declare const createRootComponent: <T extends RootComponentProps>(BaseRootComponent: FC<T>) => (props: T) => import("react/jsx-runtime").JSX.Element;
+export default createRootComponent;

package/dist/src/utils/fonts.d.ts

@@ -0,0 +1,5 @@
+export declare const getPathExtension: (path: string) => string | undefined;
+/**
+ * Given a file path to a font it resolves the CSS format field/value.
+ */
+export declare const fontFormat: (path: string, format?: string) => string;

package/dist/src/utils/getApplicationUIModule.d.ts

@@ -0,0 +1,10 @@
+import { ModuleMetadata } from '@bluealba/pae-core';
+
+/**
+ * Returns UI module of a particular application
+ */
+export declare const getApplicationUIModule: (applicationName: string) => ModuleMetadata | undefined;
+/**
+ * Returns UI module from a list of modules
+ */
+export declare const getUIModule: (modules?: ModuleMetadata[]) => ModuleMetadata | undefined;

package/dist/src/utils/getApplications.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns all authorized applications that have the user logged in.
+ */
+export declare const getApplications: () => import('@bluealba/pae-core').ApplicationWithOperations[];

package/dist/src/utils/getOperations.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Given a current application it returns the allowed operations for the current user scoped
+ * to that application plus the global ones.
+ */
+export declare const getOperations: (currentAppName?: string) => import('@bluealba/pae-core').Operation[];

package/dist/src/utils/hasAccess.d.ts

@@ -0,0 +1,8 @@
+import { Operation } from '@bluealba/pae-core';
+
+/**
+ * Given a list of user authorized (allowed) operations it returns a new function
+ * that can be used to check for operations.
+ */
+export declare const hasAccess: (authorizedOperations: Operation[]) => (...operations: string[]) => boolean;
+export default hasAccess;

package/dist/src/utils/immutable.d.ts

@@ -0,0 +1,18 @@
+export type Updater<T> = ((current: T) => T);
+export type SetOrUpdateParam<T> = T | Updater<T>;
+export type SetOrUpdateFn<T> = (valueOfUpdater: SetOrUpdateParam<T>) => void;
+/**
+ * Given an index and a transforming function it updates the given list/array by changing
+ * the element at that position with the transformation function. Returning a new list.
+ * See https://ramdajs.com/docs/#adjust for reference
+ */
+export declare const adjust: <T>(index: number, mapper: (e: T) => T, list: T[]) => T[];
+/**
+ * NEW
+ * similar to adjust but instead of passing and index you pass a predicate to find the element to update
+ */
+export declare const adjustOne: <T>(pred: (e: T) => boolean, mapper: (e: T) => T, list: T[]) => T[];
+/**
+ * Useful to implement setters that either receive a value or a transform function.
+ */
+export declare const getOrCompute: <T>(valueOrFn: SetOrUpdateParam<T>, current: T) => T;