@egen-civitas/esm-extensions 1.0.0

package/dist/public.js

@@ -0,0 +1,4 @@
+export { getExtensionNameFromId, registerExtension, attach, detach, detachAll, getAssignedExtensions, registerExtensionSlot } from "./extensions.js";
+export { setLeftNav, unsetLeftNav } from "./left-nav.js";
+export { renderExtension } from "./render.js";
+export { getExtensionStore } from "./store.js";

package/dist/render.d.ts

@@ -0,0 +1,12 @@
+/** @module @category Extension */
+import { type Parcel, type ParcelConfig } from 'single-spa';
+export interface CancelLoading {
+    (): void;
+}
+/**
+ * Mounts into a DOM node (representing an extension slot)
+ * a lazy-loaded component from *any* frontend module
+ * that registered an extension component for this slot.
+ */
+export declare function renderExtension(domElement: HTMLElement, extensionSlotName: string, extensionSlotModuleName: string, extensionId: string, renderFunction?: (application: ParcelConfig) => ParcelConfig, additionalProps?: Record<string, any>): Promise<Parcel | null>;
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,OAAO,EAAmB,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAK7E,MAAM,WAAW,aAAa;IAC5B,IAAI,IAAI,CAAC;CACV;AAID;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,WAAW,EACvB,iBAAiB,EAAE,MAAM,EACzB,uBAAuB,EAAE,MAAM,EAC/B,WAAW,EAAE,MAAM,EACnB,cAAc,GAAE,CAAC,WAAW,EAAE,YAAY,KAAK,YAAuB,EACtE,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GACxC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAyDxB"}

package/dist/render.js

@@ -0,0 +1,62 @@
+/** @module @category Extension */ import { mountRootParcel } from "single-spa";
+import { getExtensionNameFromId, getExtensionRegistration } from "./extensions.js";
+import { checkStatus } from "./helpers.js";
+import { updateInternalExtensionStore } from "./store.js";
+let parcelCount = 0;
+/**
+ * Mounts into a DOM node (representing an extension slot)
+ * a lazy-loaded component from *any* frontend module
+ * that registered an extension component for this slot.
+ */ export async function renderExtension(domElement, extensionSlotName, extensionSlotModuleName, extensionId, renderFunction = (x)=>x, additionalProps = {}) {
+    const extensionName = getExtensionNameFromId(extensionId);
+    const extensionRegistration = getExtensionRegistration(extensionId);
+    let parcel = null;
+    if (domElement) {
+        if (!extensionRegistration) {
+            throw Error(`Couldn't find extension '${extensionName}' to attach to '${extensionSlotName}'`);
+        }
+        const { meta, moduleName, online, offline, load } = extensionRegistration;
+        if (checkStatus(online, offline)) {
+            updateInternalExtensionStore((state)=>{
+                const instance = {
+                    domElement,
+                    id: extensionId,
+                    slotName: extensionSlotName,
+                    slotModuleName: extensionSlotModuleName
+                };
+                return {
+                    ...state,
+                    extensions: {
+                        ...state.extensions,
+                        [extensionName]: {
+                            ...state.extensions[extensionName],
+                            instances: [
+                                ...state.extensions[extensionName].instances,
+                                instance
+                            ]
+                        }
+                    }
+                };
+            });
+            const lifecycle = await load();
+            const id = parcelCount++;
+            parcel = mountRootParcel(renderFunction({
+                ...lifecycle,
+                name: `${extensionSlotName}/${extensionName}-${id}`
+            }), {
+                ...additionalProps,
+                _meta: meta,
+                _extensionContext: {
+                    extensionId,
+                    extensionSlotName,
+                    extensionSlotModuleName,
+                    extensionModuleName: moduleName
+                },
+                domElement
+            });
+        }
+    } else {
+        console.warn(`Tried to render ${extensionId} into ${extensionSlotName} but no DOM element was available.`);
+    }
+    return parcel;
+}

package/dist/store.d.ts

