@bleedingdev/modern-js-app-tools 3.2.0-ultramodern.1 → 3.2.0-ultramodern.100

package/dist/esm-node/plugins/deploy/platforms/templates/cloudflare-worker-loadable-server.mjs

@@ -0,0 +1,185 @@
+import loadableComponent from '@loadable/component';
+import React from 'react';
+const internals = loadableComponent?.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED || {};
+const LoadableContext = internals.Context || React.createContext(null);
+const getRequiredChunkKey = internals.getRequiredChunkKey || ((namespace)=>`${namespace}__LOADABLE_REQUIRED_CHUNKS__`);
+const scriptExtensions = new Set([
+    '.js',
+    '.mjs'
+]);
+const styleExtensions = new Set([
+    '.css'
+]);
+function uniqByUrl(assets) {
+    const seen = new Set();
+    return assets.filter((asset)=>{
+        if (seen.has(asset.url)) return false;
+        seen.add(asset.url);
+        return true;
+    });
+}
+function extname(filePath) {
+    const basename = String(filePath).split('/').pop() || '';
+    const index = basename.lastIndexOf('.');
+    return index > 0 ? basename.slice(index) : '';
+}
+function joinUrl(publicPath, filename) {
+    const base = publicPath || '/';
+    return `${base.replace(/\/+$/u, '')}/${String(filename).replace(/^\/+/u, '')}`;
+}
+function extraPropsToString(extraProps = {}) {
+    return Object.entries(extraProps).filter(([, value])=>void 0 !== value && false !== value).map(([key, value])=>true === value ? ` ${key}` : ` ${key}="${value}"`).join('');
+}
+function assetScriptType(filename) {
+    const extension = extname(filename);
+    if (scriptExtensions.has(extension)) return "script";
+    if (styleExtensions.has(extension)) return 'style';
+}
+function getAssetName(asset) {
+    return 'object' == typeof asset && asset?.name ? asset.name : asset;
+}
+function getAssetIntegrity(asset) {
+    return 'object' == typeof asset && asset?.integrity ? asset.integrity : null;
+}
+function getChunkGroupAssets(chunkGroup) {
+    const assets = chunkGroup?.assets;
+    if (Array.isArray(assets)) return assets;
+    if (assets && 'object' == typeof assets) return [
+        ...assets.js || [],
+        ...assets.css || []
+    ];
+    return [];
+}
+function getChunkGroupChildAssets(chunkGroup, type) {
+    const childAssets = chunkGroup?.childAssets?.[type];
+    return Array.isArray(childAssets) ? childAssets : [];
+}
+function chunkIncludesJs(chunkInfo) {
+    return (chunkInfo?.files || []).some((file)=>scriptExtensions.has(extname(file)));
+}
+export function ChunkExtractorManager({ extractor, children }) {
+    return React.createElement(LoadableContext.Provider, {
+        value: extractor
+    }, children);
+}
+export class ChunkExtractor {
+    constructor({ stats, entrypoints = [
+        'main'
+    ], namespace = '', outputPath = '/', publicPath } = {}){
+        this.namespace = namespace;
+        this.stats = stats || {};
+        this.publicPath = publicPath || this.stats.publicPath || '/';
+        this.outputPath = outputPath || this.stats.outputPath || '/';
+        this.entrypoints = Array.isArray(entrypoints) ? entrypoints : [
+            entrypoints
+        ];
+        this.chunks = [];
+    }
+    addChunk(chunk) {
+        if (!this.chunks.includes(chunk)) this.chunks.push(chunk);
+    }
+    collectChunks(app) {
+        return React.createElement(ChunkExtractorManager, {
+            extractor: this
+        }, app);
+    }
+    getChunkGroup(chunk) {
+        return this.stats.namedChunkGroups?.[chunk] || {
+            assets: [],
+            childAssets: {},
+            chunks: []
+        };
+    }
+    getChunkInfo(chunkId) {
+        return (this.stats.chunks || []).find((chunk)=>chunk.id === chunkId);
+    }
+    resolvePublicUrl(filename) {
+        return joinUrl(this.publicPath, filename);
+    }
+    createChunkAsset({ filename, chunk, type, linkType }) {
+        const resolvedFilename = getAssetName(filename);
+        const scriptType = assetScriptType(resolvedFilename);
+        if (!scriptType) return;
+        return {
+            filename: resolvedFilename,
+            integrity: getAssetIntegrity(filename),
+            scriptType,
+            chunk,
+            url: this.resolvePublicUrl(resolvedFilename),
+            path: String(resolvedFilename).replace(/^\/+/u, ''),
+            type,
+            linkType
+        };
+    }
+    getChunkAssets(chunks) {
+        const one = (chunk)=>getChunkGroupAssets(this.getChunkGroup(chunk)).map((filename)=>this.createChunkAsset({
+                    filename,
+                    chunk,
+                    type: 'mainAsset',
+                    linkType: 'preload'
+                })).filter(Boolean);
+        return Array.isArray(chunks) ? uniqByUrl(chunks.flatMap(one)) : one(chunks);
+    }
+    getChunkChildAssets(chunks, type) {
+        const one = (chunk)=>getChunkGroupChildAssets(this.getChunkGroup(chunk), type).map((filename)=>this.createChunkAsset({
+                    filename,
+                    chunk,
+                    type: 'childAsset',
+                    linkType: type
+                })).filter(Boolean);
+        return Array.isArray(chunks) ? uniqByUrl(chunks.flatMap(one)) : one(chunks);
+    }
+    getChunkDependencies(chunks) {
+        const one = (chunk)=>(this.getChunkGroup(chunk).chunks || []).filter((chunkId)=>chunkIncludesJs(this.getChunkInfo(chunkId)));
+        return Array.isArray(chunks) ? [
+            ...new Set(chunks.flatMap(one))
+        ] : one(chunks);
+    }
+    getRequiredChunksScriptContent() {
+        return JSON.stringify(this.getChunkDependencies(this.chunks));
+    }
+    getRequiredChunksNamesScriptContent() {
+        return JSON.stringify({
+            namedChunks: this.chunks
+        });
+    }
+    getRequiredChunksScriptTag(extraProps = {}) {
+        const id = getRequiredChunkKey(this.namespace);
+        const props = `type="application/json"${extraPropsToString(extraProps)}`;
+        return [
+            `<script id="${id}" ${props}>${this.getRequiredChunksScriptContent()}</script>`,
+            `<script id="${id}_ext" ${props}>${this.getRequiredChunksNamesScriptContent()}</script>`
+        ].join('');
+    }
+    getMainAssets(scriptType) {
+        const assets = this.getChunkAssets([
+            ...this.entrypoints,
+            ...this.chunks
+        ]);
+        return scriptType ? assets.filter((asset)=>asset.scriptType === scriptType) : assets;
+    }
+    getScriptTags(extraProps = {}) {
+        const scripts = this.getMainAssets("script").map((asset)=>`<script async data-chunk="${asset.chunk}" src="${asset.url}"${extraPropsToString(extraProps)}></script>`);
+        return [
+            this.getRequiredChunksScriptTag(extraProps),
+            ...scripts
+        ].join('');
+    }
+    getStyleTags(extraProps = {}) {
+        return this.getMainAssets('style').map((asset)=>`<link data-chunk="${asset.chunk}" rel="stylesheet" href="${asset.url}"${extraPropsToString(extraProps)}>`).join('');
+    }
+    getLinkTags(extraProps = {}) {
+        const assets = [
+            ...this.getMainAssets(),
+            ...this.getChunkChildAssets([
+                ...this.entrypoints,
+                ...this.chunks
+            ], 'preload'),
+            ...this.getChunkChildAssets([
+                ...this.entrypoints,
+                ...this.chunks
+            ], 'prefetch')
+        ];
+        return uniqByUrl(assets).map((asset)=>`<link data-chunk="${asset.chunk}" rel="${asset.linkType}" as="${asset.scriptType}" href="${asset.url}"${extraPropsToString(extraProps)}>`).join('');
+    }
+}

