mage-obsidian 1.0.11 → 1.1.0

package/jest.config.js

@@ -1,5 +1,5 @@
 export default {
     testEnvironment: 'node',
     transform: {},
-    testPathIgnorePatterns: ['/__tests__/magento_scenarios/','/node_modules/', '/__tests__/__mocks__/'],
+    testPathIgnorePatterns: ['/__tests__/magento_scenarios/','/node_modules/', '/__tests__/__mocks__/', '/__tests__/fixtures/'],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mage-obsidian",
-  "version": "1.0.11",
+  "version": "1.1.0",
   "description": "Mage Obsidian Ultis",
   "main": "./src/scripts/buildThemes.js",
   "keywords": [
@@ -25,12 +25,14 @@
     "./config/": "./src/config/"
   },
   "dependencies": {
-    "chalk": "^5.3.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
     "deepmerge": "^4.3.1",
+    "readline-sync": "^1.4.10"
+  },
+  "devDependencies": {
     "jest": "^29.7.0",
-    "jest-environment-node": "^29.7.0",
-    "readline-sync": "^1.4.10",
-    "commander": "^13.1.0"
+    "jest-environment-node": "^29.7.0"
   },
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"

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

@@ -0,0 +1,2 @@
+
+export const someOtherFunction = () => {};

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

@@ -0,0 +1,8 @@
+
+export function beforeTargetFunction(arg) {
+    return [`Modified: ${arg}`];
+}
+
+export function afterAnotherFunction(result) {
+    return `${result} - Modified`;
+}

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

@@ -0,0 +1,12 @@
+
+export function targetFunction(arg) {
+    return `Original: ${arg}`;
+}
+
+export function anotherFunction() {
+    return 'Another';
+}
+
+export default function defaultExport() {
+    return 'Default';
+}

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-a/Vendor_ModuleNameA/web/module.config.js

@@ -1,8 +1,2 @@
 export default {
-    tailwind: {
-        content: [
-            '../templates/**/*.phtml',
-            '/from_theme'
-        ]
-    }
 };

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-a/Vendor_ModuleNameB/web/module.config.js

@@ -1,7 +1,2 @@
 export default {
-    tailwind: {
-        content: [
-            '../templates/**/*.phtml'
-        ]
-    }
 };

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-a/Vendor_ModuleNameNoConfig/web/module.config.js

@@ -1,8 +1,2 @@
 export default {
-    tailwind: {
-        content: [
-            '../templates/**/*.phtml',
-            'pollo'
-        ]
-    }
 };

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-a/web/theme.config.js

@@ -1,16 +1,4 @@
 export default {
-    tailwind: {
-        theme: {
-            extend: {},
-        },
-        plugins: [],
-        content: [
-            './**/*.{vue,js}',
-            '../**/*.phtml',
-            '../*/page_layout/override/base/*.xml',
-        ],
-    },
-    ignoredTailwindConfigFromModules: [],
     ignoredCssFromModules: [
         'Vendor_ModuleNameA',
     ],

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-b/web/theme.config.js

@@ -1,21 +1,4 @@
 export default {
-    tailwind: {
-        theme: {
-            extend: {
-                textColor: {
-                    'primary': '#3490dc',
-                    'secondary': '#ffed4a',
-                    'danger': '#e3342f',
-                },
-            },
-        },
-        plugins: [],
-        content: [
-            './**/*.{vue,js}',
-            '../**/*.phtml',
-            '../*/page_layout/override/base/*.xml',
-        ],
-    },
     ignoredCssFromModules: [
         'Vendor_ModuleNameNoConfig'
     ]

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-c/Vendor_ModuleNameB/web/module.config.js

@@ -1,9 +1,2 @@
 export default {
-    tailwind: {
-        plugins: ['test_from_theme'],
-        content: [
-            '../templates/**/*.phtml',
-            '/from_theme'
-        ]
-    }
 };

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-c/web/theme.config.js

@@ -1,16 +1,2 @@
 export default {
-    tailwind: {
-        theme: {
-            extend: {
-            },
-        },
-        plugins: [],
-        content: [
-            './**/*.{vue,js}',
-            '../**/*.phtml',
-            '../*/page_layout/override/base/*.xml',
-        ],
-    },
-    includeTailwindConfigFromParentThemes: false,
-    ignoredTailwindConfigFromModules: 'all'
 }

package/src/__tests__/magento_scenarios/app/design/frontend/Vendor/theme-d/web/theme.config.js

@@ -1,14 +1,3 @@
 export default {
-    tailwind: {
-        theme: {
-            extend: {
-            },
-        },
-        plugins: [],
-        content: [],
-    },
-    ignoredTailwindConfigFromModules: [
-        'Vendor_ModuleNameC'
-    ],
     includeCssSourceFromParentThemes: false,
 }

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

@@ -0,0 +1,145 @@
+
+import { jest } from '@jest/globals';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+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');
+
+describe('generateInterceptors', () => {
+    let generateInterceptorsService;
+    let themeResolverMock;
+    let moduleResolverMock;
+    let pluginManager;
+
+    beforeEach(async () => {
+        jest.resetModules();
+
+        themeResolverMock = {
+            getThemeConfig: jest.fn(),
+        };
+
+        moduleResolverMock = {
+            getModuleConfigByThemeConfig: jest.fn(),
+            getAllJsVueFilesWithInheritanceCached: jest.fn(),
+            getAllJsVueFilesWithInheritance: jest.fn(),
+        };
+
+        jest.unstable_mockModule('../../service/themeResolverSync.js', () => ({
+            default: themeResolverMock
+        }));
+
+        jest.unstable_mockModule('../../service/moduleResolver.js', () => ({
+            default: moduleResolverMock
+        }));
+
+        // Import real pluginManager to reset state
+        pluginManager = (await import('../../service/pluginManager.js')).default;
+        pluginManager.plugins = {};
+
+        generateInterceptorsService = (await import('../../service/generateInterceptors.js')).default;
+    });
+
+    test('should generate interceptors correctly', async () => {
+        const themeName = 'Vendor/theme-test';
+
+        themeResolverMock.getThemeConfig.mockReturnValue({
+            src: '/path/to/theme'
+        });
+
+        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
+                    }
+                ]
+            }
+        });
+
+        const allFilesMap = {
+            'Vendor_TargetModule/js/target': targetModulePath,
+            'Vendor_PluginModule/js/plugin': pluginModulePath
+        };
+
+        moduleResolverMock.getAllJsVueFilesWithInheritanceCached.mockReturnValue(allFilesMap);
+
+        const result = await generateInterceptorsService.generateInterceptors(themeName);
+
+        const targetIdentifier = 'Vendor_TargetModule::js/target.js';
+        // Use bracket access check to avoid Jest treating '.' as nested property
+        expect(result[targetIdentifier]).toBeDefined();
+
+        const interceptorData = result[targetIdentifier];
+        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');
+
+        // 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(`export const targetFunction = proxy.targetFunction;`);
+
+        // Verify Proxy Behavior
+        const proxy = interceptorData.proxy;
+        const resultFunc = await proxy.targetFunction('test');
+        expect(resultFunc).toBe('Original: Modified: test');
+
+        const resultAnother = await proxy.anotherFunction();
+        expect(resultAnother).toBe('Another - Modified');
+    });
+
+    test('should handle missing target module gracefully', async () => {
+        themeResolverMock.getThemeConfig.mockReturnValue({});
+        moduleResolverMock.getModuleConfigByThemeConfig.mockResolvedValue({
+            'Vendor_TargetModule': { interceptors: [] }
+        });
+        moduleResolverMock.getAllJsVueFilesWithInheritanceCached.mockReturnValue({});
+
+        const result = await generateInterceptorsService.generateInterceptors('Vendor/theme-missing');
+        expect(result).toEqual({});
+    });
+
+    test('should throw error if plugin targets non-existent method', async () => {
+        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
+                    }
+                ]
+            }
+        });
+
+        const emptyTargetModulePath = path.join(fixturesDir, 'emptyTarget.js');
+        
+        const allFilesMap = {
+            'Vendor_TargetModule/js/target': emptyTargetModulePath,
+            'Vendor_PluginModule/js/plugin': pluginModulePath
+        };
+        
+        moduleResolverMock.getAllJsVueFilesWithInheritanceCached.mockReturnValue(allFilesMap);
+
+        // We expect the promise to reject because generateInterceptors throws on invalid target method
+        await expect(generateInterceptorsService.generateInterceptors(themeName))
+            .rejects
+            .toThrow(/does not export/);
+    });
+});

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

