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

package/.github/workflows/pull-request.yml

@@ -120,3 +120,28 @@ jobs:
       - uses: gensecaihq/Shai-Hulud-2.0-Detector@v1
         with:
           fail-on-critical: true
+
+  unit-tests:
+    name: Unit tests
+    runs-on: ubuntu-latest
+    needs: [build]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js and pnpm
+        uses: ./.github/actions/setup-node-pnpm
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          pnpm-version: ${{ env.PNPM_VERSION }}
+
+      - name: Run unit tests
+        run: |
+          echo '```bash' > coverage.txt
+          pnpm test:ci | sed 's/\x1b\[[0-9;]*m//g' >> coverage.txt
+          echo '```' >> coverage.txt
+
+      - name: Comment PR
+        uses: JoseThen/comment-pr@v1.2.0
+        with:
+          file_path: ./coverage.txt
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.0.5](https://github.com/linagora/linid-im-front-corelib/compare/v0.0.4...v0.0.5) (2025-12-03)
+
 ### [0.0.4](https://github.com/linagora/linid-im-front-corelib/compare/v0.0.3...v0.0.4) (2025-12-01)
 
 

package/CONTRIBUTING.md

@@ -161,9 +161,14 @@ npm run dev
 ## **🧪 Run Tests**
 
 ```sh
-pnpm test
+pnpm test          # Runs the full test suite once
+pnpm test:watch    # Runs tests in watch mode
+pnpm test:coverage # Generates a coverage report
+
 # or (not recommended by the dev team)
-npm run test
+npm run test          # Runs the full test suite once
+npm run test:watch    # Runs tests in watch mode
+npm run test:coverage # Generates a coverage report
 ```
 
 ---

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linagora/linid-im-front-corelib",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Core library of the LinID Identity Manager project. Provides shared types, services, components, and utilities for front-end and plugin, enabling consistent integration across the LinID ecosystem.",
   "type": "module",
   "main": "dist/core-lib.umd.js",
@@ -13,8 +13,11 @@
     }
   },
   "scripts": {
-    "build": "vite build && vue-tsc --declaration --emitDeclarationOnly",
-    "test": "vitest",
+    "build": "vite build && vue-tsc --declaration --emitDeclarationOnly -p tsconfig.lib.json",
+    "test": "vitest run",
+    "test:coverage": "vitest --run --coverage",
+    "test:watch": "vitest",
+    "test:ci": "vitest run --coverage --reporter=dot",
     "dev": "vite",
     "lint": "eslint . --max-warnings 0",
     "lint:fix": "eslint . --fix",
@@ -58,15 +61,19 @@
     "@eslint/js": "9.39.1",
     "@types/node": "20.19.9",
     "@vitejs/plugin-vue": "6.0.1",
+    "@vitest/coverage-v8": "4.0.8",
     "@vue/eslint-config-prettier": "10.2.0",
     "@vue/eslint-config-typescript": "14.6.0",
+    "@vue/test-utils": "2.4.6",
     "eslint": "9.39.1",
     "eslint-plugin-headers": "1.3.3",
     "eslint-plugin-jsdoc": "61.2.1",
     "eslint-plugin-vue": "10.5.1",
+    "happy-dom": "20.0.10",
     "prettier": "3.6.2",
     "typescript": "5.9.3",
     "vite": "7.2.2",
+    "vite-tsconfig-paths": "5.1.4",
     "vitest": "4.0.8",
     "vue-tsc": "3.1.3"
   },

package/eslint.config.js

