@modern-js/app-tools 2.69.5 → 3.0.0-alpha.0

package/dist/esm/commands/build.mjs

@@ -0,0 +1,68 @@
+import { fs, logger } from "@modern-js/utils";
+import { loadServerPlugins } from "../utils/loadPlugins";
+import { registerCompiler } from "../utils/register";
+import { generateRoutes } from "../utils/routes";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+async function copyEnvFiles(appDirectory, distDirectory) {
+    try {
+        const files = await fs.readdir(appDirectory);
+        const envFileRegex = /^\.env(\.[a-zA-Z0-9_-]+)*$/;
+        const envFiles = files.filter((file)=>envFileRegex.test(file));
+        if (0 === envFiles.length) return void logger.debug('No .env files found to copy');
+        const copyPromises = envFiles.map(async (envFile)=>{
+            const sourcePath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDirectory, envFile);
+            const targetPath = __rspack_external_node_path_c5b9b54f["default"].resolve(distDirectory, envFile);
+            try {
+                const stat = await fs.stat(sourcePath);
+                if (stat.isDirectory()) return;
+                await fs.copy(sourcePath, targetPath);
+            } catch (error) {
+                logger.warn(`Failed to copy ${envFile}:`, error);
+            }
+        });
+        await Promise.all(copyPromises);
+    } catch (error) {
+        logger.warn('Failed to copy .env files:', error);
+    }
+}
+const build = async (api, options)=>{
+    if (options?.analyze) process.env.BUNDLE_ANALYZE = 'true';
+    const resolvedConfig = api.getNormalizedConfig();
+    const appContext = api.getAppContext();
+    const hooks = api.getHooks();
+    const combinedAlias = [].concat(resolvedConfig?.resolve?.alias ?? []).concat(resolvedConfig?.source?.alias ?? []);
+    await loadServerPlugins(api, appContext.appDirectory, appContext.metaName);
+    if (appContext.moduleType && 'module' === appContext.moduleType) {
+        const { registerEsm } = await import("../esm/register-esm.mjs");
+        await registerEsm({
+            appDir: appContext.appDirectory,
+            distDir: appContext.distDirectory,
+            alias: {}
+        });
+    }
+    await registerCompiler(appContext.appDirectory, appContext.distDirectory, combinedAlias);
+    const { apiOnly } = appContext;
+    if (apiOnly) {
+        await hooks.onBeforeBuild.call({
+            environments: {},
+            bundlerConfigs: void 0,
+            isFirstCompile: false,
+            isWatch: false
+        });
+        await generateRoutes(appContext);
+        await hooks.onAfterBuild.call({
+            environments: {},
+            stats: void 0,
+            isFirstCompile: false,
+            isWatch: false
+        });
+        return;
+    }
+    logger.info('Starting production build...');
+    if (!appContext.builder) throw new Error('Expect the Builder to have been initialized, But the appContext.builder received `undefined`');
+    await appContext.builder.onAfterBuild(async ()=>copyEnvFiles(appContext.appDirectory, appContext.distDirectory));
+    await appContext.builder.build({
+        watch: options?.watch
+    });
+};
+export { build };

package/dist/esm/commands/deploy.mjs

@@ -0,0 +1,10 @@
+import { getServerPlugins } from "../utils/loadPlugins";
+const deploy = async (api, options)=>{
+    const hooks = api.getHooks();
+    const { metaName } = api.getAppContext();
+    await getServerPlugins(api, metaName);
+    await hooks.onBeforeDeploy.call(options);
+    await hooks.deploy.call();
+    await hooks.onAfterDeploy.call(options);
+};
+export { deploy };

package/dist/esm/commands/dev.mjs

