@uxland/primary-shell 1.0.14 → 1.0.16

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

@@ -0,0 +1,21 @@
+import {
+  ConfirmOptions,
+  CustomConfirmOptions,
+  NotifyOptions,
+  doConfirm,
+  notify,
+} from "@uxland/primaria-ui-components";
+
+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

@@ -1,4 +1,6 @@
 export * from "./initializer";
 export * from "./regions";
 export * from "./plugin";
-export * from "./api";
+export * from "./api/api";
+export * from "./api/broker/primaria-broker";
+import "./UI/index";

package/src/initializer.ts

@@ -1,6 +1,40 @@
-import { PrimariaShell } from "./primaria-shell";
+import { PrimariaMenuItem } from "@uxland/primaria-ui-components/src/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) => {
+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

@@ -1,8 +1,9 @@
-import { bootstrapPlugins as pluginBootstrapper } from "@uxland/fim-core";
-import type { Plugin as PluginType } from "@uxland/fim-core";
-export type { PluginDefinition, PluginInfo } from "@uxland/fim-core";
-import { PrimariaApi, primariaApiFactory } from "./api";
+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) => pluginBootstrapper(plugins, primariaApiFactory);
+export const bootstrapPlugins = (plugins: PluginDefinition[]) =>
+  pluginBootstrapper(plugins, primariaApiFactory);
 
 export type Plugin = PluginType<PrimariaApi>;

package/src/region-manager.ts

@@ -1,7 +1,17 @@
-import { HarmonixRegionManager, IRegionManager, HarmonixViewDefinition } from "@uxland/fim-core";
+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";
 
-class RegionaManagerProxy implements HarmonixRegionManager {
+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,
@@ -21,18 +31,125 @@ class RegionaManagerProxy implements HarmonixRegionManager {
     );
     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,
-): HarmonixRegionManager => new RegionaManagerProxy(pluginInfo, regionManager);
+): PrimariaRegionManager => new RegionManagerProxy(pluginInfo, regionManager);

package/src/regions.ts

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

package/dist/primaria-shell.d.ts

@@ -1,12 +0,0 @@
-import { IRegion } from '@uxland/regions';
-
-declare const PrimariaShell_base: any;
-export declare class PrimariaShell extends PrimariaShell_base {
-    render(): import('../node_modules/lit').TemplateResult<1>;
-    static styles: import('../node_modules/lit').CSSResult;
-    headerRegion: IRegion | undefined;
-    actionsToolbarRegion: IRegion | undefined;
-    sidebarRegion: IRegion | undefined;
-    mainRegion: IRegion | undefined;
-}
-export {};

package/src/api.ts