@@ -0,0 +1,97 @@
+import type { ConfigObject, ExtensionSlotConfig } from '@egen-civitas/esm-config';
+import { type LifeCycles } from 'single-spa';
+export interface ExtensionMeta {
+    [_: string]: any;
+}
+export interface ExtensionRegistration {
+    readonly name: string;
+    load(): Promise<LifeCycles>;
+    readonly moduleName: string;
+    readonly meta: Readonly<ExtensionMeta>;
+    readonly order?: number;
+    readonly online?: boolean;
+    readonly offline?: boolean;
+    readonly privileges?: string | Array<string>;
+    readonly featureFlag?: string;
+    readonly displayExpression?: string;
+}
+export interface ExtensionInfo extends ExtensionRegistration {
+    /**
+     * The instances where the extension has been rendered using `renderExtension`.
+     */
+    instances: Array<ExtensionInstance>;
+}
+export interface ExtensionInstance {
+    id: string;
+    slotName: string;
+    slotModuleName: string;
+}
+export interface ExtensionInternalStore {
+    /** Slots indexed by name */
+    slots: Record<string, ExtensionSlotInfo>;
+    /** Extensions indexed by name */
+    extensions: Record<string, ExtensionInfo>;
+}
+export type ExtensionSlotCustomState = Record<string | symbol | number, unknown> | undefined | null;
+export interface ExtensionSlotInfo {
+    /**
+     * The module in which the extension slot exists. Undefined if the slot
+     * hasn't been registered yet (but it has been attached or assigned to
+     * an extension.
+     */
+    moduleName?: string;
+    /** The name under which the extension slot has been registered. */
+    name: string;
+    /**
+     * The set of extension IDs which have been attached to this slot using `attach`.
+     * However, not all of these extension IDs should be rendered.
+     * `assignedIds` is the set defining those.
+     */
+    attachedIds: Array<string>;
+    /** The configuration provided for this slot. `null` if not yet loaded. */
+    config: Omit<ExtensionSlotConfig, 'configuration'> | null;
+    state?: ExtensionSlotCustomState;
+}
+export interface ExtensionStore {
+    slots: Record<string, ExtensionSlotState>;
+}
+export interface ExtensionSlotState {
+    moduleName?: string;
+    assignedExtensions: Array<AssignedExtension>;
+    state?: ExtensionSlotCustomState;
+}
+export interface AssignedExtension {
+    readonly id: string;
+    readonly name: string;
+    readonly moduleName: string;
+    readonly meta: Readonly<ExtensionMeta>;
+    /** The extension's config. Note that this will be `null` until the slot is mounted. */
+    readonly config: Readonly<ConfigObject> | null;
+    readonly online?: boolean | object;
+    readonly offline?: boolean | object;
+    readonly featureFlag?: string;
+}
+/** @deprecated replaced with AssignedExtension */
+export interface ConnectedExtension {
+    readonly id: string;
+    readonly name: string;
+    readonly moduleName: string;
+    readonly meta: Readonly<ExtensionMeta>;
+    /** The extension's config. Note that this will be `null` until the slot is mounted. */
+    readonly config: Readonly<ConfigObject> | null;
+}
+/**
+ * This gets the extension system's internal store. It is subject
+ * to change radically and without warning. It should not be used
+ * outside esm-core.
+ * @internal
+ */
+export declare const getExtensionInternalStore: () => import("zustand").StoreApi<ExtensionInternalStore>;
+/** @internal */
+export declare function updateInternalExtensionStore(updater: (state: ExtensionInternalStore) => ExtensionInternalStore): void;
+/**
+ * This returns a store that modules can use to get information about the
+ * state of the extension system.
+ */
+export declare const getExtensionStore: () => import("zustand").StoreApi<ExtensionStore>;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"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"}

package/dist/store.js