@@ -0,0 +1,82 @@
+import { createDevServer } from "@modern-js/server";
+import { DEFAULT_DEV_HOST, SERVER_DIR, getMeta, logger } from "@modern-js/utils";
+import { setServer } from "../utils/createServer";
+import { loadServerPlugins } from "../utils/loadPlugins";
+import { printInstructions } from "../utils/printInstructions";
+import { registerCompiler } from "../utils/register";
+import { generateRoutes } from "../utils/routes";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external__modern_js_prod_server_057184e2 from "@modern-js/prod-server";
+const dev = async (api, options, devServerOptions)=>{
+    if (options.analyze) process.env.BUNDLE_ANALYZE = 'true';
+    const normalizedConfig = api.getNormalizedConfig();
+    const appContext = api.getAppContext();
+    const hooks = api.getHooks();
+    const combinedAlias = [].concat(normalizedConfig?.resolve?.alias ?? []).concat(normalizedConfig?.source?.alias ?? []);
+    if (appContext.moduleType && 'module' === appContext.moduleType) {
+        const { registerEsm } = await import("../esm/register-esm.mjs");
+        await registerEsm({
+            appDir: appContext.appDirectory,
+            distDir: appContext.distDirectory,
+            alias: {}
+        });
+    }
+    await registerCompiler(appContext.appDirectory, appContext.distDirectory, combinedAlias);
+    const { appDirectory, port, apiOnly, metaName, serverRoutes } = appContext;
+    const meta = getMeta(metaName);
+    const serverConfigPath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDirectory, SERVER_DIR, `${meta}.server`);
+    await hooks.onBeforeDev.call();
+    if (!appContext.builder && !apiOnly) throw new Error('Expect the Builder to have been initialized, But the appContext.builder received `undefined`');
+    await generateRoutes(appContext);
+    const pluginInstances = await loadServerPlugins(api, appDirectory, metaName);
+    const serverOptions = {
+        metaName,
+        dev: {
+            https: normalizedConfig.dev.https,
+            setupMiddlewares: normalizedConfig.dev.setupMiddlewares
+        },
+        appContext: {
+            appDirectory,
+            internalDirectory: appContext.internalDirectory,
+            apiDirectory: appContext.apiDirectory,
+            lambdaDirectory: appContext.lambdaDirectory,
+            sharedDirectory: appContext.sharedDirectory,
+            bffRuntimeFramework: appContext.bffRuntimeFramework
+        },
+        serverConfigPath,
+        routes: serverRoutes,
+        pwd: appDirectory,
+        config: normalizedConfig,
+        plugins: pluginInstances,
+        ...devServerOptions
+    };
+    const host = normalizedConfig.dev?.host || DEFAULT_DEV_HOST;
+    if (apiOnly) {
+        const { server } = await createDevServer({
+            ...serverOptions,
+            runCompile: false
+        }, devServerOptions?.applyPlugins || __rspack_external__modern_js_prod_server_057184e2.applyPlugins);
+        server.listen({
+            port,
+            host
+        }, ()=>{
+            printInstructions(hooks, appContext, normalizedConfig);
+        });
+        setServer(server);
+    } else {
+        const { server, afterListen } = await createDevServer({
+            ...serverOptions,
+            builder: appContext.builder
+        }, devServerOptions?.applyPlugins || __rspack_external__modern_js_prod_server_057184e2.applyPlugins);
+        server.listen({
+            port,
+            host
+        }, async (err)=>{
+            if (err) logger.error('Occur error %s, when start dev server', err);
+            logger.debug('listen dev server done');
+            await afterListen();
+        });
+        setServer(server);
+    }
+};
+export { dev };

package/dist/esm/commands/index.mjs

@@ -0,0 +1,37 @@
+import { i18n, localeKeys } from "../locale";
+const devCommand = async (program, api)=>{
+    program.command('dev').alias('start').usage('[options]').description(i18n.t(localeKeys.command.dev.describe)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-e --entry [entry...]', i18n.t(localeKeys.command.dev.entry)).option('--analyze', i18n.t(localeKeys.command.shared.analyze)).option('--api-only', i18n.t(localeKeys.command.dev.apiOnly)).option('--web-only', i18n.t(localeKeys.command.dev.webOnly)).action(async (options)=>{
+        const { dev } = await import("./dev.js");
+        await dev(api, options);
+    });
+};
+const buildCommand = async (program, api)=>{
+    program.command('build').usage('[options]').description(i18n.t(localeKeys.command.build.describe)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('--analyze', i18n.t(localeKeys.command.shared.analyze)).option('-w --watch', i18n.t(localeKeys.command.build.watch)).action(async (options)=>{
+        const { build } = await import("./build.js");
+        await build(api, options);
+    });
+};
+const serverCommand = (program, api)=>{
+    program.command('serve').usage('[options]').description(i18n.t(localeKeys.command.serve.describe)).option('--api-only', i18n.t(localeKeys.command.dev.apiOnly)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).action(async ()=>{
+        const { serve } = await import("./serve.js");
+        await serve(api);
+    });
+};
+const deployCommand = (program, api)=>{
+    program.command('deploy').usage('[options]').option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-s --skip-build', i18n.t(localeKeys.command.shared.skipBuild)).description(i18n.t(localeKeys.command.deploy.describe)).action(async (options)=>{
+        if (!options.skipBuild) {
+            const { build } = await import("./build.js");
+            await build(api);
+        }
+        const { deploy } = await import("./deploy.js");
+        await deploy(api, options);
+        process.exit(0);
+    });
+};
+const inspectCommand = (program, api)=>{
+    program.command('inspect').description('inspect the internal configs').option("--env <env>", i18n.t(localeKeys.command.inspect.env), 'development').option('--output <output>', i18n.t(localeKeys.command.inspect.output), './').option('--verbose', i18n.t(localeKeys.command.inspect.verbose)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).action(async (options)=>{
+        const { inspect } = await import("./inspect.js");
+        inspect(api, options);
+    });
+};
+export { buildCommand, deployCommand, devCommand, inspectCommand, serverCommand };

