mage-obsidian 1.1.2 → 2.0.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/interceptorManager.js

@@ -1,137 +0,0 @@
-class InterceptorManager {
-    constructor() {
-        this.interceptors = {};
-    }
-
-    /**
-     * Register an interceptor
-     * @param {string} target - The name of the target function/method to intercept
-     * @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
-     */
-    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 interceptor type: ${type}`);
-        }
-        this.interceptors[target][type].push({ name, handler, sortOrder });
-        this.interceptors[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 interceptors = this.interceptors[target] || { before: [], around: [], after: [] };
-
-        // Execute 'before' interceptors
-        for (const interceptor of interceptors.before) {
-            const result = interceptor.handler.apply(context, args);
-            if (Array.isArray(result)) {
-                args = result;
-            }
-        }
-
-        // Execute 'around' interceptors
-        let methodToExecute = (...currentArgs) => {
-            return originalMethod.apply(context, currentArgs);
-        };
-
-        if (interceptors.around.length > 0) {
-            const aroundInterceptors = [...interceptors.around].reverse();
-            for (const interceptor of aroundInterceptors) {
-                const next = methodToExecute;
-                methodToExecute = (...currentArgs) => {
-                    return interceptor.handler.apply(context, [next, ...currentArgs]);
-                };
-            }
-        }
-
-        let result = methodToExecute(...args);
-
-        // Execute 'after' interceptors
-        for (const interceptor of interceptors.after) {
-            result = interceptor.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 interceptors = this.interceptors[target] || { before: [], around: [], after: [] };
-
-        // 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' interceptors
-        // Around interceptors receive (proceed, ...args)
-        let methodToExecute = async (...currentArgs) => {
-            return await originalMethod.apply(context, currentArgs);
-        };
-
-        // 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 interceptor.handler.apply(context, [next, ...currentArgs]);
-                };
-            }
-        }
-
-        let result = await methodToExecute(...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;
-    }
-
-    /**
-     * 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 interceptors
-     * @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 InterceptorManager();

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/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
-};