@linagora/linid-im-front-corelib 0.0.5 → 0.0.7

package/src/types/module.ts

@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2025 Linagora
- *
- * This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General
- * Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
- * any later version, provided you comply with the Additional Terms applicable for LinID Identity Manager software by
- * LINAGORA pursuant to Section 7 of the GNU Affero General Public License, subsections (b), (c), and (e), pursuant to
- * which these Appropriate Legal Notices must notably (i) retain the display of the "LinID™" trademark/logo at the top
- * of the interface window, the display of the “You are using the Open Source and free version of LinID™, powered by
- * Linagora © 2009–2013. Contribute to LinID R&D by subscribing to an Enterprise offer!” infobox and in the e-mails
- * sent with the Program, notice appended to any type of outbound messages (e.g. e-mail and meeting requests) as well
- * as in the LinID Identity Manager user interface, (ii) retain all hypertext links between LinID Identity Manager
- * and https://linid.org/, as well as between LINAGORA and LINAGORA.com, and (iii) refrain from infringing LINAGORA
- * intellectual property rights over its trademarks and commercial brands. Other Additional Terms apply, see
- * <http://www.linagora.com/licenses/> for more details.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License and its applicable Additional Terms for
- * LinID Identity Manager along with this program. If not, see <http://www.gnu.org/licenses/> for the GNU Affero
- * General Public License version 3 and <http://www.linagora.com/licenses/> for the Additional Terms applicable to the
- * LinID Identity Manager software.
- */
-
-import type { Component } from 'vue';
-import type { ModuleLifecycleHooks } from './moduleLifecycle';
-
-/**
- * Remote module interface.
- *
- * All remote modules exposed via Module Federation should implement this interface.
- * This is the contract between the host application and remote modules.
- */
-export interface RemoteModule extends ModuleLifecycleHooks {
-  /**
-   * Unique identifier for the module.
-   *
-   * Should be in kebab-case and match the ID in the module configuration.
-   */
-  id: string;
-
-  /**
-   * Human-readable name of the module.
-   */
-  name: string;
-
-  /**
-   * Version of the module.
-   *
-   * Should follow semantic versioning (semver).
-   */
-  version: string;
-
-  /**
-   * Optional description of the module.
-   *
-   * Provide a brief description of what the module does.
-   */
-  description?: string;
-}
-
-/**
- * Module configuration in the host (module-<name>.json).
- *
- * This is what the host provides to each module during the configuration phase.
- * The host reads this from `module-<name>.json` files.
- */
-export interface ModuleHostConfig {
-  /**
-   * Unique module identifier (kebab-case).
-   *
-   * Must match the module's exported `id` field.
-   */
-  id: string;
-
-  /**
-   * Module Federation remote name (must match a key in remotes.json).
-   *
-   * This is the name used to load the remote module via Module Federation.
-   */
-  remoteName: string;
-}
-
-/**
- * Module structure for a Vue component exposed via Module Federation.
- *
- * Remote modules must export a Vue component as their default export.
- */
-export interface RemoteComponentModule {
-  /**
-   * The default exported Vue component.
-   */
-  default: Component;
-}

package/src/types/moduleLifecycle.ts

