@modern-js/app-tools 3.7.0 → 3.8.0

package/dist/esm/plugins/serverBuild.mjs

@@ -17,7 +17,7 @@ const serverBuild = ()=>({
         name: '@modern-js/server-build',
         setup (api) {
             api.onAfterBuild(async ()=>{
-                const { appDirectory, distDirectory, metaName } = api.getAppContext();
+                const { appDirectory, distDirectory, metaName, moduleType } = api.getAppContext();
                 if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) return;
                 const modernConfig = api.getNormalizedConfig();
                 const distDir = path.resolve(distDirectory);
@@ -37,7 +37,8 @@ const serverBuild = ()=>({
                 }, {
                     sourceDirs,
                     distDir,
-                    tsconfigPath
+                    tsconfigPath,
+                    moduleType
                 });
             });
         }

package/dist/esm-node/builder/generator/createBuilderProviderConfig.mjs

@@ -15,6 +15,10 @@ function modifyOutputConfig(config, appContext) {
     };
 }
 function createBuilderProviderConfig(resolveConfig, appContext) {
+    const builderDevConfig = {
+        ...resolveConfig.dev
+    };
+    delete builderDevConfig.mockDir;
     const htmlConfig = {
         ...resolveConfig.html
     };
@@ -33,7 +37,7 @@ function createBuilderProviderConfig(resolveConfig, appContext) {
             ...resolveConfig.source
         },
         dev: {
-            ...resolveConfig.dev,
+            ...builderDevConfig,
             port: appContext.port
         },
         server: serverConfig,

package/dist/esm-node/bundleDocs.mjs

@@ -0,0 +1,63 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+const DEFAULT_INDEX_FILE = 'llms.txt';
+const DEFAULT_EXCLUDED_DIRS = [
+    'zh'
+];
+function bundleDocs({ source, target, indexFile = DEFAULT_INDEX_FILE, excludedDirs = DEFAULT_EXCLUDED_DIRS }) {
+    if (!node_fs.existsSync(source)) {
+        console.warn(`[bundle-docs] docs build output not found: ${source}`);
+        console.warn('[bundle-docs] skipping the bundled docs — build the docs site first if you need them');
+        return 0;
+    }
+    node_fs.rmSync(target, {
+        recursive: true,
+        force: true
+    });
+    const isBundled = (rel)=>rel === indexFile || rel.endsWith('.md') && !excludedDirs.some((dir)=>rel.startsWith(`${dir}${node_path.sep}`));
+    let count = 0;
+    for (const entry of node_fs.readdirSync(source, {
+        recursive: true,
+        withFileTypes: true
+    })){
+        if (!entry.isFile()) continue;
+        const from = node_path.join(entry.parentPath ?? entry.path, entry.name);
+        const rel = node_path.relative(source, from);
+        if (!isBundled(rel)) continue;
+        const to = node_path.join(target, rel);
+        node_fs.mkdirSync(node_path.dirname(to), {
+            recursive: true
+        });
+        node_fs.copyFileSync(from, to);
+        count++;
+    }
+    if (0 === count) throw new Error(`[bundle-docs] no files copied from ${source}`);
+    return count;
+}
+function parseArgs(argv) {
+    const options = {};
+    for(let i = 0; i < argv.length; i += 2){
+        const key = argv[i]?.replace(/^--/, '');
+        const value = argv[i + 1];
+        if (key && value) options[key] = value;
+    }
+    return options;
+}
+function runBundleDocsCli(pkgRoot) {
+    const args = parseArgs(process.argv.slice(2));
+    const source = args.source ? node_path.resolve(process.cwd(), args.source) : node_path.resolve(pkgRoot, '../../document/doc_build');
+    const target = args.target ? node_path.resolve(process.cwd(), args.target) : node_path.resolve(pkgRoot, 'docs');
+    try {
+        const count = bundleDocs({
+            source,
+            target,
+            indexFile: args.index
+        });
+        if (count > 0) console.log(`[bundle-docs] bundled ${count} doc files into docs`);
+    } catch (error) {
+        console.error(error.message);
+        process.exit(1);
+    }
+}
+export { bundleDocs, runBundleDocsCli };

package/dist/esm-node/commands/build.mjs

@@ -57,8 +57,9 @@ const build = async (api, options)=>{
     logger.info('Starting production build...');
     if (!appContext.builder) throw new Error('Expect the Builder to have been initialized, But the appContext.builder received `undefined`');
     await appContext.builder.onAfterBuild(async ()=>copyEnvFiles(appContext.appDirectory, appContext.distDirectory));
-    await appContext.builder.build({
+    const buildResult = await appContext.builder.build({
         watch: options?.watch
     });
+    if (!options?.watch) await buildResult?.close();
 };
 export { build };

package/dist/esm-node/commands/deploy.mjs

@@ -1,9 +1,11 @@
 import "node:module";
 import { getServerPlugins } from "../utils/loadPlugins.mjs";
-const deploy = async (api, options)=>{
+import { build } from "./build.mjs";
+const deploy = async (api, options = {})=>{
     const hooks = api.getHooks();
     const { metaName } = api.getAppContext();
-    await getServerPlugins(api, metaName);
+    if (options.skipBuild) await getServerPlugins(api, metaName);
+    else await build(api);
     await hooks.onBeforeDeploy.call(options);
     await hooks.deploy.call();
     await hooks.onAfterDeploy.call(options);

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

@@ -20,10 +20,6 @@ const serverCommand = (program, api)=>{
 };
 const deployCommand = (program, api)=>{
     program.command('deploy').usage('[options]').option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).option('-s --skip-build', i18n.t(localeKeys.command.shared.skipBuild)).description(i18n.t(localeKeys.command.deploy.describe)).action(async (options)=>{
-        if (!options.skipBuild) {
-            const { build } = await import("./build.mjs");
-            await build(api);
-        }
         const { deploy } = await import("./deploy.mjs");
         await deploy(api, options);
         process.exit(0);

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

@@ -1,8 +1,10 @@
 import "node:module";
+import { AGGRED_DIR } from "@modern-js/server-core";
 import { DEFAULT_ENTRY_NAME } from "@modern-js/utils";
 import { getAutoInjectEnv } from "../utils/env.mjs";
 function createDefaultConfig(appContext) {
     const dev = {
+        mockDir: `./${AGGRED_DIR.mock}`,
         cliShortcuts: {
             help: false,
             custom: (shortcuts = [])=>shortcuts.filter(({ key })=>'r' !== key && 'u' !== key && 'o' !== key)

package/dist/esm-node/index.mjs

@@ -79,7 +79,18 @@ const appTools = ()=>({
                     ].some((tag)=>getArgv().includes(tag));
                     if (isSkipBuild) return;
                 }
-                if ('dev' === command || 'start' === command || 'build' === command || 'deploy' === command) {
+                const { command: contextCommand } = api.getAppContext();
+                const shouldClean = [
+                    'dev',
+                    'start',
+                    'build',
+                    'deploy'
+                ].includes(command) || [
+                    'dev',
+                    'start',
+                    'build'
+                ].includes(contextCommand);
+                if (shouldClean) {
                     const resolvedConfig = api.getNormalizedConfig();
                     if (resolvedConfig.output.cleanDistPath) {
                         const appContext = api.getAppContext();
@@ -119,8 +130,11 @@ const appTools = ()=>({
     });
 const src = appTools;
 export { defineConfig } from "./defineConfig.mjs";
+export { build } from "./commands/build.mjs";
+export { deploy } from "./commands/deploy.mjs";
 export { dev } from "./commands/dev.mjs";
 export { serve } from "./commands/serve.mjs";
+export { closeServer } from "./utils/createServer.mjs";
 export { resolveModernRsbuildConfig } from "./rsbuild.mjs";
 export { mergeConfig } from "@modern-js/plugin/cli";
 export default src;

package/dist/esm-node/plugins/analyze/index.mjs

@@ -24,7 +24,7 @@ const analyze = ()=>({
                 const resolvedConfig = api.getNormalizedConfig();
                 const hooks = api.getHooks();
                 try {
-                    if (checkIsBuildCommands()) fs.emptydirSync(appContext.internalDirectory);
+                    if (checkIsBuildCommands(appContext.command)) fs.emptydirSync(appContext.internalDirectory);
                 } catch  {}
                 const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig.source?.entriesDir, appContext.apiDirectory);
                 const [{ getProdServerRoutes }] = await Promise.all([
@@ -118,7 +118,7 @@ const analyze = ()=>({
                     htmlTemplates
                 };
                 api.updateAppContext(appContext);
-                if (checkIsBuildCommands()) {
+                if (checkIsBuildCommands(appContext.command)) {
                     await hooks.generateEntryCode.call({
                         entrypoints
                     });

package/dist/esm-node/plugins/analyze/utils.mjs

@@ -53,7 +53,7 @@ const parseModule = async ({ source, filename })=>{
     return await parse(content);
 };
 const getServerCombinedModuleFile = (internalDirectory, entryName)=>path.join(internalDirectory, entryName, 'server-loader-combined.js');
-const checkIsBuildCommands = ()=>{
+const checkIsBuildCommands = (contextCommand)=>{
     const buildCommands = [
         'dev',
         'start',
@@ -63,7 +63,8 @@ const checkIsBuildCommands = ()=>{
         'dev-worker'
     ];
     const command = getCommand();
-    return buildCommands.includes(command);
+    if (buildCommands.includes(command)) return true;
+    return 'dev' === contextCommand || 'start' === contextCommand || 'build' === contextCommand || 'deploy' === contextCommand;
 };
 const checkIsServeCommand = ()=>{
     const command = getCommand();

package/dist/esm-node/plugins/initialize/index.mjs

@@ -26,7 +26,7 @@ const initialize = ()=>({
             api.modifyResolvedConfig(async (resolved)=>{
                 let appContext = api.getAppContext();
                 const userConfig = api.getConfig();
-                const port = await getServerPort(resolved);
+                const port = await getServerPort(resolved, appContext.command);
                 appContext = {
                     ...appContext,
                     port,
@@ -61,9 +61,10 @@ function stabilizeConfig(resolve, config, keys) {
         resolve[key] = config[key] || {};
     });
 }
-async function getServerPort(config) {
+async function getServerPort(config, contextCommand) {
     const prodPort = Number(process.env.PORT) || config.server.port || 8080;
-    if (isDev() && isDevCommand()) return getPort(Number(process.env.PORT) || prodPort);
+    const isProgrammaticDev = 'dev' === contextCommand || 'start' === contextCommand;
+    if (isDev() && (isDevCommand() || isProgrammaticDev)) return getPort(Number(process.env.PORT) || prodPort);
     return prodPort;
 }
 export default initialize;

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

@@ -18,7 +18,7 @@ const serverBuild = ()=>({
         name: '@modern-js/server-build',
         setup (api) {
             api.onAfterBuild(async ()=>{
-                const { appDirectory, distDirectory, metaName } = api.getAppContext();
+                const { appDirectory, distDirectory, metaName, moduleType } = api.getAppContext();
                 if (!checkHasCache(appDirectory) && !checkHasConfig(appDirectory, metaName)) return;
                 const modernConfig = api.getNormalizedConfig();
                 const distDir = path.resolve(distDirectory);
@@ -38,7 +38,8 @@ const serverBuild = ()=>({
                 }, {
                     sourceDirs,
                     distDir,
-                    tsconfigPath
+                    tsconfigPath,
+                    moduleType
                 });
             });
         }

package/dist/types/bundleDocs.d.ts

@@ -0,0 +1,20 @@
+export interface BundleDocsOptions {
+    /** Docs site build output (e.g. `doc_build`). */
+    source: string;
+    /** Directory to write the bundle to. */
+    target: string;
+    /** Index file to ship alongside the pages. */
+    indexFile?: string;
+    /** Top-level directories to skip. */
+    excludedDirs?: string[];
+}
+/** @returns files copied, or 0 when the source is absent */
+export declare function bundleDocs({ source, target, indexFile, excludedDirs, }: BundleDocsOptions): number;
+/**
+ * `modern-bundle-docs --source <doc_build> --target <pkg>/docs`; both default
+ * to this repo's layout.
+ *
+ * @param pkgRoot supplied by the bin shim — the compiled module cannot know
+ * its own package root portably across output formats.
+ */
+export declare function runBundleDocsCli(pkgRoot: string): void;

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

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

package/dist/types/index.d.ts

@@ -3,9 +3,12 @@ import { initAppContext } from './utils/initAppContext';
 export * from './defineConfig';
 export declare const appTools: () => CliPlugin<AppTools>;
 export { defineConfig } from './defineConfig';
+export { build } from './commands/build';
+export { deploy } from './commands/deploy';
 export { dev } from './commands/dev';
 export { serve } from './commands/serve';
-export type { DevOptions } from './utils/types';
+export { closeServer } from './utils/createServer';
+export type { BuildOptions, DeployOptions, DevOptions } from './utils/types';
 export { generateWatchFiles } from './utils/generateWatchFiles';
 export { resolveModernRsbuildConfig, type ResolveModernRsbuildConfigOptions, } from './rsbuild';
 export * from './types';

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

@@ -5,6 +5,6 @@ export declare const parseModule: ({ source, filename, }: {
     filename: string;
 }) => Promise<readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean, hasModuleSyntax: boolean]>;
 export declare const getServerCombinedModuleFile: (internalDirectory: string, entryName: string) => string;
-export declare const checkIsBuildCommands: () => boolean;
+export declare const checkIsBuildCommands: (contextCommand?: string) => boolean;
 export declare const checkIsServeCommand: () => boolean;
 export declare const isSubDirOrEqual: (parent: string, child: string) => boolean;

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

@@ -47,6 +47,12 @@ export interface DevServerUserConfig {
  * Although its name is the same as in Rsbuild, it is consumed by Modern.js.
  */
 export type DevUserConfig = Omit<BuilderDevConfig, 'setupMiddlewares'> & {
+    /**
+     * Customize the directory containing the Mock API entry file.
+     * Relative paths are resolved from the application directory.
+     * @default './config/mock'
+     */
+    mockDir?: string;
     setupMiddlewares?: SetupMiddlewares;
     /**
      * Dev server specific options.

package/docs/apis/app/commands.md

@@ -0,0 +1,241 @@
+# Commands
+
+Modern.js has some built-in commands that can help you quickly start a development server, build production environment code, and more.
+
+Through this chapter, you can learn about the built-in commands of Modern.js and how to use them.
+
+## modern dev
+
+The `modern dev` command is used to start a local development server and compile the source code in the development environment.
+
+```bash
+Usage: modern dev [options]
+
+Options:
+  -e --entry <entry>    compiler by entry
+  -c --config <config>  specify the configuration file, which can be a relative or absolute path
+  -h, --help            show command help
+  --web-only            only start web service
+  --api-only            only start API service
+```
+
+After running `modern dev`, Modern.js will watch source file changes and apply hot module replacement.
+
+```bash
+$ modern dev
+
+info    Starting dev server...
+
+  > Local:    http://localhost:8080/
+  > Network:  http://192.168.0.1:8080/
+```
+
+### Compile Partial Pages
+
+In multi-page (MPA) projects, the `--entry` option can be added to specify one or more pages to compile. In this way, only part of the code in the project will be compiled, and the dev startup speed will be faster.
+
+For example, execute `modern dev --entry`, the entry selector will be displayed in the command line interface:
+
+```text
+$ modern dev --entry
+
+? Please select the entry that needs to be built
+❯ ◯ foo
+  ◯ bar
+  ◯ baz
+```
+
+For example, if you select the `foo` entry, only the code related to the `foo` entry will be compiled, and the code of other pages will not be compiled.
+
+### Specify the page by parameter
+
+You can also specify the page name through parameters after `--entry`, and the names of multiple pages can be separated by commas.
+
+```bash
+# Compile foo page
+modern dev --entry foo
+
+# Compile foo and bar pages
+modern dev --entry foo,bar
+```
+
+## modern start
+
+`modern start` is an alias of `modern dev` command, the usage of the two are exactly the same.
+
+## modern build
+
+The `modern build` command will build production-ready artifacts in the `dist/` directory by default. You can specify the output directory by modifying the configuration [`output.distPath`](/configure/app/output/dist-path.md).
+
+```bash
+Usage: modern build [options]
+
+Options:
+  -c --config <config>  specify the configuration file, which can be a relative or absolute path
+  -h, --help            show command help
+  -w --watch            turn on watch mode, watch for changes and rebuild
+```
+
+## modern new
+
+The `modern new` command is used to enable features in an existing project.
+
+For example, add application entry, enable some optional features such as BFF, micro frontend, etc.
+
+```bash
+Usage: modern new [options]
+
+Options:
+  --config-file <configFile>  specify the configuration file, which can be a relative or absolute path
+  --lang <lang>          set the language (zh or en) for the new command.
+  -d, --debug            using debug mode to log something (default: false)
+  -c, --config <config>  set default generator config(json string)
+  --dist-tag <tag>       use specified tag version for its generator
+  --registry             set npm registry url to run npm command
+  -h, --help             show command help
+```
+
+### Add Entry
+
+In the project, execute the `new` command to add entries as follows:
+
+```text
+$ npx modern new
+? Please select the operation you want: Create Element
+? Please select the type of element to create: New "entry"
+? Please fill in the entry name: entry
+```
+
+### Enable Features
+
+In the project, execute the `new` command to enable features as follows:
+
+```text
+$ npx modern new
+? Please select the operation you want: Enable Features
+? Please select the feature name: (Use arrow keys)
+❯ Enable BFF
+  Enable SSG
+  Enable Micro Frontend
+```
+
+:::tip
+The `--config` parameter needs to use a JSON string.
+
+pnpm does not support the use of JSON strings as parameter values currently. Use `npm new` to turn on.【[Relate Issue](https://github.com/pnpm/pnpm/issues/3876)】
+:::
+
+## modern serve
+
+The `modern serve` command is used to start a Modern.js project in the production environment. It can also be used to preview the artifacts built for the production environment locally. Please note that you need to execute the [`build`](/apis/app/commands.md#modern-build) command beforehand to generate the corresponding artifacts.
+
+```bash
+Usage: modern serve [options]
+
+Options:
+  -c --config <config>  specify the configuration file, which can be a relative or absolute path
+  -h, --help            show command help
+  --api-only            only run API service
+```
+
+By default, the project will run in `localhost:8080`, you can modify the server port number with `server.port`:
+
+```js
+export default defineConfig({
+  server: {
+    port: 8081,
+  },
+});
+```
+
+## modern upgrade
+
+Execute the command `npx modern upgrade` in the project, by default, dependencies in the `package.json` are updated to the latest version.
+
+```bash
+Usage: modern upgrade [options]
+
+Options:
+  --config <config> specify the configuration file, which can be a relative or absolute path
+  --registry <registry>  specify npm registry (default: "")
+  -d,--debug             using debug mode to log something (default: false)
+  --cwd <cwd>            app directory (default: "")
+  -h, --help             show command help
+```
+
+## modern inspect
+
+The `modern inspect` command is used to view the Modern.js config, [Rsbuild config](https://v2.rsbuild.rs/config/index) and Rspack config of the project.
+
+```bash
+Usage: modern inspect [options]
+
+Options:
+  --env <env>           view the configuration in the target environment (default: "development")
+  --output <output>     Specify the path to output in the dist (default: "./")
+  --verbose             Show the full function in the result
+  -c --config <config>  specify the configuration file, which can be a relative or absolute path
+  -h, --help            show command help
+```
+
+After executing the command `npx modern inspect` in the project root directory, the following files will be generated in the `dist` directory of the project:
+
+- `modern.js.config.mjs`:The Modern.js configuration currently used.
+- `rsbuild.config.mjs`: The Rsbuild config to use at build time.
+- `rspack.config.web.mjs`: The Rspack config used by to use at build time.
+
+```bash
+➜ npx modern inspect
+
+Inspect config succeed, open following files to view the content:
+
+  - Rsbuild Config: /root/my-project/dist/rsbuild.config.mjs
+  - Rspack Config (web): /root/my-project/dist/rspack.config.web.mjs
+  - Modern.js Config: /root/my-project/dist/modern.js.config.mjs
+```
+
+### Configuration Env
+
+By default, the inspect command will output the development configs, you can use the `--env production` option to output the production configs:
+
+```bash
+modern inspect --env production
+```
+
+### Verbose content
+
+By default, the inspect command will omit the function content in the config object, you can use the `--verbose` option to output the full content of the function:
+
+```bash
+modern inspect --verbose
+```
+
+### SSR Configuration
+
+If the project has enabled SSR, an additional `rspack.config.node.mjs` file will be generated in the `dist/`, corresponding to the Rspack configuration at SSR build time.
+
+```bash
+➜ npx modern inspect
+
+Inspect config succeed, open following files to view the content:
+
+  - Rsbuild Config: /root/my-project/dist/rsbuild.config.mjs
+  - Rspack Config (web): /root/my-project/dist/rspack.config.web.mjs
+  - Rspack Config (node): /root/my-project/dist/rspack.config.node.mjs
+  - Modern.js Config: /root/my-project/dist/modern.js.config.mjs
+```
+
+## modern deploy
+
+The `modern deploy` command is used to generate artifacts required for the deployment platform.
+
+```bash
+Usage: modern deploy [options]
+
+Options:
+  -c --config <config>  Specify configuration file path, either relative or absolute
+  -s --skip-build       Skip the build stage
+  -h, --help            Display command help
+```
+
+For more details, refer to [Deploy Application](/guides/basic-features/deploy.md).

package/docs/apis/app/hooks/api/lambda.md

@@ -0,0 +1,9 @@
+# lambda/\*.ts
+
+After enabling BFF, the files under the `lambda/` directory will be registered as BFF routes according to conventions.
+
+:::note
+The files can be written in `js` or `ts` languages, but they must use `esm` syntax to export functions.
+:::
+
+For detailed information, refer to [BFF API Routes](/guides/advanced-features/bff/function.md#api-routes).

package/docs/apis/app/hooks/config/favicon.md

@@ -0,0 +1,24 @@
+# Favicon
+
+When there is a `favicon.*` file in the `config` directory at the root of the project, Modern.js will automatically set the file to the [html.favicon](/configure/app/html/favicon.md) configuration option for generating the favicon icon on the page:
+
+```
+./config
+└── favicon.ico
+```
+
+After the build is completed, you can see the following tags automatically generated in HTML:
+
+```html
+<link rel="icon" href="/favicon.ico" />
+```
+
+## Order
+
+When setting up the favicon, Modern.js looks for files in the following order:
+
+- `favicon.png`
+- `favicon.jpg`
+- `favicon.jpeg`
+- `favicon.svg`
+- `favicon.ico`

package/docs/apis/app/hooks/config/html.md

@@ -0,0 +1,5 @@
+# html/
+
+You can inject custom HTML fragments at different locations of the default internal HTML template through the `config/html` directory.
+
+For specific usage, please refer to: [Custom HTML](/guides/basic-features/html.md).

package/docs/apis/app/hooks/config/icon.md

@@ -0,0 +1,24 @@
+# Apple Touch Icon
+
+When there is an `icon.*` file in the `config` directory at the root of the project, Modern.js will automatically set the file to the [html.appIcon](/configure/app/html/app-icon.md) configuration option for generating the Apple Touch Icon icon under the iOS system.
+
+```
+./config
+└── icon.png
+```
+
+After the build is completed, you can see the following tags automatically generated in HTML:
+
+```html
+<link rel="apple-touch-icon" sizes="180x180" href="/static/image/icon.png" />
+```
+
+## Order
+
+When setting up the app icon, Modern.js looks for files in the following order:
+
+- `icon.png`
+- `icon.jpg`
+- `icon.jpeg`
+- `icon.svg`
+- `icon.ico`

package/docs/apis/app/hooks/config/mock.md

@@ -0,0 +1,6 @@
+# mock/
+
+When there is a `config/mock/index.ts` or `config/mock/index.js` file in the
+project directory, Modern.js will automatically enable the Mock service during
+development. Use [`dev.mockDir`](/configure/app/dev/mock-dir.md) to customize
+this directory.