mage-obsidian 1.1.2 → 2.1.0

package/src/scripts/buildThemes.js

@@ -1,132 +0,0 @@
-#! /usr/bin/env node
-import { Command } from 'commander';
-import { execSync } from 'child_process';
-import readlineSync from 'readline-sync';
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import configResolver from '../service/configResolver.js';
-import dotenv from 'dotenv';
-dotenv.config();
-
-const program = new Command();
-
-program
-    .option('--theme <theme>', 'Specify the active theme')
-    .option('--dev-server', 'Run the development server for a specific theme');
-
-program.parse(process.argv);
-
-const options = program.opts();
-const themesConfig = configResolver.getMagentoConfig().themes;
-
-if (options.devServer && !options.theme) {
-    console.error(chalk.red('Error: The --theme option is required when using --dev-server.'));
-    process.exit(1);
-}
-
-const theme = options.theme || 'all';
-
-const executeCommand = (command) => {
-    try {
-        execSync(command, { stdio: 'inherit' });
-    } catch (error) {
-        console.error(chalk.red(`Command failed: ${command}`), error);
-        process.exit(1);
-    }
-};
-
-function tryCreateEnvFile() {
-    const defaultEnvVars = {
-        VITE_SERVER_HOST: 'phpfpm',
-        VITE_SERVER_PORT: '5173',
-        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...'));
-
-    const envFilePath = path.resolve(process.cwd(), '.env');
-    if (fs.existsSync(envFilePath)) {
-        console.log(chalk.green('.env file already exists.'));
-        return;
-    }
-
-    let envContent = '';
-    for (const [key, defaultValue] of Object.entries(defaultEnvVars)) {
-        const userInput = readlineSync.question(chalk.yellow(`Enter value for ${key} (default: ${defaultValue}): `), {
-            defaultInput: defaultValue,
-        });
-        envContent += `${key}=${userInput || defaultValue}\n`;
-    }
-
-    fs.writeFileSync(envFilePath, envContent);
-    console.log(chalk.green('.env file created successfully.'));
-}
-
-function validateEnv() {
-    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]) {
-            missingEnvVars.push(envVar);
-        }
-    }
-    if (missingEnvVars.length > 0) {
-        console.error(chalk.red(`Missing required environment variables: ${missingEnvVars.join(', ')}`));
-        tryCreateEnvFile();
-        console.log(chalk.green('Please restart the script after setting up the .env file.'));
-        process.exit(1);
-    }
-}
-
-const buildTheme = (themeName) => {
-    console.log(chalk.cyan(`Building theme: ${themeName}`));
-    try {
-        const theme = themesConfig[themeName];
-        if (!theme) {
-            console.error(chalk.red(`Theme "${themeName}" does not exist.`));
-            process.exit(1);
-        }
-
-        process.env.CURRENT_THEME = themeName;
-        executeCommand('vite build');
-    } catch (error) {
-        console.error(chalk.red(`Failed to build theme "${themeName}":`), error);
-    }
-};
-
-const runDevServer = (themeName) => {
-    console.log(chalk.cyan(`Starting development server for theme: ${themeName}`));
-    try {
-        const theme = themesConfig[themeName];
-        if (!theme) {
-            console.error(chalk.red(`Theme "${themeName}" does not exist.`));
-            process.exit(1);
-        }
-
-        process.env.CURRENT_THEME = themeName;
-        executeCommand('vite');
-    } catch (error) {
-        console.error(chalk.red(`Failed to start development server for theme "${themeName}":`), error);
-    }
-};
-
-validateEnv();
-
-if (options.devServer) {
-    runDevServer(theme);
-} else {
-    if (theme === 'all') {
-        for (const themeName of Object.keys(themesConfig)) {
-            buildTheme(themeName);
-        }
-    } else if (themesConfig[theme]) {
-        buildTheme(theme);
-    } else {
-        console.error(chalk.red(`Theme "${theme}" does not exist.`));
-        process.exit(1);
-    }
-}

package/src/service/configResolver.js

