@openmrs/esm-extensions 6.3.1-pre.2965 → 6.3.1-pre.2997

package/dist/store.d.ts

@@ -0,0 +1,94 @@
+import type { ConfigObject, ExtensionSlotConfigObject } from '@openmrs/esm-config';
+import { type LifeCycles } from 'single-spa';
+export interface ExtensionMeta {
+    [_: string]: any;
+}
+export interface ExtensionRegistration {
+    readonly name: string;
+    load(): Promise<{
+        default?: LifeCycles;
+    } & 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;
+}
+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 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: ExtensionSlotConfigObject | null;
+}
+export interface ExtensionStore {
+    slots: Record<string, ExtensionSlotState>;
+}
+export interface ExtensionSlotState {
+    moduleName?: string;
+    assignedExtensions: Array<AssignedExtension>;
+}
+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>;

package/dist/store.js

@@ -0,0 +1,53 @@
+/** @module @category Extension */ import { isEqual } from "lodash-es";
+import { configExtensionStore } from "@openmrs/esm-config";
+import { createGlobalStore, getGlobalStore } from "@openmrs/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) {
+    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/workspaces.d.ts

@@ -0,0 +1,63 @@
+import { type ReactNode } from 'react';
+import { type LifeCycles } from 'single-spa';
+import { type WorkspaceGroupDefinition, type WorkspaceWindowState } from '@openmrs/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<{
+        default?: LifeCycles;
+    } & 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;
+    load: () => Promise<{
+        default?: LifeCycles;
+    } & LifeCycles>;
+    moduleName: string;
+    groups?: Array<string>;
+}
+/**
+ * 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 compatibile 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;

package/dist/workspaces.js

@@ -0,0 +1,121 @@
+import { getExtensionRegistration } from "./index.js";
+import { createGlobalStore } from "@openmrs/esm-state";
+import { translateFrom } from "@openmrs/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,
+                    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 compatibile 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/mock-jest.ts

@@ -0,0 +1,31 @@
+import { getGlobalStore } from '@openmrs/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];
+  });
+}

package/mock.ts

@@ -1,10 +1,12 @@
+import { vi } from 'vitest';
 import { getGlobalStore } from '@openmrs/esm-state/mock';
+import { type WorkspaceGroupRegistration, type WorkspaceRegistration } from '.';
 
-export const attach = jest.fn();
-export const detach = jest.fn();
-export const detachAll = jest.fn();
+export const attach = vi.fn();
+export const detach = vi.fn();
+export const detachAll = vi.fn();
 
-export const switchTo = jest.fn();
+export const switchTo = vi.fn();
 
 export const getExtensionStore = () => getGlobalStore('extensions', { slots: {} });
 
@@ -16,11 +18,11 @@ export const getExtensionInternalStore = () =>
 
 const mockExtensionRegistry = {};
 
-export const getExtensionRegistration = jest.fn((name) => {
+export const getExtensionRegistration = vi.fn((name) => {
   return mockExtensionRegistry[name];
 });
 
-export const registerExtension = jest.fn((ext) => {
+export const registerExtension = vi.fn((ext) => {
   mockExtensionRegistry[ext.name] = ext;
 });
 

package/package.json

@@ -1,18 +1,32 @@
 {
   "name": "@openmrs/esm-extensions",
-  "version": "6.3.1-pre.2965",
+  "version": "6.3.1-pre.2997",
   "license": "MPL-2.0",
   "description": "Coordinates extensions and extension points in the OpenMRS Frontend",
-  "browser": "dist/openmrs-esm-extensions.js",
-  "main": "src/index.ts",
+  "type": "module",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./src/public": {
+      "types": "./src/public.ts",
+      "default": "./dist/public.js"
+    },
+    "./mock": {
+      "import": "./mock.ts",
+      "require": "./mock-jest.ts"
+    }
+  },
   "source": true,
   "scripts": {
-    "test": "cross-env TZ=UTC jest --config jest.config.js --verbose false --passWithNoTests --color",
-    "test:watch": "cross-env TZ=UTC jest --watch --config jest.config.js --color",
-    "build": "webpack --mode=production",
-    "build:development": "webpack --mode development",
-    "analyze": "webpack --mode=production --env analyze=true",
-    "typescript": "tsc",
+    "test": "cross-env TZ=UTC vitest run --passWithNoTests",
+    "test:watch": "cross-env TZ=UTC vitest watch --passWithNoTests",
+    "build": "rimraf dist && concurrently \"swc --strip-leading-paths src -d dist\" \"tsc --project tsconfig.build.json\"",
+    "build:development": "rimraf dist && concurrently \"swc --strip-leading-paths src -d dist\" \"tsc --project tsconfig.build.json\"",
+    "typescript": "tsc --project tsconfig.build.json",
     "lint": "eslint src --ext ts,tsx"
   },
   "keywords": [
@@ -37,6 +51,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "lodash-es": "^4.17.21"
+  },
   "peerDependencies": {
     "@openmrs/esm-api": "6.x",
     "@openmrs/esm-config": "6.x",
@@ -47,16 +64,20 @@
     "single-spa": "6.x"
   },
   "devDependencies": {
-    "@openmrs/esm-api": "6.3.1-pre.2965",
-    "@openmrs/esm-config": "6.3.1-pre.2965",
-    "@openmrs/esm-expression-evaluator": "6.3.1-pre.2965",
-    "@openmrs/esm-feature-flags": "6.3.1-pre.2965",
-    "@openmrs/esm-state": "6.3.1-pre.2965",
-    "@openmrs/esm-utils": "6.3.1-pre.2965",
-    "single-spa": "^6.0.3"
-  },
-  "dependencies": {
-    "lodash-es": "^4.17.21"
+    "@openmrs/esm-api": "6.3.1-pre.2997",
+    "@openmrs/esm-config": "6.3.1-pre.2997",
+    "@openmrs/esm-expression-evaluator": "6.3.1-pre.2997",
+    "@openmrs/esm-feature-flags": "6.3.1-pre.2997",
+    "@openmrs/esm-state": "6.3.1-pre.2997",
+    "@openmrs/esm-utils": "6.3.1-pre.2997",
+    "@swc/cli": "^0.7.7",
+    "@swc/core": "^1.11.29",
+    "concurrently": "^9.1.2",
+    "cross-env": "^7.0.3",
+    "happy-dom": "^17.4.7",
+    "rimraf": "^6.0.1",
+    "single-spa": "^6.0.3",
+    "vitest": "^3.1.4"
   },
   "stableVersion": "6.3.0"
 }

package/src/extensions.test.ts

@@ -1,7 +1,8 @@
+import { describe, expect, it, vi } from 'vitest';
 import { createGlobalStore } from '@openmrs/esm-state';
 import { attach, registerExtensionSlot } from './extensions';
 
-jest.mock('@openmrs/esm-api', () => ({
+vi.mock('@openmrs/esm-api', () => ({
   sessionStore: createGlobalStore('mock-session-store', {
     loaded: false,
     session: null,

package/src/modals.ts

@@ -1,6 +1,6 @@
-import { getExtensionRegistration } from '@openmrs/esm-extensions';
 import { createGlobalStore } from '@openmrs/esm-state';
 import type { LifeCycles } from 'single-spa';
+import { getExtensionRegistration } from '.';
 
 /** @internal */
 export interface ModalRegistration {

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "compilerOptions": {
+    "declarationDir": "dist",
+    "emitDeclarationOnly": true
+  },
+  "extends": "./tsconfig.json",
+  "exclude": ["**/*.test.*", "**/setup-tests.*"]
+}

package/tsconfig.json

@@ -1,25 +1,5 @@
 {
-  "compilerOptions": {
-    "esModuleInterop": true,
-    "module": "esnext",
-    "target": "es2015",
-    "allowSyntheticDefaultImports": true,
-    "jsx": "react",
-    "strictNullChecks": true,
-    "moduleResolution": "node",
-    "declaration": true,
-    "declarationDir": "dist",
-    "emitDeclarationOnly": true,
-    "lib": [
-      "dom",
-      "es5",
-      "scripthost",
-      "es2015",
-      "es2015.promise",
-      "es2016.array.include",
-      "es2018",
-      "esnext"
-    ]
-  },
-  "include": ["src/**/*"]
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "../tsconfig.json",
+  "include": ["src/**/*.ts*"]
 }

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'happy-dom',
+    mockReset: true,
+  },
+});