mage-obsidian 1.0.0

package/src/scripts/buildThemes.js

@@ -0,0 +1,131 @@
+#! /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.cjs';
+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',
+    };
+
+    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'];
+    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.cjs

@@ -0,0 +1,39 @@
+const { DEPENDENCY_CONFIG_FILE_PATH, OUTPUT_THEME_DIR } = require('../config/default.cjs');
+const fs = require('fs');
+const path = require('path');
+
+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); // Termina el proceso si no se puede leer el archivo de configuración
+}
+
+const getModulesConfigArray = () => Object.entries(MAGENTO_CONFIG.modules);
+const getThemesConfigArray = () => Object.entries(MAGENTO_CONFIG.themes);
+const getAllMagentoModulesEnabled = () => MAGENTO_CONFIG.allModules;
+const isDev = () => MAGENTO_CONFIG.mode !== 'production';
+const getOutputDirFromTheme = (themePath) => path.resolve(themePath, OUTPUT_THEME_DIR);
+
+const getModuleDefinition = (moduleName) => {
+    return MAGENTO_CONFIG.modules[moduleName];
+}
+
+const getThemeDefinition = (themeName) => {
+    return MAGENTO_CONFIG.themes[themeName];
+}
+
+module.exports = {
+    getMagentoConfig: () => MAGENTO_CONFIG,
+    getModulesConfigArray,
+    getThemesConfigArray,
+    getAllMagentoModulesEnabled,
+    isDev,
+    getOutputDirFromTheme,
+    getThemeDefinition,
+    getModuleDefinition
+};

package/src/service/cssResolver.js

@@ -0,0 +1,55 @@
+import themeResolver from "./themeResolverSync.cjs";
+import path from "path";
+import { MODULE_WEB_PATH, THEME_CSS_FOLDER, THEME_MODULE_WEB_PATH } from "../config/default.cjs";
+import { resolveFileByTheme } from "./moduleResolverSync.cjs";
+import configResolver from "./configResolver.cjs";
+import fs from "fs/promises";
+
+const { getMagentoConfig, getModuleDefinition, getThemeDefinition } = configResolver;
+const MODULE_CSS_EXTEND_FILE = getMagentoConfig().MODULE_CSS_EXTEND_FILE;
+const THEME_TAILWIND_SOURCE_FILE = getMagentoConfig().THEME_TAILWIND_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.includeTailwindConfigFromParentThemes && themeDefinition.parent) {
+        imports += await getThemeImports(themeDefinition.parent, themeConfig);
+    }
+    imports += `@import "${path.join(themePath, THEME_MODULE_WEB_PATH, THEME_CSS_FOLDER, THEME_TAILWIND_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 getCssImports(themeName) {
+    const themeConfig = themeResolver.getThemeConfig(themeName);
+    const excludedModules = new Set(themeConfig.ignoredCssFromModules || []);
+    const modulesConfig = configResolver.getModulesConfigArray();
+    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 {
+            }
+        }
+    }
+    cssImports += await getThemeImports(themeName);
+    return cssImports;
+}
+
+export default getCssImports;

package/src/service/inheritModuleResolver.js

@@ -0,0 +1,57 @@
+import moduleResolver from "./moduleResolver.js";
+import path from "path";
+import configResolver from "./configResolver.cjs";
+
+export default function customResolverPlugin() {
+    const allComponents = moduleResolver.getAllJsVueFilesWithInheritanceCached();
+    const validComponentExtensions = configResolver.getMagentoConfig().ALLOWED_EXTENSIONS;
+    const extensionsPattern = validComponentExtensions.map((ext) =>
+        ext.replace('.', '')
+    ).join("|");
+    const dynamicRegex = new RegExp(
+        `(["'])([\\w\\d]+::[\\w\\d/]+\\.(${extensionsPattern}))\\1`,
+        "g"
+    );
+
+    const hasValidExtension = (filePath) =>
+        validComponentExtensions.some((ext) => filePath.endsWith(ext));
+    const hasExtension = (filePath) => !!path.extname(filePath);
+
+
+    const resolveComponentPath = (moduleName, filePath) => {
+        if (!filePath.startsWith("components/") && !filePath.startsWith("js/")) {
+            filePath = "components/" + filePath;
+        }
+        const fileName = path.join(
+            path.dirname(filePath),
+            path.parse(filePath).name
+        );
+        return allComponents[`${moduleName}/${fileName}`];
+    };
+
+    return {
+        name: "inherit-resolver",
+        resolveId: {
+            order: 'pre',
+            handler(id) {
+                if (!id) {
+                    return;
+                }
+                const idParts = id.split("::");
+                if (idParts.length === 1) {
+                    return;
+                }
+                const [moduleName, filePath] = idParts;
+                if (hasExtension(filePath) && !hasValidExtension(filePath)) {
+                    return;
+                }
+                const componentSrc = resolveComponentPath(moduleName, filePath);
+                if (!componentSrc) {
+                    return;
+                }
+
+                return componentSrc;
+            }
+        }
+    };
+}