@@ -1,63 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { DEPENDENCY_CONFIG_FILE_PATH, OUTPUT_THEME_DIR } from '../config/default.js';
-
-let MAGENTO_CONFIG;
-
-try {
-    const magentoConfigJson = fs.readFileSync(DEPENDENCY_CONFIG_FILE_PATH, 'utf-8');
-    MAGENTO_CONFIG = JSON.parse(magentoConfigJson);
-} catch (error) {
-    console.error(`Error reading or parsing configuration file at ${DEPENDENCY_CONFIG_FILE_PATH}:`, error.message);
-    console.error('Try running `devcore:frontend:config --generate` to generate the configuration file.');
-    process.exit(1);
-}
-
-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;
-export const isDev = () => MAGENTO_CONFIG.mode !== 'production';
-
-export const getOutputDirFromTheme = (themePath) =>
-    path.resolve(themePath, OUTPUT_THEME_DIR);
-
-export const getModuleDefinition = (moduleName) =>
-    MAGENTO_CONFIG.modules[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,
-    getThemesConfigArray,
-    getAllMagentoModulesEnabled,
-    isDev,
-    getOutputDirFromTheme,
-    getModuleDefinition,
-    getThemeDefinition,
-    resolveLibPath,
-    resolveNodePath,
-    resolveLibRealPath
-};

package/src/service/cssResolver.js

@@ -1,73 +0,0 @@
-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, getAllJsVueFilesWithInheritanceCached } from './moduleResolver.js';
-import configResolver from './configResolver.js';
-import fs from 'node:fs/promises';
-
-const { getMagentoConfig, getModuleDefinition, getThemeDefinition, getModulesConfigArray } = configResolver;
-
-const MODULE_CSS_EXTEND_FILE = getMagentoConfig().MODULE_CSS_EXTEND_FILE;
-const THEME_CSS_SOURCE_FILE = getMagentoConfig().THEME_CSS_SOURCE_FILE;
-
-async function getThemeImports(themeName, themeConfig) {
-    if (!themeConfig) {
-        themeConfig = themeResolver.getThemeConfig(themeName);
-    }
-    const themeDefinition = getThemeDefinition(themeName);
-    const themePath = themeDefinition.src;
-
-    let imports = '';
-    if (themeConfig.includeCssSourceFromParentThemes && themeDefinition.parent) {
-        imports += await getThemeImports(themeDefinition.parent, themeConfig);
-    }
-
-    imports += `@import "${path.join(themePath, THEME_MODULE_WEB_PATH, THEME_CSS_FOLDER, THEME_CSS_SOURCE_FILE)}";\n`;
-    return imports;
-}
-
-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);
-    }
-    return moduleConfigSourcePath;
-}
-
-async function getVueComponentsSource(themeName) {
-    const vueComponents = await getAllJsVueFilesWithInheritanceCached(themeName);
-    // split with @source al inicio
-    const vueComponentSources = Object.entries(vueComponents).map(([name, url]) => {
-        return `@source "${url}";\n`;
-    })
-    return vueComponentSources.join('');
-}
-
-async function getCssImports(themeName) {
-    const themeConfig = themeResolver.getThemeConfig(themeName);
-    const excludedModules = new Set(themeConfig.ignoredCssFromModules || []);
-    const modulesConfig = getModulesConfigArray();
-
-    let cssSource = await getVueComponentsSource(themeName);
-    let cssImports = '';
-
-    if (themeConfig.ignoredCssFromModules !== 'all') {
-        for (const [moduleName, moduleConfig] of modulesConfig) {
-            if (excludedModules.has(moduleName)) continue;
-
-            const filePath = resolveModuleCssSourcePath(moduleName, themeName);
-            try {
-                await fs.access(filePath);
-                cssImports += `@import "${filePath}";\n`;
-            } catch {
-                // ignore if file doesn't exist
-            }
-        }
-    }
-
-    cssImports += await getThemeImports(themeName);
-    return `${cssSource}\n${cssImports}`;
-}
-
-export default getCssImports;

package/src/service/defaultNodeResolver.js

@@ -1,16 +0,0 @@
-export default {
-    name: 'default-node-resolver',
-    resolveId: {
-        order: 'post',
-        handler(id) {
-            try {
-                const resolvedPath = import.meta.resolve(id);
-                if (resolvedPath) {
-                    return resolvedPath.replace('file://', '');
-                }
-            } catch (err) {
-            }
-            return null;
-        }
-    }
-};

package/src/service/magentoHrmRewrite.js

