@modern-js/app-tools 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/js/treeshaking/utils/createFileWatcher.js

@@ -0,0 +1,123 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { isDev, chokidar, createDebugger, isTest, getServerConfig } from '@modern-js/utils';
+/**
+ * Get user config from package.json.
+ * @param appDirectory - App root directory.
+ * @returns modernConfig or undefined
+ */
+// FIXME: read package.json again;
+var getPackageConfig = function getPackageConfig(appDirectory, packageJsonConfig) {
+  var PACKAGE_JSON_CONFIG_NAME = 'modernConfig';
+  var json = JSON.parse(fs.readFileSync(path.resolve(appDirectory, './package.json'), 'utf8'));
+  return json[packageJsonConfig !== null && packageJsonConfig !== void 0 ? packageJsonConfig : PACKAGE_JSON_CONFIG_NAME];
+};
+var addServerConfigToDeps = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(dependencies, appDirectory, serverConfigFile) {
+    var serverConfig;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return getServerConfig(appDirectory, serverConfigFile);
+          case 2:
+            serverConfig = _context.sent;
+            if (serverConfig) {
+              dependencies.push(serverConfig);
+            }
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return function addServerConfigToDeps(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var debug = createDebugger('watch-files');
+var md5 = function md5(data) {
+  return crypto.createHash('md5').update(data).digest('hex');
+};
+var hashMap = new Map();
+export var createFileWatcher = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(appContext, configDir, hooksRunner) {
+    var appDirectory, configFile, extraFiles, configPath, dependencies, watched, watcher;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(isDev() || isTest())) {
+              _context2.next = 17;
+              break;
+            }
+            appDirectory = appContext.appDirectory, configFile = appContext.configFile;
+            _context2.next = 4;
+            return hooksRunner.watchFiles();
+          case 4:
+            extraFiles = _context2.sent;
+            configPath = path.join(appDirectory, configDir);
+            dependencies = getPackageConfig(appContext.appDirectory, appContext.packageName) ? [path.resolve(appDirectory, './package.json')] : []; // 将 server.config 加入到 loaded.dependencies，以便对文件监听做热更新
+            _context2.next = 9;
+            return addServerConfigToDeps(dependencies, appContext.appDirectory, appContext.serverConfigFile);
+          case 9:
+            watched = ["".concat(configPath, "/html")].concat(_toConsumableArray(extraFiles), dependencies, [configFile]).filter(Boolean);
+            debug("watched: %o", watched);
+            watcher = chokidar.watch(watched, {
+              cwd: appDirectory,
+              ignoreInitial: true,
+              ignorePermissionErrors: true,
+              ignored: [/node_modules/, '**/__test__/**', '**/*.test.(js|jsx|ts|tsx)', '**/*.spec.(js|jsx|ts|tsx)', '**/*.stories.(js|jsx|ts|tsx)']
+            });
+            watcher.on('change', function (changed) {
+              var lastHash = hashMap.get(changed);
+              var currentHash = md5(fs.readFileSync(path.join(appDirectory, changed), 'utf8'));
+              if (currentHash !== lastHash) {
+                debug("file change: %s", changed);
+                hashMap.set(changed, currentHash);
+                hooksRunner.fileChange({
+                  filename: changed,
+                  eventType: 'change'
+                });
+              }
+            });
+            watcher.on('add', function (name) {
+              debug("add file: %s", name);
+              var currentHash = md5(fs.readFileSync(path.join(appDirectory, name), 'utf8'));
+              hashMap.set(name, currentHash);
+              hooksRunner.fileChange({
+                filename: name,
+                eventType: 'add'
+              });
+            });
+            watcher.on('unlink', function (name) {
+              debug("remove file: %s", name);
+              if (hashMap.has(name)) {
+                hashMap["delete"](name);
+              }
+              hooksRunner.fileChange({
+                filename: name,
+                eventType: 'unlink'
+              });
+            });
+            watcher.on('error', function (err) {
+              throw err;
+            });
+            return _context2.abrupt("return", watcher);
+          case 17:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return function createFileWatcher(_x4, _x5, _x6) {
+    return _ref2.apply(this, arguments);
+  };
+}();

package/dist/js/treeshaking/utils/restart.js

@@ -0,0 +1,45 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { cli } from '@modern-js/core';
+import { logger, program } from '@modern-js/utils';
+export function restart(_x) {
+  return _restart.apply(this, arguments);
+}
+function _restart() {
+  _restart = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(hooksRunner) {
+    var hasGetError;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            logger.info('Restart...\n');
+            hasGetError = false;
+            _context.next = 4;
+            return hooksRunner.beforeRestart();
+          case 4:
+            _context.prev = 4;
+            _context.next = 7;
+            return cli.init(cli.initOptions);
+          case 7:
+            _context.next = 13;
+            break;
+          case 9:
+            _context.prev = 9;
+            _context.t0 = _context["catch"](4);
+            console.error(_context.t0);
+            hasGetError = true;
+          case 13:
+            _context.prev = 13;
+            if (!hasGetError) {
+              program.parse(process.argv);
+            }
+            return _context.finish(13);
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[4, 9, 13, 16]]);
+  }));
+  return _restart.apply(this, arguments);
+}

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

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

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