@@ -1,154 +0,0 @@
-/*
- * Copyright (C) 2025 Linagora
- *
- * This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General
- * Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
- * any later version, provided you comply with the Additional Terms applicable for LinID Identity Manager software by
- * LINAGORA pursuant to Section 7 of the GNU Affero General Public License, subsections (b), (c), and (e), pursuant to
- * which these Appropriate Legal Notices must notably (i) retain the display of the "LinID™" trademark/logo at the top
- * of the interface window, the display of the “You are using the Open Source and free version of LinID™, powered by
- * Linagora © 2009–2013. Contribute to LinID R&D by subscribing to an Enterprise offer!” infobox and in the e-mails
- * sent with the Program, notice appended to any type of outbound messages (e.g. e-mail and meeting requests) as well
- * as in the LinID Identity Manager user interface, (ii) retain all hypertext links between LinID Identity Manager
- * and https://linid.org/, as well as between LINAGORA and LINAGORA.com, and (iii) refrain from infringing LINAGORA
- * intellectual property rights over its trademarks and commercial brands. Other Additional Terms apply, see
- * <http://www.linagora.com/licenses/> for more details.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Affero General Public License and its applicable Additional Terms for
- * LinID Identity Manager along with this program. If not, see <http://www.gnu.org/licenses/> for the GNU Affero
- * General Public License version 3 and <http://www.linagora.com/licenses/> for the Additional Terms applicable to the
- * LinID Identity Manager software.
- */
-
-import type { ModuleHostConfig } from './module';
-
-/**
- * Module lifecycle phases enumeration.
- *
- * Defines the sequence of initialization steps for remote modules.
- * Each phase is executed in order for all modules before moving to the next phase.
- */
-export enum ModuleLifecyclePhase {
-  /**
-   * Initial setup phase - module is being loaded.
-   *
-   * Use this phase to validate dependencies and prepare the module.
-   */
-  SETUP = 'setup',
-
-  /**
-   * Configuration phase - module receives configuration.
-   *
-   * Use this phase to receive and validate the host configuration.
-   */
-  CONFIGURE = 'configure',
-
-  /**
-   * Initialization phase - module initializes its core features.
-   *
-   * Use this phase to register stores and initialize resources.
-   */
-  INITIALIZE = 'initialize',
-
-  /**
-   * Ready phase - module is ready to be used.
-   *
-   * Use this phase to perform final checks and emit ready state.
-   */
-  READY = 'ready',
-
-  /**
-   * Post-initialization phase - final setup after all modules are ready.
-   *
-   * Use this phase for cross-module integrations and final setup.
-   */
-  POST_INIT = 'postInit',
-}
-
-/**
- * Result of a lifecycle phase execution.
- *
- * Modules should return this from their lifecycle hooks to indicate
- * success or failure of the phase.
- */
-export interface ModuleLifecycleResult {
-  /**
-   * Whether the phase completed successfully.
-   *
-   * If false, the module will continue through remaining phases but
-   * the error will be logged.
-   */
-  success: boolean;
-
-  /**
-   * Error message if the phase failed.
-   *
-   * Only present when success is false.
-   */
-  error?: string;
-
-  /**
-   * Additional metadata from the phase.
-   *
-   * Use this to provide debugging information or statistics.
-   */
-  metadata?: Record<string, unknown>;
-}
-
-/**
- * Module lifecycle hooks interface.
- *
- * Remote modules should implement these hooks to participate in the lifecycle.
- * All hooks are optional - implement only what your module needs.
- */
-export interface ModuleLifecycleHooks {
-  /**
-   * Called when the module is first loaded.
-   *
-   * Use this to prepare the module for initialization and validate
-   * that all required dependencies are available.
-   * @returns Promise resolving to the lifecycle result.
-   */
-  setup(): Promise<ModuleLifecycleResult>;
-
-  /**
-   * Called to configure the module with application-specific settings.
-   *
-   * Use this to receive and validate the host configuration for your module.
-   * This is where you should check that all required configuration is present.
-   * @param config - Module-specific configuration from host (from module-<name>.json).
-   * @returns Promise resolving to the lifecycle result.
-   */
-  configure(config: ModuleHostConfig): Promise<ModuleLifecycleResult>;
-
-  /**
-   * Called to initialize the module's core functionality.
-   *
-   * Use this to register Pinia stores and initialize any resources
-   * your module needs to function.
-   * @returns Promise resolving to the lifecycle result.
-   */
-  initialize(): Promise<ModuleLifecycleResult>;
-
-  /**
-   * Called when the module is ready to be used.
-   *
-   * Use this to perform final checks and emit ready state.
-   * At this point, all other modules have completed initialization.
-   * @returns Promise resolving to the lifecycle result.
-   */
-  ready(): Promise<ModuleLifecycleResult>;
-
-  /**
-   * Called after all modules have been initialized.
-   *
-   * Use this for cross-module integrations and final setup that requires
-   * all modules to be ready.
-   * @returns Promise resolving to the lifecycle result.
-   */
-  postInit(): Promise<ModuleLifecycleResult>;
-}

package/tests/unit/components/LinidZoneRenderer.spec.js