@@ -0,0 +1,54 @@
+/** @module @category Extension */ import { isEqual } from "lodash-es";
+import { configExtensionStore } from "@egen-civitas/esm-config";
+import { createGlobalStore, getGlobalStore } from "@egen-civitas/esm-state";
+const extensionInternalStore = createGlobalStore('extensionsInternal', {
+    slots: {},
+    extensions: {}
+});
+/**
+ * This gets the extension system's internal store. It is subject
+ * to change radically and without warning. It should not be used
+ * outside esm-core.
+ * @internal
+ */ export const getExtensionInternalStore = ()=>getGlobalStore('extensionsInternal', {
+        slots: {},
+        extensions: {}
+    });
+/** @internal */ export function updateInternalExtensionStore(updater) {
+    // This is a function that updates the internal extension store.
+    const state = extensionInternalStore.getState();
+    const newState = updater(state);
+    if (newState !== state) {
+        extensionInternalStore.setState(newState);
+    }
+}
+/**
+ * This returns a store that modules can use to get information about the
+ * state of the extension system.
+ */ export const getExtensionStore = ()=>getGlobalStore('extensions', {
+        slots: {}
+    });
+/**
+ * esm-config maintains its own store of the extension information it needs
+ * to generate extension configs. We keep it updated based on what's in
+ * `extensionStore`.
+ */ updateConfigExtensionStore(extensionInternalStore.getState());
+extensionInternalStore.subscribe(updateConfigExtensionStore);
+function updateConfigExtensionStore(extensionState) {
+    const configExtensionRecords = [];
+    for (let extensionInfo of Object.values(extensionState.extensions)){
+        for (let instance of extensionInfo.instances){
+            configExtensionRecords.push({
+                slotModuleName: instance.slotModuleName,
+                extensionModuleName: extensionInfo.moduleName,
+                slotName: instance.slotName,
+                extensionId: instance.id
+            });
+        }
+    }
+    if (!isEqual(configExtensionStore.getState().mountedExtensions, configExtensionRecords)) {
+        configExtensionStore.setState({
+            mountedExtensions: configExtensionRecords
+        });
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+export interface ExtensionData {
+    extensionSlotName: string;
+    extensionSlotModuleName: string;
+    extensionId: string;
+}
+export interface ComponentConfig {
+    moduleName: string;
+    featureName: string;
+    extension?: ExtensionData;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,uBAAuB,EAAE,MAAM,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B"}

package/dist/types.js

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

package/dist/workspaces.d.ts

@@ -0,0 +1,61 @@
+import { type ReactNode } from 'react';
+import { type LifeCycles } from 'single-spa';
+import { type WorkspaceGroupDefinition, type WorkspaceWindowState } from '@egen-civitas/esm-globals';
+/** See [[WorkspaceDefinition]] for more information about these properties */
+export interface WorkspaceRegistration {
+    name: string;
+    title: string;
+    titleNode?: ReactNode;
+    type: string;
+    canHide: boolean;
+    canMaximize: boolean;
+    width: 'narrow' | 'wider' | 'extra-wide';
+    preferredWindowSize: WorkspaceWindowState;
+    load(): Promise<LifeCycles>;
+    moduleName: string;
+    groups: Array<string>;
+}
+export type WorkspaceGroupRegistration = WorkspaceGroupDefinition & {
+    members: Array<string>;
+};
+/** See [[WorkspaceDefinition]] for more information about these properties */
+export interface RegisterWorkspaceOptions {
+    name: string;
+    title: string;
+    type?: string;
+    canHide?: boolean;
+    canMaximize?: boolean;
+    width?: 'narrow' | 'wider' | 'extra-wide';
+    preferredWindowSize?: WorkspaceWindowState;
+    component: string;
+    moduleName: string;
+    groups?: Array<string>;
+    load(): Promise<LifeCycles>;
+}
+/**
+ * Tells the workspace system about a workspace. This is used by the app shell
+ * to register workspaces defined in the `routes.json` file.
+ * @internal
+ */
+export declare function registerWorkspace(workspace: RegisterWorkspaceOptions): void;
+/**
+ * Tells the workspace system about a workspace group. This is used by the app shell
+ * to register workspace groups defined in the `routes.json` file.
+ * @internal
+ */
+export declare function registerWorkspaceGroup(workspaceGroup: WorkspaceGroupRegistration): void;
+/**
+ * This exists for compatibility with the old way of registering
+ * workspaces (as extensions).
+ *
+ * @param name of the workspace
+ */
+export declare function getWorkspaceRegistration(name: string): WorkspaceRegistration;
+/**
+ * This provides the workspace group registration and is also compatible with the
+ * old way of registering workspace groups (as extensions), but isn't recommended.
+ *
+ * @param name of the workspace
+ */
+export declare function getWorkspaceGroupRegistration(name: string): WorkspaceGroupRegistration;
+//# sourceMappingURL=workspaces.d.ts.map

package/dist/workspaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.d.ts","sourceRoot":"","sources":["../src/workspaces.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,KAAK,wBAAwB,EAAE,KAAK,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAKrG,8EAA8E;AAC9E,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,KAAK,EAAE,QAAQ,GAAG,OAAO,GAAG,YAAY,CAAC;IACzC,mBAAmB,EAAE,oBAAoB,CAAC;IAC1C,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACvB;AAED,MAAM,MAAM,0BAA0B,GAAG,wBAAwB,GAAG;IAClE,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACxB,CAAC;AAkBF,8EAA8E;AAC9E,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,YAAY,CAAC;IAC1C,mBAAmB,CAAC,EAAE,oBAAoB,CAAC;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB,IAAI,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,wBAAwB,QAgBpE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,cAAc,EAAE,0BAA0B,QA4BhF;AAGD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CA6B5E;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,0BAA0B,CAOtF"}

package/dist/workspaces.js

@@ -0,0 +1,122 @@
+import { getExtensionRegistration } from "./index.js";
+import { createGlobalStore } from "@egen-civitas/esm-state";
+import { translateFrom } from "@egen-civitas/esm-translations";
+const workspaceRegistrationStore = createGlobalStore('workspaceRegistrations', {
+    workspaces: {}
+});
+const workspaceGroupStore = createGlobalStore('workspaceGroups', {
+    workspaceGroups: {}
+});
+/**
+ * Tells the workspace system about a workspace. This is used by the app shell
+ * to register workspaces defined in the `routes.json` file.
+ * @internal
+ */ export function registerWorkspace(workspace) {
+    workspaceRegistrationStore.setState((state)=>({
+            workspaces: {
+                ...state.workspaces,
+                [workspace.name]: {
+                    ...workspace,
+                    load: workspace.load,
+                    preferredWindowSize: workspace.preferredWindowSize ?? 'normal',
+                    type: workspace.type ?? 'form',
+                    canHide: workspace.canHide ?? false,
+                    canMaximize: workspace.canMaximize ?? false,
+                    width: workspace.width ?? 'narrow',
+                    groups: workspace.groups ?? []
+                }
+            }
+        }));
+}
+/**
+ * Tells the workspace system about a workspace group. This is used by the app shell
+ * to register workspace groups defined in the `routes.json` file.
+ * @internal
+ */ export function registerWorkspaceGroup(workspaceGroup) {
+    workspaceGroupStore.setState((state)=>{
+        const group = state.workspaceGroups[workspaceGroup.name];
+        if (group) {
+            // This condition occurs when a workspace with a `groups` property is registered before
+            // the corresponding workspace group. In such cases, the workspace group is registered
+            // by the `attachWorkspaceToGroup` function.
+            return {
+                workspaceGroups: {
+                    ...state.workspaceGroups,
+                    [workspaceGroup.name]: {
+                        ...group,
+                        members: Array.from(new Set([
+                            ...group.members,
+                            ...workspaceGroup.members
+                        ]))
+                    }
+                }
+            };
+        } else {
+            return {
+                workspaceGroups: {
+                    ...state.workspaceGroups,
+                    [workspaceGroup.name]: {
+                        name: workspaceGroup.name,
+                        members: workspaceGroup.members
+                    }
+                }
+            };
+        }
+    });
+}
+const workspaceExtensionWarningsIssued = new Set();
+/**
+ * This exists for compatibility with the old way of registering
+ * workspaces (as extensions).
+ *
+ * @param name of the workspace
+ */ export function getWorkspaceRegistration(name) {
+    const registeredWorkspaces = workspaceRegistrationStore.getState().workspaces;
+    if (registeredWorkspaces[name]) {
+        return registeredWorkspaces[name];
+    } else {
+        const workspaceExtension = getExtensionRegistration(name);
+        if (workspaceExtension) {
+            if (!workspaceExtensionWarningsIssued.has(name)) {
+                console.warn(`The workspace '${name}' is registered as an extension. This is deprecated. Please register it in the "workspaces" section of the routes.json file.`);
+                workspaceExtensionWarningsIssued.add(name);
+            }
+            return {
+                name: workspaceExtension.name,
+                title: getTitleFromExtension(workspaceExtension),
+                moduleName: workspaceExtension.moduleName,
+                preferredWindowSize: workspaceExtension.meta?.screenSize ?? 'normal',
+                load: workspaceExtension.load,
+                type: workspaceExtension.meta?.type ?? 'form',
+                canHide: workspaceExtension.meta?.canHide ?? false,
+                canMaximize: workspaceExtension.meta?.canMaximize ?? false,
+                width: workspaceExtension.meta?.width ?? 'narrow',
+                groups: workspaceExtension.meta?.groups ?? []
+            };
+        } else {
+            throw new Error(`No workspace named '${name}' has been registered.`);
+        }
+    }
+}
+/**
+ * This provides the workspace group registration and is also compatible with the
+ * old way of registering workspace groups (as extensions), but isn't recommended.
+ *
+ * @param name of the workspace
+ */ export function getWorkspaceGroupRegistration(name) {
+    const registeredWorkspaces = workspaceGroupStore.getState().workspaceGroups;
+    if (registeredWorkspaces[name]) {
+        return registeredWorkspaces[name];
+    } else {
+        throw new Error(`No workspace group named '${name}' has been registered.`);
+    }
+}
+function getTitleFromExtension(ext) {
+    const title = ext?.meta?.title;
+    if (typeof title === 'string') {
+        return title;
+    } else if (title && typeof title === 'object') {
+        return translateFrom(ext.moduleName, title.key, title.default);
+    }
+    return ext.name;
+}

package/dist/workspaces2.d.ts

@@ -0,0 +1,61 @@
+import { type WorkspaceDefinition2, type WorkspaceGroupDefinition2, type WorkspaceWindowDefinition2 } from '@egen-civitas/esm-globals';
+export interface OpenedWorkspace {
+    workspaceName: string;
+    props: Record<string, any> | null;
+    hasUnsavedChanges: boolean;
+    /** Unique identifier for the workspace instance, used to track unique instances of the same workspace */
+    uuid: string;
+}
+export interface OpenedWindow {
+    windowName: string;
+    /** Root workspace at index 0, child workspaces follow */
+    openedWorkspaces: Array<OpenedWorkspace>;
+    props: Record<string, any> | null;
+    maximized: boolean;
+}
+export interface OpenedGroup {
+    groupName: string;
+    props: Record<string, any> | null;
+}
+export interface WorkspaceStoreState2 {
+    registeredGroupsByName: Record<string, WorkspaceGroupDefinition2 & {
+        moduleName: string;
+    }>;
+    registeredWindowsByName: Record<string, WorkspaceWindowDefinition2 & {
+        moduleName: string;
+    }>;
+    registeredWorkspacesByName: Record<string, WorkspaceDefinition2 & {
+        moduleName: string;
+    }>;
+    openedGroup: OpenedGroup | null;
+    /** Most recently opened window at the end of array. Each element has a unique windowName */
+    openedWindows: Array<OpenedWindow>;
+    /**
+     * While there can be multiple openedWindows, only the most recently opened window can be
+     * toggled shown or hidden, the rest are implicitly hidden.
+     **/
+    isMostRecentlyOpenedWindowHidden: boolean;
+    workspaceTitleByWorkspaceName: Record<string, string>;
+}
+export declare const workspace2Store: import("zustand").StoreApi<WorkspaceStoreState2>;
+/**
+ * Given a workspace name, return the window that the workspace belongs to
+ * @param workspaceName
+ * @returns
+ */
+export declare function getWindowByWorkspaceName(workspaceName: string): WorkspaceWindowDefinition2 & {
+    moduleName: string;
+};
+/**
+ * Given a window name, return the group that the window belongs to
+ * @param windowName
+ * @returns
+ */
+export declare function getGroupByWindowName(windowName: string): WorkspaceGroupDefinition2 & {
+    moduleName: string;
+};
+export declare function getOpenedWindowIndexByWorkspace(workspaceName: string): number;
+export declare function registerWorkspaceGroups2(appName: string, workspaceGroupDefs: Array<WorkspaceGroupDefinition2>): void;
+export declare function registerWorkspaceWindows2(appName: string, workspaceWindowDefs: Array<WorkspaceWindowDefinition2>): void;
+export declare function registerWorkspaces2(moduleName: string, workspaceDefs: Array<WorkspaceDefinition2>): void;
+//# sourceMappingURL=workspaces2.d.ts.map

package/dist/workspaces2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces2.d.ts","sourceRoot":"","sources":["../src/workspaces2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAChC,MAAM,2BAA2B,CAAC;AAGnC,MAAM,WAAW,eAAe;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IAClC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,yGAAyG;IACzG,IAAI,EAAE,MAAM,CAAC;CACd;AACD,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IACzC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;CACnC;AACD,MAAM,WAAW,oBAAoB;IACnC,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3F,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,0BAA0B,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7F,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1F,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,4FAA4F;IAC5F,aAAa,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;IAEnC;;;QAGI;IACJ,gCAAgC,EAAE,OAAO,CAAC;IAE1C,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvD;AAYD,eAAO,MAAM,eAAe,kDAAsE,CAAC;AAEnG;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,EAAE,MAAM;gBAhCuB,MAAM;EA6C1F;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM;gBArD4B,MAAM;EAkExF;AAED,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,MAAM,UAKpE;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,KAAK,CAAC,yBAAyB,CAAC,QAgB7G;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,mBAAmB,EAAE,KAAK,CAAC,0BAA0B,CAAC,QAiBhH;AAED,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,oBAAoB,CAAC,QAiBjG"}

package/dist/workspaces2.js

@@ -0,0 +1,116 @@
+import { createGlobalStore } from "@egen-civitas/esm-state";
+const initialState = {
+    registeredGroupsByName: {},
+    registeredWindowsByName: {},
+    registeredWorkspacesByName: {},
+    openedGroup: null,
+    openedWindows: [],
+    workspaceTitleByWorkspaceName: {},
+    isMostRecentlyOpenedWindowHidden: false
+};
+export const workspace2Store = createGlobalStore('workspace2', initialState);
+/**
+ * Given a workspace name, return the window that the workspace belongs to
+ * @param workspaceName
+ * @returns
+ */ export function getWindowByWorkspaceName(workspaceName) {
+    const { registeredWorkspacesByName, registeredWindowsByName } = workspace2Store.getState();
+    const workspace = registeredWorkspacesByName[workspaceName];
+    if (!workspace) {
+        throw new Error(`No workspace found with name: ${workspaceName}`);
+    } else {
+        const workspaceWindow = registeredWindowsByName[workspace.window];
+        if (!workspaceWindow) {
+            throw new Error(`No workspace window found with name: ${workspace.window} for workspace: ${workspaceName}`);
+        } else {
+            return workspaceWindow;
+        }
+    }
+}
+/**
+ * Given a window name, return the group that the window belongs to
+ * @param windowName
+ * @returns
+ */ export function getGroupByWindowName(windowName) {
+    const { registeredGroupsByName, registeredWindowsByName } = workspace2Store.getState();
+    const workspaceWindow = registeredWindowsByName[windowName];
+    if (!workspaceWindow) {
+        throw new Error(`No workspace window found with name: ${windowName}`);
+    } else {
+        const group = registeredGroupsByName[workspaceWindow.group];
+        if (!group) {
+            throw new Error(`No workspace group found with name: ${workspaceWindow.group} for window: ${windowName}`);
+        } else {
+            return group;
+        }
+    }
+}
+export function getOpenedWindowIndexByWorkspace(workspaceName) {
+    const { openedWindows } = workspace2Store.getState();
+    return openedWindows.findIndex((a)=>a.openedWorkspaces.find((openedWorkspace)=>openedWorkspace.workspaceName === workspaceName));
+}
+export function registerWorkspaceGroups2(appName, workspaceGroupDefs) {
+    if (workspaceGroupDefs.length == 0) {
+        return;
+    }
+    const { registeredGroupsByName } = workspace2Store.getState();
+    const newRegisteredGroupsByName = {
+        ...registeredGroupsByName
+    };
+    for (const workspaceGroupDef of workspaceGroupDefs){
+        if (newRegisteredGroupsByName[workspaceGroupDef.name]) {
+            throw new Error(`Cannot register workspace group ${workspaceGroupDef.name} more than once`);
+        }
+        newRegisteredGroupsByName[workspaceGroupDef.name] = {
+            ...workspaceGroupDef,
+            moduleName: appName
+        };
+    }
+    workspace2Store.setState({
+        registeredGroupsByName: newRegisteredGroupsByName
+    });
+}
+export function registerWorkspaceWindows2(appName, workspaceWindowDefs) {
+    if (workspaceWindowDefs.length == 0) {
+        return;
+    }
+    const { registeredWindowsByName } = workspace2Store.getState();
+    const newRegisteredWindowsByName = {
+        ...registeredWindowsByName
+    };
+    for (const windowDef of workspaceWindowDefs){
+        if (newRegisteredWindowsByName[windowDef.name]) {
+            throw new Error(`Cannot register workspace window ${windowDef.name} more than once`);
+        }
+        const registeredWindowDef = {
+            ...windowDef,
+            moduleName: appName
+        };
+        newRegisteredWindowsByName[windowDef.name] = registeredWindowDef;
+    }
+    workspace2Store.setState({
+        registeredWindowsByName: newRegisteredWindowsByName
+    });
+}
+export function registerWorkspaces2(moduleName, workspaceDefs) {
+    if (workspaceDefs.length == 0) {
+        return;
+    }
+    const { registeredWorkspacesByName } = workspace2Store.getState();
+    const newRegisteredWorkspacesByName = {
+        ...registeredWorkspacesByName
+    };
+    for (const workspaceDef of workspaceDefs){
+        if (newRegisteredWorkspacesByName[workspaceDef.name]) {
+            throw new Error(`Cannot register workspace ${workspaceDef.name} more than once`);
+        }
+        const workspaceDefWithLoader = {
+            ...workspaceDef,
+            moduleName
+        };
+        newRegisteredWorkspacesByName[workspaceDef.name] = workspaceDefWithLoader;
+    }
+    workspace2Store.setState({
+        registeredWorkspacesByName: newRegisteredWorkspacesByName
+    });
+}

package/mock-jest.ts

@@ -0,0 +1,31 @@
+import { getGlobalStore } from '@egen-civitas/esm-state/mock';
+
+export const attach = jest.fn();
+export const detach = jest.fn();
+export const detachAll = jest.fn();
+
+export const switchTo = jest.fn();
+
+export const getExtensionStore = () => getGlobalStore('extensions', { slots: {} });
+
+export const getExtensionInternalStore = () =>
+  getGlobalStore('extensions-internal', {
+    slots: {},
+    extensions: {},
+  });
+
+const mockExtensionRegistry = {};
+
+export const getExtensionRegistration = jest.fn((name) => {
+  return mockExtensionRegistry[name];
+});
+
+export const registerExtension = jest.fn((ext) => {
+  mockExtensionRegistry[ext.name] = ext;
+});
+
+export function clearMockExtensionRegistry() {
+  Object.keys(mockExtensionRegistry).forEach((key) => {
+    delete mockExtensionRegistry[key];
+  });
+}