package/dist/esm-node/plugins/deploy/platforms/templates/cloudflare-worker-path.mjs

@@ -0,0 +1,59 @@
+const trimSlashes = (value)=>String(value).replace(/^\/+|\/+$/gu, '');
+const normalizeSeparators = (value)=>String(value).replace(/\\+/gu, '/');
+export const sep = '/';
+export const delimiter = ':';
+export function isAbsolute(filePath) {
+    return normalizeSeparators(filePath).startsWith('/');
+}
+export function normalize(filePath) {
+    const normalized = normalizeSeparators(filePath);
+    const absolute = isAbsolute(normalized);
+    const parts = [];
+    for (const part of normalized.split('/'))if (part && '.' !== part) {
+        if ('..' === part) {
+            if (parts.length > 0 && '..' !== parts[parts.length - 1]) parts.pop();
+            else if (!absolute) parts.push(part);
+            continue;
+        }
+        parts.push(part);
+    }
+    const joined = parts.join('/');
+    if (absolute) return joined ? `/${joined}` : '/';
+    return joined || '.';
+}
+export function join(...segments) {
+    const joined = segments.map(normalizeSeparators).filter(Boolean).map((segment, index)=>0 === index ? segment : trimSlashes(segment)).filter(Boolean).join('/');
+    return joined ? normalize(joined) : '.';
+}
+export function resolve(...segments) {
+    const joined = join(...segments);
+    return joined.startsWith('/') ? joined : `/${joined}`;
+}
+export function dirname(filePath) {
+    const normalized = normalizeSeparators(filePath).replace(/\/+$/u, '');
+    const index = normalized.lastIndexOf('/');
+    if (index <= 0) return '/';
+    return normalized.slice(0, index);
+}
+export function basename(filePath, suffix = '') {
+    const normalized = normalizeSeparators(filePath).replace(/\/+$/u, '');
+    const base = normalized.slice(normalized.lastIndexOf('/') + 1);
+    return suffix && base.endsWith(suffix) ? base.slice(0, -suffix.length) : base;
+}
+export function extname(filePath) {
+    const base = basename(filePath);
+    const index = base.lastIndexOf('.');
+    if (index <= 0) return '';
+    return base.slice(index);
+}
+export default {
+    basename,
+    delimiter,
+    dirname,
+    extname,
+    isAbsolute,
+    join,
+    normalize,
+    resolve,
+    sep
+};