@@ -12,90 +12,40 @@ let scenarios = [
             {
                 code: 'Vendor/theme-a',
                 expected: {
-                    tailwind: {
-                        theme: { extend: {} },
-                        plugins: [],
-                        content: [
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/web/**/*.{vue,js}',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/**/*.phtml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/*/page_layout/override/base/*.xml'
-                        ]
-                    },
-                    includeTailwindConfigFromParentThemes: true,
                     includeCssSourceFromParentThemes: true,
                     ignoredCssFromModules: [
                          'Vendor_ModuleNameA'
                     ],
-                    ignoredTailwindConfigFromModules: [],
                     exposeNpmPackages: []
                 }
             },
             {
                 code: 'Vendor/theme-b',
                 expected: {
-                    tailwind: {
-                        theme: {
-                            extend: {
-                                textColor: {
-                                    'primary': '#3490dc',
-                                    'secondary': '#ffed4a',
-                                    'danger': '#e3342f',
-                                },
-                            }
-                        },
-                        plugins: [],
-                        content: [
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/web/**/*.{vue,js}',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/**/*.phtml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-a/*/page_layout/override/base/*.xml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-b/web/**/*.{vue,js}',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-b/**/*.phtml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-b/*/page_layout/override/base/*.xml'
-                        ]
-                    },
-                    includeTailwindConfigFromParentThemes: true,
                     includeCssSourceFromParentThemes: true,
                     ignoredCssFromModules: [
                         'Vendor_ModuleNameA',
                         'Vendor_ModuleNameNoConfig'
                     ],
-                    ignoredTailwindConfigFromModules: [],
                     exposeNpmPackages: []
                 }
             },
             {
                 code: 'Vendor/theme-c',
                 expected: {
-                    tailwind: {
-                        theme: { extend: {} },
-                        plugins: [],
-                        content: [
-                            'magento_scenarios/app/design/frontend/Vendor/theme-c/web/**/*.{vue,js}',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-c/**/*.phtml',
-                            'magento_scenarios/app/design/frontend/Vendor/theme-c/*/page_layout/override/base/*.xml'
-                        ]
-                    },
-                    includeTailwindConfigFromParentThemes: false,
                     includeCssSourceFromParentThemes: true,
-                    ignoredCssFromModules: [],
-                    ignoredTailwindConfigFromModules: 'all',
+                    ignoredCssFromModules: [
+                        'Vendor_ModuleNameA',
+                        'Vendor_ModuleNameNoConfig'
+                    ],
                     exposeNpmPackages: []
                 }
             },
             {
                 code: 'Vendor/theme-d',
                 expected: {
-                    tailwind: {
-                        theme: { extend: {} },
-                        plugins: [],
-                        content: []
-                    },
-                    includeTailwindConfigFromParentThemes: true,
                     includeCssSourceFromParentThemes: false,
                     ignoredCssFromModules: [],
-                    ignoredTailwindConfigFromModules: [
-                        'Vendor_ModuleNameC'
-                    ],
                     exposeNpmPackages: []
                 }
             }
@@ -107,7 +57,6 @@ for (const scenario of scenarios) {
     for (const themeKey in scenario.themes) {
         let theme = scenario.themes[themeKey];
         const expected = theme.expected;
-        expected.tailwind.content = expected.tailwind.content?.map((content) => path.resolve(__dirname, '..', content));
     }
 }
 
@@ -145,24 +94,4 @@ describe('getThemeConfig', () => {
     });
 });
 
