@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.0

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

@@ -0,0 +1,13 @@
+import "node:module";
+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,13 @@
+import "node:module";
+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,11 @@
+import "node:module";
+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,6 @@
+import "node:module";
+import { CONFIG_FILE_EXTENSIONS, findExists } from "@modern-js/utils";
+import path from "path";
+import { DEFAULT_CONFIG_FILE } from "../constants.mjs";
+const getConfigFile = (configFile, cwd = process.cwd())=>findExists(CONFIG_FILE_EXTENSIONS.map((extension)=>path.resolve(cwd, `${configFile || DEFAULT_CONFIG_FILE}${extension}`)));
+export { getConfigFile };

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

@@ -0,0 +1,27 @@
+import "node:module";
+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,28 @@
+import "node:module";
+import { address, fs } from "@modern-js/utils";
+import path from "path";
+const initAppContext = ({ metaName, appDirectory, runtimeConfigFile, options, tempDir })=>{
+    const { apiDir = 'api', sharedDir = 'shared', bffRuntimeFramework = 'hono' } = options || {};
+    const pkgPath = path.resolve(appDirectory, './package.json');
+    const moduleType = fs.existsSync(pkgPath) ? fs.readJSONSync(pkgPath).type || 'commonjs' : 'commonjs';
+    return {
+        runtimeConfigFile,
+        ip: address.ip(),
+        port: 0,
+        moduleType,
+        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
+    };
+};
+export { initAppContext };

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

@@ -0,0 +1,46 @@
+import "node:module";
+import { loadServerPlugins } from "@modern-js/server-core/node";
+import { compatibleRequire, createDebugger, dynamicImport, getInternalPlugins, tryResolve } from "@modern-js/utils";
+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 loadPlugins_loadServerPlugins(api, appDirectory, metaName) {
+    const plugins = await getServerPlugins(api, metaName);
+    const instances = await 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, loadPlugins_loadServerPlugins as loadServerPlugins };

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

@@ -0,0 +1,10 @@
+import "node:module";
+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,83 @@
+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 { fs, getAliasConfig, mergeAlias, resolveServerTsconfig } from "@modern-js/utils";
+const normalizePathValue = ({ key, value, absoluteBaseUrl })=>{
+    let normalizedValue = value;
+    if (key.startsWith('@') && normalizedValue.startsWith('@')) try {
+        normalizedValue = require.resolve(normalizedValue, {
+            paths: [
+                process.cwd(),
+                ...module.paths
+            ]
+        });
+    } catch  {}
+    return node_path.isAbsolute(normalizedValue) ? node_path.relative(absoluteBaseUrl, normalizedValue) : normalizedValue;
+};
+const normalizePathValues = ({ key, value, absoluteBaseUrl })=>{
+    const values = Array.isArray(value) ? value : [
+        value
+    ];
+    return values.map((item)=>normalizePathValue({
+            key,
+            value: item,
+            absoluteBaseUrl
+        }));
+};
+const addResolvedAlias = (paths, key, values)=>{
+    if (!key || paths[key]) return;
+    paths[key] = values;
+};
+const createRuntimePaths = ({ alias, paths, absoluteBaseUrl })=>{
+    const mergedAlias = mergeAlias(alias);
+    const normalizedPaths = Object.keys(paths).reduce((result, key)=>{
+        addResolvedAlias(result, key.endsWith('$') ? key.slice(0, -1) : key, normalizePathValues({
+            key,
+            value: paths[key],
+            absoluteBaseUrl
+        }));
+        return result;
+    }, {});
+    Object.keys(mergedAlias).forEach((key)=>{
+        if (key.includes('*') || key.endsWith('$')) return;
+        addResolvedAlias(normalizedPaths, `${key}/*`, normalizePathValues({
+            key,
+            value: mergedAlias[key],
+            absoluteBaseUrl
+        }).map((value)=>`${value}/*`));
+    });
+    return normalizedPaths;
+};
+const resolveTsRuntimeRegisterMode = ()=>{
+    const hasNativeTypeScriptSupport = process.features?.typescript;
+    const nodeMajorVersion = Number(process.versions.node.split('.')[0]);
+    const supportsNativeTypeScript = void 0 === hasNativeTypeScriptSupport ? nodeMajorVersion >= 22 : false !== hasNativeTypeScriptSupport;
+    if (supportsNativeTypeScript) return 'node-loader';
+    return 'unsupported';
+};
+const setupTsRuntime = async (appDir, distDir, alias, options = {})=>{
+    const tsconfigPath = resolveServerTsconfig(appDir, options.tsconfigPath);
+    const isTsProject = await fs.pathExists(tsconfigPath);
+    if (!isTsProject) return;
+    const registerMode = resolveTsRuntimeRegisterMode();
+    const aliasConfig = getAliasConfig(alias, {
+        appDirectory: appDir,
+        tsconfigPath
+    });
+    const { paths = {}, absoluteBaseUrl = './' } = aliasConfig;
+    const runtimePaths = createRuntimePaths({
+        alias,
+        paths,
+        absoluteBaseUrl
+    });
+    if ('unsupported' === registerMode) return;
+    if ('node-loader' === registerMode) {
+        const { registerPathsLoader } = await import("../esm/register-esm.mjs");
+        await registerPathsLoader({
+            appDir,
+            baseUrl: absoluteBaseUrl || './',
+            paths: runtimePaths
+        });
+    }
+};
+export { resolveTsRuntimeRegisterMode, setupTsRuntime };

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

