mage-obsidian 1.1.0 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mage-obsidian",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Mage Obsidian Ultis",
   "main": "./src/scripts/buildThemes.js",
   "keywords": [
@@ -22,7 +22,8 @@
     ".": "./src/scripts/buildThemes.js",
     "./service/": "./src/service/",
     "./utils/": "./src/utils/",
-    "./config/": "./src/config/"
+    "./config/": "./src/config/",
+    "./service/*": "./src/service/*"
   },
   "dependencies": {
     "chalk": "^5.4.1",

package/src/__tests__/fixtures/interceptors/pluginForNonFunction.js

@@ -0,0 +1,7 @@
+
+export function beforeConfig() {
+    console.log('Should not run');
+}
+export function beforeDefault() {
+    console.log('Should not run');
+}

package/src/__tests__/fixtures/interceptors/pluginModule.js

@@ -6,3 +6,8 @@ export function beforeTargetFunction(arg) {
 export function afterAnotherFunction(result) {
     return `${result} - Modified`;
 }
+
+export function beforeDefault() {
+    return ['Default Modified'];
+}
+

package/src/__tests__/fixtures/interceptors/targetNonFunction.js

@@ -0,0 +1,7 @@
+
+export const config = {
+    some: 'value'
+};
+export default {
+    main: 'config'
+};

package/src/__tests__/service/generateInterceptors.test.js

@@ -7,12 +7,14 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const fixturesDir = path.resolve(__dirname, '../fixtures/interceptors');
 const targetModulePath = path.join(fixturesDir, 'targetModule.js');
 const pluginModulePath = path.join(fixturesDir, 'pluginModule.js');
+const targetNonFunctionPath = path.join(fixturesDir, 'targetNonFunction.js');
+const pluginForNonFunctionPath = path.join(fixturesDir, 'pluginForNonFunction.js');
 
 describe('generateInterceptors', () => {
     let generateInterceptorsService;
     let themeResolverMock;
     let moduleResolverMock;
-    let pluginManager;
+    let interceptorManager;
 
     beforeEach(async () => {
         jest.resetModules();
@@ -35,9 +37,15 @@ describe('generateInterceptors', () => {
             default: moduleResolverMock
         }));
 
-        // Import real pluginManager to reset state
-        pluginManager = (await import('../../service/pluginManager.js')).default;
-        pluginManager.plugins = {};
+        jest.unstable_mockModule('../../service/configResolver.js', () => ({
+            default: {
+                resolveLibRealPath: jest.fn().mockReturnValue('/mocked/path/to/interceptorManager')
+            }
+        }));
+
+        // Import real interceptorManager to reset state
+        interceptorManager = (await import('../../service/interceptorManager.js')).default;
+        interceptorManager.interceptors = {};
 
         generateInterceptorsService = (await import('../../service/generateInterceptors.js')).default;
     });
@@ -50,17 +58,14 @@ describe('generateInterceptors', () => {
         });
 
         moduleResolverMock.getModuleConfigByThemeConfig.mockResolvedValue({
-            'Vendor_TargetModule': {
-                src: '/path/to/vendor/target',
-                interceptors: [
-                    {
-                        name: 'TestPlugin',
-                        target: 'Vendor_TargetModule::js/target.js',
-                        plugin: 'Vendor_PluginModule::js/plugin.js',
-                        sortOrder: 10,
-                        active: true
-                    }
-                ]
+            interceptors: {
+                'TestPlugin': {
+                    name: 'TestPlugin',
+                    target: 'Vendor_TargetModule::js/target.js',
+                    interceptor: 'Vendor_PluginModule::js/plugin.js',
+                    sortOrder: 10,
+                    active: true
+                }
             }
         });
 
@@ -81,14 +86,15 @@ describe('generateInterceptors', () => {
         expect(interceptorData).toHaveProperty('proxy');
         expect(interceptorData).toHaveProperty('source');
         expect(interceptorData).toHaveProperty('targetPath', targetModulePath);
-        expect(interceptorData.plugins).toHaveLength(1);
-        expect(interceptorData.plugins[0].name).toBe('TestPlugin');
+        expect(interceptorData.interceptors).toHaveLength(1);
+        expect(interceptorData.interceptors[0].name).toBe('TestPlugin');
 
         // Verify Source Code Generation
         const source = interceptorData.source;
-        expect(source).toContain(`import * as originalModule from '/@fs${targetModulePath}';`);
-        expect(source).toContain(`import * as plugin_0 from '/@fs${pluginModulePath}';`);
-        expect(source).toContain(`pluginManager.addPlugin('${targetIdentifier}::targetFunction', 'TestPlugin', 'before', plugin_0.beforeTargetFunction, 10);`);
+        expect(source).toContain(`import * as originalModule from '/@fs${targetModulePath}?originalIntercepted';`);
+        expect(source).toContain(`import * as interceptor_0 from '/@fs${pluginModulePath}';`);
+        expect(source).toContain(`interceptorManager.addInterceptor('${targetIdentifier}::targetFunction', 'TestPlugin', 'before', interceptor_0.beforeTargetFunction, 10);`);
+        expect(source).toContain(`interceptorManager.addInterceptor('${targetIdentifier}::default', 'TestPlugin', 'before', interceptor_0.beforeDefault, 10);`);
         expect(source).toContain(`export const targetFunction = proxy.targetFunction;`);
 
         // Verify Proxy Behavior
@@ -98,6 +104,14 @@ describe('generateInterceptors', () => {
 
         const resultAnother = await proxy.anotherFunction();
         expect(resultAnother).toBe('Another - Modified');
+
+        const resultDefault = await proxy.default();
+        expect(resultDefault).toBe('Default'); // The mock plugin returns ['Default Modified'] but the original function ignores args and returns 'Default'. 
+        // Wait, before interceptor modifies arguments. 
+        // targetModule.js: export default function defaultExport() { return 'Default'; }
+        // It doesn't take arguments, so modifying arguments won't change output unless we check arguments.
+        // But we just want to verify it was registered.
+
     });
 
     test('should handle missing target module gracefully', async () => {
@@ -115,16 +129,13 @@ describe('generateInterceptors', () => {
         const themeName = 'Vendor/theme-test';
         themeResolverMock.getThemeConfig.mockReturnValue({});
         moduleResolverMock.getModuleConfigByThemeConfig.mockResolvedValue({
-            'Vendor_TargetModule': {
-                src: '/path/to/vendor/target',
-                interceptors: [
-                    {
-                        name: 'BadPlugin',
-                        target: 'Vendor_TargetModule::js/target.js',
-                        plugin: 'Vendor_PluginModule::js/plugin.js',
-                        sortOrder: 10
-                    }
-                ]
+            interceptors: {
+                'BadPlugin': {
+                    name: 'BadPlugin',
+                    target: 'Vendor_TargetModule::js/target.js',
+                    interceptor: 'Vendor_PluginModule::js/plugin.js',
+                    sortOrder: 10
+                }
             }
         });
 
@@ -142,4 +153,44 @@ describe('generateInterceptors', () => {
             .rejects
             .toThrow(/does not export/);
     });
+
+    test('should skip interception for non-function exports', async () => {
+        const themeName = 'Vendor/theme-test';
+
+        themeResolverMock.getThemeConfig.mockReturnValue({
+            src: '/path/to/theme'
+        });
+
+        moduleResolverMock.getModuleConfigByThemeConfig.mockResolvedValue({
+            interceptors: {
+                'TestPlugin': {
+                    name: 'TestPlugin',
+                    target: 'Vendor_TargetModule::js/targetNonFunction.js',
+                    interceptor: 'Vendor_PluginModule::js/pluginForNonFunction.js',
+                    sortOrder: 10,
+                    active: true
+                }
+            }
+        });
+
+        const allFilesMap = {
+            'Vendor_TargetModule/js/targetNonFunction': targetNonFunctionPath,
+            'Vendor_PluginModule/js/pluginForNonFunction': pluginForNonFunctionPath
+        };
+
+        moduleResolverMock.getAllJsVueFilesWithInheritanceCached.mockReturnValue(allFilesMap);
+
+        const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+        const result = await generateInterceptorsService.generateInterceptors(themeName);
+
+        const targetIdentifier = 'Vendor_TargetModule::js/targetNonFunction.js';
+        
+        // Since both 'config' and 'default' are objects, and we are trying to intercept them,
+        // they should be skipped. If all are skipped, the targetIdentifier should not be in result.
+        expect(result[targetIdentifier]).toBeUndefined();
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('is not a function'));
+
+        consoleSpy.mockRestore();
+    });
 });

package/src/__tests__/service/interceptorManager_magento_behavior.test.js

@@ -0,0 +1,137 @@
+
+import { jest } from '@jest/globals';
+import interceptorManager from '../../service/interceptorManager.js';
+
+describe('InterceptorManager Magento Behavior', () => {
+    beforeEach(() => {
+        // Reset interceptors before each test
+        interceptorManager.interceptors = {};
+    });
+
+    test('Before interceptors: should chain arguments and handle null returns', async () => {
+        const targetName = 'Test::beforeChain';
+        const originalFn = jest.fn((arg1, arg2) => `Original: ${arg1}, ${arg2}`);
+        const context = {};
+
+        // Interceptor 1: Modifies arguments
+        const beforeInterceptor1 = jest.fn((arg1, arg2) => {
+            return [arg1 + '_mod1', arg2 + '_mod1'];
+        });
+
+        // Interceptor 2: Returns null (should keep arguments from Interceptor 1)
+        const beforeInterceptor2 = jest.fn((arg1, arg2) => {
+            return null;
+        });
+
+        // Interceptor 3: Modifies arguments again
+        const beforeInterceptor3 = jest.fn((arg1, arg2) => {
+            return [arg1 + '_mod3', arg2 + '_mod3'];
+        });
+
+        interceptorManager.addInterceptor(targetName, 'Interceptor1', 'before', beforeInterceptor1, 10);
+        interceptorManager.addInterceptor(targetName, 'Interceptor2', 'before', beforeInterceptor2, 20);
+        interceptorManager.addInterceptor(targetName, 'Interceptor3', 'before', beforeInterceptor3, 30);
+
+        const result = await interceptorManager.execute(targetName, originalFn, context, 'A', 'B');
+
+        // Verify Interceptor 1 received original args
+        expect(beforeInterceptor1).toHaveBeenCalledWith('A', 'B');
+
+        // Verify Interceptor 2 received args modified by Interceptor 1
+        expect(beforeInterceptor2).toHaveBeenCalledWith('A_mod1', 'B_mod1');
+
+        // Verify Interceptor 3 received args from Interceptor 1 (since Interceptor 2 returned null)
+        expect(beforeInterceptor3).toHaveBeenCalledWith('A_mod1', 'B_mod1');
+
+        // Verify Original received args modified by Interceptor 3
+        expect(originalFn).toHaveBeenCalledWith('A_mod1_mod3', 'B_mod1_mod3');
+
+        expect(result).toBe('Original: A_mod1_mod3, B_mod1_mod3');
+    });
+
+    test('Around interceptors: should wrap execution and modify args/result', async () => {
+        const targetName = 'Test::aroundChain';
+        const originalFn = jest.fn((arg) => `Original(${arg})`);
+        const context = {};
+
+        // Outer Around Interceptor
+        const aroundInterceptor1 = jest.fn(async (proceed, arg) => {
+            const result = await proceed(arg + '_outerIn');
+            return `Outer(${result})`;
+        });
+
+        // Inner Around Interceptor
+        const aroundInterceptor2 = jest.fn(async (proceed, arg) => {
+            const result = await proceed(arg + '_innerIn');
+            return `Inner(${result})`;
+        });
+
+        interceptorManager.addInterceptor(targetName, 'Interceptor1', 'around', aroundInterceptor1, 10);
+        interceptorManager.addInterceptor(targetName, 'Interceptor2', 'around', aroundInterceptor2, 20);
+
+        const result = await interceptorManager.execute(targetName, originalFn, context, 'Start');
+
+        // Execution flow:
+        // Interceptor1 (Start) -> calls proceed('Start_outerIn')
+        //   -> Interceptor2 ('Start_outerIn') -> calls proceed('Start_outerIn_innerIn')
+        //     -> Original ('Start_outerIn_innerIn') -> returns 'Original(Start_outerIn_innerIn)'
+        //   -> Interceptor2 returns 'Inner(Original(Start_outerIn_innerIn))'
+        // -> Interceptor1 returns 'Outer(Inner(Original(Start_outerIn_innerIn)))'
+
+        expect(originalFn).toHaveBeenCalledWith('Start_outerIn_innerIn');
+        expect(result).toBe('Outer(Inner(Original(Start_outerIn_innerIn)))');
+    });
+
+    test('After interceptors: should chain results', async () => {
+        const targetName = 'Test::afterChain';
+        const originalFn = jest.fn(() => 'Original');
+        const context = {};
+
+        const afterInterceptor1 = jest.fn((result) => {
+            return result + '_After1';
+        });
+
+        const afterInterceptor2 = jest.fn((result) => {
+            return result + '_After2';
+        });
+
+        interceptorManager.addInterceptor(targetName, 'Interceptor1', 'after', afterInterceptor1, 10);
+        interceptorManager.addInterceptor(targetName, 'Interceptor2', 'after', afterInterceptor2, 20);
+
+        const result = await interceptorManager.execute(targetName, originalFn, context);
+
+        expect(afterInterceptor1).toHaveBeenCalledWith('Original');
+        expect(afterInterceptor2).toHaveBeenCalledWith('Original_After1');
+        expect(result).toBe('Original_After1_After2');
+    });
+
+    test('Full Chain: Before -> Around -> Original -> After', async () => {
+        const targetName = 'Test::fullChain';
+        const originalFn = jest.fn((arg) => `Original(${arg})`);
+        const context = {};
+
+        // Before: Modifies arg
+        interceptorManager.addInterceptor(targetName, 'Before', 'before', (arg) => [arg + '_Before'], 10);
+
+        // Around: Wraps and modifies arg further
+        interceptorManager.addInterceptor(targetName, 'Around', 'around', async (proceed, arg) => {
+            const res = await proceed(arg + '_AroundIn');
+            return `Around(${res})`;
+        }, 20);
+
+        // After: Modifies result
+        interceptorManager.addInterceptor(targetName, 'After', 'after', (res) => res + '_After', 30);
+
+        const result = await interceptorManager.execute(targetName, originalFn, context, 'Start');
+
+        // Flow:
+        // Before: Start -> Start_Before
+        // Around: Start_Before -> calls proceed(Start_Before_AroundIn)
+        // Original: Start_Before_AroundIn -> returns Original(Start_Before_AroundIn)
+        // Around: returns Around(Original(Start_Before_AroundIn))
+        // After: receives Around(...) -> returns Around(...)_After
+
+        expect(originalFn).toHaveBeenCalledWith('Start_Before_AroundIn');
+        expect(result).toBe('Around(Original(Start_Before_AroundIn))_After');
+    });
+});

package/src/__tests__/vite-plugins/interceptorsPlugin.test.js

@@ -0,0 +1,121 @@
+
+import { jest } from '@jest/globals';
+// import interceptorsPlugin from '../../service/interceptorsPlugin.js'; // Removed static import
+
+describe('interceptorsPlugin', () => {
+    let plugin;
+    let mockGenerateInterceptors;
+    let mockResolve;
+    const themeName = 'Vendor/theme-test';
+
+    beforeEach(async () => {
+        jest.resetModules(); // Reset modules to ensure fresh imports and mocks
+        jest.clearAllMocks();
+
+        // Mock configResolver to prevent process.exit
+        jest.unstable_mockModule('../../service/configResolver.js', () => ({
+            default: {
+                resolveLibRealPath: jest.fn()
+            }
+        }));
+
+        // Mock generateInterceptorsService
+        mockGenerateInterceptors = jest.fn();
+        
+        // Mock the service module
+        jest.unstable_mockModule('../../service/generateInterceptors.js', () => ({
+            default: {
+                generateInterceptors: mockGenerateInterceptors
+            }
+        }));
+
+        // Re-import the plugin to use the mock
+        const pluginModule = await import('../../service/interceptorsPlugin.js');
+        const createPlugin = pluginModule.default;
+
+        plugin = createPlugin({ themeName });
+
+        // Mock Vite context
+        mockResolve = jest.fn();
+        plugin.resolve = mockResolve; // Bind mock to the plugin instance context if needed, but resolveId is called on context
+    });
+
+    test('should generate interceptors on buildStart', async () => {
+        mockGenerateInterceptors.mockResolvedValue({});
+        await plugin.buildStart.call({});
+        expect(mockGenerateInterceptors).toHaveBeenCalledWith(themeName);
+    });
+
+    test('should resolve to virtual ID if interceptor exists', async () => {
+        const targetPath = '/abs/path/to/target.js';
+        const interceptors = {
+            'Target::Method': {
+                targetPath: targetPath,
+                source: 'export const intercepted = true;'
+            }
+        };
+        mockGenerateInterceptors.mockResolvedValue(interceptors);
+        
+        // Initialize plugin
+        await plugin.buildStart.call({});
+
+        // Mock resolve to return the absolute path
+        const context = {
+            resolve: jest.fn().mockResolvedValue({ id: targetPath })
+        };
+
+        const result = await plugin.resolveId.call(context, './target.js', '/importer.js');
+        
+        expect(context.resolve).toHaveBeenCalledWith('./target.js', '/importer.js', { skipSelf: true });
+        expect(result).toBe(`\0interceptor:${targetPath}`);
+    });
+
+    test('should NOT resolve to virtual ID if importer IS the virtual ID (loop prevention)', async () => {
+        const targetPath = '/abs/path/to/target.js';
+        const interceptors = {
+            'Target::Method': {
+                targetPath: targetPath,
+                source: 'export const intercepted = true;'
+            }
+        };
+        mockGenerateInterceptors.mockResolvedValue(interceptors);
+        
+        await plugin.buildStart.call({});
+
+        const context = {
+            resolve: jest.fn().mockResolvedValue({ id: targetPath })
+        };
+
+        const virtualId = `\0interceptor:${targetPath}`;
+        const result = await plugin.resolveId.call(context, './target.js', virtualId);
+        
+        expect(result).toBeNull();
+    });
+
+    test('should load generated source for virtual ID', async () => {
+        const targetPath = '/abs/path/to/target.js';
+        const sourceCode = 'export const intercepted = true;';
+        const interceptors = {
+            'Target::Method': {
+                targetPath: targetPath,
+                source: sourceCode
+            }
+        };
+        mockGenerateInterceptors.mockResolvedValue(interceptors);
+        
+        await plugin.buildStart.call({});
+
+        const virtualId = `\0interceptor:${targetPath}`;
+        const result = plugin.load.call({}, virtualId);
+        
+        expect(result).toBe(sourceCode);
+    });
+
+    test('should return null for unknown virtual ID', async () => {
+        mockGenerateInterceptors.mockResolvedValue({});
+        await plugin.buildStart.call({});
+
+        const result = plugin.load.call({}, '\0interceptor:/unknown.js');
+        expect(result).toBeNull();
+    });
+});

package/src/scripts/buildThemes.js

@@ -43,6 +43,7 @@ function tryCreateEnvFile() {
         VITE_SERVER_SECURE: 'true',
         VITE_HMR_PATH: '/__vite_ping',
         MAGENTO_HOST: 'magento.test',
+        VITE_SERVER_ALLOWED_HOSTS: 'magento.test,localhost'
     };
 
     console.log(chalk.blue('Creating `.env` file with default or user-provided values...'));
@@ -66,7 +67,7 @@ function tryCreateEnvFile() {
 }
 
 function validateEnv() {
-    const requiredEnvVars = ['VITE_SERVER_HOST', 'VITE_SERVER_PORT', 'VITE_SERVER_SECURE', 'VITE_HMR_PATH', 'MAGENTO_HOST'];
+    const requiredEnvVars = ['VITE_SERVER_HOST', 'VITE_SERVER_PORT', 'VITE_SERVER_SECURE', 'VITE_HMR_PATH', 'MAGENTO_HOST', 'VITE_SERVER_ALLOWED_HOSTS'];
     let missingEnvVars = [];
     for (const envVar of requiredEnvVars) {
         if (!process.env[envVar]) {

package/src/service/configResolver.js

@@ -14,7 +14,6 @@ try {
 }
 
 export const getMagentoConfig = () => MAGENTO_CONFIG;
-
 export const getModulesConfigArray = () => Object.entries(MAGENTO_CONFIG.modules);
 export const getThemesConfigArray = () => Object.entries(MAGENTO_CONFIG.themes);
 export const getAllMagentoModulesEnabled = () => MAGENTO_CONFIG.allModules;
@@ -29,6 +28,26 @@ export const getModuleDefinition = (moduleName) =>
 export const getThemeDefinition = (themeName) =>
     MAGENTO_CONFIG.themes[themeName];
 
+export const MODE = process.env.NODE_ENV;
+
+export function resolveLibPath(lib) {
+    return path.join(MAGENTO_CONFIG.LIB_PATH, lib);
+}
+
+export function resolveNodePath(packageName) {
+    try {
+        const resolvedPath = import.meta.resolve(packageName);
+        return resolvedPath.replace('file://', '');
+    } catch (error) {
+        console.error(`The package ${packageName} can't be resolved.`);
+        throw error;
+    }
+}
+
+export function resolveLibRealPath(lib) {
+    return MODE === 'production' ? lib : resolveNodePath(lib);
+}
+
 export default {
     getMagentoConfig,
     getModulesConfigArray,
@@ -37,5 +56,8 @@ export default {
     isDev,
     getOutputDirFromTheme,
     getModuleDefinition,
-    getThemeDefinition
-};
+    getThemeDefinition,
+    resolveLibPath,
+    resolveNodePath,
+    resolveLibRealPath
+};

package/src/service/generateInterceptors.js

@@ -1,26 +1,28 @@
 import path from "path";
 import { pathToFileURL, fileURLToPath } from "url";
-import themeResolver from './themeResolverSync.js';
-import moduleResolver from './moduleResolver.js';
-import pluginManager from './pluginManager.js';
+import themeResolver from 'mage-obsidian/service/themeResolverSync.js';
+import moduleResolver from 'mage-obsidian/service/moduleResolver.js';
+import interceptorManager from 'mage-obsidian/service/interceptorManager.js';
+import configResolver from "mage-obsidian/service/configResolver.js";
 
 const interceptorsRegisteredByTheme = new Map();
 const generatedInterceptorsCache = new Map();
+export const KEY_INTERCEPTED = 'originalIntercepted';
 
 /**
  * Resolves the absolute path of a file using the cached file map
- * @param {string} identifier 
- * @param {Object} fileMap 
+ * @param {string} identifier
+ * @param {Object} fileMap
  * @returns {string|null}
  */
 function resolvePathFromMap(identifier, fileMap) {
     const [moduleName, relativePath] = identifier.split('::');
     if (!moduleName || !relativePath) return null;
-    
+
     const parsed = path.parse(relativePath);
     const keyPath = path.join(parsed.dir, parsed.name);
     const key = `${moduleName}/${keyPath}`;
-    
+
     return fileMap[key] || null;
 }
 
@@ -31,31 +33,28 @@ async function registerInterceptors(themeName) {
 
     const themeConfig = await themeResolver.getThemeConfig(themeName);
     const modulesConfig = await moduleResolver.getModuleConfigByThemeConfig(themeName, themeConfig);
-    
+    if (!modulesConfig || modulesConfig.interceptors === undefined) {
+        interceptorsRegisteredByTheme.set(themeName, {});
+        return {};
+    }
     // Map<Target, Map<PluginName, PluginConfig>>
     const interceptorsMap = new Map();
+    for (const [interceptorName, interceptorDefinition] of Object.entries( modulesConfig.interceptors)) {
+        const { target } = interceptorDefinition;
+        if (!interceptorName || !target) continue;
 
-    for (const [moduleName, moduleConfig] of Object.entries(modulesConfig)) {
-        if (!moduleConfig.interceptors || !Array.isArray(moduleConfig.interceptors)) {
-            continue;
+        if (!interceptorsMap.has(target)) {
+            interceptorsMap.set(target, new Map());
         }
-        for (const c of moduleConfig.interceptors) {
-            const { name, target } = c;
-            if (!name || !target) continue;
 
-            if (!interceptorsMap.has(target)) {
-                interceptorsMap.set(target, new Map());
-            }
+        const targetPlugins = interceptorsMap.get(target);
 
-            const targetPlugins = interceptorsMap.get(target);
-            
-            if (targetPlugins.has(name)) {
-                // Merge existing plugin config with new config (allows overriding sortOrder, active, etc.)
-                const existing = targetPlugins.get(name);
-                targetPlugins.set(name, { ...existing, ...c });
-            } else {
-                targetPlugins.set(name, { ...c, module: moduleName });
-            }
+        if (targetPlugins.has(interceptorName)) {
+            // Merge existing plugin config with new config (allows overriding sortOrder, active, etc.)
+            const existing = targetPlugins.get(interceptorName);
+            targetPlugins.set(interceptorName, { ...existing, ...interceptorDefinition });
+        } else {
+            targetPlugins.set(interceptorName, { ...interceptorDefinition });
         }
     }
 
@@ -65,7 +64,7 @@ async function registerInterceptors(themeName) {
         const plugins = Array.from(pluginsMap.values())
             .filter(p => p.active !== false) // Filter out inactive plugins
             .sort((a, b) => (a.sortOrder || 10) - (b.sortOrder || 10));
-        
+
         if (plugins.length > 0) {
             result[target] = plugins;
         }
@@ -81,8 +80,7 @@ async function generateInterceptors(themeName) {
     }
 
     const interceptorsConfig = await registerInterceptors(themeName);
-    const modulesConfig = await moduleResolver.getModuleConfigByThemeConfig(themeName, await themeResolver.getThemeConfig(themeName));
-    
+
     // Get all files map from cache
     let allFilesMap = {};
     try {
@@ -94,96 +92,99 @@ async function generateInterceptors(themeName) {
 
     const interceptors = {};
 
-    for (const [targetIdentifier, plugins] of Object.entries(interceptorsConfig)) {
+    for (const [target, plugins] of Object.entries(interceptorsConfig)) {
         // 1. Resolve Target Path
-        const targetPath = resolvePathFromMap(targetIdentifier, allFilesMap);
+        const targetPath = resolvePathFromMap(target, allFilesMap);
         if (!targetPath) {
-            console.warn(`Target module not found for identifier: ${targetIdentifier}`);
+            console.warn(`Target module not found for identifier: ${target}`);
             continue;
         }
 
-        // 2. Load Target Module to inspect exports
         let targetModule;
         try {
             targetModule = await import(pathToFileURL(targetPath).href);
         } catch (e) {
-            console.error(`Failed to import target module ${targetIdentifier}:`, e.message);
+            console.error(`Failed to import target module ${target}:`, e.message);
             continue;
         }
 
         const targetExports = Object.keys(targetModule);
         const methodsToIntercept = new Set();
 
-        // 3. Validate and Register Plugins
-        const validPlugins = [];
-        for (const pluginConfig of plugins) {
-            const pluginPath = resolvePathFromMap(pluginConfig.plugin, allFilesMap);
-            if (!pluginPath) {
-                console.warn(`Plugin module not found: ${pluginConfig.plugin}`);
+        // 3. Validate and Register Interceptors
+        const validInterceptors = [];
+        for (const interceptorConfig of plugins) {
+            const interceptorPath = resolvePathFromMap(interceptorConfig.interceptor, allFilesMap);
+            if (!interceptorPath) {
+                console.warn(`Interceptor module not found: ${interceptorConfig.interceptor}`);
                 continue;
             }
 
-            let pluginModule;
+            let interceptorModule;
             try {
-                pluginModule = await import(pathToFileURL(pluginPath).href);
+                interceptorModule = await import(pathToFileURL(interceptorPath).href);
             } catch (e) {
-                console.error(`Failed to import plugin module ${pluginConfig.plugin}:`, e.message);
+                console.error(`Failed to import interceptor module ${interceptorConfig.interceptor}:`, e.message);
                 continue;
             }
 
-            const pluginMethods = [];
-            for (const pluginExport of Object.keys(pluginModule)) {
+            const interceptorMethods = [];
+            for (const interceptorExport of Object.keys(interceptorModule)) {
                 let type, targetMethod;
-                
-                if (pluginExport.startsWith('before')) {
+
+                if (interceptorExport.startsWith('before')) {
                     type = 'before';
-                    targetMethod = pluginExport.substring(6);
-                } else if (pluginExport.startsWith('around')) {
+                    targetMethod = interceptorExport.substring(6);
+                } else if (interceptorExport.startsWith('around')) {
                     type = 'around';
-                    targetMethod = pluginExport.substring(6);
-                } else if (pluginExport.startsWith('after')) {
+                    targetMethod = interceptorExport.substring(6);
+                } else if (interceptorExport.startsWith('after')) {
                     type = 'after';
-                    targetMethod = pluginExport.substring(5);
+                    targetMethod = interceptorExport.substring(5);
                 } else {
                     continue;
                 }
 
                 // Check if target method exists in target module
                 if (!targetExports.includes(targetMethod) && targetMethod !== 'default') {
-                     const lowerFirst = targetMethod.charAt(0).toLowerCase() + targetMethod.slice(1);
-                     if (targetExports.includes(lowerFirst)) {
-                         targetMethod = lowerFirst;
-                     } else {
-                        // Skip invalid methods but don't crash the whole process? 
+                    const lowerFirst = targetMethod.charAt(0).toLowerCase() + targetMethod.slice(1);
+                    if (targetExports.includes(lowerFirst)) {
+                        targetMethod = lowerFirst;
+                    } else {
+                        // Skip invalid methods but don't crash the whole process?
                         // User requested error if not found.
-                        throw new Error(`Plugin ${pluginConfig.name} (${pluginConfig.plugin}) exports '${pluginExport}' but target ${targetIdentifier} does not export '${targetMethod}'`);
-                     }
+                        throw new Error(`Interceptor ${interceptorConfig.name} (${interceptorConfig.interceptor}) exports '${interceptorExport}' but target ${target} does not export '${targetMethod}'`);
+                    }
                 }
 
-                // Register the plugin with PluginManager (Runtime)
-                const methodKey = `${targetIdentifier}::${targetMethod}`;
-                pluginManager.addPlugin(
+                if (typeof targetModule[targetMethod] !== 'function') {
+                    console.warn(`Interceptor ${interceptorConfig.name} (${interceptorConfig.interceptor}) exports '${interceptorExport}' but target ${target} export '${targetMethod}' is not a function.`);
+                    continue;
+                }
+
+                const methodKey = `${target}::${targetMethod}`;
+                interceptorManager.addInterceptor(
                     methodKey,
-                    pluginConfig.name,
+                    interceptorConfig.name,
                     type,
-                    pluginModule[pluginExport],
-                    pluginConfig.sortOrder
+                    interceptorModule[interceptorExport],
+                    interceptorConfig.sortOrder
                 );
-                
+
                 methodsToIntercept.add(targetMethod);
-                pluginMethods.push({
-                    exportName: pluginExport,
+                interceptorMethods.push({
+                    exportName: interceptorExport,
                     type,
                     targetMethod,
-                    sortOrder: pluginConfig.sortOrder
+                    sortOrder: interceptorConfig.sortOrder
                 });
             }
 
-            if (pluginMethods.length > 0) {
-                validPlugins.push({
-                    ...pluginConfig,
-                    path: pluginPath,
-                    methods: pluginMethods
+            if (interceptorMethods.length > 0) {
+                validInterceptors.push({
+                    ...interceptorConfig,
+                    path: interceptorPath,
+                    methods: interceptorMethods
                 });
             }
         }
@@ -191,15 +192,15 @@ async function generateInterceptors(themeName) {
         // 4. Create Interceptor Proxy & Source Code
         if (methodsToIntercept.size > 0) {
             const wrapper = { ...targetModule };
-            const proxy = pluginManager.intercept(wrapper, targetIdentifier, true);
-            
-            const source = generateInterceptorCode(targetIdentifier, targetPath, validPlugins, targetExports);
+            const proxy = interceptorManager.intercept(wrapper, target, true);
 
-            interceptors[targetIdentifier] = {
+            const source = generateInterceptorCode(target, targetPath, validInterceptors, targetExports);
+
+            interceptors[target] = {
                 proxy,
                 targetPath,
                 targetModule,
-                plugins: validPlugins,
+                interceptors: validInterceptors,
                 source
             };
         }
@@ -209,36 +210,36 @@ async function generateInterceptors(themeName) {
     return interceptors;
 }
 
-function generateInterceptorCode(targetIdentifier, targetPath, plugins, targetExports) {
+function generateInterceptorCode(target, targetPath, interceptors, targetExports) {
     const imports = [];
     const registrations = [];
-    
+
     // Import PluginManager (Assuming it's available via alias or relative path in the build environment)
     // For Vite, we might need to adjust this path or use a virtual module ID.
     // Using a relative path from this service file might not work in the generated code context.
-    // We'll assume '@mage-obsidian/plugin-manager' or similar alias is set up, 
+    // We'll assume '@mage-obsidian/plugin-manager' or similar alias is set up,
     // or use the absolute path which Vite handles.
-    const pluginManagerPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'pluginManager.js');
-    imports.push(`import pluginManager from '/@fs${pluginManagerPath}';`);
+    const resolvedInterceptorManagerPath = configResolver.resolveLibRealPath('mage-obsidian/service/interceptorManager');
+    imports.push(`import interceptorManager from "${resolvedInterceptorManagerPath}";`);
 
     // Import Original Module
-    imports.push(`import * as originalModule from '/@fs${targetPath}';`);
-
-    // Import Plugins
-    plugins.forEach((plugin, index) => {
-        const pluginVar = `plugin_${index}`;
-        imports.push(`import * as ${pluginVar} from '/@fs${plugin.path}';`);
-        
-        plugin.methods.forEach(method => {
-            const methodKey = `${targetIdentifier}::${method.targetMethod}`;
-            registrations.push(`pluginManager.addPlugin('${methodKey}', '${plugin.name}', '${method.type}', ${pluginVar}.${method.exportName}, ${method.sortOrder});`);
+    imports.push(`import * as originalModule from '/@fs${targetPath}?${KEY_INTERCEPTED}';`);
+
+    // Import Interceptors
+    interceptors.forEach((interceptor, index) => {
+        const interceptorVar = `interceptor_${index}`;
+        imports.push(`import * as ${interceptorVar} from '/@fs${interceptor.path}';`);
+
+        interceptor.methods.forEach(method => {
+            const methodKey = `${target}::${method.targetMethod}`;
+            registrations.push(`interceptorManager.addInterceptor('${methodKey}', '${interceptor.name}', '${method.type}', ${interceptorVar}.${method.exportName}, ${method.sortOrder});`);
         });
     });
 
     // Create Interceptor
     const interceptorCode = `
 const targetWrapper = { ...originalModule };
-const proxy = pluginManager.intercept(targetWrapper, '${targetIdentifier}', true);
+const proxy = interceptorManager.intercept(targetWrapper, '${target}', true);
 `;
 
     // Exports
@@ -262,5 +263,6 @@ ${exportsCode}
 
 export default {
     registerInterceptors,
-    generateInterceptors
-};
+    generateInterceptors,
+    KEY_INTERCEPTED
+};

package/src/service/{pluginManager.js → interceptorManager.js}

@@ -1,25 +1,25 @@
-class PluginManager {
+class InterceptorManager {
     constructor() {
-        this.plugins = {};
+        this.interceptors = {};
     }
 
     /**
-     * Register a plugin
+     * Register an interceptor
      * @param {string} target - The name of the target function/method to intercept
-     * @param {string} name - Unique name for the plugin
+     * @param {string} name - Unique name for the interceptor
      * @param {string} type - 'before', 'around', 'after'
      * @param {Function} handler - The function to execute
      * @param {number} sortOrder - Order of execution
      */
-    addPlugin(target, name, type, handler, sortOrder = 10) {
-        if (!this.plugins[target]) {
-            this.plugins[target] = { before: [], around: [], after: [] };
+    addInterceptor(target, name, type, handler, sortOrder = 10) {
+        if (!this.interceptors[target]) {
+            this.interceptors[target] = { before: [], around: [], after: [] };
         }
         if (!['before', 'around', 'after'].includes(type)) {
-            throw new Error(`Invalid plugin type: ${type}`);
+            throw new Error(`Invalid interceptor type: ${type}`);
         }
-        this.plugins[target][type].push({ name, handler, sortOrder });
-        this.plugins[target][type].sort((a, b) => a.sortOrder - b.sortOrder);
+        this.interceptors[target][type].push({ name, handler, sortOrder });
+        this.interceptors[target][type].sort((a, b) => a.sortOrder - b.sortOrder);
     }
 
     /**
@@ -30,36 +30,36 @@ class PluginManager {
      * @param {Array} args - Arguments passed to the function
      */
     executeSync(target, originalMethod, context, ...args) {
-        const plugins = this.plugins[target] || { before: [], around: [], after: [] };
+        const interceptors = this.interceptors[target] || { before: [], around: [], after: [] };
 
-        // Execute 'before' plugins
-        for (const plugin of plugins.before) {
-            const result = plugin.handler.apply(context, args);
+        // Execute 'before' interceptors
+        for (const interceptor of interceptors.before) {
+            const result = interceptor.handler.apply(context, args);
             if (Array.isArray(result)) {
                 args = result;
             }
         }
 
-        // Execute 'around' plugins
+        // Execute 'around' interceptors
         let methodToExecute = (...currentArgs) => {
             return originalMethod.apply(context, currentArgs);
         };
 
-        if (plugins.around.length > 0) {
-            const aroundPlugins = [...plugins.around].reverse();
-            for (const plugin of aroundPlugins) {
+        if (interceptors.around.length > 0) {
+            const aroundInterceptors = [...interceptors.around].reverse();
+            for (const interceptor of aroundInterceptors) {
                 const next = methodToExecute;
                 methodToExecute = (...currentArgs) => {
-                    return plugin.handler.apply(context, [next, ...currentArgs]);
+                    return interceptor.handler.apply(context, [next, ...currentArgs]);
                 };
             }
         }
 
         let result = methodToExecute(...args);
 
-        // Execute 'after' plugins
-        for (const plugin of plugins.after) {
-            result = plugin.handler.apply(context, [result, ...args]);
+        // Execute 'after' interceptors
+        for (const interceptor of interceptors.after) {
+            result = interceptor.handler.apply(context, [result, ...args]);
         }
 
         return result;
@@ -73,40 +73,40 @@ class PluginManager {
      * @param {Array} args - Arguments passed to the function
      */
     async execute(target, originalMethod, context, ...args) {
-        const plugins = this.plugins[target] || { before: [], around: [], after: [] };
+        const interceptors = this.interceptors[target] || { before: [], around: [], after: [] };
 
-        // Execute 'before' plugins
-        // Before plugins can modify args by returning an array
-        for (const plugin of plugins.before) {
-            const result = await plugin.handler.apply(context, args);
+        // Execute 'before' interceptors
+        // Before interceptors can modify args by returning an array
+        for (const interceptor of interceptors.before) {
+            const result = await interceptor.handler.apply(context, args);
             if (Array.isArray(result)) {
                 args = result;
             }
         }
 
-        // Execute 'around' plugins
-        // Around plugins receive (proceed, ...args)
+        // Execute 'around' interceptors
+        // Around interceptors receive (proceed, ...args)
         let methodToExecute = async (...currentArgs) => {
             return await originalMethod.apply(context, currentArgs);
         };
 
-        // Wrap around plugins: first registered is outer-most
-        if (plugins.around.length > 0) {
-            const aroundPlugins = [...plugins.around].reverse();
-            for (const plugin of aroundPlugins) {
+        // Wrap around interceptors: first registered is outer-most
+        if (interceptors.around.length > 0) {
+            const aroundInterceptors = [...interceptors.around].reverse();
+            for (const interceptor of aroundInterceptors) {
                 const next = methodToExecute;
                 methodToExecute = async (...currentArgs) => {
-                    return await plugin.handler.apply(context, [next, ...currentArgs]);
+                    return await interceptor.handler.apply(context, [next, ...currentArgs]);
                 };
             }
         }
 
         let result = await methodToExecute(...args);
 
-        // Execute 'after' plugins
-        // After plugins receive (result, ...args) and must return result
-        for (const plugin of plugins.after) {
-            result = await plugin.handler.apply(context, [result, ...args]);
+        // Execute 'after' interceptors
+        // After interceptors receive (result, ...args) and must return result
+        for (const interceptor of interceptors.after) {
+            result = await interceptor.handler.apply(context, [result, ...args]);
         }
 
         return result;
@@ -115,7 +115,7 @@ class PluginManager {
     /**
      * Create a proxy to intercept method calls on an object
      * @param {Object} target - The target object (e.g. module exports)
-     * @param {string} namespace - Namespace for plugins
+     * @param {string} namespace - Namespace for interceptors
      * @param {boolean} useAsync - Whether to use async execution
      */
     intercept(target, namespace, useAsync = true) {
@@ -134,4 +134,4 @@ class PluginManager {
     }
 }
 
-export default new PluginManager();
+export default new InterceptorManager();

package/src/service/interceptorsPlugin.js

@@ -0,0 +1,70 @@
+import generateInterceptorsService from './generateInterceptors.js';
+
+export default function interceptorsPlugin(options = {}) {
+    const { themeName } = options;
+    let interceptorsMap = new Map(); // path -> interceptorData
+
+    return {
+        name: 'mage-obsidian:interceptors',
+        enforce: 'pre',
+
+        async buildStart() {
+            if (!themeName) {
+                console.warn('[mage-obsidian:interceptors] themeName option is missing. Interceptors will not be generated.');
+                return;
+            }
+            
+            try {
+                const interceptors = await generateInterceptorsService.generateInterceptors(themeName);
+                
+                // Create a map for fast lookup by file path
+                for (const key in interceptors) {
+                    const data = interceptors[key];
+                    if (data.targetPath) {
+                        interceptorsMap.set(data.targetPath, data);
+                    }
+                }
+            } catch (error) {
+                console.error('[mage-obsidian:interceptors] Failed to generate interceptors:', error);
+            }
+        },
+
+        async resolveId(source, importer) {
+            // Skip if we haven't loaded interceptors or if it's a virtual module
+            if (interceptorsMap.size === 0 || source.startsWith('\0')) return null;
+
+            // Try to resolve the import to a full path
+            const resolution = await this.resolve(source, importer, { skipSelf: true });
+            
+            if (!resolution || !resolution.id) return null;
+            
+            // Clean up the ID (remove query params)
+            const resolvedId = resolution.id.split('?')[0];
+
+            if (interceptorsMap.has(resolvedId)) {
+                const virtualId = `\0interceptor:${resolvedId}`;
+                
+                // Check if we are inside the interceptor trying to import the original
+                if (importer === virtualId) {
+                    return null; // Allow original import
+                }
+
+                return virtualId;
+            }
+
+            return null;
+        },
+
+        load(id) {
+            if (id.startsWith('\0interceptor:')) {
+                const originalPath = id.slice('\0interceptor:'.length);
+                const data = interceptorsMap.get(originalPath);
+                
+                if (data) {
+                    return data.source;
+                }
+            }
+            return null;
+        }
+    };
+}

package/src/service/moduleResolver.js

@@ -125,7 +125,7 @@ function resolveFileByTheme(themeName, moduleName, filePath) {
 
 async function resolveModuleConfig(moduleName, themeName) {
     const module = configResolver.getMagentoConfig().modules[moduleName];
-    let moduleConfigSourcePath = resolveFileByTheme(themeName, moduleName, MODULE_CONFIG_FIL);
+    let moduleConfigSourcePath = resolveFileByTheme(themeName, moduleName, MODULE_CONFIG_FILE);
 
     if (!moduleConfigSourcePath && !module) {
         return null;