-describe('getTailwindThemeConfig', () => {
-    let themeResolver;
-
-    beforeEach(() => {
-        jest.resetModules();
-    });
-
-    test.each(scenarios.flatMap(({ scenario, themes }) =>
-        themes.map(({ code, expected }) => ([ scenario, code, expected ]))
-    ))('Scenario "%s", Theme "%s"', async ( scenario, code, expected ) => {
-        themeResolver = await setupThemeResolver(scenario);
-
-        const result = await themeResolver.getTailwindThemeConfig(code);
-
-        expect(result).toMatchObject(
-            expected.tailwind,
-            `Expected:\n${JSON.stringify(expected.tailwind, null, 2)}\nReceived:\n${JSON.stringify(result, null, 2)}\nScenario: "${scenario}", Theme: "${code}"`
-        );
-    });
-});
 

package/src/config/default.js

@@ -22,5 +22,6 @@ export const OUTPUT_THEME_DIR = 'web/generated';
 export const OUTPUT_JS_DIR = 'js/';
 export const OUTPUT_CSS_DIR = 'css/';
 export const PRECOMPILED_FOLDER = '.precompiled';
+export const INTERCEPTORS_FOLDER = 'interceptors';
 
 export const ALL_JS_VUE_FILES_WITH_INHERITANCE_FILE_NAME = 'allJsVueFilesWithInheritance.json';