@@ -1,43 +0,0 @@
-import moduleResolver from "./moduleResolver.js";
-
-export default () => {
-    const components = moduleResolver.getAllJsVueFilesWithInheritanceCached();
-    return {
-        name: 'handle-magento-routes-middleware',
-            configureServer(server) {
-            server.middlewares.use((req, res, next) => {
-                const url = req.url;
-
-                const matchedKey = Object.keys(components).find((key) => url.includes(key));
-
-                if (matchedKey) {
-                    const filePath = components[matchedKey];
-                    let suffix = '/@fs';
-                    if (matchedKey === 'lib/vue') {
-                        suffix = '/';
-                    } else if (matchedKey.startsWith('lib/')) {
-                        suffix = '/@fs';
-                        const fileExtension = filePath.split('.').pop();
-                        let mimeType = 'application/node';
-                        if (
-                            fileExtension === 'cjs' ||
-                            fileExtension === 'mjs' ||
-                            fileExtension === 'js'
-                        ) mimeType = 'application/javascript';
-                        if (fileExtension === 'css') mimeType = 'text/css';
-                        if (fileExtension === 'json') mimeType = 'application/json';
-                        if (fileExtension === 'html') mimeType = 'text/html';
-
-                        res.setHeader('Content-Type', mimeType);
-                    } else {
-                        suffix = '/@fs';
-                    }
-                    req.url = `${suffix}${filePath}`;
-                    next();
-                } else {
-                    next();
-                }
-            });
-        },
-    }
-}

package/src/service/moduleResolver.js