package/dist/esm/commands/inspect.mjs

@@ -0,0 +1,15 @@
+const inspect = async (api, options)=>{
+    const appContext = api.getAppContext();
+    if (!appContext.builder) throw new Error('Expect the Builder to have been initialized, But the appContext.builder received `undefined`');
+    const metaName = 'modern-js' === appContext.metaName ? 'modern.js' : appContext.metaName;
+    return appContext.builder.inspectConfig({
+        mode: options.env,
+        verbose: options.verbose,
+        outputPath: options.output,
+        writeToDisk: true,
+        extraConfigs: {
+            [metaName]: api.getNormalizedConfig()
+        }
+    });
+};
+export { inspect };

package/dist/esm/commands/serve.mjs

@@ -0,0 +1,47 @@
+import path from "path";
+import { SERVER_DIR, getMeta, getTargetDir, isApiOnly, logger } from "@modern-js/utils";
+import { loadServerPlugins } from "../utils/loadPlugins";
+import { printInstructions } from "../utils/printInstructions";
+import * as __rspack_external__modern_js_prod_server_057184e2 from "@modern-js/prod-server";
+const serve = async (api, serverOptions)=>{
+    const appContext = api.getAppContext();
+    const userConfig = api.getNormalizedConfig();
+    const hooks = api.getHooks();
+    const { distDirectory, appDirectory, internalDirectory, port, metaName, serverRoutes } = appContext;
+    const { isCrossProjectServer } = userConfig?.bff || {};
+    logger.info("Starting production server...");
+    const apiOnly = await isApiOnly(appContext.appDirectory, userConfig?.source?.entriesDir, appContext.apiDirectory);
+    let runMode;
+    if (apiOnly) runMode = 'apiOnly';
+    const meta = getMeta(metaName);
+    const serverConfigPath = path.resolve(distDirectory, SERVER_DIR, `${meta}.server`);
+    const pluginInstances = await loadServerPlugins(api, appDirectory, metaName);
+    const app = await (serverOptions?.launcher || __rspack_external__modern_js_prod_server_057184e2.createProdServer)({
+        metaName,
+        pwd: distDirectory,
+        config: {
+            ...userConfig,
+            dev: userConfig.dev,
+            output: {
+                path: userConfig.output.distPath?.root,
+                ...userConfig.output || {}
+            }
+        },
+        routes: serverRoutes,
+        plugins: pluginInstances,
+        serverConfigPath,
+        appContext: {
+            appDirectory,
+            internalDirectory,
+            sharedDirectory: getTargetDir(appContext.sharedDirectory, appContext.appDirectory, appContext.distDirectory),
+            apiDirectory: isCrossProjectServer ? appContext.apiDirectory : getTargetDir(appContext.apiDirectory, appContext.appDirectory, appContext.distDirectory),
+            lambdaDirectory: isCrossProjectServer ? appContext.lambdaDirectory : getTargetDir(appContext.lambdaDirectory, appContext.appDirectory, appContext.distDirectory),
+            bffRuntimeFramework: appContext.bffRuntimeFramework
+        },
+        runMode
+    });
+    app.listen(port, async ()=>{
+        await printInstructions(hooks, appContext, userConfig);
+    });
+};
+export { serve };

package/dist/esm/compat/hooks.mjs