package/src/service/generateInterceptors.js

@@ -0,0 +1,266 @@
+import path from "path";
+import { pathToFileURL, fileURLToPath } from "url";
+import themeResolver from './themeResolverSync.js';
+import moduleResolver from './moduleResolver.js';
+import pluginManager from './pluginManager.js';
+
+const interceptorsRegisteredByTheme = new Map();
+const generatedInterceptorsCache = new Map();
+
+/**
+ * Resolves the absolute path of a file using the cached file map
+ * @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;
+}
+
+async function registerInterceptors(themeName) {
+    if (interceptorsRegisteredByTheme.has(themeName)) {
+        return interceptorsRegisteredByTheme.get(themeName);
+    }
+
+    const themeConfig = await themeResolver.getThemeConfig(themeName);
+    const modulesConfig = await moduleResolver.getModuleConfigByThemeConfig(themeName, themeConfig);
+    
+    // Map<Target, Map<PluginName, PluginConfig>>
+    const interceptorsMap = new Map();
+
+    for (const [moduleName, moduleConfig] of Object.entries(modulesConfig)) {
+        if (!moduleConfig.interceptors || !Array.isArray(moduleConfig.interceptors)) {
+            continue;
+        }
+        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);
+            
+            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 });
+            }
+        }
+    }
+
+    // Convert Map to structured object and sort plugins
+    const result = {};
+    for (const [target, pluginsMap] of interceptorsMap) {
+        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;
+        }
+    }
+
+    interceptorsRegisteredByTheme.set(themeName, result);
+    return result;
+}
+
+async function generateInterceptors(themeName) {
+    if (generatedInterceptorsCache.has(themeName)) {
+        return generatedInterceptorsCache.get(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 {
+        allFilesMap = moduleResolver.getAllJsVueFilesWithInheritanceCached(themeName);
+    } catch (e) {
+        console.warn(`Cache not found for theme ${themeName}, falling back to async generation.`);
+        allFilesMap = await moduleResolver.getAllJsVueFilesWithInheritance(themeName);
+    }
+
+    const interceptors = {};
+
+    for (const [targetIdentifier, plugins] of Object.entries(interceptorsConfig)) {
+        // 1. Resolve Target Path
+        const targetPath = resolvePathFromMap(targetIdentifier, allFilesMap);
+        if (!targetPath) {
+            console.warn(`Target module not found for identifier: ${targetIdentifier}`);
+            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);
+            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}`);
+                continue;
+            }
+
+            let pluginModule;
+            try {
+                pluginModule = await import(pathToFileURL(pluginPath).href);
+            } catch (e) {
+                console.error(`Failed to import plugin module ${pluginConfig.plugin}:`, e.message);
+                continue;
+            }
+
+            const pluginMethods = [];
+            for (const pluginExport of Object.keys(pluginModule)) {
+                let type, targetMethod;
+                
+                if (pluginExport.startsWith('before')) {
+                    type = 'before';
+                    targetMethod = pluginExport.substring(6);
+                } else if (pluginExport.startsWith('around')) {
+                    type = 'around';
+                    targetMethod = pluginExport.substring(6);
+                } else if (pluginExport.startsWith('after')) {
+                    type = 'after';
+                    targetMethod = pluginExport.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? 
+                        // User requested error if not found.
+                        throw new Error(`Plugin ${pluginConfig.name} (${pluginConfig.plugin}) exports '${pluginExport}' but target ${targetIdentifier} does not export '${targetMethod}'`);
+                     }
+                }
+
+                // Register the plugin with PluginManager (Runtime)
+                const methodKey = `${targetIdentifier}::${targetMethod}`;
+                pluginManager.addPlugin(
+                    methodKey,
+                    pluginConfig.name,
+                    type,
+                    pluginModule[pluginExport],
+                    pluginConfig.sortOrder
+                );
+                
+                methodsToIntercept.add(targetMethod);
+                pluginMethods.push({
+                    exportName: pluginExport,
+                    type,
+                    targetMethod,
+                    sortOrder: pluginConfig.sortOrder
+                });
+            }
+
+            if (pluginMethods.length > 0) {
+                validPlugins.push({
+                    ...pluginConfig,
+                    path: pluginPath,
+                    methods: pluginMethods
+                });
+            }
+        }
+
+        // 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);
+
+            interceptors[targetIdentifier] = {
+                proxy,
+                targetPath,
+                targetModule,
+                plugins: validPlugins,
+                source
+            };
+        }
+    }
+
+    generatedInterceptorsCache.set(themeName, interceptors);
+    return interceptors;
+}
+
+function generateInterceptorCode(targetIdentifier, targetPath, plugins, 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, 
+    // 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}';`);
+
+    // 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});`);
+        });
+    });
+
+    // Create Interceptor
+    const interceptorCode = `
+const targetWrapper = { ...originalModule };
+const proxy = pluginManager.intercept(targetWrapper, '${targetIdentifier}', true);
+`;
+
+    // Exports
+    const exportsCode = targetExports.map(exp => {
+        if (exp === 'default') {
+            return `export default proxy.default;`;
+        }
+        return `export const ${exp} = proxy.${exp};`;
+    }).join('\n');
+
+    return `
+${imports.join('\n')}
+
+${registrations.join('\n')}
+
+${interceptorCode}
+
+${exportsCode}
+`;
+}
+
+export default {
+    registerInterceptors,
+    generateInterceptors
+};

package/src/service/moduleResolver.js

@@ -110,22 +110,22 @@ function getModuleConfigPath(moduleSrc) {
     return path.join(moduleSrc, 'view/frontend/web/', MODULE_CONFIG_FILE);
 }
 
-function resolveFileByTheme(themeName, moduleName, filePath, includeTailwindConfigFromParentThemes) {
+function resolveFileByTheme(themeName, moduleName, filePath) {
     const theme = configResolver.getMagentoConfig().themes[themeName];
     const fullFilePath = path.join(theme.src, moduleName, 'web', filePath);
     if (fs.existsSync(fullFilePath)) {
         return fullFilePath;
     }
 
-    if (includeTailwindConfigFromParentThemes && theme.parent) {
-        return resolveFileByTheme(theme.parent, moduleName, filePath, includeTailwindConfigFromParentThemes);
+    if (theme.parent) {
+        return resolveFileByTheme(theme.parent, moduleName, filePath);
     }
     return null;
 }
 
-async function resolveModuleConfig(moduleName, themeName, includeTailwindConfigFromParentThemes) {
+async function resolveModuleConfig(moduleName, themeName) {
     const module = configResolver.getMagentoConfig().modules[moduleName];
-    let moduleConfigSourcePath = resolveFileByTheme(themeName, moduleName, MODULE_CONFIG_FILE, includeTailwindConfigFromParentThemes);
+    let moduleConfigSourcePath = resolveFileByTheme(themeName, moduleName, MODULE_CONFIG_FIL);
 
     if (!moduleConfigSourcePath && !module) {
         return null;
@@ -158,20 +158,8 @@ async function getModuleConfigByThemeConfig(themeName, themeConfig) {
     let modulesConfig = {};
 
     for (const moduleName of modules) {
-        let moduleConfig = await resolveModuleConfig(moduleName, themeName, themeConfig.includeTailwindConfigFromParentThemes);
+        let moduleConfig = await resolveModuleConfig(moduleName, themeName);
         if (!moduleConfig) continue;
-        if (
-            themeConfig.ignoredTailwindConfigFromModules === 'all' ||
-            themeConfig.ignoredTailwindConfigFromModules.includes(moduleName)
-        ) {
-            moduleConfig.tailwind = {};
-        } else if (moduleConfig.tailwind?.content) {
-            const moduleSrc = configResolver.getMagentoConfig().modules[moduleName].src;
-            moduleConfig.tailwind.content = moduleConfig.tailwind.content.map((content) =>
-                path.join(moduleSrc, 'view/frontend/web', content)
-            );
-        }
-
         modulesConfig = deepmerge(modulesConfig, moduleConfig);
     }
 

package/src/service/pluginManager.js

@@ -0,0 +1,137 @@
+class PluginManager {
+    constructor() {
+        this.plugins = {};
+    }
+
+    /**
+     * Register a plugin
+     * @param {string} target - The name of the target function/method to intercept
+     * @param {string} name - Unique name for the plugin
+     * @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: [] };
+        }
+        if (!['before', 'around', 'after'].includes(type)) {
+            throw new Error(`Invalid plugin type: ${type}`);
+        }
+        this.plugins[target][type].push({ name, handler, sortOrder });
+        this.plugins[target][type].sort((a, b) => a.sortOrder - b.sortOrder);
+    }
+
+    /**
+     * Execute the intercepted method chain synchronously
+     * @param {string} target - The target method name
+     * @param {Function} originalMethod - The original function
+     * @param {Object} context - The 'this' context
+     * @param {Array} args - Arguments passed to the function
+     */
+    executeSync(target, originalMethod, context, ...args) {
+        const plugins = this.plugins[target] || { before: [], around: [], after: [] };
+
+        // Execute 'before' plugins
+        for (const plugin of plugins.before) {
+            const result = plugin.handler.apply(context, args);
+            if (Array.isArray(result)) {
+                args = result;
+            }
+        }
+
+        // Execute 'around' plugins
+        let methodToExecute = (...currentArgs) => {
+            return originalMethod.apply(context, currentArgs);
+        };
+
+        if (plugins.around.length > 0) {
+            const aroundPlugins = [...plugins.around].reverse();
+            for (const plugin of aroundPlugins) {
+                const next = methodToExecute;
+                methodToExecute = (...currentArgs) => {
+                    return plugin.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]);
+        }
+
+        return result;
+    }
+
+    /**
+     * Execute the intercepted method chain
+     * @param {string} target - The target method name
+     * @param {Function} originalMethod - The original function
+     * @param {Object} context - The 'this' context
+     * @param {Array} args - Arguments passed to the function
+     */
+    async execute(target, originalMethod, context, ...args) {
+        const plugins = this.plugins[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);
+            if (Array.isArray(result)) {
+                args = result;
+            }
+        }
+
+        // Execute 'around' plugins
+        // Around plugins 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) {
+                const next = methodToExecute;
+                methodToExecute = async (...currentArgs) => {
+                    return await plugin.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]);
+        }
+
+        return result;
+    }
+
+    /**
+     * 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 {boolean} useAsync - Whether to use async execution
+     */
+    intercept(target, namespace, useAsync = true) {
+        return new Proxy(target, {
+            get: (obj, prop) => {
+                const value = obj[prop];
+                if (typeof value === 'function') {
+                    return (...args) => {
+                        const method = useAsync ? this.execute : this.executeSync;
+                        return method.call(this, `${namespace}::${String(prop)}`, value, obj, ...args);
+                    };
+                }
+                return value;
+            }
+        });
+    }
+}
+
+export default new PluginManager();

