@bleedingdev/modern-js-app-tools 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/esm-node/builder/shared/lazyCompilation.mjs

@@ -1,4 +1,5 @@
 import "node:module";
+import node_path from "node:path";
 import { collectRouteComponentFiles, normalizeModulePath } from "@modern-js/utils";
 function aggregateEagerRouteComponentFiles(byEntry) {
     const files = new Set();
@@ -21,6 +22,18 @@ function buildSSRLazyCompilationTest(eagerRouteFiles, userTest) {
         return userTestFn(m);
     };
 }
+function buildDefaultLazyCompilationTest(appDirectory, internalDirectory) {
+    let dirs;
+    return (m)=>{
+        if (!('resource' in m) || 'string' != typeof m.resource) return true;
+        dirs ??= {
+            app: normalizeModulePath(appDirectory),
+            internal: normalizeModulePath(internalDirectory)
+        };
+        const file = m.resource.split('?')[0].split(node_path.sep).join('/');
+        return file.startsWith(`${dirs.app}/`) && !file.startsWith(`${dirs.internal}/`) && !file.slice(dirs.app.length).includes('/node_modules/');
+    };
+}
 function planSSRLazyCompilation(current, info) {
     if (!current) return {
         apply: false
@@ -42,4 +55,4 @@ function planSSRLazyCompilation(current, info) {
         }
     };
 }
-export { aggregateEagerRouteComponentFiles, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };
+export { aggregateEagerRouteComponentFiles, buildDefaultLazyCompilationTest, buildSSRLazyCompilationTest, collectRouteComponentFiles, normalizeModulePath, planSSRLazyCompilation };

package/dist/esm-node/commands/build.mjs

@@ -57,9 +57,8 @@ const build = async (api, options)=>{
     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));
-    const buildResult = await appContext.builder.build({
+    await appContext.builder.build({
         watch: options?.watch
     });
-    if (!options?.watch) await buildResult?.close();
 };
 export { build };

package/dist/esm-node/commands/deploy.mjs

@@ -1,11 +1,9 @@
 import "node:module";
 import { getServerPlugins } from "../utils/loadPlugins.mjs";
-import { build } from "./build.mjs";
 const deploy = async (api, options = {})=>{
     const hooks = api.getHooks();
     const { metaName } = api.getAppContext();
-    if (options.skipBuild) await getServerPlugins(api, metaName);
-    else await build(api);
+    await getServerPlugins(api, metaName);
     await hooks.onBeforeDeploy.call(options);
     await hooks.deploy.call();
     await hooks.onAfterDeploy.call(options);

package/dist/esm-node/commands/index.mjs

@@ -1,5 +1,9 @@
 import "node:module";
 import { i18n, localeKeys } from "../locale/index.mjs";
+const deployTargetOption = [
+    '--deploy-target <target>',
+    'deploy target; overrides deploy.target and MODERNJS_DEPLOY'
+];
 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.mjs");
@@ -7,7 +11,7 @@ const devCommand = async (program, api)=>{
     });
 };
 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)=>{
+    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)).option(...deployTargetOption).action(async (options)=>{
         const { build } = await import("./build.mjs");
         await build(api, options);
     });
@@ -19,7 +23,11 @@ const serverCommand = (program, 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)=>{
+    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)).option(...deployTargetOption).description(i18n.t(localeKeys.command.deploy.describe)).action(async (options)=>{
+        if (!options.skipBuild) {
+            const { build } = await import("./build.mjs");
+            await build(api);
+        }
         const { deploy } = await import("./deploy.mjs");
         await deploy(api, options);
         process.exit(0);

package/dist/esm-node/compat/hooks.mjs

@@ -60,7 +60,7 @@ function handleSetupResult(setupResult, api) {
             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));
+                else return transformHookResult(key, await fn(transformParams));
             });
         }
     });

package/dist/esm-node/esm/ts-paths-loader.mjs

@@ -15,8 +15,9 @@ const getParentPath = (parentURL)=>{
     } catch  {}
     return process.cwd();
 };
