@egen-civitas/esm-extensions 1.0.0

package/README.md

@@ -0,0 +1,4 @@
+# egen-esm-extensions
+
+`egen-esm-extensions` connects Extensions with Extension Slots.
+It is part of the Egen Frontend [Extension System](https://github.com/egen-civitas/egen-rfc-frontend/pull/27/files).

package/dist/extensions.d.ts

@@ -0,0 +1,92 @@
+/** @module @category Extension */
+import { type AssignedExtension, type ExtensionInternalStore, type ExtensionRegistration, type ExtensionSlotCustomState } from './store.js';
+/**
+ * Given an extension ID, which is a string uniquely identifying
+ * an instance of an extension within an extension slot, this
+ * returns the extension name.
+ *
+ * @example
+ * ```js
+ * getExtensionNameFromId("foo#bar")
+ *  --> "foo"
+ * getExtensionNameFromId("baz")
+ *  --> "baz"
+ * ```
+ */
+export declare function getExtensionNameFromId(extensionId: string): string;
+export declare function getExtensionRegistrationFrom(state: ExtensionInternalStore, extensionId: string): ExtensionRegistration | undefined;
+export declare function getExtensionRegistration(extensionId: string): ExtensionRegistration | undefined;
+/**
+ * Extensions must be registered in order to be rendered.
+ * This is handled by the app shell, when extensions are provided
+ * via the `routes.json` file and registered through `registerApp()`.
+ * @internal
+ */
+export declare const registerExtension: (extensionRegistration: ExtensionRegistration) => void;
+/**
+ * Attach an extension to an extension slot.
+ *
+ * This will cause the extension to be rendered into the specified
+ * extension slot, unless it is removed by configuration. Using
+ * `attach` is an alternative to specifying the `slot` or `slots`
+ * in the extension declaration.
+ *
+ * It is particularly useful when creating a slot into which
+ * you want to render an existing extension. This enables you
+ * to do so without modifying the extension's declaration, which
+ * may be impractical or inappropriate, for example if you are
+ * writing a module for a specific implementation.
+ *
+ * @param slotName a name uniquely identifying the slot
+ * @param extensionId an extension name, with an optional #-suffix
+ *    to distinguish it from other instances of the same extension
+ *    attached to the same slot.
+ */
+export declare function attach(slotName: string, extensionId: string): void;
+/**
+ * Detaches an extension from an extension slot.
+ *
+ * @param extensionSlotName The name of the extension slot to detach from.
+ * @param extensionId The ID of the extension to detach.
+ *
+ * @deprecated Avoid using this. Extension attachments should be considered declarative.
+ */
+export declare function detach(extensionSlotName: string, extensionId: string): void;
+/**
+ * Detaches all extensions from an extension slot.
+ *
+ * @param extensionSlotName The name of the extension slot to clear.
+ *
+ * @deprecated Avoid using this. Extension attachments should be considered declarative.
+ */
+export declare function detachAll(extensionSlotName: string): void;
+/**
+ * Gets the list of extensions assigned to a given slot
+ *
+ * @param slotName The slot to load the assigned extensions for
+ * @returns An array of extensions assigned to the named slot
+ */
+export declare function getAssignedExtensions(slotName: string): Array<AssignedExtension>;
+/**
+ * Used by by extension slots at mount time.
+ *
+ * @param moduleName The name of the module that contains the extension slot
+ * @param slotName The extension slot name that is actually used
+ * @param state Optional custom state for the slot, which will be stored in the extension store.
+ * @internal
+ */
+export declare const registerExtensionSlot: (moduleName: string, slotName: string, state?: ExtensionSlotCustomState) => void;
+/**
+ * Used by extension slots to update the copy of the state for the extension slot
+ *
+ * @param slotName The name of the slot with state to update
+ * @param state A copy of the new state
+ * @param partial Whether this should be applied as a partial
+ */
+export declare function updateExtensionSlotState(slotName: string, state: ExtensionSlotCustomState, partial?: boolean): void;
+/**
+ * @internal
+ * Just for testing.
+ */
+export declare const reset: () => void;
+//# sourceMappingURL=extensions.d.ts.map

package/dist/extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAAA,kCAAkC;AA4BlC,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAM9B,MAAM,YAAY,CAAC;AAsHpB;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,UAGzD;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,sBAAsB,EAC7B,WAAW,EAAE,MAAM,GAClB,qBAAqB,GAAG,SAAS,CAGnC;AAED,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAG/F;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAAC,qBAAqB,EAAE,qBAAqB,KAAK,IAO9E,CAAC;AAEL;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QA4B3D;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,iBAAiB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,QAmBpE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,iBAAiB,EAAE,MAAM,QAmBlD;AAqHD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAoBhF;AAwBD;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,wBAAwB,KAAK,IA2C5G,CAAC;AAEL;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,wBAAwB,EAAE,OAAO,GAAE,OAAe,QAcnH;AAED;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,MAAM,IAMtB,CAAC"}

package/dist/extensions.js

@@ -0,0 +1,394 @@
+/** @module @category Extension */ /*
+ * We have the following extension modes:
+ *
+ * - attached (set via code in form of: attach, detach, ...)
+ * - configured (set via configuration in form of: added, removed, ...)
+ * - assigned (computed from attached and configured)
+ * - connected (computed from assigned using connectivity and online / offline)
+ */ import { sessionStore, userHasAccess } from "@egen-civitas/esm-api";
+import { getExtensionConfigFromExtensionSlotStore, getExtensionConfigFromStore, getExtensionSlotConfig, getExtensionSlotConfigFromStore, getExtensionSlotsConfigStore, getExtensionsConfigStore } from "@egen-civitas/esm-config";
+import { evaluateAsBoolean } from "@egen-civitas/esm-expression-evaluator";
+import { featureFlagsStore } from "@egen-civitas/esm-feature-flags";
+import { subscribeConnectivityChanged } from "@egen-civitas/esm-globals";
+import { isOnline as isOnlineFn } from "@egen-civitas/esm-utils";
+import { isEqual, merge } from "lodash-es";
+import { checkStatusFor } from "./helpers.js";
+import { getExtensionInternalStore, getExtensionStore, updateInternalExtensionStore } from "./store.js";
+const extensionInternalStore = getExtensionInternalStore();
+const extensionStore = getExtensionStore();
+const slotsConfigStore = getExtensionSlotsConfigStore();
+const extensionsConfigStore = getExtensionsConfigStore();
+// Keep the output store updated
+function updateExtensionOutputStore(internalState, extensionSlotConfigs, extensionsConfigStore, featureFlagStore, sessionStore) {
+    const slots = {};
+    const isOnline = isOnlineFn();
+    const enabledFeatureFlags = Object.entries(featureFlagStore.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);
+    for (let [slotName, slot] of Object.entries(internalState.slots)){
+        const { config } = getExtensionSlotConfigFromStore(extensionSlotConfigs, slot.name);
+        const assignedExtensions = getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionsConfigStore, enabledFeatureFlags, isOnline, sessionStore.session);
+        slots[slotName] = {
+            moduleName: slot.moduleName,
+            assignedExtensions
+        };
+    }
+    if (!isEqual(extensionStore.getState().slots, slots)) {
+        extensionStore.setState({
+            slots
+        });
+    }
+}
+extensionInternalStore.subscribe((internalStore)=>{
+    updateExtensionOutputStore(internalStore, slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState());
+});
+slotsConfigStore.subscribe((slotConfigs)=>{
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotConfigs, extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState());
+});
+extensionsConfigStore.subscribe((extensionConfigs)=>{
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionConfigs, featureFlagsStore.getState(), sessionStore.getState());
+});
+featureFlagsStore.subscribe((featureFlagStore)=>{
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagStore, sessionStore.getState());
+});
+sessionStore.subscribe((session)=>{
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), session);
+});
+function updateOutputStoreToCurrent() {
+    updateExtensionOutputStore(extensionInternalStore.getState(), slotsConfigStore.getState(), extensionsConfigStore.getState(), featureFlagsStore.getState(), sessionStore.getState());
+}
+updateOutputStoreToCurrent();
+subscribeConnectivityChanged(updateOutputStoreToCurrent);
+function createNewExtensionSlotInfo(slotName, moduleName, state) {
+    return {
+        moduleName,
+        name: slotName,
+        attachedIds: [],
+        config: null,
+        state
+    };
+}
+/**
+ * Given an extension ID, which is a string uniquely identifying
+ * an instance of an extension within an extension slot, this
+ * returns the extension name.
+ *
+ * @example
+ * ```js
+ * getExtensionNameFromId("foo#bar")
+ *  --> "foo"
+ * getExtensionNameFromId("baz")
+ *  --> "baz"
+ * ```
+ */ export function getExtensionNameFromId(extensionId) {
+    const [extensionName] = extensionId.split('#');
+    return extensionName;
+}
+export function getExtensionRegistrationFrom(state, extensionId) {
+    const name = getExtensionNameFromId(extensionId);
+    return state.extensions[name];
+}
+export function getExtensionRegistration(extensionId) {
+    const state = extensionInternalStore.getState();
+    return getExtensionRegistrationFrom(state, extensionId);
+}
+/**
+ * Extensions must be registered in order to be rendered.
+ * This is handled by the app shell, when extensions are provided
+ * via the `routes.json` file and registered through `registerApp()`.
+ * @internal
+ */ export const registerExtension = (extensionRegistration)=>extensionInternalStore.setState((state)=>{
+        state.extensions[extensionRegistration.name] = {
+            ...extensionRegistration,
+            instances: []
+        };
+        return state;
+    });
+/**
+ * Attach an extension to an extension slot.
+ *
+ * This will cause the extension to be rendered into the specified
+ * extension slot, unless it is removed by configuration. Using
+ * `attach` is an alternative to specifying the `slot` or `slots`
+ * in the extension declaration.
+ *
+ * It is particularly useful when creating a slot into which
+ * you want to render an existing extension. This enables you
+ * to do so without modifying the extension's declaration, which
+ * may be impractical or inappropriate, for example if you are
+ * writing a module for a specific implementation.
+ *
+ * @param slotName a name uniquely identifying the slot
+ * @param extensionId an extension name, with an optional #-suffix
+ *    to distinguish it from other instances of the same extension
+ *    attached to the same slot.
+ */ export function attach(slotName, extensionId) {
+    updateInternalExtensionStore((state)=>{
+        const existingSlot = state.slots[slotName];
+        if (!existingSlot) {
+            return {
+                ...state,
+                slots: {
+                    ...state.slots,
+                    [slotName]: {
+                        ...createNewExtensionSlotInfo(slotName),
+                        attachedIds: [
+                            extensionId
+                        ]
+                    }
+                }
+            };
+        } else {
+            return {
+                ...state,
+                slots: {
+                    ...state.slots,
+                    [slotName]: {
+                        ...existingSlot,
+                        attachedIds: [
+                            ...existingSlot.attachedIds,
+                            extensionId
+                        ]
+                    }
+                }
+            };
+        }
+    });
+}
+/**
+ * Detaches an extension from an extension slot.
+ *
+ * @param extensionSlotName The name of the extension slot to detach from.
+ * @param extensionId The ID of the extension to detach.
+ *
+ * @deprecated Avoid using this. Extension attachments should be considered declarative.
+ */ export function detach(extensionSlotName, extensionId) {
+    updateInternalExtensionStore((state)=>{
+        const existingSlot = state.slots[extensionSlotName];
+        if (existingSlot && existingSlot.attachedIds.includes(extensionId)) {
+            return {
+                ...state,
+                slots: {
+                    ...state.slots,
+                    [extensionSlotName]: {
+                        ...existingSlot,
+                        attachedIds: existingSlot.attachedIds.filter((id)=>id !== extensionId)
+                    }
+                }
+            };
+        } else {
+            return state;
+        }
+    });
+}
+/**
+ * Detaches all extensions from an extension slot.
+ *
+ * @param extensionSlotName The name of the extension slot to clear.
+ *
+ * @deprecated Avoid using this. Extension attachments should be considered declarative.
+ */ export function detachAll(extensionSlotName) {
+    updateInternalExtensionStore((state)=>{
+        const existingSlot = state.slots[extensionSlotName];
+        if (existingSlot) {
+            return {
+                ...state,
+                slots: {
+                    ...state.slots,
+                    [extensionSlotName]: {
+                        ...existingSlot,
+                        attachedIds: []
+                    }
+                }
+            };
+        } else {
+            return state;
+        }
+    });
+}
+/**
+ * Get an order index for the extension. This will
+ * come from either its configured order, its registered order
+ * parameter, or the order in which it happened to be attached.
+ */ function getOrder(extensionId, configuredOrder, registeredOrderIndex, attachedOrder) {
+    const configuredIndex = configuredOrder.indexOf(extensionId);
+    if (configuredIndex !== -1) {
+        return configuredIndex;
+    } else if (registeredOrderIndex !== undefined) {
+        // extensions that don't have a configured order should appear after those that do
+        return 1000 + registeredOrderIndex;
+    } else {
+        const assignedIndex = attachedOrder.indexOf(extensionId);
+        if (assignedIndex !== -1) {
+            // extensions that have neither a configured nor registered order should appear
+            // after all others
+            return 2000 + assignedIndex;
+        } else {
+            return -1;
+        }
+    }
+}
+function getAssignedExtensionsFromSlotData(slotName, internalState, config, extensionConfigStoreState, enabledFeatureFlags, isOnline, session) {
+    const attachedIds = internalState.slots[slotName].attachedIds;
+    const assignedIds = calculateAssignedIds(config, attachedIds);
+    const extensions = [];
+    // Create context once for all extensions in this slot
+    const slotState = internalState.slots[slotName]?.state;
+    const expressionContext = slotState && typeof slotState === 'object' ? {
+        session,
+        ...slotState
+    } : {
+        session
+    };
+    for (let id of assignedIds){
+        const { config: rawExtensionConfig } = getExtensionConfigFromStore(extensionConfigStoreState, slotName, id);
+        const rawExtensionSlotExtensionConfig = getExtensionConfigFromExtensionSlotStore(config, slotName, id);
+        const extensionConfig = merge(rawExtensionConfig, rawExtensionSlotExtensionConfig);
+        const name = getExtensionNameFromId(id);
+        const extension = internalState.extensions[name];
+        // if the extension has not been registered yet, do not include it
+        if (extension) {
+            const requiredPrivileges = extensionConfig?.['Display conditions']?.privileges ?? extension.privileges ?? [];
+            if (requiredPrivileges && (typeof requiredPrivileges === 'string' || Array.isArray(requiredPrivileges) && requiredPrivileges.length > 0)) {
+                if (!session?.user) {
+                    continue;
+                }
+                if (!userHasAccess(requiredPrivileges, session.user)) {
+                    continue;
+                }
+            }
+            const displayConditionExpression = extensionConfig?.['Display conditions']?.expression || extension.displayExpression;
+            if (displayConditionExpression !== undefined && typeof displayConditionExpression === 'string' && displayConditionExpression.trim().length > 0) {
+                try {
+                    if (!evaluateAsBoolean(displayConditionExpression, expressionContext)) {
+                        continue;
+                    }
+                } catch (e) {
+                    console.error(`Error while evaluating expression '${displayConditionExpression}' for extension ${name} in slot ${slotName}`, e);
+                    continue;
+                }
+            }
+            if (extension.featureFlag && !enabledFeatureFlags.includes(extension.featureFlag)) {
+                continue;
+            }
+            if (window.offlineEnabled && !checkStatusFor(isOnline, extension.online, extension.offline)) {
+                continue;
+            }
+            extensions.push({
+                id,
+                name,
+                moduleName: extension.moduleName,
+                config: extensionConfig,
+                featureFlag: extension.featureFlag,
+                meta: extension.meta,
+                online: extensionConfig?.['Display conditions']?.online ?? extension.online ?? true,
+                offline: extensionConfig?.['Display conditions']?.offline ?? extension.offline ?? false
+            });
+        }
+    }
+    return extensions;
+}
+/**
+ * Gets the list of extensions assigned to a given slot
+ *
+ * @param slotName The slot to load the assigned extensions for
+ * @returns An array of extensions assigned to the named slot
+ */ export function getAssignedExtensions(slotName) {
+    const internalState = extensionInternalStore.getState();
+    const { config: slotConfig } = getExtensionSlotConfig(slotName);
+    const extensionStoreState = extensionsConfigStore.getState();
+    const featureFlagState = featureFlagsStore.getState();
+    const sessionState = sessionStore.getState();
+    const isOnline = isOnlineFn();
+    const enabledFeatureFlags = Object.entries(featureFlagState.flags).filter(([, { enabled }])=>enabled).map(([name])=>name);
+    return getAssignedExtensionsFromSlotData(slotName, internalState, slotConfig, extensionStoreState, enabledFeatureFlags, isOnline, sessionState.session);
+}
+function calculateAssignedIds(config, attachedIds) {
+    const addedIds = config.add || [];
+    const removedIds = config.remove || [];
+    const idOrder = config.order || [];
+    const { extensions } = extensionInternalStore.getState();
+    return [
+        ...attachedIds,
+        ...addedIds
+    ].filter((id)=>!removedIds.includes(id)).sort((idA, idB)=>{
+        const ai = getOrder(idA, idOrder, extensions[getExtensionNameFromId(idA)]?.order, attachedIds);
+        const bi = getOrder(idB, idOrder, extensions[getExtensionNameFromId(idB)]?.order, attachedIds);
+        if (bi === -1) {
+            return -1;
+        } else if (ai === -1) {
+            return 1;
+        } else {
+            return ai - bi;
+        }
+    });
+}
+/**
+ * Used by by extension slots at mount time.
+ *
+ * @param moduleName The name of the module that contains the extension slot
+ * @param slotName The extension slot name that is actually used
+ * @param state Optional custom state for the slot, which will be stored in the extension store.
+ * @internal
+ */ export const registerExtensionSlot = (moduleName, slotName, state)=>extensionInternalStore.setState((currentState)=>{
+        const existingModuleName = currentState.slots[slotName]?.moduleName;
+        if (existingModuleName && existingModuleName != moduleName) {
+            console.warn(`An extension slot with the name '${slotName}' already exists. Refusing to register the same slot name twice (in "registerExtensionSlot"). The existing one is from module ${existingModuleName}.`);
+            return currentState;
+        }
+        if (existingModuleName && existingModuleName == moduleName) {
+            // Re-rendering an existing slot
+            return currentState;
+        }
+        if (currentState.slots[slotName]) {
+            return {
+                ...currentState,
+                slots: {
+                    ...currentState.slots,
+                    [slotName]: {
+                        ...currentState.slots[slotName],
+                        moduleName,
+                        state
+                    }
+                }
+            };
+        }
+        const slot = createNewExtensionSlotInfo(slotName, moduleName, state);
+        return {
+            ...currentState,
+            slots: {
+                ...currentState.slots,
+                [slotName]: {
+                    ...slot
+                }
+            }
+        };
+    });
+/**
+ * Used by extension slots to update the copy of the state for the extension slot
+ *
+ * @param slotName The name of the slot with state to update
+ * @param state A copy of the new state
+ * @param partial Whether this should be applied as a partial
+ */ export function updateExtensionSlotState(slotName, state, partial = false) {
+    extensionInternalStore.setState((currentState)=>{
+        const newState = partial ? merge(currentState.slots[slotName].state, state) : state;
+        return {
+            ...currentState,
+            slots: {
+                ...currentState.slots,
+                [slotName]: {
+                    ...currentState.slots[slotName],
+                    state: newState
+                }
+            }
+        };
+    });
+}
+/**
+ * @internal
+ * Just for testing.
+ */ export const reset = ()=>extensionStore.setState(()=>{
+        return {
+            slots: {},
+            extensions: {}
+        };
+    });