@@ -0,0 +1,19 @@
+import "node:module";
+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,16 @@
+import "node:module";
+import { MAIN_ENTRY_NAME, ROUTE_SPEC_FILE, fs } from "@modern-js/utils";
+import path from "path";
+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/esm-node/utils/types.mjs

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

package/dist/types/baseline.d.ts

@@ -0,0 +1,46 @@
+import type { AppUserConfig } from './types';
+export interface AppBaselineOptions {
+    /**
+     * Stable producer identity used by BFF cross-project clients.
+     * @default "app"
+     */
+    appId?: string;
+    /**
+     * Enable BFF requestId contract by default.
+     * @default true
+     */
+    enableBffRequestId?: boolean;
+    /**
+     * Enable telemetry contract by default.
+     * Exporters are still configured separately by applications.
+     * @default true
+     */
+    enableTelemetry?: boolean;
+    /**
+     * Enable telemetry exporters by default.
+     * @default true
+     */
+    enableTelemetryExporters?: boolean;
+    /**
+     * OTLP exporter endpoint.
+     * @default process.env.MODERN_TELEMETRY_OTLP_ENDPOINT || 'http://127.0.0.1:4318/v1/logs'
+     */
+    otlpEndpoint?: string;
+    /**
+     * VictoriaMetrics exporter endpoint.
+     * @default process.env.MODERN_TELEMETRY_VICTORIA_ENDPOINT || 'http://127.0.0.1:8428/api/v1/import/prometheus'
+     */
+    victoriaMetricsEndpoint?: string;
+    /**
+     * Enable fail-loud startup probing for telemetry exporters.
+     * @default true
+     */
+    telemetryFailLoudStartup?: boolean;
+    /**
+     * Enable app-level Module Federation SSR handshake by default.
+     * @default true
+     */
+    enableModuleFederationSSR?: boolean;
+}
+export declare const createAppBaselineConfig: (options?: AppBaselineOptions) => AppUserConfig;
+export declare const withAppBaseline: (config: AppUserConfig, options?: AppBaselineOptions) => AppUserConfig;

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

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

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

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin } from '@modern-js/builder';
+import type { BuilderOptions } from '../shared';
+export declare const builderPluginAdapterCopy: (options: BuilderOptions) => RsbuildPlugin;

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,16 @@
+import type { Rspack, RspackChain } from '@rsbuild/core';
+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;
+    }) => {
+        minimized: boolean;
+    };
+    from: string;
+    to: string;
+    context: string;
+    noErrorOnMissing: boolean;
+    transform: (content: Buffer, absoluteFrom: string) => string | Buffer<ArrayBufferLike>;
+};
+export declare function createUploadPattern(appContext: AppToolsContext, config: AppNormalizedConfig): Rspack.CopyRspackPluginOptions['patterns']['0'];

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

@@ -0,0 +1,6 @@
+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, "plugins">;
+};

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

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

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

@@ -0,0 +1,3 @@
+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

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

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

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

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

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { BuilderOptions } from '../types';
+export declare const builderPluginAdapterPrecompress: (options: BuilderOptions) => RsbuildPlugin;

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

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

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

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

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

@@ -0,0 +1,5 @@
+export * from './adapterBasic';
+export * from './adapterHtml';
+export * from './adapterPrecompress';
+export * from './adapterSSR';
+export * from './builderHooks';

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

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

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

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

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

@@ -0,0 +1,32 @@
+import type { Rspack, ScriptLoading } from '@rsbuild/core';
+export interface RouteAssets {
+    [routeId: string]: {
+        chunkIds?: (string | number)[];
+        assets?: string[];
+        referenceCssAssets?: string[];
+    };
+}
+type Compiler = Rspack.Compiler;
+type Options = {
+    HtmlBundlerPlugin: typeof Rspack.HtmlRspackPlugin;
+    staticJsDir?: string;
+    enableInlineRouteManifests: boolean;
+    disableFilenameHash?: boolean;
+    scriptLoading?: ScriptLoading;
+    nonce?: string;
+};
+export declare class RouterPlugin {
+    readonly name: string;
+    private HtmlBundlerPlugin;
+    private enableInlineRouteManifests;
+    private staticJsDir;
+    private disableFilenameHash?;
+    private scriptLoading?;
+    private nonce?;
+    constructor({ staticJsDir, HtmlBundlerPlugin, enableInlineRouteManifests, disableFilenameHash, scriptLoading, nonce, }: Options);
+    private isTargetNodeOrWebWorker;
+    private getEntryChunks;
+    private getEntryChunkFiles;
+    apply(compiler: Compiler): void;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export * from './HtmlAsyncChunkPlugin';
+export * from './HtmlBottomTemplate';
+export * from './RouterPlugin';

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

@@ -0,0 +1,8 @@
+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/index.d.ts

@@ -0,0 +1,3 @@
+export * from './builderPlugins';
+export * from './createCopyInfo';
+export * from './types';

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,4 @@
+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>, options?: BuildOptions) => Promise<void>;

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

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

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