package/src/service/magentoHrmRewrite.js

@@ -0,0 +1,24 @@
+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];
+                    const suffix = matchedKey === 'lib/vue' ? '/' : '/@fs';
+                    req.url = `${suffix}${filePath}`;
+                    next();
+                } else {
+                    next();
+                }
+            });
+        },
+    }
+}

package/src/service/moduleResolver.js

@@ -0,0 +1,103 @@
+import path from "path";
+import configResolver from "./configResolver.cjs";
+import {
+    ALL_JS_VUE_FILES_WITH_INHERITANCE_FILE_NAME,
+    MODULE_WEB_PATH,
+    PRECOMPILED_FOLDER,
+    THEME_MODULE_WEB_PATH
+} from "../config/default.cjs";
+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];
+}
+
+export default {
+    getAllJsVueFilesWithInheritance,
+    getAllJsVueFilesWithInheritanceCached
+};

package/src/service/moduleResolverSync.cjs

@@ -0,0 +1,84 @@
+const path = require("path");
+const fs = require("fs");
+const deepmerge = require("deepmerge");
+const configResolver = require("./configResolver.cjs");
+
+const moduleConfigByThemeCache = new Map();
+
+const MODULE_CONFIG_FILE = configResolver.getMagentoConfig().MODULE_CONFIG_FILE;
+
+/**
+ * Gets the theme configuration file path.
+ * @returns {string} Full path to the configuration file.
+ * @param moduleSrc
+ */
+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;
+    }
+
+    if (includeTailwindConfigFromParentThemes && theme.parent) {
+        return resolveFileByTheme(theme.parent, moduleName, filePath, includeTailwindConfigFromParentThemes);
+    }
+    return null;
+}
+
+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;
+    }
+    return require(moduleConfigSourcePath);
+}
+
+/**
+ * Retrieves the Tailwind configuration for a theme synchronously.
+ * Uses a cache system to optimize performance.
+ * @param {string} themeName - Name of the theme.
+ * @returns {object|null} Tailwind configuration object.
+ */
+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 = resolveModuleConfig(moduleName, themeName, themeConfig.includeTailwindConfigFromParentThemes);
+        if (!moduleConfig) {
+            continue;
+        }
+        if (themeConfig.ignoredTailwindConfigFromModules === 'all' || themeConfig.ignoredTailwindConfigFromModules.includes(moduleName)) {
+            moduleConfig.tailwind = {};
+        } else if (moduleConfig.tailwind && moduleConfig.tailwind.content) {
+            const moduleSrc = configResolver.getMagentoConfig().modules[moduleName].src;
+            moduleConfig.tailwind.content = moduleConfig.tailwind.content.map((content) =>
+                path.join(moduleSrc, 'web', content)
+            );
+        }
+        modulesConfig = deepmerge(modulesConfig, moduleConfig);
+    }
+    return modulesConfig;
+}
+
+module.exports = {
+    getModuleConfigByThemeConfig,
+    resolveFileByTheme
+};

package/src/service/preCompileFiles.js

@@ -0,0 +1,37 @@
+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.cjs";
+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