+const resolveSourcePath = (resolvedPath, context, defaultResolve)=>defaultResolve(context.conditions?.find((condition)=>'require' === condition || 'import' === condition) === 'require' ? resolvedPath : pathToFileURL(resolvedPath).href, context, defaultResolve);
 async function initialize({ appDir: currentAppDir, baseUrl, paths }) {
-    appDir = node_path.resolve(currentAppDir);
+    appDir = node_fs.existsSync(currentAppDir) ? node_fs.realpathSync(currentAppDir) : node_path.resolve(currentAppDir);
     matchPath = createMatchPath(baseUrl || './', paths || {});
 }
 function resolve(specifier, context, defaultResolve) {
@@ -26,12 +27,12 @@ function resolve(specifier, context, defaultResolve) {
     if ((specifier.startsWith('./') || specifier.startsWith('../')) && !node_path.extname(specifier) && isAppFile) {
         const matchedPath = node_path.resolve(parentPath, specifier);
         const resolvedPath = findSourceEntry(matchedPath) || matchedPath;
-        if (resolvedPath && node_fs.existsSync(resolvedPath)) return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
+        if (resolvedPath && node_fs.existsSync(resolvedPath)) return resolveSourcePath(resolvedPath, context, defaultResolve);
     }
-    if (!matchPath) return defaultResolve(specifier, context, defaultResolve);
+    if (!matchPath || !isAppFile) return defaultResolve(specifier, context, defaultResolve);
     const match = findMatchedSourcePath(matchPath, specifier);
     if (!match) return defaultResolve(specifier, context, defaultResolve);
     const resolvedPath = findSourceEntry(match) || match;
-    return defaultResolve(pathToFileURL(resolvedPath).href, context, defaultResolve);
+    return resolveSourcePath(resolvedPath, context, defaultResolve);
 }
 export { initialize, resolve };

package/dist/esm-node/index.mjs

@@ -1,9 +1,10 @@
-import __rslib_shim_module__ from "node:module";
-const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import "node:module";
+import { resolveDeployTarget } from "@modern-js/app-tools-extensions/deploy-output/target";
+import { createPolicyDefaultsPlugin } from "@modern-js/app-tools-extensions/policy-defaults";
 import { castArray } from "@modern-js/builder";
 import { getLocaleLanguage } from "@modern-js/i18n-utils/language-detector";
 import { createAsyncHook } from "@modern-js/plugin";
-import { cleanRequireCache, deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
+import { deprecatedCommands, emptyDir, getArgv, getCommand } from "@modern-js/utils";
 import path from "path";
 import { buildCommand, deployCommand, devCommand, infoCommand, inspectCommand, serverCommand } from "./commands/index.mjs";
 import { compatPlugin } from "./compat/index.mjs";
@@ -13,21 +14,20 @@ import analyze from "./plugins/analyze/index.mjs";
 import deploy from "./plugins/deploy/index.mjs";
 import initialize from "./plugins/initialize/index.mjs";
 import serverBuild from "./plugins/serverBuild.mjs";
-import serverRuntime from "./plugins/serverRuntime.mjs";
 import { generateWatchFiles } from "./utils/generateWatchFiles.mjs";
 import { initAppContext } from "./utils/initAppContext.mjs";
 import { restart } from "./utils/restart.mjs";
 export * from "./defineConfig.mjs";
 export * from "./types/index.mjs";
-const appTools = ()=>({
+const appTools = (options = {})=>({
         name: '@modern-js/app-tools',
         usePlugins: [
-            serverRuntime(),
             compatPlugin(),
             initialize(),
             analyze(),
             serverBuild(),
-            deploy()
+            deploy(),
+            createPolicyDefaultsPlugin(options)
         ],
         post: [
             '@modern-js/plugin-initialize',
@@ -74,6 +74,11 @@ const appTools = ()=>({
                 deprecatedCommands(program);
             });
             api.onPrepare(async ()=>{
+                api.updateAppContext({
+                    deployTarget: resolveDeployTarget({
+                        configTarget: api.getNormalizedConfig().deploy?.target
+                    })
+                });
                 const command = getCommand();
                 if ('deploy' === command) {
                     const isSkipBuild = [
@@ -82,18 +87,12 @@ const appTools = ()=>({
                     ].some((tag)=>getArgv().includes(tag));
                     if (isSkipBuild) return;
                 }
-                const { command: contextCommand } = api.getAppContext();
-                const shouldClean = [
+                if ([
                     'dev',
                     'start',
                     'build',
                     'deploy'
-                ].includes(command) || [
-                    'dev',
-                    'start',
-                    'build'
-                ].includes(contextCommand);
-                if (shouldClean) {
+                ].includes(command)) {
                     const resolvedConfig = api.getNormalizedConfig();
                     if (resolvedConfig.output.cleanDistPath) {
                         const appContext = api.getAppContext();
@@ -124,17 +123,10 @@ const appTools = ()=>({
                     await restart(api.getHooks(), filename);
                 }
             });
-            api.onBeforeRestart(()=>{
-                cleanRequireCache([
-                    require.resolve('./plugins/analyze')
-                ]);
-            });
         }
     });
 const src = appTools;
 export { defineConfig } from "./defineConfig.mjs";
-export { build } from "./commands/build.mjs";
-export { deploy } from "./commands/deploy.mjs";
 export { dev } from "./commands/dev.mjs";
 export { serve } from "./commands/serve.mjs";
 export { resolveModernRsbuildConfig } from "./rsbuild.mjs";

package/dist/esm-node/plugins/analyze/getFileSystemEntry.mjs

@@ -62,6 +62,6 @@ const getFileSystemEntry = async (hooks, appContext, config)=>{
         }));
         return scanDir(hooks, dirs);
     } else throw Error("source.entriesDir accept a directory.");
-    throw Error(`src dir ${entriesDir} not found.`);
+    else throw Error(`src dir ${entriesDir} not found.`);
 };
 export { getFileSystemEntry, hasEntry, hasServerEntry };

package/dist/esm-node/plugins/analyze/getServerRoutes.mjs

@@ -27,7 +27,7 @@ const applyRouteOptions = (original, routeOptions)=>{
             ...original,
             urlPath: url
         };
-        {
+        else {
             const { path: urlPath, ...other } = url;
             return {
                 ...original,

package/dist/esm-node/plugins/analyze/index.mjs

@@ -24,7 +24,7 @@ const analyze = ()=>({
                 const resolvedConfig = api.getNormalizedConfig();
                 const hooks = api.getHooks();
                 try {
-                    if (checkIsBuildCommands(appContext.command)) fs.emptydirSync(appContext.internalDirectory);
+                    if (checkIsBuildCommands()) fs.emptydirSync(appContext.internalDirectory);
                 } catch  {}
                 const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
                 const [{ getProdEntrypoints, getProdServerRoutes }] = await Promise.all([
@@ -126,7 +126,7 @@ const analyze = ()=>({
                     htmlTemplates
                 };
                 api.updateAppContext(appContext);
-                if (checkIsBuildCommands(appContext.command)) {
+                if (checkIsBuildCommands()) {
                     await hooks.generateEntryCode.call({
                         entrypoints
                     });

package/dist/esm-node/plugins/analyze/utils.mjs

@@ -1,6 +1,6 @@
 import "node:module";
 import { JS_EXTENSIONS, getCommand, normalizeToPosixPath } from "@modern-js/utils";
-import { parse } from "es-module-lexer";
+import { init, parse } from "es-module-lexer";
 import { transform } from "esbuild";
 import fs from "fs";
 import path from "path";
@@ -10,14 +10,14 @@ const walkDirectory = (dir)=>fs.readdirSync(dir).reduce((previous, filename)=>{
             ...previous,
             ...walkDirectory(filePath)
         ];
-        return [
+        else return [
             ...previous,
             filePath
         ];
     }, []);
 const replaceWithAlias = (base, filePath, alias)=>{
     if (filePath.includes(base)) return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
-    return filePath;
+    else return filePath;
 };
 const parseModule = async ({ source, filename })=>{
     let content = source;
@@ -36,10 +36,11 @@ const parseModule = async ({ source, filename })=>{
         });
         content = result.code;
     }
-    return await parse(content);
+    await init();
+    return parse(content);
 };
 const getServerCombinedModuleFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
-const checkIsBuildCommands = (contextCommand)=>{
+const checkIsBuildCommands = ()=>{
     const buildCommands = [
         'dev',
         'start',
@@ -49,8 +50,7 @@ const checkIsBuildCommands = (contextCommand)=>{
         'dev-worker'
     ];
     const command = getCommand();
-    if (buildCommands.includes(command)) return true;
-    return 'dev' === contextCommand || 'start' === contextCommand || 'build' === contextCommand || 'deploy' === contextCommand;
+    return buildCommands.includes(command);
 };
 const checkIsServeCommand = ()=>{
     const command = getCommand();

package/dist/esm-node/plugins/deploy/index.mjs

@@ -1,6 +1,6 @@
 import "node:module";
 import { createCloudflarePreset } from "@modern-js/app-tools-extensions/cloudflare";
-import { provider } from "std-env";
+import { getDeployingTarget } from "@modern-js/app-tools-extensions/deploy-output/target";
 import { createGhPagesPreset } from "./platforms/gh-pages.mjs";
 import { createNetlifyPreset } from "./platforms/netlify.mjs";
 import { createNodePreset } from "./platforms/node.mjs";
@@ -13,24 +13,11 @@ const deployPresets = {
     ghPages: createGhPagesPreset,
     cloudflare: createCloudflarePreset
 };
-const getSupportedDeployTargets = ()=>Object.keys(deployPresets);
-const isDeployTarget = (target)=>Object.prototype.hasOwnProperty.call(deployPresets, target);
-const providerDeployTargets = {
-    vercel: 'vercel',
-    netlify: 'netlify',
-    cloudflare: 'cloudflare',
-    cloudflare_pages: 'cloudflare',
-    cloudflare_workers: 'cloudflare'
-};
-const normalizeDetectedProvider = (value)=>value ? providerDeployTargets[value] : void 0;
-const resolveDeployTarget = (modernConfig, envDeployTarget = process.env.MODERNJS_DEPLOY, detectedProvider = provider)=>modernConfig.deploy?.target || envDeployTarget || normalizeDetectedProvider(detectedProvider) || 'node';
 async function getDeployPreset(appContext, modernConfig, deployTarget, api) {
     const { appDirectory, distDirectory, metaName } = appContext;
     const { useSSR, useAPI, useWebServer } = getProjectUsage(appDirectory, distDirectory, metaName);
     const needModernServer = useSSR || useAPI || useWebServer;
-    if (!isDeployTarget(deployTarget)) throw new Error(`Unknown deploy target: '${deployTarget}'. deploy.target or MODERNJS_DEPLOY should be one of: ${getSupportedDeployTargets().join(', ')}.`);
-    const createPreset = deployPresets[deployTarget];
-    return createPreset({
+    return deployPresets[deployTarget]({
         appContext,
         modernConfig,
         needModernServer,
@@ -42,11 +29,9 @@ const deploy = ()=>({
         setup: (api)=>{
             api.deploy(async ()=>{
                 const appContext = api.getAppContext();
-                const { metaName } = appContext;
-                const modernConfig = api.getNormalizedConfig();
-                const deployTarget = resolveDeployTarget(modernConfig);
-                if ('modern-js' !== metaName && !modernConfig.deploy?.target && !process.env.MODERNJS_DEPLOY) return;
-                const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget, api);
+                const deployTarget = getDeployingTarget(appContext);
+                if (!deployTarget) return;
+                const deployPreset = await getDeployPreset(appContext, api.getNormalizedConfig(), deployTarget, api);
                 deployPreset?.prepare && await deployPreset?.prepare();
                 deployPreset?.writeOutput && await deployPreset?.writeOutput();
                 deployPreset?.genEntry && await deployPreset?.genEntry();
@@ -55,4 +40,3 @@ const deploy = ()=>({
         }
     });
 export default deploy;
-export { getSupportedDeployTargets, resolveDeployTarget };

package/dist/esm-node/plugins/deploy/platforms/netlify.mjs

@@ -1,6 +1,7 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
 import node_path from "node:path";
+import { traceDeployFiles } from "@modern-js/app-tools-extensions/deploy-output/trace-files";
 import { fs, removeModuleSyncFromExports } from "@modern-js/utils";
 import { nodeDepEmit } from "ndepe";
 import { isMainEntry } from "../../../utils/routes.mjs";
@@ -73,8 +74,8 @@ const createNetlifyPreset = ({ appContext, modernConfig, needModernServer })=>{
             if (!needModernServer) return;
             const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
             const netlifyEntry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server/netlify') : require.resolve('@modern-js/prod-server/netlify');
-            if (!entry || !netlifyEntry) throw new Error('Cannot find @modern-js/prod-server');
             await nodeDepEmit({
+                traceFiles: traceDeployFiles,
                 appDir: appDirectory,
                 sourceDir: funcsDirectory,
                 includeEntries: [

package/dist/esm-node/plugins/deploy/platforms/node.mjs

@@ -1,12 +1,14 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { createRequire } from "node:module";
 import node_path from "node:path";
+import { traceDeployFiles } from "@modern-js/app-tools-extensions/deploy-output/trace-files";
 import { chalk, fs, removeModuleSyncFromExports } from "@modern-js/utils";
 import { nodeDepEmit } from "ndepe";
 import { readTemplate, resolveESMDependency } from "../utils/index.mjs";
 import { generateHandler } from "../utils/generator.mjs";
 const createNodePreset = ({ appContext, modernConfig })=>{
-    const { appDirectory, distDirectory, moduleType } = appContext;
+    const { appDirectory, distDirectory, moduleType, serverPlugins } = appContext;
     const isEsmProject = 'module' === moduleType;
     const outputDirectory = node_path.join(appDirectory, '.output');
     const staticDirectory = node_path.join(outputDirectory, 'static');
@@ -36,12 +38,19 @@ const createNodePreset = ({ appContext, modernConfig })=>{
         async end () {
             const filter = (filePath)=>!filePath.startsWith(staticDirectory) && !filePath.endsWith('.map');
             const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
-            if (!entry) throw new Error('Cannot find @modern-js/prod-server');
+            const requireFromApp = createRequire(node_path.join(appDirectory, 'package.json'));
+            const pluginEntries = new Set();
+            for (const plugin of serverPlugins)for (const specifier of plugin.includeEntries ?? []){
+                pluginEntries.add(requireFromApp.resolve(specifier));
+                if (isEsmProject) pluginEntries.add(await resolveESMDependency(specifier, appDirectory));
+            }
             await nodeDepEmit({
+                traceFiles: traceDeployFiles,
                 appDir: appDirectory,
                 sourceDir: outputDirectory,
                 includeEntries: [
-                    entry
+                    entry,
+                    ...pluginEntries
                 ],
                 copyWholePackage (pkgName) {
                     return '@modern-js/utils' === pkgName;

package/dist/esm-node/plugins/deploy/platforms/templates/node-entry.cjs

@@ -35,10 +35,11 @@ async function main() {
     const app = await createProdServer(prodServerOptions);
     const port = process.env.PORT || 8080;
     app.listen({
-        host: '::',
         port
     }, ()=>{
-        console.log(`\x1b[32mServer is listening on http://[::]:${port}`, '\x1b[0m');
+        const address = app.address();
+        const loopback = 'IPv6' === address.family ? '[::1]' : '127.0.0.1';
+        console.log(`\x1b[32mServer is listening on http://${loopback}:${address.port}`, '\x1b[0m');
     });
 }
 main();

package/dist/esm-node/plugins/deploy/platforms/templates/node-entry.mjs

@@ -37,10 +37,11 @@ async function main() {
     const app = await createProdServer(prodServerOptions);
     const port = process.env.PORT || 8080;
     app.listen({
-        host: '::',
         port
     }, ()=>{
-        console.log(`\x1b[32mServer is listening on http://[::]:${port}`, '\x1b[0m');
+        const address = app.address();
+        const loopback = 'IPv6' === address.family ? '[::1]' : '127.0.0.1';
+        console.log(`\x1b[32mServer is listening on http://${loopback}:${address.port}`, '\x1b[0m');
     });
 }
 main();

package/dist/esm-node/plugins/deploy/platforms/vercel.mjs

@@ -1,6 +1,7 @@
 import __rslib_shim_module__ from "node:module";
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
 import node_path from "node:path";
+import { traceDeployFiles } from "@modern-js/app-tools-extensions/deploy-output/trace-files";
 import { fs, removeModuleSyncFromExports } from "@modern-js/utils";
 import { nodeDepEmit } from "ndepe";
 import { isMainEntry } from "../../../utils/routes.mjs";
@@ -93,8 +94,8 @@ const createVercelPreset = ({ appContext, modernConfig, needModernServer })=>{
         async end () {
             if (!needModernServer) return;
             const entry = isEsmProject ? await resolveESMDependency('@modern-js/prod-server') : require.resolve('@modern-js/prod-server');
-            if (!entry) throw new Error('Cannot find @modern-js/prod-server');
             await nodeDepEmit({
+                traceFiles: traceDeployFiles,
                 appDir: appDirectory,
                 sourceDir: funcsDirectory,
                 includeEntries: [

package/dist/esm-node/plugins/deploy/utils/index.mjs

@@ -1,12 +1,11 @@
 import "node:module";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-import { ROUTE_SPEC_FILE, SERVER_DIR, dynamicImport, fs, getMeta } from "@modern-js/utils";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { ROUTE_SPEC_FILE, SERVER_DIR, fs, getMeta } from "@modern-js/utils";
+import { moduleResolve } from "import-meta-resolve";
 import path from "path";
 import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
 import { dirname as __rspack_dirname } from "node:path";
 var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(import.meta.url));
-var __rspack_import_meta_filename__ = __rspack_fileURLToPath(import.meta.url);
 const normalizePath = (filePath)=>filePath.replace(/\\/g, '/');
 const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
     const routeJSON = path.join(distDirectory, ROUTE_SPEC_FILE);
@@ -31,17 +30,20 @@ const getProjectUsage = (appDirectory, distDirectory, metaName)=>{
 };
 const getTemplatePath = (file)=>path.join(__rspack_import_meta_dirname__, '../platforms/templates', file);
 const readTemplate = async (file)=>(await fs.readFile(getTemplatePath(file))).toString();
-const resolveESMDependency = async (entry)=>{
-    const conditions = new Set([
-        'node',
-        'import',
-        'module',
-        'default'
-    ]);
+const DEPLOY_CONDITIONS = [
+    'node',
+    'import',
+    'module',
+    'default'
+];
+const resolveESMDependency = async (entry, fromDirectory)=>{
+    const base = fromDirectory ? pathToFileURL(path.join(fromDirectory, 'package.json')) : pathToFileURL(`${__rspack_import_meta_dirname__}/`);
     try {
-        const resolverPath = pathToFileURL(createRequire(__rspack_import_meta_filename__).resolve('import-meta-resolve')).href;
-        const { moduleResolve } = await dynamicImport(resolverPath);
-        return normalizePath(moduleResolve(entry, pathToFileURL(`${__rspack_import_meta_dirname__}/`), conditions, false).pathname.replace(/^\/(\w):/, '$1:'));
-    } catch (err) {}
+        return normalizePath(fileURLToPath(moduleResolve(entry, base, new Set(DEPLOY_CONDITIONS), false)));
+    } catch (cause) {
+        throw new Error(`Cannot resolve "${entry}" with conditions [${DEPLOY_CONDITIONS.join(', ')}] from ${base.href}: ${cause.message}`, {
+            cause
+        });
+    }
 };
 export { getProjectUsage, getTemplatePath, normalizePath, readTemplate, resolveESMDependency };

package/dist/esm-node/plugins/initialize/index.mjs

@@ -1,5 +1,6 @@
 import "node:module";
 import { ensureAbsolutePath, getPort, isDev, isDevCommand } from "@modern-js/utils";
+import { buildDefaultLazyCompilationTest } from "../../builder/shared/lazyCompilation.mjs";
 import { createDefaultConfig, isLazyCompilationSafeByDefault } from "../../config/index.mjs";
 const initialize = ()=>({
         name: '@modern-js/plugin-initialize',
@@ -18,7 +19,8 @@ const initialize = ()=>({
                     ...defaultConfig.dev,
                     lazyCompilation: {
                         imports: true,
-                        entries: false
+                        entries: false,
+                        test: buildDefaultLazyCompilationTest(appContext.appDirectory, appContext.internalDirectory)
                     }
                 };
                 return defaultConfig;
@@ -26,7 +28,7 @@ const initialize = ()=>({
             api.modifyResolvedConfig(async (resolved)=>{
                 let appContext = api.getAppContext();
                 const userConfig = api.getConfig();
-                const port = await getServerPort(resolved, appContext.command);
+                const port = await getServerPort(resolved);
                 appContext = {
                     ...appContext,
                     port,
@@ -61,10 +63,9 @@ function stabilizeConfig(resolve, config, keys) {
         resolve[key] = config[key] || {};
     });
 }
-async function getServerPort(config, contextCommand) {
+async function getServerPort(config) {
     const prodPort = Number(process.env.PORT) || config.server.port || 8080;
-    const isProgrammaticDev = 'dev' === contextCommand || 'start' === contextCommand;
-    if (isDev() && (isDevCommand() || isProgrammaticDev)) return getPort(Number(process.env.PORT) || prodPort);
+    if (isDev() && isDevCommand()) return getPort(Number(process.env.PORT) || prodPort);
     return prodPort;
 }
 export default initialize;

package/dist/esm-node/plugins/serverBuild.mjs

@@ -30,10 +30,8 @@ const serverBuild = ()=>({
                     sourceDirs.push(serverDir);
                     if (fs.existsSync(sharedDir)) sourceDirs.push(sharedDir);
                 }
-                const { server } = modernConfig;
                 const { alias } = modernConfig.source;
                 if (sourceDirs.length > 0) await compile(appDirectory, {
-                    server,
                     alias
                 }, {
                     sourceDirs,

package/dist/esm-node/run/index.mjs

@@ -8,21 +8,21 @@ import { loadInternalPlugins } from "../utils/loadPlugins.mjs";
 async function createRunOptions({ cwd, initialLog, metaName = 'modern-js', version, internalPlugins, configFile }) {
     const nodeVersion = process.versions.node;
     const versionArr = nodeVersion.split('.').map(Number);
-    if (versionArr[0] < 26 || 26 === versionArr[0] && versionArr[1] < 7) throw new Error(`
+    if (versionArr[0] < 26 || 26 === versionArr[0] && versionArr[1] < 10) throw new Error(`
   ${chalk.bgRed.white.bold(' UNSUPPORTED NODE.JS RUNTIME ')}
 
-  ${chalk.red.bold(`UltraModern.js requires Node.js >=26.7.0; detected v${nodeVersion}.`)}
+  ${chalk.red.bold(`UltraModern.js requires Node.js >=26.10.0; detected v${nodeVersion}.`)}
   ${chalk.red('- Legacy Node runtimes and TypeScript transpiler fallbacks are unsupported.')}
 
   ${chalk.yellow('▸ Detected Runtime:')}  ${chalk.yellow.bold(`Node.js v${nodeVersion}`)}
-  ${chalk.green('▸ Required Minimum:')} ${chalk.green.bold('Node.js v26.7.0 or higher')}
-  ${chalk.green('▸ Pinned Runtime:')} ${chalk.green.bold('Node.js v26.7.0')}
+  ${chalk.green('▸ Required Minimum:')} ${chalk.green.bold('Node.js v26.10.0 or higher')}
+  ${chalk.green('▸ Pinned Runtime:')} ${chalk.green.bold('Node.js v26.10.0')}
 
   ${chalk.cyan('Immediate Action Required:')}
     ${chalk.gray('├──')} ${chalk.yellow('Recommended Upgrade')}
        ${chalk.bold('mise install && mise exec -- node --version')}
     ${chalk.gray('├──')} ${chalk.yellow('Manual Installation')}
-       ${chalk.underline('https://nodejs.org/download/release/v26.7.0/')}
+       ${chalk.underline('https://nodejs.org/download/release/v26.10.0/')}
      ${chalk.gray('└──')} ${chalk.yellow('Environment Verification')}
        ${chalk.bold('node -v && npm -v')}
 

package/dist/esm-node/server-plugin.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { default } from "@modern-js/server-runtime-extensions/server-plugin";

package/dist/esm-node/types/config/base.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export * from "./output.mjs";

package/dist/esm-node/types/plugin-base.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/types/plugin.mjs

@@ -1 +1,2 @@
 import "node:module";
+export * from "./plugin-base.mjs";

package/dist/esm-node/utils/initAppContext.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-import { address, fs } from "@modern-js/utils";
+import { fs, ip } from "@modern-js/utils";
 import path from "path";
 function isSymlinkedNodeModules(appDirectory) {
     try {
@@ -18,7 +18,7 @@ const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, te
     const moduleType = fs.existsSync(pkgPath) ? fs.readJSONSync(pkgPath).type || 'commonjs' : 'commonjs';
     return {
         runtimeConfigFile,
-        ip: address.ip(),
+        ip: ip(),
         port: 0,
         moduleType,
         apiDirectory: path.resolve(appDirectory, apiDir),