@@ -1,3 +1,3 @@
-import type { IAppContext, NormalizedConfig } from '@modern-js/core';
 import type { Entrypoint } from '@modern-js/types';
-export declare const getBundleEntry: (appContext: IAppContext, config: NormalizedConfig) => Entrypoint[];
+import type { AppNormalizedConfig, IAppContext } from '../types';
+export declare const getBundleEntry: (appContext: IAppContext, config: AppNormalizedConfig) => Entrypoint[];

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

@@ -1,4 +1,4 @@
-import type { NormalizedConfig, IAppContext } from '@modern-js/core';
 import type { Entrypoint } from '@modern-js/types';
+import type { AppNormalizedConfig, IAppContext } from '../types';
 export type { Entrypoint };
-export declare const getFileSystemEntry: (appContext: IAppContext, config: NormalizedConfig) => Entrypoint[];
+export declare const getFileSystemEntry: (appContext: IAppContext, config: AppNormalizedConfig) => Entrypoint[];

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

@@ -1,9 +1,9 @@
-import type { IAppContext, NormalizedConfig, PluginAPI } from '@modern-js/core';
 import type { Entrypoint, HtmlTemplates } from '@modern-js/types';
-export declare const getHtmlTemplate: (entrypoints: Entrypoint[], api: PluginAPI, {
+import type { AppNormalizedConfig, AppTools, IAppContext, PluginAPI } from '../types';
+export declare const getHtmlTemplate: (entrypoints: Entrypoint[], api: PluginAPI<AppTools>, {
   appContext,
   config
 }: {
   appContext: IAppContext;
-  config: NormalizedConfig;
+  config: AppNormalizedConfig;
 }) => Promise<HtmlTemplates>;

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

@@ -1,9 +1,10 @@
-import type { NormalizedConfig, IAppContext } from '@modern-js/core';
+import type { IAppContext } from '@modern-js/core';
 import type { Entrypoint, ServerRoute } from '@modern-js/types';
+import type { AppNormalizedConfig } from '../types';
 export declare const getServerRoutes: (entrypoints: Entrypoint[], {
   appContext,
   config
 }: {
   appContext: IAppContext;
-  config: NormalizedConfig;
+  config: AppNormalizedConfig;
 }) => ServerRoute[];

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

@@ -1,42 +1,4 @@
-import type { CliPlugin, RuntimePlugin, ImportStatement } from '@modern-js/core';
-import type { RouteLegacy, Entrypoint, ServerRoute, HtmlPartials, NestedRoute, PageRoute } from '@modern-js/types';
-import type { AppHooks } from '../hooks';
-export declare const modifyEntryImports: import("@modern-js/plugin").AsyncWaterfall<{
-  imports: ImportStatement[];
-  entrypoint: Entrypoint;
-}>;
-export declare const modifyEntryExport: import("@modern-js/plugin").AsyncWaterfall<{
-  entrypoint: Entrypoint;
-  exportStatement: string;
-}>;
-export declare const addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
-export declare const modifyEntryRuntimePlugins: import("@modern-js/plugin").AsyncWaterfall<{
-  entrypoint: Entrypoint;
-  plugins: RuntimePlugin[];
-}>;
-export declare const modifyEntryRenderFunction: import("@modern-js/plugin").AsyncWaterfall<{
-  entrypoint: Entrypoint;
-  code: string;
-}>;
-export declare const modifyAsyncEntry: import("@modern-js/plugin").AsyncWaterfall<{
-  entrypoint: Entrypoint;
-  code: string;
-}>;
-export declare const modifyFileSystemRoutes: import("@modern-js/plugin").AsyncWaterfall<{
-  entrypoint: Entrypoint;
-  routes: RouteLegacy[] | (NestedRoute | PageRoute)[];
-}>;
-export declare const modifyServerRoutes: import("@modern-js/plugin").AsyncWaterfall<{
-  routes: ServerRoute[];
-}>;
-export declare const htmlPartials: import("@modern-js/plugin").AsyncWaterfall<{
-  entrypoint: Entrypoint;
-  partials: HtmlPartials;
-}>;
-export declare const beforeGenerateRoutes: import("@modern-js/plugin").AsyncWaterfall<{
-  entrypoint: Entrypoint;
-  code: string;
-}>;
-export declare const addDefineTypes: import("@modern-js/plugin").AsyncWaterfall<void>;
-declare const _default: () => CliPlugin<AppHooks>;
+import type { CliPlugin } from '@modern-js/core';
+import { AppTools } from '../types';
+declare const _default: () => CliPlugin<AppTools>;
 export default _default;

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

@@ -1,5 +1,5 @@
-import type { RuntimePlugin } from '@modern-js/core';
 import type { Entrypoint, NestedRoute, PageRoute, RouteLegacy } from '@modern-js/types';
+import type { RuntimePlugin } from '../types';
 export declare const index: ({
   mountId,
   imports,

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

@@ -1,5 +1,5 @@
 import type { Entrypoint } from '@modern-js/types';
-import type { ImportStatement } from '@modern-js/core';
+import type { ImportStatement } from '../types';
 export declare const walkDirectory: (dir: string) => string[];
 export declare const getDefaultImports: ({
   entrypoint,

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

@@ -1,6 +1,6 @@
 import { BuilderPlugin } from '@modern-js/builder-shared';
 import type { BuilderPluginAPI } from '@modern-js/builder-webpack-provider';
-import type { IAppContext, NormalizedConfig } from '@modern-js/core';
+import type { IAppContext, AppNormalizedConfig } from '../../types';
 declare type Parameter<T extends (arg: any) => void> = Parameters<T>[0];
 declare type FnParameter<T extends {
   [p: string]: (arg: any) => void;
@@ -9,5 +9,5 @@ export declare type PluginCompatModernOptions = FnParameter<Partial<Pick<Builder
 /**
  * Provides default configuration consistent with `@modern-js/webpack`
  */
-export declare const PluginCompatModern: (appContext: IAppContext, modernConfig: NormalizedConfig, options?: PluginCompatModernOptions) => BuilderPlugin<BuilderPluginAPI>;
+export declare const PluginCompatModern: (appContext: IAppContext, modernConfig: AppNormalizedConfig, options?: PluginCompatModernOptions) => BuilderPlugin<BuilderPluginAPI>;
 export {};

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

@@ -1,9 +1,11 @@
 import { BuilderInstance, BuilderTarget, CreateBuilderOptions } from '@modern-js/builder';
-import type { IAppContext, NormalizedConfig } from '@modern-js/core';
+import { BuilderConfig } from '@modern-js/builder-webpack-provider';
+import type { IAppContext } from '@modern-js/core';
+import type { AppNormalizedConfig } from '../types';
 import { PluginCompatModernOptions } from './builderPlugins/compatModern';
 export declare type BuilderOptions = {
   target?: BuilderTarget | BuilderTarget[];
-  normalizedConfig: NormalizedConfig;
+  normalizedConfig: AppNormalizedConfig;
   appContext: IAppContext;
   compatPluginConfig?: PluginCompatModernOptions;
 };
@@ -12,4 +14,5 @@ export declare function createBuilderForEdenX({
   appContext,
   compatPluginConfig
 }: BuilderOptions): Promise<BuilderInstance>;
+export declare function createBuilderProviderConfig(normalizedConfig: AppNormalizedConfig, appContext: IAppContext): BuilderConfig;
 export declare function createBuilderOptions(target: BuilderTarget | BuilderTarget[], appContext: IAppContext): CreateBuilderOptions;

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

@@ -1,7 +1,7 @@
 /// <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): {
+import { AppNormalizedConfig, IAppContext } from '../types';
+export declare function createCopyPattern(appContext: IAppContext, config: AppNormalizedConfig, patternsType: 'upload' | 'public', chain?: WebpackChain): {
   info: (file: {
     sourceFilename: string;
   }) => {

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

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

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

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

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

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

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

@@ -1,3 +1,11 @@
 import type { PluginAPI } from '@modern-js/core';
 import type { InspectOptions } from '../utils/types';
-export declare const inspect: (api: PluginAPI, options: InspectOptions) => Promise<any>;
+import type { AppTools } from '../types';
+export declare const inspect: (api: PluginAPI<AppTools>, options: InspectOptions) => Promise<{
+  builderConfig: string;
+  bundlerConfigs: string[];
+  origin: {
+    builderConfig: Record<string, any>;
+    bundlerConfigs: Record<string, any>[];
+  };
+}>;

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

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

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

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

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

@@ -0,0 +1,2 @@
+export { createDefaultConfig, createLegacyDefaultConfig } from './default';
+export { initialNormalizedConfig, checkIsLegacyConfig } from './initial';

package/dist/types/config/initial/createHtmlConfig.d.ts

@@ -0,0 +1,2 @@
+import { AppLegacyNormalizedConfig, AppNormalizedConfig } from '../../types';
+export declare function createHtmlConfig(config: Readonly<AppLegacyNormalizedConfig>): AppNormalizedConfig['html'];

package/dist/types/config/initial/createOutputConfig.d.ts

@@ -0,0 +1,2 @@
+import { AppLegacyNormalizedConfig, AppNormalizedConfig } from '../../types';
+export declare function createOutputConfig(config: Readonly<AppLegacyNormalizedConfig>): AppNormalizedConfig['output'];

package/dist/types/config/initial/createSourceConfig.d.ts

@@ -0,0 +1,2 @@
+import { AppLegacyNormalizedConfig, AppNormalizedConfig } from '../../types';
+export declare function createSourceConfig(config: AppLegacyNormalizedConfig): AppNormalizedConfig['source'];

package/dist/types/config/initial/createToolsConfig.d.ts

@@ -0,0 +1,2 @@
+import { AppLegacyNormalizedConfig, AppNormalizedConfig } from '../../types';
+export declare function createToolsConfig(config: AppLegacyNormalizedConfig): AppNormalizedConfig['tools'];

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

@@ -0,0 +1,4 @@
+import { AppNormalizedConfig, IAppContext, AppLegacyUserConfig, AppUserConfig } from '../../types';
+export { transformNormalizedConfig } from './transformNormalizedConfig';
+export declare function checkIsLegacyConfig(config: AppLegacyUserConfig | AppUserConfig): config is AppLegacyUserConfig;
+export declare function initialNormalizedConfig(config: AppNormalizedConfig, appContext: IAppContext): AppNormalizedConfig;

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

@@ -0,0 +1,4 @@
+import { AppNormalizedConfig, IAppContext } from '../../types';
+export declare function initHtmlConfig(config: AppNormalizedConfig, appContext: IAppContext): import("@modern-js/builder-shared").SharedHtmlConfig;
+export declare function initSourceConfig(config: AppNormalizedConfig, appContext: IAppContext): void;
+export declare function initToolsConfig(config: AppNormalizedConfig): void;

package/dist/types/config/initial/transformNormalizedConfig.d.ts

@@ -0,0 +1,2 @@
+import { AppLegacyNormalizedConfig, AppNormalizedConfig } from '../../types';
+export declare function transformNormalizedConfig(config: AppLegacyNormalizedConfig): AppNormalizedConfig;

package/dist/types/defineConfig.d.ts

@@ -0,0 +1,7 @@
+import { AppUserConfig, AppLegacyUserConfig } from './types';
+export declare const defineConfig: (config: AppUserConfig) => AppUserConfig;
+/**
+ * @deprecated
+ * Using defineConfig first.
+ */
+export declare const defineLegacyConfig: (config: AppLegacyUserConfig) => AppLegacyUserConfig;

package/dist/types/hooks.d.ts

@@ -1,42 +1,2 @@
-import type { webpack } from '@modern-js/builder-webpack-provider/types';
-export declare const beforeDev: import("@modern-js/plugin").AsyncWorkflow<void, unknown>;
-export declare const afterDev: import("@modern-js/plugin").AsyncWorkflow<void, unknown>;
-export declare const beforeCreateCompiler: import("@modern-js/plugin").AsyncWorkflow<{
-  bundlerConfigs: webpack.Configuration[];
-}, unknown>;
-export declare const afterCreateCompiler: import("@modern-js/plugin").AsyncWorkflow<{
-  compiler: webpack.Compiler | webpack.MultiCompiler | undefined;
-}, unknown>;
-export declare const beforePrintInstructions: import("@modern-js/plugin").AsyncWaterfall<{
-  instructions: string;
-}>;
-export declare const beforeBuild: import("@modern-js/plugin").AsyncWorkflow<{
-  bundlerConfigs?: webpack.Configuration[] | undefined;
-}, unknown>;
-export declare const afterBuild: import("@modern-js/plugin").AsyncWorkflow<{
-  stats?: webpack.Stats | webpack.MultiStats | undefined;
-}, unknown>;
-export declare const beforeDeploy: import("@modern-js/plugin").AsyncWorkflow<Record<string, any>, unknown>;
-export declare const afterDeploy: import("@modern-js/plugin").AsyncWorkflow<Record<string, any>, unknown>;
-export declare const hooks: {
-  beforeDev: import("@modern-js/plugin").AsyncWorkflow<void, unknown>;
-  afterDev: import("@modern-js/plugin").AsyncWorkflow<void, unknown>;
-  beforeCreateCompiler: import("@modern-js/plugin").AsyncWorkflow<{
-    bundlerConfigs: webpack.Configuration[];
-  }, unknown>;
-  afterCreateCompiler: import("@modern-js/plugin").AsyncWorkflow<{
-    compiler: webpack.Compiler | webpack.MultiCompiler | undefined;
-  }, unknown>;
-  beforePrintInstructions: import("@modern-js/plugin").AsyncWaterfall<{
-    instructions: string;
-  }>;
-  beforeBuild: import("@modern-js/plugin").AsyncWorkflow<{
-    bundlerConfigs?: webpack.Configuration[] | undefined;
-  }, unknown>;
-  afterBuild: import("@modern-js/plugin").AsyncWorkflow<{
-    stats?: webpack.Stats | webpack.MultiStats | undefined;
-  }, unknown>;
-  beforeDeploy: import("@modern-js/plugin").AsyncWorkflow<Record<string, any>, unknown>;
-  afterDeploy: import("@modern-js/plugin").AsyncWorkflow<Record<string, any>, unknown>;
-};
-export declare type AppHooks = typeof hooks;
+import { AppToolsHooks } from './types/hooks';
+export declare const hooks: AppToolsHooks;

package/dist/types/index.d.ts

@@ -1,6 +1,6 @@
-import { defineConfig, CliPlugin } from '@modern-js/core';
-import { hooks, AppHooks } from './hooks';
-export { defineConfig, hooks };
-export type { AppHooks, CliPlugin };
-declare const _default: () => CliPlugin<AppHooks>;
+import { CliPlugin } from '@modern-js/core';
+import { AppTools } from './types';
+export * from './defineConfig';
+export * from './types';
+declare const _default: () => CliPlugin<AppTools>;
 export default _default;

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

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

package/dist/types/schema/Schema.d.ts

@@ -0,0 +1,14 @@
+export declare type ValidateSchema = {
+  target: string;
+  schema: any;
+};
+export declare class Schema extends Map<string, any> {
+  private schema;
+  constructor(baseSchema?: Record<string, any>);
+  setSchema(key: string, object: Record<string, any>): this;
+  set(key: string, value: any): this;
+  has(key: string): boolean;
+  get(key: string): any;
+  delete(key: string): boolean;
+  generate(): ValidateSchema[];
+}

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

@@ -0,0 +1,4 @@
+import { Schema } from './Schema';
+declare const schema: Schema;
+export { default as legacySchema } from './legacy';
+export { schema };

package/dist/types/schema/legacy.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from './Schema';
+declare const schema: Schema;
+export default schema;

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

@@ -0,0 +1,9 @@
+export interface MicroFrontend {
+  enableHtmlEntry?: boolean;
+  externalBasicLibrary?: boolean;
+  moduleApp?: string;
+}
+export interface DeployUserConfig {
+  microFrontend?: boolean | MicroFrontend;
+}
+export declare type DeployNormalizedConfig = DeployUserConfig;

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

@@ -0,0 +1,13 @@
+import type { BuilderConfig } from '@modern-js/builder-webpack-provider';
+declare type BuilderEnvConfig = Required<BuilderConfig>['dev'];
+export declare type DevProxyOptions = string | Record<string, string>;
+export interface DevUserConfig extends Pick<BuilderEnvConfig, 'assetPrefix' | 'https'> {
+  /**
+   * The configuration of `dev.proxy` is provided by `proxy` plugin.
+   * Please use `yarn new` or `pnpm new` to enable the corresponding capability.
+   * @requires `proxy` plugin
+   */
+  proxy?: string | Record<string, string>;
+}
+export declare type DevNormalizedConfig = DevUserConfig;
+export {};

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

@@ -0,0 +1,4 @@
+import type { BuilderConfig } from '@modern-js/builder-webpack-provider';
+export declare type BuilderExperimentsConfig = Required<BuilderConfig>['experiments'];
+export declare type ExperimentsUserConfig = BuilderExperimentsConfig;
+export declare type ExperimentsNormalizedConfig = ExperimentsUserConfig;

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

@@ -0,0 +1,4 @@
+import type { BuilderConfig } from '@modern-js/builder-webpack-provider';
+export declare type BuilderHtmlConfig = Required<BuilderConfig>['html'];
+export declare type HtmlUserConfig = BuilderHtmlConfig;
+export declare type HtmlNormalizedConfig = HtmlUserConfig;

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

@@ -0,0 +1,62 @@
+import type { UserConfig } from '@modern-js/core';
+import type { ServerUserConfig, ServerNormalizedConfig, BffUserConfig, BffNormalizedConfig } from '@modern-js/server-core';
+import type { AppToolsHooks } from '../hooks';
+import type { OutputNormalizedConfig, OutputUserConfig } from './output';
+import type { SourceNormalizedConfig, SourceUserConfig } from './source';
+import type { DevNormalizedConfig, DevUserConfig } from './dev';
+import type { ToolsNormalizedConfig, ToolsUserConfig } from './tools';
+import type { HtmlNormalizedConfig, HtmlUserConfig } from './html';
+import type { SecurityNormalizedConfig, SecurityUserConfig } from './security';
+import type { DeployNormalizedConfig, DeployUserConfig } from './deploy';
+import type { ExperimentsUserConfig, ExperimentsNormalizedConfig } from './experiments';
+import type { PerformanceNormalizedConfig, PerformanceUserConfig } from './performance';
+export * from './output';
+export interface RuntimeUserConfig {
+  [name: string]: any;
+}
+export interface RuntimeByEntriesUserConfig {
+  [name: string]: RuntimeUserConfig;
+}
+export declare type RuntimeNormalizedConfig = RuntimeUserConfig;
+export declare type RuntimeByEntriesNormalizedConfig = RuntimeByEntriesUserConfig;
+export interface AppToolsUserConfig {
+  source?: SourceUserConfig;
+  output?: OutputUserConfig;
+  server?: ServerUserConfig;
+  dev?: DevUserConfig;
+  deploy?: DeployUserConfig;
+  html?: HtmlUserConfig;
+  tools?: ToolsUserConfig;
+  runtime?: RuntimeUserConfig;
+  security?: SecurityUserConfig;
+  runtimeByEntries?: RuntimeByEntriesUserConfig;
+  performance?: PerformanceUserConfig;
+  experiments?: ExperimentsUserConfig;
+  /**
+   * The configuration of `bff` is provided by `bff` plugin.
+   * Please use `yarn new` or `pnpm new` to enable the corresponding capability.
+   * @requires `bff` plugin
+   */
+  bff?: BffUserConfig;
+}
+export declare type AppToolsNormalizedConfig = {
+  source: SourceNormalizedConfig;
+  bff: BffNormalizedConfig;
+  dev: DevNormalizedConfig;
+  deploy: DeployNormalizedConfig;
+  html: HtmlNormalizedConfig;
+  runtime: RuntimeNormalizedConfig;
+  runtimeByEntries: RuntimeByEntriesNormalizedConfig;
+  output: OutputNormalizedConfig;
+  security: SecurityNormalizedConfig;
+  server: ServerNormalizedConfig;
+  tools: ToolsNormalizedConfig;
+  performance: PerformanceNormalizedConfig;
+  experiments: ExperimentsNormalizedConfig;
+  cliOptions?: Record<string, any>;
+  _raw: UserConfig<{
+    hooks: AppToolsHooks;
+    userConfig: AppToolsUserConfig;
+    normalizedConfig: AppToolsNormalizedConfig;
+  }>;
+};