package/dist/esm-node/rsbuild.mjs

@@ -1,17 +1,19 @@
 import "node:module";
 import { parseRspackConfig } from "@modern-js/builder";
+import { INTERNAL_RUNTIME_PLUGINS } from "@modern-js/utils";
 import { builderPluginAdapterBasic, builderPluginAdapterHooks } from "./builder/shared/builderPlugins/index.mjs";
 import { DEFAULT_CONFIG_FILE } from "./constants.mjs";
 import { getConfigFile } from "./utils/getConfigFile.mjs";
+import { loadInternalPlugins } from "./utils/loadPlugins.mjs";
 import { __webpack_require__ } from "./rslib-runtime.mjs";
 import * as __rspack_external__modern_js_plugin_cli_caa09fa2 from "@modern-js/plugin/cli";
 __webpack_require__.add({
-    "@modern-js/plugin/cli?f956" (module) {
+    "@modern-js/plugin/cli?8936" (module) {
         module.exports = __rspack_external__modern_js_plugin_cli_caa09fa2;
     }
 });
 const MODERN_META_NAME = 'modern-js';
-const { createConfigOptions: createConfigOptions } = __webpack_require__("@modern-js/plugin/cli?f956");
+const { createConfigOptions: createConfigOptions } = __webpack_require__("@modern-js/plugin/cli?8936");
 async function resolveModernRsbuildConfig(options) {
     const { cwd = process.cwd(), metaName = MODERN_META_NAME } = options;
     const configFile = options.configPath || getConfigFile(void 0, cwd);
@@ -20,6 +22,7 @@ async function resolveModernRsbuildConfig(options) {
         command: options.command,
         cwd,
         configFile,
+        internalPlugins: await loadInternalPlugins(cwd, INTERNAL_RUNTIME_PLUGINS),
         metaName,
         modifyModernConfig: options.modifyModernConfig
     });

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<any>;

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<any>;

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: any;
+};

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<any>;

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;

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

@@ -0,0 +1,4 @@
+import type { AppNormalizedConfig } from '../../types';
+import type { AppToolsContext } from '../../types/plugin';
+export declare function initHtmlConfig(config: AppNormalizedConfig, appContext: AppToolsContext): AppNormalizedConfig['html'];
+export declare function initSourceConfig(config: AppNormalizedConfig, appContext: AppToolsContext): void;

package/dist/types/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_CONFIG_FILE = "modern.config";
+export declare const DEFAULT_RUNTIME_CONFIG_FILE = "modern.runtime";

package/dist/types/defineConfig.d.ts

@@ -0,0 +1,11 @@
+import type { AppUserConfig } from './types';
+export type ConfigParams = {
+    env: string;
+    command: string;
+};
+export type UserConfigExport<Config> = Config | ((env: ConfigParams) => Config | Promise<Config>);
+/**
+ * This function helps you to autocomplete configuration types.
+ * It accepts a direct config object, or a function that returns a config.
+ */
+export declare const defineConfig: (config: UserConfigExport<AppUserConfig>) => UserConfigExport<import("./types").AppToolsUserConfig>;