@@ -123,9 +123,10 @@ export default defineConfigWithVueTs(
     files: [
       '**/*.test.ts',
       '**/*.spec.ts',
+      '**/*.test.js',
+      '**/*.spec.js',
       '**/__tests__/**',
       '**/*.config.*',
-      '**/*.config.*',
     ],
     rules: {
       'jsdoc/require-jsdoc': 'off',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linagora/linid-im-front-corelib",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Core library of the LinID Identity Manager project. Provides shared types, services, components, and utilities for front-end and plugin, enabling consistent integration across the LinID ecosystem.",
   "type": "module",
   "main": "dist/core-lib.umd.js",
@@ -47,21 +47,28 @@
     "@eslint/js": "9.39.1",
     "@types/node": "20.19.9",
     "@vitejs/plugin-vue": "6.0.1",
+    "@vitest/coverage-v8": "4.0.8",
     "@vue/eslint-config-prettier": "10.2.0",
     "@vue/eslint-config-typescript": "14.6.0",
+    "@vue/test-utils": "2.4.6",
     "eslint": "9.39.1",
     "eslint-plugin-headers": "1.3.3",
     "eslint-plugin-jsdoc": "61.2.1",
     "eslint-plugin-vue": "10.5.1",
+    "happy-dom": "20.0.10",
     "prettier": "3.6.2",
     "typescript": "5.9.3",
     "vite": "7.2.2",
+    "vite-tsconfig-paths": "5.1.4",
     "vitest": "4.0.8",
     "vue-tsc": "3.1.3"
   },
   "scripts": {
-    "build": "vite build && vue-tsc --declaration --emitDeclarationOnly",
-    "test": "vitest",
+    "build": "vite build && vue-tsc --declaration --emitDeclarationOnly -p tsconfig.lib.json",
+    "test": "vitest run",
+    "test:coverage": "vitest --run --coverage",
+    "test:watch": "vitest",
+    "test:ci": "vitest run --coverage --reporter=dot",
     "dev": "vite",
     "lint": "eslint . --max-warnings 0",
     "lint:fix": "eslint . --fix",

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

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,138 @@
+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

@@ -0,0 +1,146 @@
+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');
+    });
+  });
+});

package/tests/unit/stores/linidZoneStore.spec.js

@@ -0,0 +1,94 @@
+import { createPinia, setActivePinia } from 'pinia';
+import { useLinidZoneStore } from 'src/stores/linidZoneStore';
+import { beforeEach, describe, expect, it } from 'vitest';
+
+describe('Test store: linidZoneStore', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+  });
+
+  describe('Test initial state', () => {
+    it('should initialize with empty zones', () => {
+      const store = useLinidZoneStore();
+
+      expect(store.zones).toEqual({});
+    });
+  });
+
+  describe('Test function: register', () => {
+    it('should register an entry in a new zone', () => {
+      const store = useLinidZoneStore();
+      const entry = {
+        plugin: 'test-plugin/TestComponent',
+        props: {},
+      };
+
+      store.register('list-page.sidebar', entry);
+
+      expect(store.zones['list-page.sidebar']).toBeDefined();
+      expect(store.zones['list-page.sidebar']).toHaveLength(1);
+      expect(store.zones['list-page.sidebar'][0]).toEqual(entry);
+    });
+
+    it('should register multiple entries in the same zone', () => {
+      const store = useLinidZoneStore();
+      const entry1 = {
+        plugin: 'plugin-1/Component1',
+        props: {},
+      };
+      const entry2 = {
+        plugin: 'plugin-2/Component2',
+        props: { value: 42 },
+      };
+
+      store.register('list-page.sidebar', entry1);
+      store.register('list-page.sidebar', entry2);
+
+      expect(store.zones['list-page.sidebar']).toHaveLength(2);
+      expect(store.zones['list-page.sidebar'][0]).toEqual(entry1);
+      expect(store.zones['list-page.sidebar'][1]).toEqual(entry2);
+    });
+
+    it('should register entries in different zones independently', () => {
+      const store = useLinidZoneStore();
+      const headerEntry = {
+        plugin: 'header-plugin/HeaderComponent',
+        props: {},
+      };
+      const footerEntry = {
+        plugin: 'footer-plugin/FooterComponent',
+        props: {},
+      };
+
+      store.register('list-page.header', headerEntry);
+      store.register('list-page.footer', footerEntry);
+
+      expect(store.zones['list-page.header']).toHaveLength(1);
+      expect(store.zones['list-page.footer']).toHaveLength(1);
+      expect(store.zones['list-page.header'][0]).toEqual(headerEntry);
+      expect(store.zones['list-page.footer'][0]).toEqual(footerEntry);
+    });
+
+    it('should handle entries with complex props', () => {
+      const store = useLinidZoneStore();
+      const entry = {
+        plugin: 'complex-plugin/ComplexComponent',
+        props: {
+          title: 'Test Title',
+          count: 123,
+          enabled: true,
+          config: {
+            nested: {
+              value: 'deep',
+            },
+          },
+          items: ['a', 'b', 'c'],
+        },
+      };
+
+      store.register('list-page.body', entry);
+
+      expect(store.zones['list-page.body'][0].props).toEqual(entry.props);
+    });
+  });
+});