@@ -1,102 +0,0 @@
-import {
-  HarmonixApi,
-  PluginInfo,
-  IRegionManager,
-  createRegionManager,
-  createRegionHost,
-  ApiFactory,
-} from "@uxland/fim-core";
-import { createRegionManagerProxy } from "./region-manager";
-
-interface PrimariaHttpClient {
-  get(url: string): Promise<any>;
-  post(url: string, data: any): Promise<any>;
-}
-
-interface NotifyOptions {
-  message: string;
-  delay: number;
-  dissmissible: boolean;
-}
-
-interface PrimariaInteractionManager {
-  notify(options: NotifyOptions): Promise<any>;
-}
-
-interface PrimariaMediator {
-  publish(event: string, data: any): Promise<any>;
-  subscribe(event: string, handler: any): Promise<any>;
-  sendCommand(command: string, data: any): Promise<any>;
-  registerCommand(command: string, handler: any): Promise<any>;
-}
-
-export interface PrimariaApi extends HarmonixApi {
-  httpClient: PrimariaHttpClient;
-  interactionManager: PrimariaInteractionManager;
-  mediator: PrimariaMediator;
-}
-
-const regionManager: IRegionManager = createRegionManager("primaria");
-export const PrimariaRegionHost: any = createRegionHost(regionManager as any);
-
-/**
- * Factory function that creates a Primaria API instance.
- *
- * @param {PluginInfo} pluginInfo - Information about the plugin
- * @return {PrimariaApi} The created Primaria API instance
- */
-export const primariaApiFactory: ApiFactory<PrimariaApi> = (
-  pluginInfo: PluginInfo,
-): PrimariaApi => {
-  return {
-    pluginInfo: pluginInfo,
-    regionManager: createRegionManagerProxy(pluginInfo, regionManager),
-    httpClient: {
-      get: (url: string) => fetch(url).then((r) => r.json()),
-      post: (url: string, data: any) =>
-        fetch(url, {
-          method: "POST",
-          body: JSON.stringify(data),
-        }).then((r) => r.json()),
-    },
-    interactionManager: {
-      notify: (options: NotifyOptions) => {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            resolve(null);
-          }, options.delay);
-        });
-      },
-    },
-    mediator: {
-      publish: (event: string, data: any) => {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            resolve(null);
-          }, 100);
-        });
-      },
-      subscribe: (event: string, handler: any) => {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            resolve(null);
-          }, 100);
-        });
-      },
-      sendCommand: (command: string, data: any) => {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            resolve(null);
-          }, 100);
-        });
-      },
-      registerCommand: (command: string, handler: any) => {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            resolve(null);
-          }, 100);
-        });
-      },
-    },
-  };
-};

package/src/primaria-shell.ts

@@ -1,77 +0,0 @@
-import { IRegion, region } from "@uxland/regions";
-import { LitElement, css, html } from "lit";
-import { PrimariaRegionHost } from "./api";
-import { customElement } from "lit/decorators.js";
-import { regions } from "./regions";
-import "@uxland/primaria-ui-components";
-
-//@ts-ignore
-@customElement("primaria-shell")
-export class PrimariaShell extends PrimariaRegionHost(LitElement) {
-  render() {
-    return html` <div class="container">
-      <div class="header">
-        <div id="header-region-container"></div>
-        <div id="actions-toolbar-region-container"></div>
-      </div>
-
-      <div class="main-container">
-        <div id="sidebar-region-region-container"></div>
-        <div id="main-region-region-container"></div>
-      </div>
-    </div>`;
-  }
-
-  static styles = css`
-  :host {
-    width: 100%;
-    overflow: hidden;
-  }
-  .container {
-    width: 100%;
-    height: 100%;
-    display: flex;
-    flex-direction: column;
-    background: aliceblue;
-  }
-  .header {
-    display: flex;
-    flex-direction: row;
-    justify-content: space-between;
-    background-color: blue;
-    height: 60px;
-    background-color: white;
-    color: black;
-    box-shadow: rgba(0, 0, 0, 0.12) 0px 4px 3px, rgba(0, 0, 0, 0.24) 0px 1px 2px;
-    z-index: 1;
-
-    #actions-toolbar-region-container{
-      display: flex;
-      flex-direction:row;
-    }
-  }
-  .main-container {
-    min-height: 1px;
-    height: 100%;
-    display: flex;
-    flex-direction: row;
-    #sidebar-region-region-container {
-      background: white;
-      width: 15vw;
-      box-shadow: rgba(0, 0, 0, 0.12) 4px -1px 3px, rgba(0, 0, 0, 0.24) 0px 1px 2px;
-    }
-  }
-  `;
-
-  @region({ targetId: "header-region-container", name: regions.header })
-  headerRegion: IRegion | undefined;
-
-  @region({ targetId: "actions-toolbar-region-container", name: regions.actionsToolbar })
-  actionsToolbarRegion: IRegion | undefined;
-
-  @region({ targetId: "sidebar-region-region-container", name: regions.sidebar })
-  sidebarRegion: IRegion | undefined;
-
-  @region({ targetId: "main-region-region-container", name: regions.main })
-  mainRegion: IRegion | undefined;
-}