@uxland/primary-shell 1.1.0 → 2.0.0

package/src/api/global-state/global-state.ts

@@ -0,0 +1,49 @@
+import { PrimariaBroker } from "../broker/primaria-broker";
+
+export abstract class PrimariaGlobalStateManager {
+  abstract setData(key: string, value: any): void;
+  abstract getData(key: string): any;
+  abstract clearData(): void;
+}
+
+class PrimariaGlobalStateManagerImpl implements PrimariaGlobalStateManager {
+  private state: { [key: string]: any } = {};
+  constructor(public broker: PrimariaBroker) {}
+
+  /**
+   * Sets the value of a key in the state object and publishes an event with the event bus.
+   *
+   * @param {string} key - The key to set the value for.
+   * @param {any} value - The value to set for the key.
+   * @return {void} This function does not return anything.
+   */
+  setData(key: string, value: any): void {
+    this.state[key] = value;
+    this.broker.publish("data-setted", {
+      key: key,
+      value: value,
+    });
+  }
+
+  /**
+   * Retrieves the value associated with the specified key from the state object.
+   *
+   * @param {string} key - The key to retrieve the value for.
+   * @return {any} The value associated with the specified key, or undefined if the key does not exist in the state object.
+   */
+  getData(key: string): any {
+    return this.state[key];
+  }
+
+  /**
+   * Clears all data stored in the state object.
+   *
+   * @return {void} This function does not return anything.
+   */
+  public clearData(): void {
+    this.state = {};
+  }
+}
+
+export const createGlobalStateManager = (broker: PrimariaBroker) =>
+  new PrimariaGlobalStateManagerImpl(broker);

package/src/api/interaction-manager/interaction.ts

@@ -0,0 +1,21 @@
+import {
+  ConfirmOptions,
+  CustomConfirmOptions,
+  NotifyOptions,
+  doConfirm,
+  notify,
+} from "../../UI/shared-components/primaria-interaction";
+
+export interface PrimariaInteractionManager {
+  notify(options: NotifyOptions): Promise<any>;
+  doConfirm(options: ConfirmOptions): Promise<boolean>;
+  doCustomConfirm(options: CustomConfirmOptions): Promise<boolean>;
+}
+
+export const createInteractionManager: () => PrimariaInteractionManager = () => {
+  return {
+    notify: (options: NotifyOptions) => notify(options),
+    doConfirm: (options: ConfirmOptions) => doConfirm(options),
+    doCustomConfirm: (options: CustomConfirmOptions) => doConfirm(options),
+  } as PrimariaInteractionManager;
+};

package/src/api/localization/localization.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it, vi } from "vitest";
+import { createLocaleManager } from "./localization";
+
+const pluginInfo = { pluginId: "testPlugin" };
+
+// Mock data
+const translations = {
+  en: { testPlugin: { hello: "Hello" } },
+  es: { testPlugin: { hello: "Hola" } },
+};
+
+describe("createLocaleManager", () => {
+  it("should return an object with translate, getTranslations, and getCurrentLanguage functions", async () => {
+    const localeManager = await createLocaleManager(pluginInfo.pluginId)(translations as any);
+    expect(localeManager).toHaveProperty("translate");
+    expect(localeManager).toHaveProperty("getTranslations");
+    expect(localeManager).toHaveProperty("getCurrentLanguage");
+  });
+
+  it("should translate a given path using localizer", async () => {
+    const localeManager = await createLocaleManager(pluginInfo.pluginId)(translations as any);
+    const result = localeManager.translate("hello");
+    expect(result).toBe("Hello");
+  });
+
+  it("should return the full path if no exist translation for given path", async () => {
+    const localeManager = await createLocaleManager(pluginInfo.pluginId)(translations as any);
+    const result = localeManager.translate("hellaaa");
+    expect(result).toBe("testPlugin.hellaaa");
+  });
+
+  it("should return the path if there is an error translating", async () => {
+    const localeManager = await createLocaleManager(pluginInfo.pluginId)(translations as any);
+    const translateSpy = vi.spyOn(localeManager, "translate").mockImplementation(() => {
+      throw new Error("mocked error");
+    });
+
+    let result;
+    try {
+      result = localeManager.translate("hello");
+    } catch (error) {
+      result = "hello";
+    }
+
+    expect(result).toBe("hello");
+    // Restore the original implementation
+    translateSpy.mockRestore();
+  });
+
+  it("should get translations for the current language", async () => {
+    const localeManager = await createLocaleManager(pluginInfo.pluginId)(translations);
+    const result = localeManager.getTranslations();
+    expect(result).toEqual(translations.en.testPlugin);
+  });
+
+  it("should get the current language", async () => {
+    const localeManager = await createLocaleManager(pluginInfo.pluginId)(translations);
+    const result = localeManager.getCurrentLanguage();
+    expect(result).toBe("en");
+  });
+});