@@ -0,0 +1,67 @@
+import { getModifyHtmlPartials } from "../plugins/analyze/getHtmlTemplate";
+import { transformHookParams, transformHookResult, transformHookRunner } from "./utils";
+function getHookRunners(context) {
+    const { hooks } = context;
+    return {
+        afterPrepare: async ()=>hooks.onAfterPrepare.call(),
+        deploy: async ()=>hooks.deploy.call(),
+        _internalRuntimePlugins: async (params)=>hooks._internalRuntimePlugins.call(params),
+        _internalServerPlugins: async (params)=>hooks._internalServerPlugins.call(params),
+        checkEntryPoint: async (params)=>hooks.checkEntryPoint.call(params),
+        modifyEntrypoints: async (params)=>hooks.modifyEntrypoints.call(params),
+        modifyFileSystemRoutes: async (params)=>hooks.modifyFileSystemRoutes.call(params),
+        modifyServerRoutes: async (params)=>hooks.modifyServerRoutes.call(params),
+        generateEntryCode: async (params)=>hooks.generateEntryCode.call(params),
+        beforeGenerateRoutes: async (params)=>hooks.onBeforeGenerateRoutes.call(params),
+        beforePrintInstructions: async (params)=>hooks.onBeforePrintInstructions.call(params),
+        appendEntryCode: async (params)=>{
+            const result = await hooks?.appendEntryCode.call(params);
+            return result;
+        },
+        jestConfig: async (utils)=>{
+            const result = await hooks?.jestConfig.call(utils, (utils)=>utils);
+            return result;
+        },
+        afterTest: async ()=>hooks.afterTest.call(),
+        config: async ()=>hooks.config.call(),
+        resolvedConfig: (params)=>hooks.modifyResolvedConfig.call(params),
+        htmlPartials: async (params)=>{
+            await hooks.modifyHtmlPartials.call({
+                entrypoint: params.entrypoint,
+                partials: getModifyHtmlPartials(params.partials)
+            });
+            return {
+                partials: params.partials
+            };
+        },
+        commands: async (params)=>hooks.addCommand.call(params),
+        watchFiles: async ()=>hooks.addWatchFiles.call(),
+        prepare: async ()=>hooks.onPrepare.call(),
+        fileChange: async (params)=>hooks.onFileChanged.call(params),
+        beforeCreateCompiler: async (params)=>hooks.onBeforeCreateCompiler.call(params),
+        afterCreateCompiler: async (params)=>hooks.onAfterCreateCompiler.call(params),
+        beforeBuild: async (params)=>hooks.onBeforeBuild.call(params),
+        afterBuild: async (params)=>hooks.onAfterBuild.call(params),
+        beforeDev: async ()=>hooks.onBeforeDev.call(),
+        afterDev: async (params)=>hooks.onDevCompileDone.call(params),
+        beforeDeploy: async (options)=>hooks.onBeforeDeploy.call(options),
+        afterDeploy: async (options)=>hooks.onAfterDeploy.call(options),
+        beforeExit: async ()=>hooks.onBeforeExit.call(),
+        beforeRestart: async ()=>hooks.onBeforeRestart.call()
+    };
+}
+function handleSetupResult(setupResult, api) {
+    if (!setupResult) return;
+    Object.keys(setupResult).forEach((key)=>{
+        const fn = setupResult[key];
+        if ('function' == typeof fn) {
+            const newAPI = transformHookRunner(key);
+            if (newAPI && api[newAPI]) api[newAPI](async (...params)=>{
+                const { isMultiple, params: transformParams } = transformHookParams(key, params);
+                if (isMultiple) return transformHookResult(key, await fn(...transformParams));
+                return transformHookResult(key, await fn(transformParams));
+            });
+        }
+    });
+}
+export { getHookRunners, handleSetupResult };

package/dist/esm/compat/index.mjs

@@ -0,0 +1,28 @@
+import { createAsyncHook } from "@modern-js/plugin";
+import { getHookRunners } from "./hooks";
+const compatPlugin = ()=>({
+        name: '@modern-js/app-tools-compat',
+        _registryApi: (getAppContext, updateAppContext)=>{
+            const getInternalContext = ()=>getAppContext()._internalContext;
+            return {
+                useAppContext: ()=>{
+                    const { _internalContext, ...appContext } = getAppContext();
+                    return appContext;
+                },
+                setAppContext: (context)=>updateAppContext(context),
+                useConfigContext: ()=>getInternalContext().config,
+                useResolvedConfigContext: ()=>getInternalContext().normalizedConfig,
+                useHookRunners: ()=>getHookRunners(getInternalContext())
+            };
+        },
+        registryHooks: {
+            jestConfig: createAsyncHook(),
+            afterTest: createAsyncHook()
+        },
+        setup: (api)=>{
+            api.updateAppContext({
+                toolsType: 'app-tools'
+            });
+        }
+    });
+export { compatPlugin };