@@ -1,135 +0,0 @@
-import { flushPromises, shallowMount } from '@vue/test-utils';
-import { createPinia, setActivePinia } from 'pinia';
-import LinidZoneRenderer from 'src/components/LinidZoneRenderer.vue';
-import * as federationService from 'src/services/federationService';
-import { useLinidZoneStore } from 'src/stores/linidZoneStore';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { nextTick, watch } from 'vue';
-
-vi.mock('src/services/federationService', () => ({
-  loadAsyncComponent: vi.fn(),
-}));
-
-describe('Test component: LinidZoneRenderer', () => {
-  let pinia;
-  let store;
-  let wrapper;
-
-  beforeEach(() => {
-    pinia = createPinia();
-    setActivePinia(pinia);
-    store = useLinidZoneStore();
-    wrapper = shallowMount(LinidZoneRenderer, {
-      props: { zone: '' },
-      global: { plugins: [pinia] },
-    });
-    vi.clearAllMocks();
-  });
-
-  describe('Test watchEffect', () => {
-    it('should initialize isLoadingComplete to false when mounted', async () => {
-      const values = [];
-      const stopWatch = watch(
-        () => wrapper.vm.isLoadingComplete,
-        (newVal) => {
-          values.push(newVal);
-        },
-        { flush: 'sync' }
-      );
-
-      await wrapper.setProps({ zone: 'zone-test' });
-
-      await flushPromises();
-      await nextTick();
-      stopWatch();
-
-      expect(values).toEqual([false, true]);
-    });
-
-    it('should set isLoadingComplete to true after initialization', async () => {
-      wrapper.setProps({ zone: 'any-zone' });
-
-      await flushPromises();
-      await nextTick();
-
-      expect(wrapper.vm.isLoadingComplete).toBe(true);
-    });
-
-    it('should not call loadAsyncComponent when the zone is not registered in store', async () => {
-      wrapper.setProps({ zone: 'unregistered-zone' });
-
-      await flushPromises();
-      await nextTick();
-
-      expect(federationService.loadAsyncComponent).not.toHaveBeenCalled();
-      expect(wrapper.vm.components).toEqual([]);
-    });
-
-    it('should not call loadAsyncComponent when the zone is registered has no entries', async () => {
-      wrapper.vm.linidZoneStore.zones['empty-zone'] = [];
-
-      wrapper.setProps({ zone: 'empty-zone' });
-
-      await flushPromises();
-      await nextTick();
-
-      expect(federationService.loadAsyncComponent).not.toHaveBeenCalled();
-      expect(wrapper.vm.components).toEqual([]);
-    });
-
-    it('should load components from store when zone is registered and has entries', async () => {
-      const MockComponentA = {
-        name: 'MockComponent',
-        template: '<div>Mock</div>',
-      };
-      const MockComponentB = {
-        name: 'MockComponent',
-        template: '<div>Mock</div>',
-      };
-      vi.mocked(federationService.loadAsyncComponent)
-        .mockReturnValueOnce(MockComponentA)
-        .mockReturnValueOnce(MockComponentB);
-
-      store.register('test-zone', {
-        plugin: 'test-plugin/MockComponentA',
-        props: { title: 'Test' },
-      });
-
-      store.register('test-zone', {
-        plugin: 'test-plugin/MockComponentB',
-        props: {},
-      });
-
-      wrapper.setProps({ zone: 'test-zone' });
-
-      await flushPromises();
-      await nextTick();
-
-      expect(federationService.loadAsyncComponent).toHaveBeenCalledTimes(2);
-      expect(federationService.loadAsyncComponent).toHaveBeenCalledWith(
-        'test-plugin/MockComponentA'
-      );
-      expect(federationService.loadAsyncComponent).toHaveBeenCalledWith(
-        'test-plugin/MockComponentB'
-      );
-
-      expect(wrapper.vm.components).toHaveLength(2);
-
-      expect(wrapper.vm.components[0].plugin).toBe(
-        'test-plugin/MockComponentA'
-      );
-      expect(wrapper.vm.components[0].props).toEqual({ title: 'Test' });
-      expect(JSON.stringify(wrapper.vm.components[0].component)).toEqual(
-        JSON.stringify(MockComponentA)
-      );
-
-      expect(wrapper.vm.components[1].plugin).toBe(
-        'test-plugin/MockComponentB'
-      );
-      expect(wrapper.vm.components[1].props).toEqual({});
-      expect(JSON.stringify(wrapper.vm.components[1].component)).toEqual(
-        JSON.stringify(MockComponentB)
-      );
-    });
-  });
-});

package/tests/unit/lifecycle/skeleton.spec.js