package/src/api/localization/localization.ts

@@ -0,0 +1,54 @@
+import { getLanguage, getLocales, localizerFactory, setLocales } from "@uxland/localization";
+
+/**
+ * Creates a locale manager for a given plugin ID and translations.
+ *
+ * @param {string} pluginId - The ID of the plugin.
+ * @param {Record<string, Record<string, string>>} translations - The translations for the plugin.
+ * @return {Promise<{
+ *   translate: (path: string, variables?: Record<string, string>) => string,
+ *   getTranslations: () => Record<string, string>,
+ *   getCurrentLanguage: () => string,
+ * }>} A promise that resolves to an object with methods for translating strings and getting translations.
+ */
+export const createLocaleManager =
+  (pluginId: string) => (translations: Record<string, Record<string, string>>) => {
+    const localizer = localizerFactory(getLanguage(), translations, "", true);
+    setLocales(translations);
+    return Promise.resolve({
+      /**
+       * Translates the given path using the provided variables and the plugin's ID.
+       *
+       * @param {string} path - The path to be translated.
+       * @param {Record<string, string>} [variables] - Optional variables to be used in the translation.
+       * @return {string} The translated string, or the original path if an error occurs.
+       */
+      translate: (path: string, variables?: Record<string, string>) => {
+        try {
+          return localizer(`${pluginId}.${path}`, variables);
+        } catch (e) {
+          console.error(e);
+          return path;
+        }
+      },
+      /**
+       * Retrieves the translations for the current language and plugin.
+       *
+       * @return {Record<string, string>} The translations for the current language and plugin.
+       */
+      getTranslations: () => {
+        const translations = getLocales();
+        const language = getLanguage();
+        return translations[language][pluginId] || {};
+      },
+
+      /**
+       * Retrieves the current language.
+       *
+       * @return {string} The current language.
+       */
+      getCurrentLanguage: () => {
+        return getLanguage();
+      },
+    });
+  };

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const primariaShellId = "primaria-shell";
+export const clinicalMonitoringId = "clinical-monitoring";

package/src/index.ts

@@ -0,0 +1,12 @@
+export * from "./initializer";
+export * from "./regions";
+export * from "./plugin";
+export * from "./api/api";
+export * from "./api/broker/primaria-broker";
+import "./UI/index";
+export { PrimariaMenuItem } from "./UI/shared-components/primaria-menu-item/primaria-menu-item";
+export { confirmMixin } from "./UI/shared-components/primaria-interaction";
+export type {
+  IConfirmMixin,
+  CustomConfirmOptions,
+} from "./UI/shared-components/primaria-interaction";

package/src/initializer.ts

@@ -1,5 +1,40 @@
-import { PrimaryShell } from "./primary-shell";
+import { PrimariaMenuItem } from "./UI/shared-components/primaria-menu-item/primaria-menu-item";
+import { selectableAdapterFactory as factory, regionAdapterRegistry } from "@uxland/regions";
+import { ClinicalMonitoring } from "./UI/components/clinical-monitoring/clinical-monitoring";
+import { PrimariaShell } from "./UI/components/primaria-shell/primaria-shell";
+import { appendTheme } from "./UI/styles/theme/apply-theme";
+import { shellApi } from "./api/api";
+import { initializeLocalization } from "./locales";
+import { shellRegions } from "./regions";
+import { clinicalMonitoringId } from "./constants";
 
-export const initializeShell = (element : HTMLElement) => {
-    element.appendChild(new PrimaryShell());
-}
+export const initializeShell = async (element: HTMLElement) => {
+  initializeLocalization(shellApi);
+  regionAdapterRegistry.registerAdapterFactory("primaria-content-switcher", factory);
+  const shell = new PrimariaShell();
+  element.appendChild(shell as any);
+  appendTheme();
+  registerViews();
+};
+
+const registerViews = () => {
+  shellApi.regionManager.registerMainView(
+    {
+      id: clinicalMonitoringId,
+      factory: () => {
+        const mainItem = new ClinicalMonitoring();
+        return Promise.resolve(mainItem as unknown as HTMLElement);
+      },
+    },
+    "Seguiment Clínic",
+  );
+  shellApi.regionManager.registerMenu({
+    id: clinicalMonitoringId,
+    factory: () => {
+      const menuItem = new PrimariaMenuItem("add_box", "Seguiment clínic", () => {
+        shellApi.regionManager.activateView(shellRegions.main, "clinical-monitoring");
+      });
+      return Promise.resolve(menuItem);
+    },
+  });
+};