@@ -0,0 +1,16 @@
+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 precompileCss(themeName);
+    await precompileJs(themeName);
+    isPrecompiled = true;
+}

package/src/service/setupGlobals.js

@@ -0,0 +1,19 @@
+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/tailwindResolver.cjs

@@ -0,0 +1,15 @@
+const themeResolver = require('./themeResolverSync.cjs');
+const moduleResolver = require('./moduleResolverSync.cjs');
+const deepmerge = require('deepmerge');
+
+function getTailwindConfigByTheme(themeName) {
+    const themeConfig = themeResolver.getThemeConfig(themeName);
+    return deepmerge(
+        moduleResolver.getModuleConfigByThemeConfig(themeName, themeConfig)?.tailwind ?? {},
+        themeConfig?.tailwind ?? {}
+    );
+}
+
+module.exports = {
+    getTailwindConfigByTheme
+};

package/src/service/themeResolverSync.cjs

@@ -0,0 +1,80 @@
+const path = require("path");
+const fs = require("fs");
+const deepmerge = require("deepmerge");
+const { THEME_MODULE_WEB_PATH } = require("../config/default.cjs");
+const configResolver = require("./configResolver.cjs");
+
+const themeConfigCache = new Map();
+
+function getThemeConfigPath(themeSrc) {
+    return path.join(themeSrc, THEME_MODULE_WEB_PATH, configResolver.getMagentoConfig().THEME_CONFIG_FILE);
+}
+
+const themeConfigPlainCache = new Map();
+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 = require(configPath);
+        themeConfig = themeConfig.default ?? themeConfig;
+        themeConfigPlainCache.set(themeName, themeConfig);
+        return deepmerge({}, themeConfig);
+    } catch {
+        console.error(`Failed to load configuration for theme "${themeName}"`);
+        return null;
+    }
+}
+
+function getThemeConfig(themeName) {
+    if (themeConfigCache.has(themeName)) return themeConfigCache.get(themeName);
+
+    const themeDefinition = configResolver.getMagentoConfig().themes[themeName];
+    if (!themeDefinition) return null;
+
+    let themeConfig = loadThemeConfig(themeDefinition, themeName);
+    if (!themeConfig) return null;
+    if (themeConfig.includeTailwindConfigFromParentThemes === undefined) {
+        themeConfig.includeTailwindConfigFromParentThemes = true;
+    }
+    if (themeConfig.includeCssSourceFromParentThemes === undefined) {
+        themeConfig.includeCssSourceFromParentThemes = true;
+    }
+    if (themeConfig.ignoredCssFromModules === undefined) {
+        themeConfig.ignoredCssFromModules = [];
+    }
+    if (themeConfig.ignoredTailwindConfigFromModules === undefined) {
+        themeConfig.ignoredTailwindConfigFromModules = [];
+    }
+    if (themeConfig.exposeNpmPackages === undefined) {
+        themeConfig.exposeNpmPackages = [];
+    }
+    if (themeConfig.tailwind === undefined) {
+        themeConfig.tailwind = {};
+    }
+
+
+    if (themeConfig.tailwind?.content) {
+        themeConfig.tailwind.content = themeConfig.tailwind.content.map((content) =>
+            path.join(themeDefinition.src, "web", content)
+        );
+    }
+    const includeTailwindConfigFromParentThemes = themeConfig.includeTailwindConfigFromParentThemes !== undefined ? themeConfig.includeTailwindConfigFromParentThemes : true;
+    if (includeTailwindConfigFromParentThemes && themeDefinition.parent) {
+        themeConfig = deepmerge(getThemeConfig(themeDefinition.parent) || {}, themeConfig);
+    }
+
+    themeConfigCache.set(themeName, themeConfig);
+    return themeConfig;
+}
+
+function getTailwindThemeConfig(themeName) {
+    return getThemeConfig(themeName)?.tailwind ?? {};
+}
+
+module.exports = {
+    getThemeConfig,
+    getTailwindThemeConfig
+};

package/src/templates/base_main_js_file.js

@@ -0,0 +1,5 @@
+import * as vue from 'vue';
+import './precompiled.css';
+
+export * from 'vue';
+