@@ -1,138 +0,0 @@
-import { BasicRemoteModule } from 'src/lifecycle/skeleton';
-import { beforeEach, describe, expect, it } from 'vitest';
-
-describe('Test class: BasicRemoteModule', () => {
-  describe('Test constructor', () => {
-    it('should create a module with required parameters', () => {
-      const module = new BasicRemoteModule(
-        'test-module',
-        'Test Module',
-        '1.0.0'
-      );
-
-      expect(module.id).toBe('test-module');
-      expect(module.name).toBe('Test Module');
-      expect(module.version).toBe('1.0.0');
-      expect(module.description).toBeUndefined();
-    });
-
-    it('should create a module with description', () => {
-      const module = new BasicRemoteModule(
-        'test-module',
-        'Test Module',
-        '1.0.0',
-        'A test module for unit testing'
-      );
-
-      expect(module.id).toBe('test-module');
-      expect(module.name).toBe('Test Module');
-      expect(module.version).toBe('1.0.0');
-      expect(module.description).toBe('A test module for unit testing');
-    });
-  });
-
-  describe('Test lifecycle hooks', () => {
-    let module;
-
-    beforeEach(() => {
-      module = new BasicRemoteModule(
-        'test-module',
-        'Test Module',
-        '1.0.0',
-        'Test description'
-      );
-    });
-
-    describe('Test hook: setup', () => {
-      it('should return success by default', async () => {
-        const result = await module.setup();
-
-        expect(result).toEqual({ success: true });
-      });
-    });
-
-    describe('Test hook: configure', () => {
-      it('should return success with empty config', async () => {
-        const result = await module.configure({});
-
-        expect(result).toEqual({ success: true });
-      });
-
-      it('should return success with valid config', async () => {
-        const config = {
-          id: 'test-module',
-          remoteName: 'testModule',
-        };
-
-        const result = await module.configure(config);
-
-        expect(result).toEqual({ success: true });
-      });
-    });
-
-    describe('Test hook: initialize', () => {
-      it('should return success by default', async () => {
-        const result = await module.initialize();
-
-        expect(result).toEqual({ success: true });
-      });
-    });
-
-    describe('Test hook: ready', () => {
-      it('should return success by default', async () => {
-        const result = await module.ready();
-
-        expect(result).toEqual({ success: true });
-      });
-    });
-
-    describe('Test hook: postInit', () => {
-      it('should return success by default', async () => {
-        const result = await module.postInit();
-
-        expect(result).toEqual({ success: true });
-      });
-    });
-  });
-
-  describe('Test module extension', () => {
-    it('should allow extending the class', () => {
-      class CustomModule extends BasicRemoteModule {
-        constructor() {
-          super('custom-module', 'Custom Module', '1.0.0');
-        }
-      }
-
-      const module = new CustomModule();
-
-      expect(module).toBeInstanceOf(BasicRemoteModule);
-      expect(module.id).toBe('custom-module');
-      expect(module.name).toBe('Custom Module');
-      expect(module.version).toBe('1.0.0');
-    });
-
-    it('should allow overriding lifecycle methods', async () => {
-      class OverriddenModule extends BasicRemoteModule {
-        constructor() {
-          super('override-module', 'Override Module', '1.0.0');
-        }
-
-        async configure(config) {
-          if (!config.required) {
-            return { success: false, error: 'Missing required config' };
-          }
-          return { success: true };
-        }
-      }
-
-      const module = new OverriddenModule();
-
-      const failResult = await module.configure({});
-      expect(failResult.success).toBe(false);
-      expect(failResult.error).toBe('Missing required config');
-
-      const successResult = await module.configure({ required: true });
-      expect(successResult.success).toBe(true);
-    });
-  });
-});

package/tests/unit/services/federationService.spec.js

