@modern-js/app-tools 1.21.3 → 2.0.0-beta.0

package/dist/js/treeshaking/utils/createCompiler.js

@@ -0,0 +1,117 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { chalk, logger } from '@modern-js/utils';
+import createBuilder from "../builder";
+import { printInstructions } from "./printInstructions";
+export var createDevCompiler = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(_ref) {
+    var api, target, normalizedConfig, appContext, hookRunners, builder;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            api = _ref.api, target = _ref.target, normalizedConfig = _ref.normalizedConfig, appContext = _ref.appContext;
+            _context4.prev = 1;
+            hookRunners = api.useHookRunners();
+            _context4.next = 5;
+            return createBuilder({
+              target: target,
+              normalizedConfig: normalizedConfig,
+              appContext: appContext,
+              compatPluginConfig: {
+                onDevCompileDone: function onDevCompileDone(_ref3) {
+                  return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+                    var isFirstCompile;
+                    return _regeneratorRuntime().wrap(function _callee$(_context) {
+                      while (1) {
+                        switch (_context.prev = _context.next) {
+                          case 0:
+                            isFirstCompile = _ref3.isFirstCompile;
+
+                            if (process.stdout.isTTY || isFirstCompile) {
+                              hookRunners.afterDev();
+
+                              if (isFirstCompile) {
+                                printInstructions(hookRunners, appContext, normalizedConfig);
+                              }
+                            }
+
+                          case 2:
+                          case "end":
+                            return _context.stop();
+                        }
+                      }
+                    }, _callee);
+                  }))();
+                },
+                onBeforeCreateCompiler: function onBeforeCreateCompiler(_ref4) {
+                  return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+                    var bundlerConfigs;
+                    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                      while (1) {
+                        switch (_context2.prev = _context2.next) {
+                          case 0:
+                            bundlerConfigs = _ref4.bundlerConfigs;
+                            _context2.next = 3;
+                            return hookRunners.beforeCreateCompiler({
+                              bundlerConfigs: bundlerConfigs
+                            });
+
+                          case 3:
+                          case "end":
+                            return _context2.stop();
+                        }
+                      }
+                    }, _callee2);
+                  }))();
+                },
+                onAfterCreateCompiler: function onAfterCreateCompiler(_ref5) {
+                  return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+                    var compiler;
+                    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                      while (1) {
+                        switch (_context3.prev = _context3.next) {
+                          case 0:
+                            compiler = _ref5.compiler;
+                            _context3.next = 3;
+                            return hookRunners.afterCreateCompiler({
+                              compiler: compiler
+                            });
+
+                          case 3:
+                          case "end":
+                            return _context3.stop();
+                        }
+                      }
+                    }, _callee3);
+                  }))();
+                }
+              }
+            });
+
+          case 5:
+            builder = _context4.sent;
+            return _context4.abrupt("return", builder.createCompiler());
+
+          case 9:
+            _context4.prev = 9;
+            _context4.t0 = _context4["catch"](1);
+            logger.log(chalk.red("Failed to compile."));
+            logger.log();
+            logger.log(_context4.t0); // FIXME: 这里最好抛出异常，执行 process.exit 的地方尽可能少或者控制在几个统一的地方比较合适
+            // eslint-disable-next-line no-process-exit
+
+            process.exit(1);
+
+          case 15:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[1, 9]]);
+  }));
+
+  return function createDevCompiler(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/utils/createServer.js

@@ -0,0 +1,83 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { Server } from '@modern-js/server';
+var server = null;
+export var getServer = function getServer() {
+  return server;
+};
+export var closeServer = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!server) {
+              _context.next = 4;
+              break;
+            }
+
+            _context.next = 3;
+            return server.close();
+
+          case 3:
+            server = null;
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function closeServer() {
+    return _ref.apply(this, arguments);
+  };
+}();
+export var createServer = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(options) {
+    var app;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!server) {
+              _context2.next = 3;
+              break;
+            }
+
+            _context2.next = 3;
+            return server.close();
+
+          case 3:
+            server = new Server(options);
+            _context2.next = 6;
+            return server.init();
+
+          case 6:
+            app = _context2.sent;
+            return _context2.abrupt("return", app);
+
+          case 8:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function createServer(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+export var injectDataLoaderPlugin = function injectDataLoaderPlugin(internalPlugins) {
+  var DataLoaderPlugin = require.resolve('@modern-js/plugin-data-loader/server');
+
+  return _objectSpread(_objectSpread({}, internalPlugins), {}, {
+    '@modern-js/plugin-data-loader': {
+      path: DataLoaderPlugin,
+      forced: true
+    }
+  });
+};

package/dist/js/treeshaking/utils/getSpecifiedEntries.js

@@ -0,0 +1,68 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { inquirer } from '@modern-js/utils';
+export var getSpecifiedEntries = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(entry, entrypoints) {
+    var entryNames, _yield$inquirer$promp, selected;
+
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            entryNames = entrypoints.map(function (e) {
+              return e.entryName;
+            });
+
+            if (entry) {
+              _context.next = 3;
+              break;
+            }
+
+            return _context.abrupt("return", entryNames);
+
+          case 3:
+            if (!(typeof entry === 'boolean')) {
+              _context.next = 9;
+              break;
+            }
+
+            _context.next = 6;
+            return inquirer.prompt([{
+              type: 'checkbox',
+              name: 'selected',
+              choices: entryNames,
+              message: '请选择需要构建的入口',
+              validate: function validate(answer) {
+                if (answer.length < 1) {
+                  return 'You must choose at least one topping.';
+                }
+
+                return true;
+              }
+            }]);
+
+          case 6:
+            _yield$inquirer$promp = _context.sent;
+            selected = _yield$inquirer$promp.selected;
+            return _context.abrupt("return", selected);
+
+          case 9:
+            entry.forEach(function (name) {
+              if (!entryNames.includes(name)) {
+                throw new Error("can not found entry ".concat(name, ", compiler entry should in ").concat(entryNames.join(', ')));
+              }
+            });
+            return _context.abrupt("return", entry);
+
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getSpecifiedEntries(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/utils/language.js

@@ -0,0 +1,5 @@
+import { I18CLILanguageDetector } from '@modern-js/plugin-i18n/language-detector';
+export function getLocaleLanguage() {
+  var detector = new I18CLILanguageDetector();
+  return detector.detect();
+}

package/dist/js/treeshaking/utils/printInstructions.js

@@ -0,0 +1,35 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { prettyInstructions, logger } from '@modern-js/utils';
+export var printInstructions = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(hookRunners, appContext, config) {
+    var message, _yield$hookRunners$be, instructions;
+
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            message = prettyInstructions(appContext, config); // call beforePrintInstructions hook.
+
+            _context.next = 3;
+            return hookRunners.beforePrintInstructions({
+              instructions: message
+            });
+
+          case 3:
+            _yield$hookRunners$be = _context.sent;
+            instructions = _yield$hookRunners$be.instructions;
+            logger.info(instructions);
+
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function printInstructions(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/utils/routes.js

@@ -0,0 +1,33 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import path from 'path';
+import { fs, ROUTE_SPEC_FILE } from '@modern-js/utils';
+
+var generateRoutes = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(appContext) {
+    var serverRoutes, distDirectory, output;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            serverRoutes = appContext.serverRoutes, distDirectory = appContext.distDirectory;
+            output = JSON.stringify({
+              routes: serverRoutes
+            }, null, 2);
+            _context.next = 4;
+            return fs.outputFile(path.join(distDirectory, ROUTE_SPEC_FILE), output);
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function generateRoutes(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+export { generateRoutes };

package/dist/types/analyze/constants.d.ts

@@ -2,6 +2,7 @@ export declare const JS_EXTENSIONS: string[];
 export declare const INDEX_FILE_NAME = "index";
 export declare const APP_FILE_NAME = "App";
 export declare const PAGES_DIR_NAME = "pages";
+export declare const NESTED_ROUTES_DIR = "routes";
 export declare const FILE_SYSTEM_ROUTES_FILE_NAME = "routes.js";
 export declare const ENTRY_POINT_FILE_NAME = "index.js";
 export declare const ENTRY_BOOTSTRAP_FILE_NAME = "bootstrap.js";

package/dist/types/analyze/generateCode.d.ts

@@ -1,4 +1,4 @@
-import type { IAppContext, NormalizedConfig, PluginAPI, ImportStatement } from '@modern-js/core';
+import { IAppContext, NormalizedConfig, PluginAPI, ImportStatement } from '@modern-js/core';
 import type { Entrypoint } from '@modern-js/types';
 export declare const createImportStatements: (statements: ImportStatement[]) => string;
 export declare const generateCode: (appContext: IAppContext, config: NormalizedConfig, entrypoints: Entrypoint[], api: PluginAPI) => Promise<void>;

package/dist/types/analyze/{getClientRoutes.d.ts → getClientRoutes/getRoutes.d.ts}

@@ -1,9 +1,4 @@
-import type { Entrypoint, Route } from '@modern-js/types';
-export type { Route };
-export interface Identifier {
-  name: string;
-  path: string;
-}
+import type { Entrypoint, NestedRoute, PageRoute } from '@modern-js/types';
 export declare const getClientRoutes: ({
   entrypoint,
   srcDirectory,
@@ -16,4 +11,4 @@ export declare const getClientRoutes: ({
   srcAlias: string;
   internalDirectory: string;
   internalDirAlias: string;
-}) => Route[];
+}) => (NestedRoute | PageRoute)[];

package/dist/types/analyze/getClientRoutes/getRoutesLegacy.d.ts

@@ -0,0 +1,15 @@
+import type { Entrypoint, RouteLegacy } from '@modern-js/types';
+export type { RouteLegacy as Route };
+export declare const getClientRoutes: ({
+  entrypoint,
+  srcDirectory,
+  srcAlias,
+  internalDirectory,
+  internalDirAlias
+}: {
+  entrypoint: Entrypoint;
+  srcDirectory: string;
+  srcAlias: string;
+  internalDirectory: string;
+  internalDirAlias: string;
+}) => RouteLegacy[];

package/dist/types/analyze/getClientRoutes/index.d.ts

@@ -0,0 +1,2 @@
+export { getClientRoutes } from './getRoutes';
+export { getClientRoutes as getClientRoutesLegacy } from './getRoutesLegacy';

package/dist/types/analyze/getClientRoutes/utils.d.ts

@@ -0,0 +1,5 @@
+declare const debug: import("@modern-js/utils/compiled/debug").Debugger;
+export { debug };
+export declare const findLayout: (dir: string) => string | false;
+export declare const getRouteWeight: (route: string) => number;
+export declare const shouldSkip: (file: string) => boolean;

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

@@ -1,5 +1,5 @@
 import type { CliPlugin, RuntimePlugin, ImportStatement } from '@modern-js/core';
-import type { Route, Entrypoint, ServerRoute, HtmlPartials } from '@modern-js/types';
+import type { RouteLegacy, Entrypoint, ServerRoute, HtmlPartials, NestedRoute, PageRoute } from '@modern-js/types';
 export declare const modifyEntryImports: import("@modern-js/plugin").AsyncWaterfall<{
   imports: ImportStatement[];
   entrypoint: Entrypoint;
@@ -23,7 +23,7 @@ export declare const modifyAsyncEntry: import("@modern-js/plugin").AsyncWaterfal
 }>;
 export declare const modifyFileSystemRoutes: import("@modern-js/plugin").AsyncWaterfall<{
   entrypoint: Entrypoint;
-  routes: Route[];
+  routes: RouteLegacy[] | (NestedRoute | PageRoute)[];
 }>;
 export declare const modifyServerRoutes: import("@modern-js/plugin").AsyncWaterfall<{
   routes: ServerRoute[];

package/dist/types/analyze/nestedRoutes.d.ts

@@ -0,0 +1,5 @@
+import type { NestedRoute } from '@modern-js/types';
+export declare const walk: (dirname: string, rootDir: string, alias: {
+  name: string;
+  basename: string;
+}) => Promise<NestedRoute | null>;

package/dist/types/analyze/templates.d.ts

@@ -1,5 +1,5 @@
 import type { RuntimePlugin } from '@modern-js/core';
-import type { Entrypoint, Route } from '@modern-js/types';
+import type { Entrypoint, NestedRoute, PageRoute, RouteLegacy } from '@modern-js/types';
 export declare const index: ({
   mountId,
   imports,
@@ -25,8 +25,22 @@ export declare const html: (partials: {
   head: string[];
   body: string[];
 }) => string;
+export declare const routesForServer: ({
+  routes,
+  alias
+}: {
+  routes: (NestedRoute | PageRoute)[];
+  alias: {
+    name: string;
+    basename: string;
+  };
+}) => string;
 export declare const fileSystemRoutes: ({
-  routes
+  routes,
+  ssrMode,
+  nestedRoutesEntry
 }: {
-  routes: Route[];
+  routes: RouteLegacy[] | (NestedRoute | PageRoute)[];
+  ssrMode: 'string' | 'stream' | false;
+  nestedRoutesEntry?: string | undefined;
 }) => string;

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

@@ -14,4 +14,5 @@ export declare const getDefaultImports: ({
   internalDirAlias: string;
   internalDirectory: string;
 }) => ImportStatement[];
-export declare const isRouteComponentFile: (filePath: string) => boolean;
+export declare const isRouteComponentFile: (filePath: string) => boolean;
+export declare const replaceWithAlias: (base: string, filePath: string, alias: string) => string;

package/dist/types/builder/builderPlugins/compatModern.d.ts

@@ -0,0 +1,14 @@
+import { BuilderPlugin } from '@modern-js/builder-shared';
+import type { BuilderPluginAPI } from '@modern-js/builder-webpack-provider';
+import type { IAppContext, NormalizedConfig } from '@modern-js/core';
+declare type Parameter<T extends (arg: any) => void> = Parameters<T>[0];
+declare type FnParameter<T extends {
+  [p: string]: (arg: any) => void;
+}> = { [P in keyof T]: Parameter<T[P]> };
+export declare type PluginCompatModernOptions = FnParameter<Partial<Pick<BuilderPluginAPI, 'onAfterBuild' | 'onAfterCreateCompiler' | 'onAfterStartDevServer' | 'onBeforeBuild' | 'onBeforeCreateCompiler' | 'onBeforeStartDevServer' | 'onDevCompileDone' | 'onExit'>>>;
+/**
+ * Provides default configuration consistent with `@modern-js/webpack`
+ */
+
+export declare const PluginCompatModern: (appContext: IAppContext, modernConfig: NormalizedConfig, options?: PluginCompatModernOptions) => BuilderPlugin<BuilderPluginAPI>;
+export {};

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

@@ -0,0 +1,6 @@
+import type { BuilderConfig } from '@modern-js/builder-webpack-provider';
+import type { IAppContext, NormalizedConfig } from '@modern-js/core';
+export declare function createHtmlConfig(normalizedConfig: NormalizedConfig, appContext: IAppContext): BuilderConfig['html'];
+export declare function createBuilderAppIcon(configDir: NormalizedConfig['source']['configDir'], appContext: IAppContext): string | undefined;
+export declare function createBuilderCrossorigin(scriptExt: NormalizedConfig['output']['scriptExt']): "anonymous" | "use-credentials" | undefined;
+export declare function createBuilderFavicon(favicon: NormalizedConfig['output']['favicon'], configDir: NormalizedConfig['source']['configDir'], appContext: IAppContext): string | undefined;

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

@@ -0,0 +1,3 @@
+import type { BuilderConfig } from '@modern-js/builder-webpack-provider';
+import type { IAppContext, NormalizedConfig } from '@modern-js/core';
+export declare function createOutputConfig(normalizedConfig: NormalizedConfig, appContext: IAppContext): BuilderConfig['output'];

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

@@ -0,0 +1,5 @@
+import { BuilderConfig } from '@modern-js/builder-webpack-provider';
+import { IAppContext, NormalizedConfig } from '@modern-js/core';
+export declare function createSourceConfig(normalizedConfig: NormalizedConfig, appContext: IAppContext): BuilderConfig['source'];
+export declare function createBuilderInclude(include: NormalizedConfig['source']['include'], appContext: IAppContext): (string | RegExp)[];
+export declare function createBuilderModuleScope(moduleScopes: NormalizedConfig['source']['moduleScopes']): any[] | undefined;

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

@@ -0,0 +1,13 @@
+import type { BuilderConfig } from '@modern-js/builder-webpack-provider';
+import type { NormalizedConfig } from '@modern-js/core';
+export declare function createToolsConfig(normalizedConfig: NormalizedConfig): BuilderConfig['tools'];
+export declare function createBuilderTsChecker(output: NormalizedConfig['output']): false | {
+  issue: {
+    include: {
+      file: string;
+    }[];
+    exclude: {
+      file: string;
+    }[];
+  };
+};

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

@@ -0,0 +1,19 @@
+import { BuilderInstance, BuilderTarget, CreateBuilderOptions } from '@modern-js/builder';
+import type { IAppContext, NormalizedConfig } from '@modern-js/core';
+import { PluginCompatModernOptions } from './builderPlugins/compatModern';
+export declare type BuilderOptions = {
+  target?: BuilderTarget | BuilderTarget[];
+  normalizedConfig: NormalizedConfig;
+  appContext: IAppContext;
+  compatPluginConfig?: PluginCompatModernOptions;
+};
+
+declare const _default: ({
+  target,
+  normalizedConfig,
+  appContext,
+  compatPluginConfig
+}: BuilderOptions) => Promise<BuilderInstance>;
+
+export default _default;
+export declare function createBuilderOptions(target: BuilderTarget | BuilderTarget[], appContext: IAppContext): CreateBuilderOptions;

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

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { WebpackChain } from '@modern-js/builder-webpack-provider';
+import { IAppContext, NormalizedConfig } from '@modern-js/core';
+export declare function createCopyPattern(appContext: IAppContext, config: NormalizedConfig, patternsType: 'upload' | 'public', chain?: WebpackChain): {
+  info: (file: {
+    sourceFilename: string;
+  }) => {
+    minimized: boolean;
+  };
+  from: string;
+  to: string;
+  context: string;
+  noErrorOnMissing: boolean;
+  transform: (content: Buffer, absoluteFrom: string) => string | Buffer;
+} | {
+  info: (file: {
+    sourceFilename: string;
+  }) => {
+    minimized: boolean;
+  };
+  from: string;
+  to: string;
+  context: string;
+  noErrorOnMissing: boolean;
+  transform?: undefined;
+};

package/dist/types/builder/webpackPlugins/htmlAsyncChunkPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { webpack } from '@modern-js/builder-webpack-provider';
+import type HtmlWebpackPlugin from '@modern-js/builder-webpack-provider/html-webpack-plugin';
+export declare class HtmlAsyncChunkPlugin {
+  name: string;
+  htmlWebpackPlugin: typeof HtmlWebpackPlugin;
+  constructor(htmlWebpackPlugin: typeof HtmlWebpackPlugin);
+  apply(compiler: webpack.Compiler): void;
+}

package/dist/types/builder/webpackPlugins/htmlBottomTemplate.d.ts

@@ -0,0 +1,10 @@
+import type { webpack } from '@modern-js/builder-webpack-provider';
+import type HtmlWebpackPlugin from '@modern-js/builder-webpack-provider/html-webpack-plugin';
+export declare class BottomTemplatePlugin {
+  htmlWebpackPlugin: typeof HtmlWebpackPlugin;
+  bottomTemplateReg: RegExp;
+  bodyRegExp: RegExp;
+  name: string;
+  constructor(htmlWebpackPlugin: typeof HtmlWebpackPlugin);
+  apply(compiler: webpack.Compiler): void;
+}

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

@@ -1,3 +1,4 @@
 import { PluginAPI } from '@modern-js/core';
 import type { BuildOptions } from '../utils/types';
-export declare const build: (api: PluginAPI, options?: BuildOptions) => Promise<void>;
+import type { AppHooks } from '../hooks';
+export declare const build: (api: PluginAPI<AppHooks>, options?: BuildOptions) => Promise<void>;

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

@@ -1,2 +1,3 @@
 import type { PluginAPI } from '@modern-js/core';
-export declare const deploy: (api: PluginAPI, options: any) => Promise<void>;
+import type { AppHooks } from '../hooks';
+export declare const deploy: (api: PluginAPI<AppHooks>, options: any) => Promise<void>;

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

@@ -1,3 +1,4 @@
 import { PluginAPI } from '@modern-js/core';
 import { DevOptions } from '../utils/types';
-export declare const dev: (api: PluginAPI, options: DevOptions) => Promise<void>;
+import type { AppHooks } from '../hooks';
+export declare const dev: (api: PluginAPI<AppHooks>, options: DevOptions) => Promise<void>;

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

@@ -1,7 +1,6 @@
-import { Configuration, WebpackConfigTarget } from '@modern-js/webpack';
-import type { PluginAPI, NormalizedConfig, IAppContext } from '@modern-js/core';
+import type { PluginAPI } from '@modern-js/core';
 import type { InspectOptions } from '../utils/types';
-export declare const formatWebpackConfig: (config: Configuration, verbose?: boolean) => string;
-export declare const inspect: (api: PluginAPI, options: InspectOptions) => void;
-export declare const getTagByWebpackTarget: (webpackTarget: WebpackConfigTarget) => "client" | "modern" | "ssr";
-export declare const printInspectResult: (webpackTarget: WebpackConfigTarget, appContext: IAppContext, resolvedConfig: NormalizedConfig, options: InspectOptions) => string;
+export declare const inspect: (api: PluginAPI, options: InspectOptions) => Promise<{
+  builderConfig: string;
+  bundlerConfigs: string[];
+}>;

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

@@ -1,2 +1,3 @@
 import type { PluginAPI } from '@modern-js/core';
-export declare const start: (api: PluginAPI) => Promise<void>;
+import type { AppHooks } from '../hooks';
+export declare const start: (api: PluginAPI<AppHooks>) => Promise<void>;