@@ -0,0 +1,9 @@
+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>, options: DevOptions, devServerOptions?: ExtraServerOptions) => Promise<void>;
+export {};

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

@@ -0,0 +1,10 @@
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import type { Command } from '@modern-js/utils';
+import type { AppTools } from '../types';
+export declare const devCommand: (program: Command, api: CLIPluginAPI<AppTools>) => Promise<void>;
+export declare const buildCommand: (program: Command, api: CLIPluginAPI<AppTools>) => Promise<void>;
+export declare const serverCommand: (program: Command, api: CLIPluginAPI<AppTools>) => void;
+export declare const deployCommand: (program: Command, api: CLIPluginAPI<AppTools>) => void;
+export declare const inspectCommand: (program: Command, api: CLIPluginAPI<AppTools>) => void;
+export declare const infoCommand: (program: Command, api: CLIPluginAPI<AppTools>) => void;
+export declare const runtimeOperationsCommand: (program: Command, api: CLIPluginAPI<AppTools>) => Promise<void>;

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

@@ -0,0 +1,18 @@
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import type { AppTools } from '../types';
+import type { InfoOptions } from '../utils/types';
+export interface EntryInfo {
+    entryName: string;
+    isMainEntry: boolean;
+    entry: string;
+    isAutoMount: boolean;
+    isCustomSourceEntry: boolean;
+    customEntry: boolean;
+    ssr: boolean | 'stream' | 'string';
+    ssg: boolean;
+}
+export interface ProjectInfo {
+    entries: EntryInfo[];
+    apiOnly: boolean;
+}
+export declare const info: (api: CLIPluginAPI<AppTools>, options?: InfoOptions) => Promise<void>;

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

@@ -0,0 +1,4 @@
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import type { AppTools } from '../types';
+import type { InspectOptions } from '../utils/types';
+export declare const inspect: (api: CLIPluginAPI<AppTools>, options: InspectOptions) => Promise<import("@rsbuild/core").InspectConfigResult>;

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

@@ -0,0 +1,11 @@
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import type { Command } from '@modern-js/utils';
+import type { AppTools } from '../types';
+import type { RuntimeFallbackSignalOptions } from '../utils/types';
+export declare const resolveRuntimeEndpoint: (input: string | undefined, defaultPath: string) => string;
+export declare const resolveToken: ({ token, tokenEnv, }: {
+    token?: string;
+    tokenEnv?: string;
+}) => string | undefined;
+export declare const createRuntimeFallbackSignalPayload: (options: RuntimeFallbackSignalOptions) => Record<string, unknown>;
+export declare const runtimeCommand: (program: Command, _api: CLIPluginAPI<AppTools>) => Promise<void>;

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

@@ -0,0 +1,8 @@
+import type { CLIPluginAPI } from '@modern-js/plugin';
+import { createProdServer } from '@modern-js/prod-server';
+import type { AppTools } from '../types';
+type ExtraServerOptions = {
+    launcher?: typeof createProdServer;
+};
+export declare const serve: (api: CLIPluginAPI<AppTools>, serverOptions?: ExtraServerOptions) => Promise<void>;
+export {};

package/dist/types/compat/hooks.d.ts

@@ -0,0 +1,7 @@
+import type { InternalContext } from '@modern-js/plugin';
+import type { AppTools } from '../types';
+/**
+ * old plugin useHookRunners function result
+ */
+export declare function getHookRunners(context: InternalContext<AppTools>): Record<string, any>;
+export declare function handleSetupResult(setupResult: Record<string, (...args: any) => any>, api: Record<string, any>): void;

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

@@ -0,0 +1,2 @@
+import type { AppTools, CliPlugin } from '../types';
+export declare const compatPlugin: () => CliPlugin<AppTools>;

package/dist/types/compat/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Maps old plugin hook function names to new plugin API names
+ */
+export declare function transformHookRunner(hookRunnerName: string): string | undefined;
+/**
+ * Note:
+ * isMultiple Indicates whether the function parameter represents multiple values.
+ */
+export declare function transformHookParams(hookRunnerName: string, params: any): {
+    isMultiple: boolean;
+    params: any;
+};
+export declare function transformHookResult(hookRunnerName: string, result: any): any;

package/dist/types/config/default.d.ts

@@ -0,0 +1,3 @@
+import type { AppUserConfig } from '../types';
+import type { AppToolsContext } from '../types/plugin';
+export declare function createDefaultConfig(appContext: AppToolsContext): AppUserConfig;

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

@@ -0,0 +1,2 @@
+export * from './default';
+export * from './initialize';

package/dist/types/config/initialize/index.d.ts

@@ -0,0 +1,3 @@
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/plugin';
+export declare function initialNormalizedConfig(config: AppNormalizedConfig, appContext: AppToolsContext): AppNormalizedConfig;