@@ -1,146 +0,0 @@
-import { loadRemote } from '@module-federation/enhanced/runtime';
-import { loadAsyncComponent } from 'src/services/federationService';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { defineAsyncComponent } from 'vue';
-
-vi.mock('@module-federation/enhanced/runtime');
-vi.mock('vue', async () => {
-  const actual = await vi.importActual('vue');
-  return {
-    ...actual,
-    defineAsyncComponent: vi.fn((loader) => loader),
-  };
-});
-
-describe('Test service: federationService', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Test function: loadAsyncComponent', () => {
-    it('should load a remote component successfully', async () => {
-      const testComponent = { default: 'RemoteTestComponent' };
-      const remoteModule = { './TestComponent': testComponent };
-      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
-
-      const loader = loadAsyncComponent('test-plugin/TestComponent');
-      const result = await loader();
-
-      expect(loadRemote).toHaveBeenCalledTimes(1);
-      expect(loadRemote).toHaveBeenCalledWith('test-plugin/TestComponent');
-      expect(defineAsyncComponent).toHaveBeenCalled();
-      expect(result).toEqual('RemoteTestComponent');
-    });
-
-    it('should throw an error if remote component export a null default', async () => {
-      const testComponent = { default: null };
-      const remoteModule = { './TestComponent': testComponent };
-      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
-
-      const loader = loadAsyncComponent('invalid-plugin/TestComponent');
-
-      await expect(loader()).rejects.toThrow(
-        'Failed to load component from invalid-plugin'
-      );
-      expect(loadRemote).toHaveBeenCalledWith('invalid-plugin/TestComponent');
-    });
-
-    it('should throw an error if remote component export an undefined default', async () => {
-      const testComponent = { default: undefined };
-      const remoteModule = { './TestComponent': testComponent };
-      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
-
-      const loader = loadAsyncComponent('invalid-plugin/TestComponent');
-
-      await expect(loader()).rejects.toThrow(
-        'Failed to load component from invalid-plugin'
-      );
-      expect(loadRemote).toHaveBeenCalledWith('invalid-plugin/TestComponent');
-    });
-
-    it('should throw an error if remote component does not have a default export', async () => {
-      const testComponent = { toto: vi.fn() };
-      const remoteModule = { './TestComponent': testComponent };
-      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
-
-      const loader = loadAsyncComponent('invalid-plugin/TestComponent');
-
-      await expect(loader()).rejects.toThrow(
-        'Failed to load component from invalid-plugin'
-      );
-      expect(loadRemote).toHaveBeenCalledWith('invalid-plugin/TestComponent');
-    });
-
-    it('should throw an error if module is null', async () => {
-      vi.mocked(loadRemote).mockResolvedValue(null);
-
-      const loader = loadAsyncComponent('null-plugin/TestComponent');
-
-      await expect(loader()).rejects.toThrow(
-        'Failed to load component from null-plugin'
-      );
-    });
-
-    it('should throw an error if module is undefined', async () => {
-      vi.mocked(loadRemote).mockResolvedValue(undefined);
-
-      const loader = loadAsyncComponent('undefined-plugin/TestComponent');
-
-      await expect(loader()).rejects.toThrow(
-        'Failed to load component from undefined-plugin'
-      );
-    });
-
-    it('should throw an error if loadRemote rejects', async () => {
-      const error = new Error('Network error');
-
-      vi.mocked(loadRemote).mockRejectedValue(error);
-
-      const loader = loadAsyncComponent('failing-plugin/TestComponent');
-
-      await expect(loader()).rejects.toThrow('Network error');
-      expect(loadRemote).toHaveBeenCalledWith('failing-plugin/TestComponent');
-    });
-
-    it('should handle different plugin names', async () => {
-      const plugins = ['plugin-a', 'plugin-b', 'plugin-c'];
-      const testComponentA = { default: 'RemoteTestComponentA' };
-      const remoteModuleA = { './TestComponent': testComponentA };
-      const testComponentB = { default: 'RemoteTestComponentB' };
-      const remoteModuleB = { './TestComponent': testComponentB };
-      const testComponentC = { default: 'RemoteTestComponentC' };
-      const remoteModuleC = { './TestComponent': testComponentC };
-
-      vi.mocked(loadRemote)
-        .mockResolvedValueOnce(remoteModuleA['./TestComponent'])
-        .mockResolvedValueOnce(remoteModuleB['./TestComponent'])
-        .mockResolvedValueOnce(remoteModuleC['./TestComponent']);
-
-      for (const plugin of plugins) {
-        const loader = loadAsyncComponent(`${plugin}/TestComponent`);
-        const result = await loader();
-        const lastChar = plugin.charAt(plugin.length - 1).toUpperCase();
-
-        expect(loadRemote).toHaveBeenCalledWith(`${plugin}/TestComponent`);
-        expect(result).toEqual(`RemoteTestComponent${lastChar}`);
-      }
-
-      expect(loadRemote).toHaveBeenCalledTimes(3);
-    });
-
-    it('should handle module with additional exports', async () => {
-      const testComponent = {
-        default: 'RemoteTestComponent',
-        namedExport1: 'value1',
-        namedExport2: 'value2',
-      };
-      const remoteModule = { './TestComponent': testComponent };
-      vi.mocked(loadRemote).mockResolvedValue(remoteModule['./TestComponent']);
-
-      const loader = loadAsyncComponent('multi-export-plugin');
-      const result = await loader();
-
-      expect(result).toEqual('RemoteTestComponent');
-    });
-  });
-});