mage-obsidian 1.0.9 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mage-obsidian",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Mage Obsidian Ultis",
   "main": "./src/scripts/buildThemes.js",
   "keywords": [

package/src/service/cssResolver.js

@@ -1,63 +1,192 @@
-import themeResolver from './themeResolverSync.js';
-import path from 'node:path';
-import { MODULE_WEB_PATH, THEME_CSS_FOLDER, THEME_MODULE_WEB_PATH } from '../config/default.js';
-import { resolveFileByTheme } from './moduleResolver.js';
-import configResolver from './configResolver.js';
-import fs from 'node:fs/promises';
+import path from "path";
+import configResolver from "./configResolver.js";
+import {
+    ALL_JS_VUE_FILES_WITH_INHERITANCE_FILE_NAME,
+    MODULE_WEB_PATH,
+    PRECOMPILED_FOLDER,
+    THEME_MODULE_WEB_PATH
+} from "../config/default.js";
+import getFilesFromFolders from '../utils/findComponents.js'
+import fs from "fs";
+import deepmerge from "deepmerge";
 
-const { getMagentoConfig, getModuleDefinition, getThemeDefinition, getModulesConfigArray } = configResolver;
+const defaultFoldersToMap = [
+    {
+        src: configResolver.getMagentoConfig().VUE_COMPONENTS_PATH,
+        ext: [
+            'vue',
+            'js'
+        ]
+    },
+    {
+        src: configResolver.getMagentoConfig().JS_PATH,
+        ext: [
+            'js'
+        ]
+    }
+];
+
+const cachedModulesByTheme = {};
 
-const MODULE_CSS_EXTEND_FILE = getMagentoConfig().MODULE_CSS_EXTEND_FILE;
-const THEME_CSS_SOURCE_FILE = getMagentoConfig().THEME_CSS_SOURCE_FILE;
+async function getAllJsVueFilesFromActiveModules() {
+    let result = {};
+    for (const entry of configResolver.getModulesConfigArray()) {
+        const [moduleName, moduleConfig] = entry;
+        const moduleResult = await getFilesFromFolders(
+            moduleName,
+            path.resolve(moduleConfig.src, MODULE_WEB_PATH),
+            defaultFoldersToMap
+        );
+        Object.assign(result, moduleResult);
+    }
+    return result;
+}
 
-async function getThemeImports(themeName, themeConfig) {
-    if (!themeConfig) {
-        themeConfig = themeResolver.getThemeConfig(themeName);
+async function getAllJsVueFilesFromTheme(themeName) {
+    let result = {};
+    const theme = configResolver.getMagentoConfig().themes[themeName];
+    if (!theme) {
+        return {}
     }
-    const themeDefinition = getThemeDefinition(themeName);
-    const themePath = themeDefinition.src;
 
-    let imports = '';
-    if (themeConfig.includeCssSourceFromParentThemes && themeDefinition.parent) {
-        imports += await getThemeImports(themeDefinition.parent, themeConfig);
+    if (theme.parent) {
+        result = await getAllJsVueFilesFromTheme(theme.parent)
     }
 
-    imports += `@import "${path.join(themePath, THEME_MODULE_WEB_PATH, THEME_CSS_FOLDER, THEME_CSS_SOURCE_FILE)}";\n`;
-    return imports;
+    for (const moduleName of configResolver.getAllMagentoModulesEnabled()) {
+        const modulePath = path.resolve(theme.src, moduleName, THEME_MODULE_WEB_PATH);
+        const moduleResult = await getFilesFromFolders(
+            moduleName,
+            modulePath,
+            defaultFoldersToMap
+        );
+        if (moduleResult) {
+            result = deepmerge(result, moduleResult);
+        }
+    }
+    const moduleResult = await getFilesFromFolders(
+        'Theme',
+        path.resolve(theme.src, THEME_MODULE_WEB_PATH),
+        defaultFoldersToMap
+    );
+    result = deepmerge(result, moduleResult);
+    return result;
 }
 
-function resolveModuleCssSourcePath(moduleName, themeName) {
-    let moduleConfigSourcePath = resolveFileByTheme(themeName, moduleName, 'css', MODULE_CSS_EXTEND_FILE);
-    if (!moduleConfigSourcePath) {
-        const moduleDefinition = getModuleDefinition(moduleName);
-        moduleConfigSourcePath = path.join(moduleDefinition.src, MODULE_WEB_PATH, 'css', MODULE_CSS_EXTEND_FILE);
+
+function getAllJsVueFilesWithInheritanceCached(themeName) {
+    themeName = themeName ?? process.env.CURRENT_THEME;
+    if (cachedModulesByTheme[themeName]) {
+        return cachedModulesByTheme[themeName];
     }
-    return moduleConfigSourcePath;
+    //check if exits
+
+    const filePath = path.join(PRECOMPILED_FOLDER, themeName, ALL_JS_VUE_FILES_WITH_INHERITANCE_FILE_NAME);
+    const fileContent = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(fileContent);
+    cachedModulesByTheme[themeName] = data;
+    return data;
+}
+
+async function getAllJsVueFilesWithInheritance(themeName) {
+    themeName = themeName ?? process.env.CURRENT_THEME;
+    if (cachedModulesByTheme[themeName]) {
+        return cachedModulesByTheme[themeName];
+    }
+    const allJsVueFilesFromModules = await getAllJsVueFilesFromActiveModules();
+    const allJsVueFilesFromThemes = await getAllJsVueFilesFromTheme(themeName);
+    cachedModulesByTheme[themeName] = deepmerge(allJsVueFilesFromModules, allJsVueFilesFromThemes);
+    return cachedModulesByTheme[themeName];
 }
 
-async function getCssImports(themeName) {
-    const themeConfig = themeResolver.getThemeConfig(themeName);
-    const excludedModules = new Set(themeConfig.ignoredCssFromModules || []);
-    const modulesConfig = getModulesConfigArray();
+const moduleConfigByThemeCache = new Map();
 
-    let cssImports = '';
+const MODULE_CONFIG_FILE = configResolver.getMagentoConfig().MODULE_CONFIG_FILE;
 
-    if (themeConfig.ignoredCssFromModules !== 'all') {
-        for (const [moduleName, moduleConfig] of modulesConfig) {
-            if (excludedModules.has(moduleName)) continue;
+/**
+ * Gets the theme configuration file path.
+ * @param {string} moduleSrc
+ * @returns {string} Full path to the configuration file.
+ */
+function getModuleConfigPath(moduleSrc) {
+    return path.join(moduleSrc, 'view/frontend/web/', MODULE_CONFIG_FILE);
+}
+
+function resolveFileByTheme(themeName, moduleName, filePath, includeTailwindConfigFromParentThemes) {
+    const theme = configResolver.getMagentoConfig().themes[themeName];
+    const fullFilePath = path.join(theme.src, moduleName, 'web', filePath);
+    if (fs.existsSync(fullFilePath)) {
+        return fullFilePath;
+    }
 
-            const filePath = resolveModuleCssSourcePath(moduleName, themeName);
-            try {
-                await fs.access(filePath);
-                cssImports += `@import "${filePath}";\n`;
-            } catch {
-                // ignore if file doesn't exist
-            }
+    if (includeTailwindConfigFromParentThemes && theme.parent) {
+        return resolveFileByTheme(theme.parent, moduleName, filePath, includeTailwindConfigFromParentThemes);
+    }
+    return null;
+}
+
+async function resolveModuleConfig(moduleName, themeName, includeTailwindConfigFromParentThemes) {
+    const module = configResolver.getMagentoConfig().modules[moduleName];
+    let moduleConfigSourcePath = resolveFileByTheme(themeName, moduleName, MODULE_CONFIG_FILE, includeTailwindConfigFromParentThemes);
+
+    if (!moduleConfigSourcePath && !module) {
+        return null;
+    }
+    if (!moduleConfigSourcePath) {
+        moduleConfigSourcePath = getModuleConfigPath(module.src);
+    }
+    if (!fs.existsSync(moduleConfigSourcePath)) {
+        return null;
+    }
+
+    // Importación dinámica común en ESModules
+    const moduleConfig = await import(moduleConfigSourcePath);
+    return moduleConfig.default ?? moduleConfig;
+}
+
+/**
+ * Retrieves the Tailwind configuration for a theme synchronously.
+ * Uses a cache system to optimize performance.
+ * @param {string} themeName - Name of the theme.
+ * @param {object} themeConfig
+ * @returns {object|null} Tailwind configuration object.
+ */
+async function getModuleConfigByThemeConfig(themeName, themeConfig) {
+    if (moduleConfigByThemeCache.has(themeName)) {
+        return moduleConfigByThemeCache.get(themeName);
+    }
+    if (!themeConfig) return null;
+    const modules = configResolver.getAllMagentoModulesEnabled();
+    let modulesConfig = {};
+
+    for (const moduleName of modules) {
+        let moduleConfig = await resolveModuleConfig(moduleName, themeName, themeConfig.includeTailwindConfigFromParentThemes);
+        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);
     }
 
-    cssImports += await getThemeImports(themeName);
-    return cssImports;
+    moduleConfigByThemeCache.set(themeName, modulesConfig);
+    return modulesConfig;
 }
 
-export default getCssImports;
+export default {
+    getAllJsVueFilesWithInheritance,
+    getAllJsVueFilesWithInheritanceCached,
+    getModuleConfigByThemeConfig,
+    resolveFileByTheme
+};
+
+export { getModuleConfigByThemeConfig, resolveFileByTheme, getAllJsVueFilesWithInheritance, getAllJsVueFilesWithInheritanceCached };
+

package/src/service/preCompileMagentoFiles.js

@@ -10,7 +10,7 @@ export default async (themeName) => {
     execSync('rm -rf .precompiled/*', { stdio: 'inherit' });
     execSync(`mkdir -p .precompiled/${themeName}`, { stdio: 'inherit' });
     console.log('Generating precompiled files');
-    await precompileCss(themeName);
     await precompileJs(themeName);
+    await precompileCss(themeName);
     isPrecompiled = true;
 }