package/dist/esm/compat/utils.mjs

@@ -0,0 +1,95 @@
+import { getModifyHtmlPartials } from "../plugins/analyze/getHtmlTemplate";
+function transformHookRunner(hookRunnerName) {
+    switch(hookRunnerName){
+        case 'beforeConfig':
+            console.error('The `beforeConfig` hook has been deprecated. Please define your code directly in the setup function instead.');
+            return;
+        case 'prepare':
+            return 'onPrepare';
+        case 'afterPrepare':
+            return 'onAfterPrepare';
+        case 'beforeGenerateRoutes':
+            return 'onBeforeGenerateRoutes';
+        case 'beforePrintInstructions':
+            return 'onBeforePrintInstructions';
+        case 'resolvedConfig':
+            return 'modifyResolvedConfig';
+        case 'commands':
+            return 'addCommand';
+        case 'watchFiles':
+            return 'addWatchFiles';
+        case 'fileChange':
+            return 'onFileChanged';
+        case 'beforeCreateCompiler':
+            return 'onBeforeCreateCompiler';
+        case 'afterCreateCompiler':
+            return 'onAfterCreateCompiler';
+        case 'beforeBuild':
+            return 'onBeforeBuild';
+        case 'afterBuild':
+            return 'onAfterBuild';
+        case 'beforeDev':
+            return 'onBeforeDev';
+        case 'afterDev':
+            return 'onDevCompileDone';
+        case 'beforeDeploy':
+            return 'onBeforeDeploy';
+        case 'afterDeploy':
+            return 'onAfterDeploy';
+        case 'beforeExit':
+            return 'onBeforeExit';
+        case 'beforeRestart':
+            return 'onBeforeRestart';
+        case 'htmlPartials':
+            return 'modifyHtmlPartials';
+        default:
+            return hookRunnerName;
+    }
+}
+function transformHookParams(hookRunnerName, params) {
+    switch(hookRunnerName){
+        case 'resolvedConfig':
+            return {
+                isMultiple: false,
+                params: {
+                    resolved: params[0]
+                }
+            };
+        case 'htmlPartials':
+            return {
+                isMultiple: false,
+                params: {
+                    partials: {
+                        top: params[0].partials.top.current,
+                        head: params[0].partials.head.current,
+                        body: params[0].partials.body.current
+                    },
+                    entrypoint: params[0].entrypoint
+                }
+            };
+        case 'jestConfig':
+            return {
+                isMultiple: true,
+                params: params
+            };
+        default:
+            return {
+                isMultiple: false,
+                params: params[0]
+            };
+    }
+}
+function transformHookResult(hookRunnerName, result) {
+    switch(hookRunnerName){
+        case 'resolvedConfig':
+            return result.resolved;
+        case 'htmlPartials':
+            return {
+                partials: getModifyHtmlPartials(result.partials),
+                entrypoint: result.entrypoint
+            };
+        default:
+            return result;
+    }
+}
+export { transformHookParams, transformHookResult, transformHookRunner };

package/dist/esm/config/default.mjs