@@ -1,178 +0,0 @@
-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 defaultFoldersToMap = [
-    {
-        src: configResolver.getMagentoConfig().VUE_COMPONENTS_PATH,
-        ext: [
-            'vue',
-            'js'
-        ]
-    },
-    {
-        src: configResolver.getMagentoConfig().JS_PATH,
-        ext: [
-            'js'
-        ]
-    }
-];
-
-const cachedModulesByTheme = {};
-
-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 getAllJsVueFilesFromTheme(themeName) {
-    let result = {};
-    const theme = configResolver.getMagentoConfig().themes[themeName];
-    if (!theme) {
-        return {}
-    }
-
-    if (theme.parent) {
-        result = await getAllJsVueFilesFromTheme(theme.parent)
-    }
-
-    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 getAllJsVueFilesWithInheritanceCached(themeName) {
-    themeName = themeName ?? process.env.CURRENT_THEME;
-    if (cachedModulesByTheme[themeName]) {
-        return cachedModulesByTheme[themeName];
-    }
-    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];
-}
-
-const moduleConfigByThemeCache = new Map();
-
-const MODULE_CONFIG_FILE = configResolver.getMagentoConfig().MODULE_CONFIG_FILE;
-
-/**
- * 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) {
-    const theme = configResolver.getMagentoConfig().themes[themeName];
-    const fullFilePath = path.join(theme.src, moduleName, 'web', filePath);
-    if (fs.existsSync(fullFilePath)) {
-        return fullFilePath;
-    }
-
-    if (theme.parent) {
-        return resolveFileByTheme(theme.parent, moduleName, filePath);
-    }
-    return null;
-}
-
-async function resolveModuleConfig(moduleName, themeName) {
-    const module = configResolver.getMagentoConfig().modules[moduleName];
-    let moduleConfigSourcePath = resolveFileByTheme(themeName, moduleName, MODULE_CONFIG_FILE);
-
-    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);
-        if (!moduleConfig) continue;
-        modulesConfig = deepmerge(modulesConfig, moduleConfig);
-    }
-
-    moduleConfigByThemeCache.set(themeName, modulesConfig);
-    return modulesConfig;
-}
-
-export default {
-    getAllJsVueFilesWithInheritance,
-    getAllJsVueFilesWithInheritanceCached,
-    getModuleConfigByThemeConfig,
-    resolveFileByTheme
-};
-
-export { getModuleConfigByThemeConfig, resolveFileByTheme, getAllJsVueFilesWithInheritance, getAllJsVueFilesWithInheritanceCached };
-

package/src/service/preCompileFiles.js

@@ -1,37 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import moduleResolver from "./moduleResolver.js";
-import {
-    PRECOMPILED_FOLDER,
-    ALL_JS_VUE_FILES_WITH_INHERITANCE_FILE_NAME
-} from "../config/default.js";
-import getCssImports from "./cssResolver.js";
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-async function writeToFile(outputPath, content) {
-    await fs.mkdir(path.dirname(outputPath), { recursive: true });
-    await fs.writeFile(outputPath, content, 'utf-8');
-}
-
-async function precompileCss(themeName) {
-    const cssContent = await getCssImports(themeName);
-    const outputPath = path.resolve(PRECOMPILED_FOLDER, themeName, 'precompiled.css');
-    await writeToFile(outputPath, cssContent);
-}
-
-async function precompileJs(themeName) {
-    const baseJsPath = path.resolve(__dirname, '../templates/base_main_js_file.js');
-    const jsOutputPath = path.resolve(PRECOMPILED_FOLDER, themeName, 'precompiled.js');
-    await fs.copyFile(baseJsPath, jsOutputPath);
-
-    const vueFilesOutputPath = path.join(PRECOMPILED_FOLDER, themeName, ALL_JS_VUE_FILES_WITH_INHERITANCE_FILE_NAME);
-    const vueFiles = await moduleResolver.getAllJsVueFilesWithInheritance(themeName);
-    await writeToFile(vueFilesOutputPath, JSON.stringify(vueFiles));
-}
-
-export {
-    precompileCss,
-    precompileJs
-};

package/src/service/preCompileMagentoFiles.js

@@ -1,16 +0,0 @@
-import { precompileCss, precompileJs } from "./preCompileFiles.js";
-import {execSync} from "child_process";
-
-let isPrecompiled = false;
-export default async (themeName) => {
-    if (isPrecompiled) {
-        return;
-    }
-    console.log('Cleaning .precompiled folder');
-    execSync('rm -rf .precompiled/*', { stdio: 'inherit' });
-    execSync(`mkdir -p .precompiled/${themeName}`, { stdio: 'inherit' });
-    console.log('Generating precompiled files');
-    await precompileJs(themeName);
-    await precompileCss(themeName);
-    isPrecompiled = true;
-}

package/src/service/setupGlobals.js

@@ -1,19 +0,0 @@
-import path from 'path';
-global.appRoot = path.resolve(path.resolve(), 'node_modules');
-global.importFromNode = async (moduleName) => {
-    const suffixTries = [
-        '.js',
-        '/index.js',
-        '/src/index.js',
-    ];
-    for (const suffix of suffixTries) {
-        try {
-            return await import(`${moduleName}${suffix}`);
-        } catch (error) {
-        }
-    }
-    throw new Error(`Module ${moduleName} not found`);
-}
-global.getPathFromNodeModules = (moduleName) => {
-    return path.resolve(global.appRoot, moduleName);
-}

package/src/service/themeResolverSync.js

@@ -1,67 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { fileURLToPath } from "url";
-import deepmerge from "deepmerge";
-import { THEME_MODULE_WEB_PATH } from "../config/default.js";
-import configResolver from "./configResolver.js";
-
-const themeConfigCache = new Map();
-const themeConfigPlainCache = new Map();
-
-function getThemeConfigPath(themeSrc) {
-  return path.join(
-    themeSrc,
-    THEME_MODULE_WEB_PATH,
-    configResolver.getMagentoConfig().THEME_CONFIG_FILE
-  );
-}
-
-async function loadThemeConfig(themeDefinition, themeName) {
-  if (!themeDefinition) return null;
-  if (themeConfigPlainCache.has(themeName)) return themeConfigPlainCache.get(themeName);
-
-  try {
-    const configPath = getThemeConfigPath(themeDefinition.src);
-    fs.accessSync(configPath, fs.constants.F_OK);
-
-    let themeConfig = await import(pathToFileUrl(configPath));
-    themeConfig = themeConfig.default ?? themeConfig;
-
-    themeConfigPlainCache.set(themeName, themeConfig);
-    return deepmerge({}, themeConfig);
-  } catch (error) {
-    console.error(`Failed to load configuration for theme "${themeName}":`, error.message);
-    return null;
-  }
-}
-
-function pathToFileUrl(filePath) {
-  const resolvedPath = path.resolve(filePath);
-  const fileUrl = new URL(`file://${resolvedPath}`);
-  return fileUrl.href;
-}
-
-export async function getThemeConfig(themeName) {
-  if (themeConfigCache.has(themeName)) return themeConfigCache.get(themeName);
-
-  const themeDefinition = configResolver.getMagentoConfig().themes[themeName];
-  if (!themeDefinition) return null;
-
-  let themeConfig = await loadThemeConfig(themeDefinition, themeName);
-  if (!themeConfig) return null;
-
-  themeConfig.includeCssSourceFromParentThemes ??= true;
-  themeConfig.ignoredCssFromModules ??= [];
-  themeConfig.exposeNpmPackages ??= [];
-  if (themeDefinition.parent) {
-    const parentConfig = await getThemeConfig(themeDefinition.parent);
-    themeConfig = deepmerge(parentConfig || {}, themeConfig);
-  }
-  themeConfigCache.set(themeName, themeConfig);
-  return themeConfig;
-}
-
-// Export default con todo
-export default {
-  getThemeConfig
-};