@openmrs/esm-extensions 3.1.15-pre.891 → 3.2.1-pre.1010

package/src/store.ts

@@ -2,8 +2,9 @@ import isEqual from "lodash-es/isEqual";
 import {
   configExtensionStore,
   ConfigExtensionStoreElement,
+  ExtensionSlotConfigObject,
 } from "@openmrs/esm-config";
-import { createGlobalStore } from "@openmrs/esm-state";
+import { createGlobalStore, getGlobalStore } from "@openmrs/esm-state";
 
 export interface ExtensionMeta {
   [_: string]: any;
@@ -31,82 +32,115 @@ export interface ExtensionInstance {
   id: string;
 }
 
-export interface ExtensionStore {
+export interface ExtensionInternalStore {
   /** Slots indexed by name */
   slots: Record<string, ExtensionSlotInfo>;
   /** Extensions indexed by name */
   extensions: Record<string, ExtensionInfo>;
 }
 
-export interface ExtensionSlotInstance {
-  /**
-   * A set of additional extension IDs which have been added to to this slot despite not being
-   * explicitly `attach`ed to it.
-   * An example may be an extension which is added to the slot via the configuration.
-   */
-  addedIds: Array<string>;
-  /**
-   * A set of extension IDs which have been removed/hidden from this slot, even though they have
-   * previously been `attach`ed/added to it.
-   * An example may be an extension which is removed from the slot via the configuration.
-   */
-  removedIds: Array<string>;
-  /**
-   * A set allowing explicit ordering of the `assignedIds`.
-   */
-  idOrder: Array<string>;
-}
-
 export interface ExtensionSlotInfo {
   /**
-   * The name under which the extension slot has been registered.
+   * 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 mapping of modules / extension slot instances where the extension slot has been used.
-   */
-  instances: Record<string, ExtensionSlotInstance>;
-  /**
-   * The set of extension IDs which have been attached to this slot.
-   * This is essentially a complete history of `attach` calls to this specific slot.
+   * 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 extension slot. `null` if not yet loaded. */
+  config: ExtensionSlotConfigObject | null;
 }
 
-export const extensionStore = createGlobalStore<ExtensionStore>("extensions", {
-  slots: {},
-  extensions: {},
-});
+export interface ExtensionStore {
+  slots: Record<string, ExtensionSlotState>;
+}
+
+export interface ExtensionSlotState {
+  moduleName: string;
+  assignedExtensions: Array<AssignedExtension>;
+}
 
+export interface AssignedExtension {
+  id: string;
+  name: string;
+  moduleName: string;
+  meta: ExtensionMeta;
+  online?: boolean | object;
+  offline?: boolean | object;
+}
+
+export interface ConnectedExtension {
+  id: string;
+  name: string;
+  meta: ExtensionMeta;
+}
+
+const extensionInternalStore = createGlobalStore<ExtensionInternalStore>(
+  "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<ExtensionInternalStore>("extensionsInternal", {
+    slots: {},
+    extensions: {},
+  });
+
+/** @internal */
 export type MaybeAsync<T> = T | Promise<T>;
 
 let storeUpdates: Promise<void> = Promise.resolve();
 
-export function updateExtensionStore(
-  updater: (state: ExtensionStore) => MaybeAsync<ExtensionStore>
+/** @internal */
+export function updateInternalExtensionStore(
+  updater: (state: ExtensionInternalStore) => MaybeAsync<ExtensionInternalStore>
 ) {
   storeUpdates = storeUpdates.then(async () => {
-    const state = extensionStore.getState();
+    const state = extensionInternalStore.getState();
     const newState = await updater(state);
 
     if (newState !== state) {
-      extensionStore.setState(newState);
+      extensionInternalStore.setState(newState);
     }
   });
 }
 
+/**
+ * This returns a [store](https://github.com/developit/unistore#store)
+ * that modules can use to get information about the state of the
+ * extension system.
+ */
+export const getExtensionStore = () =>
+  getGlobalStore<ExtensionStore>("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(extensionStore.getState());
-extensionStore.subscribe(updateConfigExtensionStore);
+updateConfigExtensionStore(extensionInternalStore.getState());
+extensionInternalStore.subscribe(updateConfigExtensionStore);
 
-function updateConfigExtensionStore(extensionState: ExtensionStore) {
+function updateConfigExtensionStore(extensionState: ExtensionInternalStore) {
   const configExtensionRecords: Array<ConfigExtensionStoreElement> = [];
 
   for (let extensionInfo of Object.values(extensionState.extensions)) {