package/dist/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function checkStatus(online?: boolean | object, offline?: boolean | object): boolean;
+export declare function checkStatusFor(status: boolean, online?: boolean | object, offline?: boolean | object): boolean;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,MAAM,GAAE,OAAO,GAAG,MAAa,EAAE,OAAO,GAAE,OAAO,GAAG,MAAc,WAE7F;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,GAAE,OAAO,GAAG,MAAa,EAAE,OAAO,GAAE,OAAO,GAAG,MAAc,WAEjH"}

package/dist/helpers.js

@@ -0,0 +1,7 @@
+import { isOnline } from "@egen-civitas/esm-utils";
+export function checkStatus(online = true, offline = false) {
+    return checkStatusFor(isOnline(), online, offline);
+}
+export function checkStatusFor(status, online = true, offline = false) {
+    return Boolean(status ? online : offline);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './extensions.js';
+export * from './helpers.js';
+export * from './left-nav.js';
+export * from './modals.js';
+export * from './workspaces.js';
+export * from './workspaces2.js';
+export * from './render.js';
+export * from './store.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./extensions.js";
+export * from "./helpers.js";
+export * from "./left-nav.js";
+export * from "./modals.js";
+export * from "./workspaces.js";
+export * from "./workspaces2.js";
+export * from "./render.js";
+export * from "./store.js";
+export * from "./types.js";

package/dist/left-nav.d.ts

@@ -0,0 +1,38 @@
+import { type ComponentConfig } from './types.js';
+import { type ExtensionSlotState } from './store.js';
+type LeftNavMode = 'normal' | 'collapsed' | 'hidden';
+export interface LeftNavStore {
+    slotName: string | null;
+    basePath: string;
+    mode: LeftNavMode;
+    componentContext?: ComponentConfig;
+    state?: ExtensionSlotState;
+}
+/** @internal */
+export declare const leftNavStore: import("zustand").StoreApi<LeftNavStore>;
+export interface SetLeftNavParams {
+    name: string;
+    basePath: string;
+    /**
+     * In normal mode, the left nav is shown in desktop mode, and collapse into hamburger menu button in tablet mode
+     * In collapsed mode, the left nav is always collapsed, regardless of desktop / tablet mode.
+     * In hidden mode, the left nav is not shown at all.
+     */
+    mode?: LeftNavMode;
+    componentContext?: ComponentConfig;
+    state?: ExtensionSlotState;
+}
+/**
+ * Sets the current left nav context. Must be paired with {@link unsetLeftNav}.
+ *
+ * @deprecated Please use {@link useLeftNav} instead. This function will be made internal in a future release.
+ */
+export declare function setLeftNav({ name, basePath, mode, componentContext, state }: SetLeftNavParams): void;
+/**
+ * Unsets the left nav context if the current context is for the supplied name.
+ *
+ * @deprecated Please use {@link useLeftNav} instead. This function will be made internal in a future release.
+ */
+export declare function unsetLeftNav(name: string): void;
+export {};
+//# sourceMappingURL=left-nav.d.ts.map

package/dist/left-nav.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"left-nav.d.ts","sourceRoot":"","sources":["../src/left-nav.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,KAAK,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;AACrD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,WAAW,CAAC;IAClB,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAED,gBAAgB;AAChB,eAAO,MAAM,YAAY,0CAIvB,CAAC;AAEH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,EAAE,gBAAgB,QAE7F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,QAIxC"}

package/dist/left-nav.js

@@ -0,0 +1,28 @@
+import { createGlobalStore } from "@egen-civitas/esm-state";
+/** @internal */ export const leftNavStore = createGlobalStore('left-nav', {
+    slotName: null,
+    basePath: window.spaBase,
+    mode: 'normal'
+});
+/**
+ * Sets the current left nav context. Must be paired with {@link unsetLeftNav}.
+ *
+ * @deprecated Please use {@link useLeftNav} instead. This function will be made internal in a future release.
+ */ export function setLeftNav({ name, basePath, mode, componentContext, state }) {
+    leftNavStore.setState({
+        slotName: name,
+        basePath,
+        mode: mode ?? 'normal',
+        componentContext,
+        state
+    });
+}
+/**
+ * Unsets the left nav context if the current context is for the supplied name.
+ *
+ * @deprecated Please use {@link useLeftNav} instead. This function will be made internal in a future release.
+ */ export function unsetLeftNav(name) {
+    if (leftNavStore.getState().slotName === name) {
+        leftNavStore.setState(leftNavStore.getInitialState(), true);
+    }
+}

package/dist/modals.d.ts

@@ -0,0 +1,12 @@
+import { type LifeCycles } from 'single-spa';
+/** @internal */
+export interface ModalRegistration {
+    name: string;
+    load(): Promise<LifeCycles>;
+    moduleName: string;
+}
+/** @internal */
+export declare function registerModal(modalRegistration: ModalRegistration): void;
+/** @internal */
+export declare function getModalRegistration(modalName: string): ModalRegistration | undefined;
+//# sourceMappingURL=modals.d.ts.map

package/dist/modals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modals.d.ts","sourceRoot":"","sources":["../src/modals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAI7C,gBAAgB;AAChB,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB;AAWD,gBAAgB;AAChB,wBAAgB,aAAa,CAAC,iBAAiB,EAAE,iBAAiB,QAKjE;AAED,gBAAgB;AAChB,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAkBrF"}

package/dist/modals.js

@@ -0,0 +1,28 @@
+import { createGlobalStore } from "@egen-civitas/esm-state";
+import { getExtensionRegistration } from "./index.js";
+const modalRegistryStore = createGlobalStore('modalRegistry', {
+    modals: {}
+});
+/** @internal */ export function registerModal(modalRegistration) {
+    modalRegistryStore.setState((state)=>{
+        state.modals[modalRegistration.name] = modalRegistration;
+        return state;
+    });
+}
+/** @internal */ export function getModalRegistration(modalName) {
+    let modalRegistration = modalRegistryStore.getState().modals[modalName];
+    if (!modalRegistration) {
+        const extensionRegistration = getExtensionRegistration(modalName);
+        if (extensionRegistration) {
+            modalRegistration = {
+                name: modalName,
+                load: extensionRegistration.load,
+                moduleName: extensionRegistration.moduleName
+            };
+            console.warn(`Modal ${modalName} was registered as an extension. This is deprecated and will be removed in the future. Please register it in the "modals" section of routes.json instead of the "extensions" section.`);
+            // Register it so the warning only appears once
+            registerModal(modalRegistration);
+        }
+    }
+    return modalRegistration;
+}

package/dist/public.d.ts

@@ -0,0 +1,7 @@
+export { getExtensionNameFromId, registerExtension, attach, detach, detachAll, getAssignedExtensions, registerExtensionSlot, } from './extensions.js';
+export { type LeftNavStore, setLeftNav, unsetLeftNav, type SetLeftNavParams } from './left-nav.js';
+export { type CancelLoading, renderExtension } from './render.js';
+export { type ExtensionMeta, type ExtensionRegistration, type ExtensionStore, type AssignedExtension, type ConnectedExtension, type ExtensionSlotState, getExtensionStore, } from './store.js';
+export { type WorkspaceRegistration } from './workspaces.js';
+export { type ExtensionData, type ComponentConfig } from './types.js';
+//# sourceMappingURL=public.d.ts.map

package/dist/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../src/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,MAAM,EACN,MAAM,EACN,SAAS,EACT,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACnG,OAAO,EAAE,KAAK,aAAa,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC"}