package/src/locales.ts

@@ -0,0 +1,24 @@
+import { setLanguage } from "@uxland/localization";
+import { PrimariaApi } from "./api/api";
+import { clinicalMonitoringId, primariaShellId } from "./constants";
+
+let shellLocaleManager;
+
+export const initializeLocalization = async (api: PrimariaApi) => {
+  setLanguage("ca");
+  const localeManager = await api.createLocaleManager(locales);
+  shellLocaleManager = localeManager;
+};
+
+export { shellLocaleManager };
+
+export const locales = {
+  ca: {
+    [primariaShellId]: {
+      title: "Estació de Treball Clínica",
+    },
+    [clinicalMonitoringId]: {
+      title: "Seguiment Clínic",
+    },
+  },
+};

package/src/plugin.ts

@@ -0,0 +1,9 @@
+import { bootstrapPlugins as pluginBootstrapper } from "@uxland/harmonix";
+import type { PluginDefinition, Plugin as PluginType } from "@uxland/harmonix";
+export type { PluginDefinition, PluginInfo } from "@uxland/harmonix";
+import { PrimariaApi, primariaApiFactory } from "./api/api";
+
+export const bootstrapPlugins = (plugins: PluginDefinition[]) =>
+  pluginBootstrapper(plugins, primariaApiFactory);
+
+export type Plugin = PluginType<PrimariaApi>;

package/src/region-manager.ts