package/src/service/themeResolverSync.js

@@ -50,36 +50,18 @@ export async function getThemeConfig(themeName) {
   let themeConfig = await loadThemeConfig(themeDefinition, themeName);
   if (!themeConfig) return null;
 
-  themeConfig.includeTailwindConfigFromParentThemes ??= true;
   themeConfig.includeCssSourceFromParentThemes ??= true;
   themeConfig.ignoredCssFromModules ??= [];
-  themeConfig.ignoredTailwindConfigFromModules ??= [];
   themeConfig.exposeNpmPackages ??= [];
-  themeConfig.tailwind ??= {};
-
-  if (themeConfig.tailwind?.content) {
-    themeConfig.tailwind.content = themeConfig.tailwind.content.map((content) =>
-      path.join(themeDefinition.src, "web", content)
-    );
-  }
-
-  const includeParent = themeConfig.includeTailwindConfigFromParentThemes;
-  if (includeParent && themeDefinition.parent) {
+  if (themeDefinition.parent) {
     const parentConfig = await getThemeConfig(themeDefinition.parent);
     themeConfig = deepmerge(parentConfig || {}, themeConfig);
   }
-
   themeConfigCache.set(themeName, themeConfig);
   return themeConfig;
 }
 
-export async function getTailwindThemeConfig(themeName) {
-  const themeConfig = await getThemeConfig(themeName);
-  return themeConfig?.tailwind ?? {};
-}
-
 // Export default con todo
 export default {
-  getThemeConfig,
-  getTailwindThemeConfig
+  getThemeConfig
 };

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

@@ -1,188 +0,0 @@
-import { jest } from '@jest/globals';
-import createMockConfigResolver from '../__mocks__/configResolver.js';
-import path from 'path';
-import {fileURLToPath} from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-let scenarios = [
-    {
-        scenario: 'a',
-        themes: [
-            {
-                code: 'Vendor/theme-a',
-                expected: {
-                    tailwind: {
-                        content: [
-                            'magento_scenarios/app/code/Vendor/ModuleNameA/view/frontend/templates/**/*.phtml',
-                            'magento_scenarios/app/code/Vendor/ModuleNameA/view/frontend/web/from_theme',
-                            'magento_scenarios/app/code/Vendor/ModuleNameB/view/frontend/templates/**/*.phtml',
-                            'magento_scenarios/app/code/Vendor/ModuleNameC/view/frontend/templates/**/*.phtml'
-                        ]
-                    }
-                }
-            },
-            {
-                code: 'Vendor/theme-b',
-                expected: {
-                    tailwind: {
-                        content: [
-                            'magento_scenarios/app/code/Vendor/ModuleNameA/view/frontend/templates/**/*.phtml',
-                            'magento_scenarios/app/code/Vendor/ModuleNameA/view/frontend/web/from_theme',
-                            'magento_scenarios/app/code/Vendor/ModuleNameB/view/frontend/templates/**/*.phtml',
-                            'magento_scenarios/app/code/Vendor/ModuleNameC/view/frontend/templates/**/*.phtml'
-                        ]
-                    }
-                }
-            },
-            {
-                code: 'Vendor/theme-c',
-                expected: {
-                    tailwind: {}
-                }
-            },
-            {
-                code: 'Vendor/theme-d',
-                expected: {
-                    tailwind: {
-                        theme: { extend: {} },
-                        plugins: [],
-                        content: [
-                            'magento_scenarios/app/code/Vendor/ModuleNameA/view/frontend/templates/**/*.phtml',
-                            'magento_scenarios/app/code/Vendor/ModuleNameB/view/frontend/templates/**/*.phtml'
-                        ]
-                    }
-                }
-            }
-        ]
-    }
-];
-
-for (const scenario of scenarios) {
-    for (const themeKey in scenario.themes) {
-        let theme = scenario.themes[themeKey];
-        const expected = theme.expected;
-        expected.tailwind.content = expected.tailwind.content?.map((content) => path.resolve(__dirname, '..', content));
-    }
-}
-
-
-let scenariosForResolveFileByTheme = [
-    {
-        scenario: 'a',
-        themes: [
-            {
-                code: 'Vendor/theme-a',
-                moduleName: 'Vendor_ModuleNameA',
-                filePath: 'module.config.js',
-                includeTailwindConfigFromParentThemes: true,
-                expected: 'magento_scenarios/app/design/frontend/Vendor/theme-a/Vendor_ModuleNameA/web/module.config.js'
-            },
-            {
-                code: 'Vendor/theme-a',
-                moduleName: 'Vendor_ModuleNameA',
-                filePath: 'no_exist_file.js',
-                includeTailwindConfigFromParentThemes: true,
-                expected: null
-            },
-            {
-                code: 'Vendor/theme-b',
-                moduleName: 'Vendor_ModuleNameA',
-                filePath: 'module.config.js',
-                includeTailwindConfigFromParentThemes: true,
-                expected: 'magento_scenarios/app/design/frontend/Vendor/theme-a/Vendor_ModuleNameA/web/module.config.js'
-            },
-            {
-                code: 'Vendor/theme-b',
-                moduleName: 'Vendor_ModuleNameA',
-                filePath: 'module.config.js',
-                includeTailwindConfigFromParentThemes: false,
-                expected: null
-            },
-            {
-                code: 'Vendor/theme-c',
-                moduleName: 'Vendor_ModuleNameA',
-                filePath: 'module.config.js',
-                includeTailwindConfigFromParentThemes: true,
-                expected: 'magento_scenarios/app/design/frontend/Vendor/theme-a/Vendor_ModuleNameA/web/module.config.js'
-            },
-            {
-                code: 'Vendor/theme-c',
-                moduleName: 'Vendor_ModuleNameB',
-                filePath: 'module.config.js',
-                includeTailwindConfigFromParentThemes: true,
-                expected: 'magento_scenarios/app/design/frontend/Vendor/theme-c/Vendor_ModuleNameB/web/module.config.js'
-            },
-            {
-                code: 'Vendor/theme-d',
-                moduleName: 'Vendor_ModuleNameA',
-                filePath: 'module.config.js',
-                includeTailwindConfigFromParentThemes: false,
-                expected: null
-            },
-            {
-                code: 'Vendor/theme-d',
-                moduleName: 'Vendor_ModuleNameA',
-                filePath: 'module.config.js',
-                includeTailwindConfigFromParentThemes: true,
-                expected: null
-            }
-        ]
-    }
-];
-
-for (const scenario of scenariosForResolveFileByTheme) {
-    for (const themeKey in scenario.themes) {
-        let theme = scenario.themes[themeKey];
-        if (!theme.expected) continue;
-        theme.expected = path.resolve(__dirname, '..', theme.expected)
-    }
-}
-
-async function setupResolvers(scenario) {
-    jest.unstable_mockModule('#service/configResolver.js', () => ({
-        __esModule: true,
-        default: createMockConfigResolver(scenario).default,
-    }));
-    const moduleResolver = await import('#service/moduleResolver.js');
-    const themeResolver = await import('#service/themeResolverSync.js');
-
-    return { moduleResolver, themeResolver };
-}
-
-
-describe('getModuleConfigByThemeConfig', () => {
-    beforeEach(() => {
-        jest.resetModules();
-    });
-
-    test.each(scenarios.flatMap(({ scenario, themes }) =>
-        themes.map(({ code, expected }) => ([ scenario, code, expected ]))
-    ))('Scenario "%s", Theme "%s"', async ( scenario, code, expected ) => {
-        const { themeResolver, moduleResolver } = await setupResolvers(scenario);
-        const themeConfig = await themeResolver.getThemeConfig(code);
-        const result = await moduleResolver.getModuleConfigByThemeConfig(code, themeConfig);
-        expect(result).toEqual(
-            expected,
-            `Expected:\n${JSON.stringify(expected, null, 2)}\nReceived:\n${JSON.stringify(result, null, 2)}\nScenario: "${scenario}", Theme: "${code}"`
-        );
-    });
-});
-
-describe('resolveFileByTheme', () => {
-    beforeEach(() => {
-        jest.resetModules();
-    });
-
-    test.each(scenariosForResolveFileByTheme.flatMap(({ scenario, themes }) =>
-        themes.map(({ code, expected, moduleName, filePath, includeTailwindConfigFromParentThemes }) => ([scenario, code, expected, moduleName, filePath, includeTailwindConfigFromParentThemes]))
-    ))('Scenario "%s", Theme "%s"', async ( scenario, code, expected, moduleName, filePath, includeTailwindConfigFromParentThemes ) => {
-        const { moduleResolver } = await setupResolvers(scenario);
-        const result = await moduleResolver.resolveFileByTheme(code, moduleName, filePath, includeTailwindConfigFromParentThemes);
-        expect(result).toEqual(
-            expected,
-            `Expected:\n${JSON.stringify(expected, null, 2)}\nReceived:\n${JSON.stringify(result, null, 2)}\nScenario: "${scenario}", Theme: "${code}"`
-        );
-    });
-});
-

package/src/service/tailwindResolver.js

@@ -1,11 +0,0 @@
-import themeResolver from './themeResolverSync.js';
-import moduleResolver from './moduleResolver.js';
-import deepmerge from 'deepmerge';
-
-export function getTailwindConfigByTheme(themeName) {
-    const themeConfig = themeResolver.getThemeConfig(themeName);
-    return deepmerge(
-        moduleResolver.getModuleConfigByThemeConfig(themeName, themeConfig)?.tailwind ?? {},
-        themeConfig?.tailwind ?? {}
-    );
-}