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

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

@@ -0,0 +1,48 @@
+import fs from "fs";
+import path from "path";
+import { compile } from "@modern-js/server-utils";
+import { SERVER_DIR, SHARED_DIR, getMeta } from "@modern-js/utils";
+const TS_CONFIG_FILENAME = 'tsconfig.json';
+function checkHasCache(appDir) {
+    const tsFilepath = path.resolve(appDir, SERVER_DIR, 'cache.ts');
+    const jsfilepath = path.resolve(appDir, SERVER_DIR, 'cache.js');
+    return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
+}
+function checkHasConfig(appDir, metaName = 'modern-js') {
+    const meta = getMeta(metaName);
+    const tsFilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.ts`);
+    const jsfilepath = path.resolve(appDir, SERVER_DIR, `${meta}.server.js`);
+    return fs.existsSync(tsFilepath) || fs.existsSync(jsfilepath);
+}
+const serverBuild = ()=>({
+        name: '@modern-js/server-build',
+        setup (api) {
+            api.onAfterBuild(async ()=>{
+                const { appDirectory, distDirectory, metaName } = api.getAppContext();
+                if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) return;
+                const modernConfig = api.getNormalizedConfig();
+                const distDir = path.resolve(distDirectory);
+                const serverDir = path.resolve(appDirectory, SERVER_DIR);
+                const sharedDir = path.resolve(appDirectory, SHARED_DIR);
+                const tsconfigPath = path.resolve(appDirectory, TS_CONFIG_FILENAME);
+                const sourceDirs = [];
+                if (fs.existsSync(serverDir)) {
+                    sourceDirs.push(serverDir);
+                    if (fs.existsSync(sharedDir)) sourceDirs.push(sharedDir);
+                }
+                const { server } = modernConfig;
+                const { alias } = modernConfig.source;
+                const { babel } = modernConfig.tools;
+                if (sourceDirs.length > 0) await compile(appDirectory, {
+                    server,
+                    alias,
+                    babelConfig: babel
+                }, {
+                    sourceDirs,
+                    distDir,
+                    tsconfigPath
+                });
+            });
+        }
+    });
+export { serverBuild as default };

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

@@ -0,0 +1,15 @@
+const serverRuntime = ()=>({
+        name: '@modern-js/plugin-server-runtime',
+        setup (api) {
+            api.config(()=>({
+                    output: {
+                        externals: [
+                            {
+                                '@modern-js/server-runtime': '@modern-js/server-runtime'
+                            }
+                        ]
+                    }
+                }));
+        }
+    });
+export { serverRuntime as default };

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

@@ -0,0 +1,60 @@
+import { initAppDir } from "@modern-js/plugin/cli";
+import { run } from "@modern-js/plugin/run";
+import { chalk, minimist } from "@modern-js/utils";
+import { handleSetupResult } from "../compat/hooks.mjs";
+import { getConfigFile } from "../utils/getConfigFile.mjs";
+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] <= 16) console.warn(`
+  ${chalk.bgRed.white.bold(' ⚠️ CRITICAL NODE.JS VERSION ALERT ⚠️ ')}
+
+  ${chalk.red.bold('Node.js 16 End-of-Life Notice:')}
+  ${chalk.red('- Security updates and support have ended for Node.js 16')}
+
+  ${chalk.yellow('▸ Detected Runtime:')}  ${chalk.yellow.bold(`Node.js v${nodeVersion}`)}
+  ${chalk.green('▸ Required Minimum:')} ${chalk.green.bold('Node.js LTS (v18.x or higher)')}
+  ${chalk.green('▸ Recommended:')} ${chalk.green.bold('Node.js LTS (v22.x or higher)')}
+
+  ${chalk.cyan('Immediate Action Required:')}
+    ${chalk.gray('├──')} ${chalk.yellow('Recommended Upgrade')}
+       ${chalk.bold('nvm install 22 --lts && nvm use 22')}
+    ${chalk.gray('├──')} ${chalk.yellow('Manual Installation')}
+       ${chalk.underline('https://nodejs.org/download/release/lts-hydrogen/')}
+     ${chalk.gray('└──')} ${chalk.yellow('Environment Verification')}
+       ${chalk.bold('node -v && npm -v')}
+
+  ${chalk.hex('#AAAAAA').italic('[Security Advisory] Node.js 16 is no longer supported. Upgrade immediately for security and compatibility.')}
+      `);
+    const command = process.argv[2];
+    const cliParams = minimist(process.argv.slice(2));
+    const SUPPORT_CONFIG_PARAM_COMMANDS = [
+        'dev',
+        'build',
+        'deploy',
+        'start',
+        'serve',
+        'inspect',
+        'upgrade'
+    ];
+    let customConfigFile;
+    if (SUPPORT_CONFIG_PARAM_COMMANDS.includes(command)) customConfigFile = cliParams.config || cliParams.c;
+    if ('new' === command) customConfigFile = cliParams['config-file'];
+    const appDirectory = await initAppDir(cwd);
+    const finalConfigFile = customConfigFile || getConfigFile(configFile);
+    const plugins = await loadInternalPlugins(appDirectory, internalPlugins);
+    return {
+        cwd,
+        initialLog: initialLog || `Modern.js Framework v${version}`,
+        configFile: finalConfigFile,
+        metaName,
+        internalPlugins: plugins,
+        handleSetupResult: handleSetupResult
+    };
+}
+async function run_run(options) {
+    const runOptions = await createRunOptions(options);
+    await run(runOptions);
+}
+export { createRunOptions, run_run as run };

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

@@ -0,0 +1 @@
+export * from "./output.mjs";

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

@@ -0,0 +1 @@
+export * from "./config/index.mjs";

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

@@ -0,0 +1,11 @@
+import { join } from "path";
+import { OUTPUT_CONFIG_FILE, ensureAbsolutePath, fs } from "@modern-js/utils";
+import { stringify } from "flatted";
+const emitResolvedConfig = async (appDirectory, resolvedConfig)=>{
+    const outputPath = ensureAbsolutePath(appDirectory, join(resolvedConfig.output.distPath?.root || './dist', OUTPUT_CONFIG_FILE));
+    const output = stringify(resolvedConfig);
+    await fs.writeFile(outputPath, output, {
+        encoding: 'utf-8'
+    });
+};
+export { emitResolvedConfig };

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

@@ -0,0 +1,12 @@
+let server = null;
+const getServer = ()=>server;
+const setServer = (newServer)=>{
+    server = newServer;
+};
+const closeServer = async ()=>{
+    if (server) {
+        server.close();
+        server = null;
+    }
+};
+export { closeServer, getServer, setServer };

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

@@ -0,0 +1,12 @@
+import { cutNameByHyphen } from "@modern-js/utils/universal";
+function getAutoInjectEnv(appContext) {
+    const { metaName } = appContext;
+    const prefix = `${cutNameByHyphen(metaName)}_`.toUpperCase();
+    const envReg = new RegExp(`^${prefix}`);
+    return Object.keys(process.env).reduce((prev, key)=>{
+        const value = process.env[key];
+        if (envReg.test(key) && void 0 !== value) prev[`process.env.${key}`] = value;
+        return prev;
+    }, {});
+}
+export { getAutoInjectEnv };

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

@@ -0,0 +1,10 @@
+import path from "path";
+async function generateWatchFiles(appContext, configDir) {
+    const { appDirectory, configFile } = appContext;
+    const configPath = path.join(appDirectory, configDir || '');
+    return [
+        `${configPath}/html`,
+        configFile || './config'
+    ];
+}
+export { generateWatchFiles };

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

@@ -0,0 +1,5 @@
+import path from "path";
+import { CONFIG_FILE_EXTENSIONS, findExists } from "@modern-js/utils";
+import { DEFAULT_CONFIG_FILE } from "../constants.mjs";
+const getConfigFile = (configFile)=>findExists(CONFIG_FILE_EXTENSIONS.map((extension)=>path.resolve(process.cwd(), `${configFile || DEFAULT_CONFIG_FILE}${extension}`)));
+export { getConfigFile };

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

@@ -0,0 +1,26 @@
+import { chalk, inquirer } from "@modern-js/utils";
+import { i18n, localeKeys } from "../locale/index.mjs";
+const getSelectedEntries = async (entry, entrypoints)=>{
+    const entryNames = entrypoints.map((e)=>e.entryName);
+    if (!entry) return entryNames;
+    if ('boolean' == typeof entry) {
+        const { selected } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'selected',
+                choices: entryNames,
+                message: i18n.t(localeKeys.command.dev.selectEntry),
+                validate (answer) {
+                    if (answer.length < 1) return i18n.t(localeKeys.command.dev.requireEntry);
+                    return true;
+                }
+            }
+        ]);
+        return selected;
+    }
+    entry.forEach((name)=>{
+        if (!entryNames.includes(name)) throw new Error(`Can not found entry ${chalk.yellow(name)}, the entry should be one of ${chalk.yellow(entryNames.join(', '))}`);
+    });
+    return entry;
+};
+export { getSelectedEntries };

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

@@ -0,0 +1,26 @@
+import path from "path";
+import { address, fs } from "@modern-js/utils";
+const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, tempDir })=>{
+    const { apiDir = 'api', sharedDir = 'shared' } = options || {};
+    const pkgPath = path.resolve(appDirectory, './package.json');
+    return {
+        runtimeConfigFile,
+        ip: address.ip(),
+        port: 0,
+        moduleType: fs.existsSync(pkgPath) ? require(pkgPath).type || 'commonjs' : 'commonjs',
+        apiDirectory: path.resolve(appDirectory, apiDir),
+        lambdaDirectory: path.resolve(appDirectory, apiDir, 'lambda'),
+        sharedDirectory: path.resolve(appDirectory, sharedDir),
+        serverPlugins: [],
+        internalDirectory: path.resolve(appDirectory, tempDir || `./node_modules/.${metaName}`),
+        htmlTemplates: {},
+        serverRoutes: [],
+        entrypoints: [],
+        checkedEntries: [],
+        apiOnly: false,
+        internalDirAlias: `@_${metaName.replace(/-/g, '_')}_internal`,
+        internalSrcAlias: `@_${metaName.replace(/-/g, '_')}_src`,
+        bffRuntimeFramework: 'hono'
+    };
+};
+export { initAppContext };

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

@@ -0,0 +1,45 @@
+import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
+import * as __rspack_external__modern_js_prod_server_057184e2 from "@modern-js/prod-server";
+const debug = createDebugger('load-plugins');
+async function getServerPlugins(api, metaName = 'modern-js') {
+    const hooks = api.getHooks();
+    const { plugins } = await hooks._internalServerPlugins.call({
+        plugins: []
+    });
+    const filtedPlugins = plugins.filter((plugin)=>plugin.name.includes(metaName));
+    api.updateAppContext({
+        serverPlugins: filtedPlugins
+    });
+    return filtedPlugins;
+}
+async function loadServerPlugins(api, appDirectory, metaName) {
+    const plugins = await getServerPlugins(api, metaName);
+    const instances = await (0, __rspack_external__modern_js_prod_server_057184e2.loadServerPlugins)(plugins, appDirectory);
+    return instances;
+}
+const resolveCliPlugin = async (p, appDirectory)=>{
+    const pkg = 'string' == typeof p ? p : p[0];
+    const pluginOptions = 'string' == typeof p ? void 0 : p[1];
+    const path = tryResolve(pkg, appDirectory);
+    let module;
+    try {
+        module = await compatibleRequire(path);
+    } catch (e) {
+        ({ default: module } = await dynamicImport(path));
+    }
+    if ('function' == typeof module) {
+        const result = module(pluginOptions);
+        return result;
+    }
+    return module;
+};
+const loadInternalPlugins = async (appDirectory, internalPlugins)=>{
+    const plugins = getInternalPlugins(appDirectory, internalPlugins);
+    const loadedPlugins = await Promise.all(plugins.map((plugin)=>{
+        const loadedPlugin = resolveCliPlugin(plugin, appDirectory);
+        debug("resolve plugin %s: %s", plugin, loadedPlugin);
+        return loadedPlugin;
+    }));
+    return loadedPlugins;
+};
+export { getServerPlugins, loadInternalPlugins, loadServerPlugins };

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

@@ -0,0 +1,9 @@
+import { logger, prettyInstructions } from "@modern-js/utils";
+const printInstructions = async (hooks, appContext, config)=>{
+    const message = prettyInstructions(appContext, config);
+    const { instructions } = await hooks.onBeforePrintInstructions.call({
+        instructions: message
+    });
+    logger.log(instructions);
+};
+export { printInstructions };

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

@@ -0,0 +1,75 @@
+import { fs, getAliasConfig, loadFromProject, logger, readTsConfigByFile } from "@modern-js/utils";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+const registerEsbuild = async ({ isTsProject, tsConfig, distDir })=>{
+    const esbuildRegister = await import("esbuild-register/dist/node");
+    esbuildRegister.register({
+        tsconfigRaw: isTsProject ? tsConfig : void 0,
+        hookIgnoreNodeModules: true,
+        hookMatcher: (fileName)=>!fileName.startsWith(distDir)
+    });
+};
+const registerCompiler = async (appDir, distDir, alias)=>{
+    const TS_CONFIG_FILENAME = "tsconfig.json";
+    const tsconfigPath = __rspack_external_node_path_c5b9b54f["default"].resolve(appDir, TS_CONFIG_FILENAME);
+    const isTsProject = await fs.pathExists(tsconfigPath);
+    const aliasConfig = getAliasConfig(alias, {
+        appDirectory: appDir,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
+    const tsPaths = Object.keys(paths).reduce((o, key)=>{
+        let tsPath = paths[key];
+        if ('string' == typeof tsPath && key.startsWith('@') && tsPath.startsWith('@')) try {
+            tsPath = require.resolve(tsPath, {
+                paths: [
+                    process.cwd(),
+                    ...module.paths
+                ]
+            });
+        } catch  {}
+        if ('string' == typeof tsPath && __rspack_external_node_path_c5b9b54f["default"].isAbsolute(tsPath)) tsPath = __rspack_external_node_path_c5b9b54f["default"].relative(absoluteBaseUrl, tsPath);
+        if ('string' == typeof tsPath) tsPath = [
+            tsPath
+        ];
+        return {
+            ...o,
+            [`${key}`]: tsPath
+        };
+    }, {});
+    let tsConfig = {};
+    if (isTsProject) tsConfig = readTsConfigByFile(tsconfigPath);
+    const { MODERN_NODE_LOADER } = process.env;
+    if ('esbuild' !== MODERN_NODE_LOADER && isTsProject) try {
+        const tsNode = await loadFromProject('ts-node', appDir);
+        const tsNodeOptions = tsConfig['ts-node'];
+        tsNode.register({
+            project: tsconfigPath,
+            scope: true,
+            files: true,
+            transpileOnly: true,
+            ignore: [
+                '(?:^|/)node_modules/',
+                `(?:^|/)${__rspack_external_node_path_c5b9b54f["default"].relative(appDir, distDir)}/`
+            ],
+            ...tsNodeOptions
+        });
+    } catch (error) {
+        if (process.env.DEBUG) logger.error(error);
+        await registerEsbuild({
+            isTsProject,
+            tsConfig,
+            distDir
+        });
+    }
+    else await registerEsbuild({
+        isTsProject,
+        tsConfig,
+        distDir
+    });
+    const tsConfigPaths = (await import("@modern-js/utils/tsconfig-paths")).default;
+    if (await fs.pathExists(appDir)) tsConfigPaths.register({
+        baseUrl: absoluteBaseUrl || './',
+        paths: tsPaths
+    });
+};
+export { registerCompiler };

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

@@ -0,0 +1,18 @@
+import { cli } from "@modern-js/plugin/cli";
+import { chalk, clearConsole, getFullArgv, logger } from "@modern-js/utils";
+import { program } from "@modern-js/utils/commander";
+async function restart(hooks, filename) {
+    clearConsole();
+    logger.info(`Restart because ${chalk.yellow(filename)} is changed...\n`);
+    let hasGetError = false;
+    await hooks.onBeforeRestart.call();
+    try {
+        await cli.init(cli.getPrevInitOptions());
+    } catch (err) {
+        console.error(err);
+        hasGetError = true;
+    } finally{
+        if (!hasGetError) program.parse(getFullArgv());
+    }
+}
+export { restart };

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

@@ -0,0 +1,15 @@
+import path from "path";
+import { MAIN_ENTRY_NAME, ROUTE_SPEC_FILE, fs } from "@modern-js/utils";
+const generateRoutes = async (appContext)=>{
+    const { serverRoutes, distDirectory } = appContext;
+    const output = JSON.stringify({
+        routes: serverRoutes
+    }, null, 2);
+    await fs.outputFile(path.join(distDirectory, ROUTE_SPEC_FILE), output);
+};
+const getPathWithoutExt = (filename)=>{
+    const extname = path.extname(filename);
+    return filename.slice(0, -extname.length);
+};
+const isMainEntry = (entryName, mainEntryName)=>entryName === (mainEntryName || MAIN_ENTRY_NAME);
+export { generateRoutes, getPathWithoutExt, isMainEntry };

package/dist/types/builder/builder-rspack/index.d.ts

@@ -1,2 +1,2 @@
 import type { BuilderOptions } from '../shared';
-export declare function createRspackBuilderForModern(options: BuilderOptions<'rspack'>): Promise<import("@modern-js/uni-builder/.").UniBuilderInstance>;
+export declare function createRspackBuilderForModern(options: BuilderOptions): Promise<import("@rsbuild/core").RsbuildInstance>;

package/dist/types/builder/generator/adapterCopy.d.ts

@@ -1,4 +1,3 @@
-import type { RsbuildPlugin } from '@modern-js/uni-builder';
-import type { Bundler } from '../../types';
+import type { RsbuildPlugin } from '@modern-js/builder';
 import type { BuilderOptions } from '../shared';
-export declare const builderPluginAdapterCopy: <B extends Bundler>(options: BuilderOptions<B>) => RsbuildPlugin;
+export declare const builderPluginAdapterCopy: (options: BuilderOptions) => RsbuildPlugin;

package/dist/types/builder/generator/createBuilderProviderConfig.d.ts

@@ -1,3 +1,3 @@
-import type { AppNormalizedConfig, Bundler } from '../../types';
-import type { AppToolsContext } from '../../types/new';
-export declare function createBuilderProviderConfig<B extends Bundler>(resolveConfig: AppNormalizedConfig<B>, appContext: AppToolsContext<B>): Omit<AppNormalizedConfig<B>, 'plugins'>;
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/plugin';
+export declare function createBuilderProviderConfig(resolveConfig: AppNormalizedConfig, appContext: AppToolsContext): Omit<AppNormalizedConfig, 'plugins'>;

package/dist/types/builder/generator/createCopyPattern.d.ts

@@ -1,7 +1,7 @@
 import type { Rspack, RspackChain } from '@rsbuild/core';
-import type { AppNormalizedConfig, Bundler } from '../../types';
-import type { AppToolsContext } from '../../types/new';
-export declare function createPublicPattern<B extends Bundler>(appContext: AppToolsContext<B>, config: AppNormalizedConfig, chain: RspackChain): {
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/plugin';
+export declare function createPublicPattern(appContext: AppToolsContext, config: AppNormalizedConfig, chain: RspackChain): {
     info: (file: {
         sourceFilename: string;
     }) => {
@@ -11,6 +11,6 @@ export declare function createPublicPattern<B extends Bundler>(appContext: AppTo
     to: string;
     context: string;
     noErrorOnMissing: boolean;
-    transform: (content: Buffer, absoluteFrom: string) => string | Buffer;
+    transform: (content: Buffer, absoluteFrom: string) => string | Buffer<ArrayBufferLike>;
 };
-export declare function createUploadPattern<B extends Bundler>(appContext: AppToolsContext<B>, config: AppNormalizedConfig<B>): Rspack.CopyRspackPluginOptions['patterns']['0'];
+export declare function createUploadPattern(appContext: AppToolsContext, config: AppNormalizedConfig): Rspack.CopyRspackPluginOptions['patterns']['0'];

package/dist/types/builder/generator/getBuilderEnvironments.d.ts

@@ -1,6 +1,6 @@
-import type { AppNormalizedConfig, Bundler } from '../../types';
-import type { AppToolsContext } from '../../types/new';
-export declare function getBuilderEnvironments<B extends Bundler>(normalizedConfig: AppNormalizedConfig<B>, appContext: AppToolsContext<B>, tempBuilderConfig: Omit<AppNormalizedConfig<B>, 'plugins'>): {
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/plugin';
+export declare function getBuilderEnvironments(normalizedConfig: AppNormalizedConfig, appContext: AppToolsContext, tempBuilderConfig: Omit<AppNormalizedConfig, 'plugins'>): {
     environments: Record<string, import("@rsbuild/core").EnvironmentConfig>;
-    builderConfig: Omit<AppNormalizedConfig<B_1>, "plugins">;
+    builderConfig: Omit<AppNormalizedConfig, "plugins">;
 };

package/dist/types/builder/generator/index.d.ts

@@ -1,9 +1,8 @@
-import { type BundlerType, type UniBuilderInstance } from '@modern-js/uni-builder';
-import type { Bundler } from '../../types';
+import { type BundlerType } from '@modern-js/builder';
 import type { BuilderOptions } from '../shared';
 /**
  * @param options BuilderOptions
  * @param bundlerType BundlerType
  * @returns BuilderInstance
  */
-export declare function generateBuilder<B extends Bundler>(options: BuilderOptions<B>, bundlerType: BundlerType): Promise<UniBuilderInstance>;
+export declare function generateBuilder(options: BuilderOptions, bundlerType: BundlerType): Promise<import("@rsbuild/core").RsbuildInstance>;

package/dist/types/builder/index.d.ts

@@ -1,3 +1,3 @@
-export declare function createBuilderGenerator(bundler: 'webpack' | 'rspack'): Promise<typeof import("./builder-rspack/index.js").createRspackBuilderForModern | typeof import("./builder-webpack/index.js").createWebpackBuilderForModern>;
-export { parseRspackConfig } from '@modern-js/uni-builder';
+export declare function createBuilderGenerator(): Promise<typeof import("./builder-rspack/index.js").createRspackBuilderForModern>;
+export { parseRspackConfig } from '@modern-js/builder';
 export { builderPluginAdapterBasic, builderPluginAdapterHooks, } from './shared/builderPlugins';

package/dist/types/builder/shared/builderPlugins/adapterBasic.d.ts

@@ -1,4 +1,3 @@
 import type { RsbuildPlugin } from '@rsbuild/core';
-import type { Bundler } from '../../../types';
 import type { BuilderOptions } from '../types';
-export declare const builderPluginAdapterBasic: <B extends Bundler>(options: BuilderOptions<B>) => RsbuildPlugin;
+export declare const builderPluginAdapterBasic: (options: BuilderOptions) => RsbuildPlugin;

package/dist/types/builder/shared/builderPlugins/adapterHtml.d.ts

@@ -1,4 +1,3 @@
 import type { RsbuildPlugin } from '@rsbuild/core';
-import type { Bundler } from '../../../types';
 import type { BuilderOptions } from '../types';
-export declare const builderPluginAdapterHtml: <B extends Bundler>(options: BuilderOptions<B>) => RsbuildPlugin;
+export declare const builderPluginAdapterHtml: (options: BuilderOptions) => RsbuildPlugin;

package/dist/types/builder/shared/builderPlugins/adapterSSR.d.ts

@@ -1,4 +1,3 @@
 import { type RsbuildPlugin } from '@rsbuild/core';
-import type { Bundler } from '../../../types';
 import type { BuilderOptions } from '../types';
-export declare const builderPluginAdapterSSR: <B extends Bundler>(options: BuilderOptions<B>) => RsbuildPlugin;
+export declare const builderPluginAdapterSSR: (options: BuilderOptions) => RsbuildPlugin;

package/dist/types/builder/shared/builderPlugins/builderHooks.d.ts

@@ -1,4 +1,3 @@
 import type { RsbuildPlugin } from '@rsbuild/core';
-import type { Bundler } from '../../../types';
 import type { BuilderOptions } from '../types';
-export declare const builderPluginAdapterHooks: <B extends Bundler>(options: BuilderOptions<B>) => RsbuildPlugin;
+export declare const builderPluginAdapterHooks: (options: BuilderOptions) => RsbuildPlugin;

package/dist/types/builder/shared/bundlerPlugins/HtmlAsyncChunkPlugin.d.ts

@@ -1,7 +1,7 @@
-import type { HtmlWebpackPlugin, Rspack, webpack } from '@modern-js/uni-builder';
+import type { Rspack } from '@modern-js/builder';
 export declare class HtmlAsyncChunkPlugin {
     name: string;
-    htmlWebpackPlugin: typeof HtmlWebpackPlugin;
-    constructor(htmlWebpackPlugin: typeof HtmlWebpackPlugin);
-    apply(compiler: webpack.Compiler | Rspack.Compiler): void;
+    htmlWebpackPlugin: typeof Rspack.HtmlRspackPlugin;
+    constructor(htmlWebpackPlugin: typeof Rspack.HtmlRspackPlugin);
+    apply(compiler: Rspack.Compiler): void;
 }

package/dist/types/builder/shared/bundlerPlugins/HtmlBottomTemplate.d.ts

@@ -1,9 +1,9 @@
-import type { HtmlWebpackPlugin, Rspack, webpack } from '@modern-js/uni-builder';
+import type { Rspack } from '@modern-js/builder';
 export declare class BottomTemplatePlugin {
-    htmlWebpackPlugin: typeof HtmlWebpackPlugin;
+    htmlWebpackPlugin: typeof Rspack.HtmlRspackPlugin;
     bottomTemplateReg: RegExp;
     bodyRegExp: RegExp;
     name: string;
-    constructor(htmlWebpackPlugin: typeof HtmlWebpackPlugin);
-    apply(compiler: Rspack.Compiler | webpack.Compiler): void;
+    constructor(htmlWebpackPlugin: typeof Rspack.HtmlRspackPlugin);
+    apply(compiler: Rspack.Compiler): void;
 }

package/dist/types/builder/shared/bundlerPlugins/RouterPlugin.d.ts

@@ -1,6 +1,4 @@
-import type { HtmlWebpackPlugin, Rspack, webpack } from '@modern-js/uni-builder';
-import type { ScriptLoading } from '@rsbuild/core';
-export declare const ROUTE_DEPS_COMPILATION_KEY: unique symbol;
+import type { Rspack, ScriptLoading } from '@rsbuild/core';
 export interface RouteAssets {
     [routeId: string]: {
         chunkIds?: (string | number)[];
@@ -8,9 +6,9 @@ export interface RouteAssets {
         referenceCssAssets?: string[];
     };
 }
-type Compiler = webpack.Compiler | Rspack.Compiler;
+type Compiler = Rspack.Compiler;
 type Options = {
-    HtmlBundlerPlugin: typeof HtmlWebpackPlugin;
+    HtmlBundlerPlugin: typeof Rspack.HtmlRspackPlugin;
     staticJsDir?: string;
     enableInlineRouteManifests: boolean;
     disableFilenameHash?: boolean;

package/dist/types/builder/shared/createCopyInfo.d.ts

@@ -1,7 +1,8 @@
-import type { AppNormalizedConfig, Bundler } from '../../types';
-import type { AppToolsContext } from '../../types/new';
-export declare function createCopyInfo<B extends Bundler>(appContext: AppToolsContext<B>, config: AppNormalizedConfig<B>): {
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/plugin';
+export declare function createCopyInfo(appContext: AppToolsContext, config: AppNormalizedConfig): {
     configDir: string;
     uploadDir: string;
     publicDir: string;
+    customPublicDirs: string[];
 };

package/dist/types/builder/shared/loaders/serverModuleLoader.d.ts

@@ -1,3 +1,3 @@
-import type { Rspack, webpack } from '@modern-js/uni-builder';
-declare function loader(this: webpack.LoaderContext<void> | Rspack.LoaderContext): string;
+import type { Rspack } from '@modern-js/builder';
+declare function loader(this: Rspack.LoaderContext): string;
 export default loader;

package/dist/types/builder/shared/types.d.ts

@@ -1,6 +1,6 @@
-import type { AppNormalizedConfig, Bundler } from '../../types';
-import type { AppToolsContext } from '../../types/new';
-export type BuilderOptions<B extends Bundler> = {
-    normalizedConfig: AppNormalizedConfig<B>;
-    appContext: AppToolsContext<B>;
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/plugin';
+export type BuilderOptions = {
+    normalizedConfig: AppNormalizedConfig;
+    appContext: AppToolsContext;
 };

package/dist/types/commands/build.d.ts

@@ -1,4 +1,4 @@
-import type { CLIPluginAPI } from '@modern-js/plugin-v2';
+import type { CLIPluginAPI } from '@modern-js/plugin';
 import type { AppTools } from '../types';
 import type { BuildOptions } from '../utils/types';
-export declare const build: (api: CLIPluginAPI<AppTools<"shared">>, options?: BuildOptions) => Promise<void>;
+export declare const build: (api: CLIPluginAPI<AppTools>, options?: BuildOptions) => Promise<void>;

package/dist/types/commands/deploy.d.ts

@@ -1,3 +1,3 @@
-import type { CLIPluginAPI } from '@modern-js/plugin-v2';
+import type { CLIPluginAPI } from '@modern-js/plugin';
 import type { AppTools } from '../types';
-export declare const deploy: (api: CLIPluginAPI<AppTools<"shared">>, options: any) => Promise<void>;
+export declare const deploy: (api: CLIPluginAPI<AppTools>, options: any) => Promise<void>;

package/dist/types/commands/dev.d.ts

@@ -1,9 +1,9 @@
-import type { CLIPluginAPI } from '@modern-js/plugin-v2';
+import type { CLIPluginAPI } from '@modern-js/plugin';
 import { type ApplyPlugins } from '@modern-js/server';
 import type { AppTools } from '../types';
 import type { DevOptions } from '../utils/types';
 interface ExtraServerOptions {
     applyPlugins?: ApplyPlugins;
 }
-export declare const dev: (api: CLIPluginAPI<AppTools<"shared">>, options: DevOptions, devServerOptions?: ExtraServerOptions) => Promise<void>;
+export declare const dev: (api: CLIPluginAPI<AppTools>, options: DevOptions, devServerOptions?: ExtraServerOptions) => Promise<void>;
 export {};