package/tsconfig.json

@@ -1,30 +1,14 @@
 {
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": [
-      "ESNext",
-      "DOM"
-    ],
-    "allowJs": true,
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "types": [
-      "node",
-      "vite/client",
-      "vue"
-    ],
-    "declaration": true,
-    "declarationDir": "dist/types",
-    "outDir": "dist"
-  },
-  "include": [
-    "src/**/*.ts",
-    "src/**/*.vue",
-    "vite.config.ts"
+  "files": [],
+  "references": [
+    {
+      "path": "./tsconfig.node.json"
+    },
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
   ]
 }

package/tsconfig.lib.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext", "DOM"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "types": ["node", "vite/client", "vue"],
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "exclude": ["vite.config.ts", "tests", "vitest.config.ts"]
+}

package/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "nodenext",
+    "strict": true,
+    "types": ["node"]
+  },
+  "include": ["vite.config.ts", "vitest.config.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "baseUrl": ".",
+    "outDir": "./out-tsc/vitest",
+    "allowJs": true,
+    "module": "esnext",
+    "moduleResolution": "bundler"
+  },
+  "include": ["tests", "src"],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/vite.config.ts

@@ -1,22 +1,17 @@
-/// <reference types="node" />
-import {defineConfig} from "vite";
-import vue from "@vitejs/plugin-vue";
-import path from "path";
-import fs from "fs";
-import {fileURLToPath} from "url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import vue from '@vitejs/plugin-vue';
+import fs from 'fs';
+import path from 'path';
+import { defineConfig } from 'vite';
 
 export default defineConfig({
   plugins: [
     vue(),
 
     {
-      name: "copy-package-json",
+      name: 'copy-package-json',
       closeBundle() {
-        const src = path.resolve(__dirname, "package.json");
-        const dest = path.resolve(__dirname, "dist", "package.json");
+        const src = path.resolve(__dirname, 'package.json');
+        const dest = path.resolve(__dirname, 'dist', 'package.json');
         if (fs.existsSync(src)) {
           fs.copyFileSync(src, dest);
         }
@@ -26,15 +21,15 @@ export default defineConfig({
 
   build: {
     lib: {
-      entry: path.resolve(__dirname, "src/index.ts"),
-      name: "CoreLib",
+      entry: path.resolve(__dirname, 'src/index.ts'),
+      name: 'CoreLib',
       fileName: (format) => `core-lib.${format}.js`,
     },
     rollupOptions: {
-      external: ["vue"],
+      external: ['vue'],
       output: {
         globals: {
-          vue: "Vue",
+          vue: 'Vue',
         },
       },
     },

package/vitest.config.ts

@@ -0,0 +1,19 @@
+import vue from '@vitejs/plugin-vue';
+import tsconfigPaths from 'vite-tsconfig-paths';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'happy-dom',
+    globals: true,
+    include: ['tests/unit/**/*.{test,spec}.js'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'html', 'lcov'],
+      reportsDirectory: './coverage',
+      include: ['src/**/*.{ts,js,vue}'],
+      exclude: ['**/tests/**', 'src/types/**', 'src/index.ts'],
+    },
+  },
+  plugins: [vue(), tsconfigPaths()],
+});

package/dist/types/vite.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("vite").UserConfig;
-export default _default;