@@ -0,0 +1,155 @@
+import { HarmonixRegionManager, IRegionManager, HarmonixViewDefinition } from "@uxland/harmonix";
+import { PluginInfo } from "./plugin";
+import { IRegion } from "@uxland/regions";
+import { shellRegions } from "./regions";
+import { TitleView } from "./UI/components/title-view/title-view";
+
+export interface PrimariaRegionManager extends HarmonixRegionManager {
+  registerMenu(view: HarmonixViewDefinition): Promise<void>;
+  registerQuickAction(view: HarmonixViewDefinition): Promise<void>;
+  registerMainView(view: HarmonixViewDefinition, title: string): Promise<void>;
+  activateMainView(viewId: string): Promise<void>;
+}
+
+class RegionManagerProxy implements PrimariaRegionManager {
+  constructor(
+    private pluginInfo: PluginInfo,
+    private regionManager: IRegionManager,
+  ) {}
+  /**
+   * Register a view in a specific region.
+   *
+   * @param {string} regionName - The name of the region to register the view with.
+   * @param {HarmonixViewDefinition} view - The view definition to be registered.
+   * @return {Promise<void>} A promise that resolves when the view is successfully registered.
+   */
+  registerView(regionName: string, view: HarmonixViewDefinition): Promise<void> {
+    this.regionManager.registerViewWithRegion(
+      regionName,
+      `${this.pluginInfo.pluginId}::${view.id}`,
+      view,
+    );
+    return Promise.resolve();
+  }
+  /**
+   * Removes a view from a specific region.
+   *
+   * @param {string} regionName - The name of the region to remove the view from.
+   * @param {string} viewId - The ID of the view to be removed.
+   * @return {Promise<void>} A promise that resolves when the view is successfully removed.
+   */
+  removeView(regionName: string, viewId: string): Promise<void> {
+    this.regionManager.getRegion(regionName).removeView(`${this.pluginInfo.pluginId}::${viewId}`);
+    return Promise.resolve();
+  }
+  /**
+   * Activates a view in a specific region.
+   *
+   * @param {string} regionName - The name of the region where the view is located.
+   * @param {string} viewId - The ID of the view to be activated.
+   * @return {Promise<void>} A promise that resolves when the view is successfully activated.
+   */
+  activateView(regionName: string, viewId: string): Promise<void> {
+    this.regionManager.getRegion(regionName).activate(`${this.pluginInfo.pluginId}::${viewId}`);
+    return Promise.resolve();
+  }
+  /**
+   * Deactivates a view in a specific region.
+   *
+   * @param {string} regionName - The name of the region where the view is located.
+   * @param {string} viewId - The ID of the view to be deactivated.
+   * @return {Promise<void>} A promise that resolves when the view is successfully deactivated.
+   */
+  deactivateView(regionName: string, viewId: string): Promise<void> {
+    this.regionManager.getRegion(regionName).deactivate(`${this.pluginInfo.pluginId}::${viewId}`);
+    return Promise.resolve();
+  }
+  /**
+   * Retrieves a region by its name.
+   *
+   * @param {string} regionName - The name of the region to retrieve.
+   * @return {Promise<IRegion>} A promise that resolves to the retrieved region.
+   */
+  getRegion(regionName: string): Promise<IRegion> {
+    return Promise.resolve(this.regionManager.getRegion(regionName));
+  }
+  /**
+   * Checks if a view with the given ID exists in a specific region.
+   *
+   * @param {string} regionName - The name of the region to check.
+   * @param {string} viewId - The ID of the view to check for.
+   * @return {Promise<boolean>} A promise that resolves to true if the view exists, false otherwise.
+   */
+  containsView(regionName: string, viewId: string) {
+    const region = this.regionManager.getRegion(regionName);
+    return Promise.resolve(region?.containsView(`${this.pluginInfo.pluginId}::${viewId}`));
+  }
+  /**
+   * Checks if a view with the given ID is active in a specific region.
+   *
+   * @param {string} regionName - The name of the region to check.
+   * @param {string} viewId - The ID of the view to check for.
+   * @return {Promise<boolean>} A promise that resolves to true if the view is active, false otherwise.
+   */
+  isViewActive(regionName: string, viewId: string) {
+    const region = this.regionManager.getRegion(regionName);
+    return Promise.resolve(region?.isViewActive(`${this.pluginInfo.pluginId}::${viewId}`));
+  }
+
+  registerMenu(view: HarmonixViewDefinition): Promise<void> {
+    this.regionManager.registerViewWithRegion(
+      shellRegions.menu,
+      `${this.pluginInfo.pluginId}::${view.id}`,
+      view,
+    );
+    return Promise.resolve();
+  }
+  registerQuickAction(view: HarmonixViewDefinition): Promise<void> {
+    this.regionManager.registerViewWithRegion(
+      shellRegions.quickActions,
+      `${this.pluginInfo.pluginId}::${view.id}`,
+      view,
+    );
+    return Promise.resolve();
+  }
+  registerMainView(view: HarmonixViewDefinition, title: string): Promise<void> {
+    this.regionManager.registerViewWithRegion(
+      shellRegions.main,
+      `${this.pluginInfo.pluginId}::${view.id}`,
+      view,
+    );
+    const titleView = createTitleView(view.id, title);
+    this.regionManager.registerViewWithRegion(
+      shellRegions.header,
+      `${this.pluginInfo.pluginId}::${view.id}`,
+      titleView,
+    );
+    return Promise.resolve();
+  }
+  activateMainView(viewId: string): Promise<void> {
+    this.regionManager
+      .getRegion(shellRegions.main)
+      .activate(`${this.pluginInfo.pluginId}::${viewId}`);
+    this.regionManager
+      .getRegion(shellRegions.header)
+      .activate(`${this.pluginInfo.pluginId}::${viewId}`);
+    return Promise.resolve();
+  }
+}
+
+const createTitleView = (id: string, title: string): HarmonixViewDefinition => ({
+  id: id,
+  factory: () => Promise.resolve(new TitleView(title)),
+});
+
+/**
+ * Creates a proxy for the region manager with the given plugin info and region manager instance.
+ *
+ * @param {PluginInfo} pluginInfo - The plugin information.
+ * @param {IRegionManager} regionManager - The region manager instance.
+ * @return {HarmonixRegionManager} The created region manager proxy.
+ */
+export const createRegionManagerProxy = (
+  pluginInfo: PluginInfo,
+  regionManager: IRegionManager,
+): PrimariaRegionManager => new RegionManagerProxy(pluginInfo, regionManager);

package/src/regions.ts

@@ -1,7 +1,18 @@
-export const regions = {
-  header: 'header-region',
-  actionsToolbar: 'actions-toolbar-region',
-  main: 'main-region',
-  sidebar: 'asidebar-region',
-  footer: 'footer-region'
+export const shellRegions = {
+  header: "header-region",
+  headerActions: "header-actions-region",
+  main: "main-region",
+  menu: "menu-region",
+  quickActions: "quick-actions-region",
+  floating: "floating-region",
 };
+
+export const clinicalMonitoringRegions = {
+  sidebar: "widgets-sidebar-region",
+  header: "header-widgets-region",
+  content: "content-widgets-region",
+};
+
+export type PrimariaRegionNames =
+  | (typeof shellRegions)[keyof typeof shellRegions]
+  | (typeof clinicalMonitoringRegions)[keyof typeof clinicalMonitoringRegions];