@@ -0,0 +1,90 @@
+import { DEFAULT_ENTRY_NAME } from "@modern-js/utils";
+import { getAutoInjectEnv } from "../utils/env";
+function createDefaultConfig(appContext) {
+    const dev = {
+        cliShortcuts: {
+            help: false,
+            custom: (shortcuts = [])=>shortcuts.filter(({ key })=>'r' !== key && 'u' !== key)
+        }
+    };
+    const output = {
+        distPath: {
+            root: 'dist',
+            html: 'html',
+            js: 'static/js',
+            css: 'static/css',
+            server: 'bundles',
+            worker: 'worker'
+        },
+        cleanDistPath: true,
+        enableInlineRouteManifests: true,
+        disableInlineRouteManifests: false
+    };
+    const source = {
+        entries: void 0,
+        mainEntryName: DEFAULT_ENTRY_NAME,
+        enableAsyncEntry: false,
+        disableDefaultEntries: false,
+        entriesDir: './src',
+        configDir: './config',
+        globalVars: getAutoInjectEnv(appContext),
+        alias: {}
+    };
+    const resolve = {
+        alias: {
+            [appContext.internalDirAlias]: appContext.internalDirectory,
+            [appContext.internalSrcAlias]: appContext.srcDirectory,
+            '@': appContext.srcDirectory,
+            '@shared': appContext.sharedDirectory
+        }
+    };
+    const html = {
+        title: '',
+        mountId: 'root',
+        meta: {
+            charset: {
+                charset: 'utf-8'
+            },
+            viewport: 'width=device-width, initial-scale=1.0, shrink-to-fit=no, viewport-fit=cover, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no',
+            'http-equiv': {
+                'http-equiv': 'x-ua-compatible',
+                content: 'ie=edge'
+            },
+            renderer: 'webkit',
+            layoutmode: 'standard',
+            imagemode: 'force',
+            'wap-font-scale': 'no',
+            'format-detection': 'telephone=no'
+        }
+    };
+    const server = {
+        routes: void 0,
+        publicRoutes: void 0,
+        ssr: void 0,
+        ssrByEntries: void 0,
+        baseUrl: '/',
+        port: 8080
+    };
+    return {
+        source,
+        resolve,
+        output,
+        server,
+        dev,
+        html,
+        tools: {
+            tsChecker: {
+                issue: {
+                    exclude: [
+                        {
+                            file: '**/api/lambda/**/*'
+                        }
+                    ]
+                }
+            }
+        },
+        plugins: [],
+        builderPlugins: []
+    };
+}
+export { createDefaultConfig };

package/dist/{esm-node/config/index.js → esm/config/index.mjs}

@@ -1,3 +1,2 @@
-export * from "./legacy";
 export * from "./initialize";
 export * from "./default";

package/dist/esm/config/initialize/index.mjs

@@ -0,0 +1,7 @@
+import { initHtmlConfig, initSourceConfig } from "./inits";
+function initialNormalizedConfig(config, appContext) {
+    initHtmlConfig(config, appContext);
+    initSourceConfig(config, appContext);
+    return config;
+}
+export { initialNormalizedConfig };

package/dist/esm/config/initialize/inits.mjs

@@ -0,0 +1,54 @@
+import path, { isAbsolute } from "path";
+import { findExists } from "@modern-js/utils";
+function initHtmlConfig(config, appContext) {
+    const ICON_EXTENSIONS = [
+        'png',
+        'jpg',
+        'jpeg',
+        'svg',
+        'ico'
+    ];
+    config.html.appIcon = createBuilderAppIcon(config, appContext);
+    config.html.favicon = createBuilderFavicon(config, appContext);
+    return config.html;
+    function createBuilderAppIcon(config, appContext) {
+        const { appIcon } = config.html;
+        const { configDir } = config.source;
+        const getDefaultAppIcon = ()=>{
+            const appIconPath = findExists(ICON_EXTENSIONS.map((ext)=>path.resolve(appContext.appDirectory, configDir || './config', `icon.${ext}`)));
+            return appIconPath ? {
+                icons: [
+                    {
+                        src: appIconPath,
+                        size: 180
+                    }
+                ]
+            } : void 0;
+        };
+        return appIcon || getDefaultAppIcon() || void 0;
+    }
+    function createBuilderFavicon(config, appContext) {
+        const { configDir } = config.source;
+        const { favicon } = config.html;
+        const getDefaultFavicon = ()=>findExists(ICON_EXTENSIONS.map((ext)=>path.resolve(appContext.appDirectory, configDir || './config', `favicon.${ext}`)));
+        return favicon || getDefaultFavicon() || void 0;
+    }
+}
+function initSourceConfig(config, appContext) {
+    config.source.include = createBuilderInclude(config, appContext);
+}
+function createBuilderInclude(config, appContext) {
+    const { include } = config.source;
+    const defaultInclude = [
+        appContext.internalDirectory
+    ];
+    const transformInclude = (include || []).map((include)=>{
+        if ('string' == typeof include) {
+            if (isAbsolute(include)) return include;
+            return new RegExp(include);
+        }
+        return include;
+    }).concat(defaultInclude);
+    return transformInclude;
+}
+export { initHtmlConfig, initSourceConfig };

package/dist/esm/constants.mjs

@@ -0,0 +1,3 @@
+const DEFAULT_CONFIG_FILE = 'modern.config';
+const DEFAULT_RUNTIME_CONFIG_FILE = 'modern.runtime';
+export { DEFAULT_CONFIG_FILE, DEFAULT_RUNTIME_CONFIG_FILE };

package/dist/esm/defineConfig.mjs

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