@gravity-ui/app-builder 0.29.3-beta.0 → 0.30.0

package/README.md

@@ -330,3 +330,141 @@ worker.onmessage = ({data: {result}}) => {
 
 worker.postMessage({a: 1, b: 2});
 ```
+
+##### Module Federation
+
+Module Federation is a Webpack 5 feature that enables micro-frontend architecture, where JavaScript applications can dynamically load code from each other at runtime.
+
+`app-builder` uses `@module-federation/enhanced` for advanced Module Federation support.
+
+- `moduleFederation` (`object`) — Module Federation configuration
+  - `name` (`string`) — unique name of the application in the Module Federation ecosystem. Required parameter.
+  - `version` (`string`) — application version. When specified, the entry file will be named `entry-{version}.js` instead of `entry.js`.
+  - `publicPath` (`string`) — base URL for loading resources of this micro-frontend. Required parameter.
+  - `remotes` (`string[]`) — list of remote application names that this application can load. Simplified alternative to `originalRemotes`.
+  - `originalRemotes` (`RemotesObject`) — full configuration of remote applications in Module Federation Plugin format.
+  - `remotesRuntimeVersioning` (`boolean`) — enables runtime versioning for remote applications.
+  - `isolateStyles` (`object`) — CSS style isolation settings to prevent conflicts between micro-frontends.
+    - `getPrefix` (`(entryName: string) => string`) — function to generate CSS class prefix.
+    - `prefixSelector` (`(prefix: string, selector: string, prefixedSelector: string, filePath: string) => string`) — function to add prefix to CSS selectors.
+  - Also supports all standard options from [@module-federation/enhanced](https://module-federation.io/), except `name` and `remotes`, such as:
+    - `filename` — entry file name (default `remoteEntry.js`)
+    - `exposes` — modules that this application exports
+    - `shared` — shared dependencies between applications
+    - `runtimePlugins` — plugins for Module Federation runtime
+
+**Host Application Configuration Example:**
+
+Host applications consume remote modules from other micro-frontends:
+
+```ts
+export default defineConfig({
+  client: {
+    moduleFederation: {
+      name: 'shell',
+      publicPath: 'https://cdn.example.com/my-app/',
+      // Simple remotes configuration
+      remotes: ['header', 'footer', 'sidebar'],
+      shared: {
+        react: {singleton: true, requiredVersion: '^18.0.0'},
+        'react-dom': {singleton: true, requiredVersion: '^18.0.0'},
+        lodash: {singleton: true},
+      },
+    },
+  },
+});
+```
+
+**Advanced Host Configuration:**
+
+```ts
+export default defineConfig({
+  client: {
+    moduleFederation: {
+      name: 'main-shell',
+      version: '2.1.0',
+      publicPath: 'https://cdn.example.com/my-app/',
+      // Detailed remotes configuration
+      originalRemotes: {
+        header: 'header@https://cdn.example.com/header/remoteEntry.js',
+        footer: 'footer@https://cdn.example.com/footer/remoteEntry.js',
+        userProfile: 'userProfile@https://cdn.example.com/user-profile/remoteEntry.js',
+      },
+      remotesRuntimeVersioning: true,
+      isolateStyles: {
+        getPrefix: (entryName) => `.app-${entryName}`,
+        prefixSelector: (prefix, selector, prefixedSelector, filePath) => {
+          if (
+            [prefix, ':root', 'html', 'body', '.g-root', '.remote-app'].some((item) =>
+              selector.startsWith(item),
+            ) ||
+            filePath.includes('@gravity-ui/chartkit')
+          ) {
+            return selector;
+          }
+          return prefixedSelector;
+        },
+      },
+      shared: {
+        react: {singleton: true, requiredVersion: '^18.0.0'},
+        'react-dom': {singleton: true, requiredVersion: '^18.0.0'},
+        lodash: {singleton: true},
+      },
+    },
+  },
+});
+```
+
+**Remote Application Configuration Example:**
+
+Remote applications expose their modules for consumption by host applications:
+
+```ts
+export default defineConfig({
+  client: {
+    moduleFederation: {
+      name: 'header',
+      publicPath: 'https://cdn.example.com/my-app/',
+      // Expose modules for other applications
+      exposes: {
+        './Header': './src/components/Header',
+        './Navigation': './src/components/Navigation',
+        './UserMenu': './src/components/UserMenu',
+      },
+      shared: {
+        react: {singleton: true, requiredVersion: '^18.0.0'},
+        'react-dom': {singleton: true, requiredVersion: '^18.0.0'},
+        lodash: {singleton: true},
+      },
+    },
+  },
+});
+```
+
+**Bidirectional Configuration Example:**
+
+Applications can be both host and remote simultaneously:
+
+```ts
+export default defineConfig({
+  client: {
+    moduleFederation: {
+      name: 'dashboard',
+      version: '1.5.0',
+      publicPath: 'https://cdn.example.com/my-app/',
+      // Consume remote modules
+      remotes: ['charts', 'notifications'],
+      // Expose own modules
+      exposes: {
+        './DashboardLayout': './src/layouts/DashboardLayout',
+        './DataTable': './src/components/DataTable',
+      },
+      shared: {
+        react: {singleton: true, requiredVersion: '^18.0.0'},
+        'react-dom': {singleton: true, requiredVersion: '^18.0.0'},
+        lodash: {singleton: true},
+      },
+    },
+  },
+});
+```

package/dist/cli.js

@@ -1,44 +1,39 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const semver_1 = __importDefault(require("semver"));
-const util_1 = __importDefault(require("util"));
-const common_tags_1 = require("common-tags");
-require("./common/env");
-const logger_1 = __importDefault(require("./common/logger"));
-const create_cli_1 = require("./create-cli");
+import semver from 'semver';
+import util from 'util';
+import { stripIndent } from 'common-tags';
+import './common/env';
+import logger from './common/logger';
+import { createCli } from './create-cli';
 const MIN_NODE_VERSION = '18.0.0';
 const { version } = process;
-if (!semver_1.default.satisfies(version, `>=${MIN_NODE_VERSION}`, {
+if (!semver.satisfies(version, `>=${MIN_NODE_VERSION}`, {
     includePrerelease: true,
 })) {
-    logger_1.default.panic((0, common_tags_1.stripIndent)(`
+    logger.panic(stripIndent `
             App-builder requires Node.js ${MIN_NODE_VERSION} or higher (you have ${version}).
             Upgrade Node to the latest stable release.
-        `));
+        `);
 }
-if (semver_1.default.prerelease(version)) {
-    logger_1.default.warning((0, common_tags_1.stripIndent)(`
+if (semver.prerelease(version)) {
+    logger.warning(stripIndent `
             You are currently using a prerelease version of Node (${version}), which is not supported.
             You can use this for testing, but we do not recommend it in production.
             Before reporting any bugs, please test with a supported version of Node (>=${MIN_NODE_VERSION}).
-        `));
+        `);
 }
 process.on('unhandledRejection', (reason) => {
     // This will exit the process in newer Node anyway so lets be consistent
     // across versions and crash
     // reason can be anything, it can be a message, an object, ANYTHING!
     // we convert it to an error object
-    const error = reason instanceof Error ? reason : new Error(util_1.default.format(reason));
-    logger_1.default.panic('UNHANDLED REJECTION', error);
+    const error = reason instanceof Error ? reason : new Error(util.format(reason));
+    logger.panic('UNHANDLED REJECTION', error);
 });
 process.on('uncaughtException', (error) => {
-    logger_1.default.panic('UNHANDLED EXCEPTION', error);
+    logger.panic('UNHANDLED EXCEPTION', error);
 });
 process.on('exit', (code) => {
-    logger_1.default.message(`Exit with code: ${code}`);
+    logger.message(`Exit with code: ${code}`);
 });
-(0, create_cli_1.createCli)(process.argv);
+createCli(process.argv);

package/dist/commands/build/build-lib.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const signal_exit_1 = require("signal-exit");
-const controllable_script_1 = require("../../common/child-process/controllable-script");
-function default_1(config) {
+import { onExit } from 'signal-exit';
+import { ControllableScript } from '../../common/child-process/controllable-script';
+export default function (config) {
     return new Promise((resolve, reject) => {
-        const build = new controllable_script_1.ControllableScript(`
+        const build = new ControllableScript(`
         const {buildLibrary} = require(${JSON.stringify(require.resolve('../../common/library'))});
         buildLibrary({lib: ${JSON.stringify(config.lib)}});
             `, null);
@@ -26,7 +23,7 @@ function default_1(config) {
                 await build.stop('SIGTERM');
                 process.exit(1);
             });
-            (0, signal_exit_1.onExit)((_code, signal) => {
+            onExit((_code, signal) => {
                 build.stop(signal);
             });
         }, (error) => {

package/dist/commands/build/build-service/client.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildClient = buildClient;
-const compile_1 = require("../../../common/webpack/compile");
-function buildClient(config) {
-    return (0, compile_1.clientCompile)(config.client, config.configPath);
+import { clientCompile } from '../../../common/webpack/compile';
+export function buildClient(config) {
+    return clientCompile(config.client, config.configPath);
 }

package/dist/commands/build/build-service/index.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const utils_1 = require("../../../common/utils");
-function default_1(config) {
-    const shouldCompileClient = (0, utils_1.shouldCompileTarget)(config.target, 'client');
-    const shouldCompileServer = (0, utils_1.shouldCompileTarget)(config.target, 'server');
+import { shouldCompileTarget } from '../../../common/utils';
+export default function (config) {
+    const shouldCompileClient = shouldCompileTarget(config.target, 'client');
+    const shouldCompileServer = shouldCompileTarget(config.target, 'server');
     const compilations = [];
     if (shouldCompileClient) {
         compilations.push((async () => {

package/dist/commands/build/build-service/server.js

@@ -1,13 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildServer = buildServer;
-const signal_exit_1 = require("signal-exit");
-const controllable_script_1 = require("../../../common/child-process/controllable-script");
-const paths_1 = __importDefault(require("../../../common/paths"));
-const utils_1 = require("../../../common/utils");
+import { onExit } from 'signal-exit';
+import { ControllableScript } from '../../../common/child-process/controllable-script';
+import paths from '../../../common/paths';
+import { createRunFolder } from '../../../common/utils';
 function createSWCBuildScript(config) {
     return `
 const {Logger} = require(${JSON.stringify(require.resolve('../../../common/logger'))});
@@ -16,8 +10,8 @@ const {compile} = require(${JSON.stringify(require.resolve('../../../common/swc/
 const logger = new Logger('server', ${config.verbose});
 compile({
     logger,
-    outputPath: ${JSON.stringify(paths_1.default.appDist)},
-    projectPath: ${JSON.stringify(paths_1.default.appServer)},
+    outputPath: ${JSON.stringify(paths.appDist)},
+    projectPath: ${JSON.stringify(paths.appServer)},
 });`;
 }
 function createTypescriptBuildScript(config) {
@@ -35,12 +29,12 @@ const {Logger} = require(${JSON.stringify(require.resolve('../../../common/logge
 const {compile} = require(${JSON.stringify(require.resolve('../../../common/typescript/compile'))});
 
 const logger = new Logger('server', ${config.verbose});
-compile(ts, {logger, projectPath: ${JSON.stringify(paths_1.default.appServer)}});`;
+compile(ts, {logger, projectPath: ${JSON.stringify(paths.appServer)}});`;
 }
-function buildServer(config) {
-    (0, utils_1.createRunFolder)();
+export function buildServer(config) {
+    createRunFolder(config);
     return new Promise((resolve, reject) => {
-        const build = new controllable_script_1.ControllableScript(config.server.compiler === 'swc'
+        const build = new ControllableScript(config.server.compiler === 'swc'
             ? createSWCBuildScript(config)
             : createTypescriptBuildScript(config), null);
         build.start().then(() => {
@@ -60,7 +54,7 @@ function buildServer(config) {
                 await build.stop('SIGTERM');
                 process.exit(1);
             });
-            (0, signal_exit_1.onExit)((_code, signal) => {
+            onExit((_code, signal) => {
                 build.stop(signal);
             });
         }, (error) => {

package/dist/commands/build/index.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const models_1 = require("../../common/models");
-async function default_1(config) {
+import { isLibraryConfig } from '../../common/models';
+export default async function (config) {
     process.env.NODE_ENV = 'production';
     // eslint-disable-next-line security/detect-non-literal-require
-    const { default: build } = require((0, models_1.isLibraryConfig)(config) ? './build-lib' : './build-service');
+    const { default: build } = require(isLibraryConfig(config) ? './build-lib' : './build-service');
     return build(config);
 }

package/dist/commands/dev/client.js

@@ -1,46 +1,17 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.watchClientCompilation = watchClientCompilation;
-const path = __importStar(require("node:path"));
-const fs = __importStar(require("node:fs"));
-const webpack_1 = __importDefault(require("webpack"));
-const webpack_dev_server_1 = __importDefault(require("webpack-dev-server"));
-const webpack_manifest_plugin_1 = require("webpack-manifest-plugin");
-const webpack_assets_manifest_1 = __importDefault(require("webpack-assets-manifest"));
-const utils_1 = require("../../common/utils");
-const rspack_manifest_plugin_1 = require("rspack-manifest-plugin");
-const core_1 = require("@rspack/core");
-const dev_server_1 = require("@rspack/dev-server");
-const paths_1 = __importDefault(require("../../common/paths"));
-const logger_1 = require("../../common/logger");
-const config_1 = require("../../common/webpack/config");
-async function watchClientCompilation(config, onManifestReady) {
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import webpack from 'webpack';
+import WebpackDevServer from 'webpack-dev-server';
+import { getCompilerHooks } from 'webpack-manifest-plugin';
+import WebpackAssetsManifest from 'webpack-assets-manifest';
+import { deferredPromise, getAppRunPath } from '../../common/utils';
+import { getCompilerHooks as getRspackCompilerHooks } from 'rspack-manifest-plugin';
+import { rspack, } from '@rspack/core';
+import { RspackDevServer } from '@rspack/dev-server';
+import paths from '../../common/paths';
+import { Logger } from '../../common/logger';
+import { rspackConfigFactory, webpackConfigFactory } from '../../common/webpack/config';
+export async function watchClientCompilation(config, onManifestReady) {
     const clientCompilation = await buildDevServer(config);
     const compiler = clientCompilation.compiler;
     subscribeToManifestReadyEvent(compiler, onManifestReady);
@@ -48,7 +19,7 @@ async function watchClientCompilation(config, onManifestReady) {
 }
 async function buildDevServer(config) {
     const bundler = config.client.bundler;
-    const logger = new logger_1.Logger('client', config.verbose);
+    const logger = new Logger('client', config.verbose);
     const { publicPath } = config.client;
     const { webSocketPath = path.normalize(`/${publicPath}/sockjs-node`), writeToDisk, ...devServer } = config.client.devServer || {};
     const normalizedConfig = { ...config.client, devServer: { ...devServer, webSocketPath } };
@@ -57,7 +28,7 @@ async function buildDevServer(config) {
     let rspackConfigs = [];
     if (bundler === 'webpack') {
         webpackConfigs = [
-            await (0, config_1.webpackConfigFactory)({
+            await webpackConfigFactory({
                 webpackMode: "development" /* WebpackMode.Dev */,
                 config: normalizedConfig,
                 configPath: config.configPath,
@@ -65,8 +36,8 @@ async function buildDevServer(config) {
             }),
         ];
         if (isSsr) {
-            const ssrLogger = new logger_1.Logger('client(SSR)', config.verbose);
-            webpackConfigs.push(await (0, config_1.webpackConfigFactory)({
+            const ssrLogger = new Logger('client(SSR)', config.verbose);
+            webpackConfigs.push(await webpackConfigFactory({
                 webpackMode: "development" /* WebpackMode.Dev */,
                 config: normalizedConfig,
                 configPath: config.configPath,
@@ -77,7 +48,7 @@ async function buildDevServer(config) {
     }
     else {
         rspackConfigs = [
-            await (0, config_1.rspackConfigFactory)({
+            await rspackConfigFactory({
                 webpackMode: "development" /* WebpackMode.Dev */,
                 config: normalizedConfig,
                 configPath: config.configPath,
@@ -85,8 +56,8 @@ async function buildDevServer(config) {
             }),
         ];
         if (isSsr) {
-            const ssrLogger = new logger_1.Logger('client(SSR)', config.verbose);
-            rspackConfigs.push(await (0, config_1.rspackConfigFactory)({
+            const ssrLogger = new Logger('client(SSR)', config.verbose);
+            rspackConfigs.push(await rspackConfigFactory({
                 webpackMode: "development" /* WebpackMode.Dev */,
                 config: normalizedConfig,
                 configPath: config.configPath,
@@ -98,14 +69,14 @@ async function buildDevServer(config) {
     // Rspack multicompiler dont work with lazy compilation.
     // Pass a single config to avoid multicompiler when SSR disabled.
     const compiler = bundler === 'rspack'
-        ? (0, core_1.rspack)(isSsr ? rspackConfigs : rspackConfigs[0])
-        : (0, webpack_1.default)(webpackConfigs);
-    const staticFolder = path.resolve(paths_1.default.appDist, 'public');
+        ? rspack(isSsr ? rspackConfigs : rspackConfigs[0])
+        : webpack(webpackConfigs);
+    const staticFolder = path.resolve(paths.appDist, 'public');
     const options = {
         static: staticFolder,
         setupMiddlewares(middlewares) {
             if (config.client.lazyCompilation && bundler === 'rspack') {
-                const lazyCompilationMiddleware = core_1.rspack.experiments.lazyCompilationMiddleware(compiler);
+                const lazyCompilationMiddleware = rspack.experiments.lazyCompilationMiddleware(compiler, rspackConfigs[0]?.experiments?.lazyCompilation);
                 return [lazyCompilationMiddleware, ...middlewares];
             }
             return middlewares;
@@ -117,7 +88,7 @@ async function buildDevServer(config) {
                 if (writeToDisk === true) {
                     return true;
                 }
-                if (isSsr && target.startsWith(paths_1.default.appSsrBuild)) {
+                if (isSsr && target.startsWith(paths.appSsrBuild)) {
                     return true;
                 }
                 if (typeof writeToDisk === 'function') {
@@ -152,7 +123,7 @@ async function buildDevServer(config) {
     };
     const listenOn = options.port || options.ipc;
     if (!listenOn) {
-        options.ipc = path.resolve(paths_1.default.appDist, 'run/client.sock');
+        options.ipc = path.resolve(getAppRunPath(config), 'client.sock');
     }
     const proxy = options.proxy || [];
     if (config.client.lazyCompilation && bundler !== 'rspack') {
@@ -184,10 +155,10 @@ async function buildDevServer(config) {
     options.proxy = proxy;
     let server;
     if (bundler === 'rspack') {
-        server = new dev_server_1.RspackDevServer(options, compiler);
+        server = new RspackDevServer(options, compiler);
     }
     else {
-        server = new webpack_dev_server_1.default(options, compiler);
+        server = new WebpackDevServer(options, compiler);
     }
     try {
         await server.start();
@@ -214,21 +185,21 @@ function subscribeToManifestReadyEvent(compiler, onManifestReady) {
             throw new Error('Something goes wrong!');
         }
         if (!isRspackCompiler(currentCompiler)) {
-            const assetsManifestPlugin = config.plugins.find((plugin) => plugin instanceof webpack_assets_manifest_1.default);
+            const assetsManifestPlugin = config.plugins.find((plugin) => plugin instanceof WebpackAssetsManifest);
             if (assetsManifestPlugin) {
-                const assetsManifestReady = (0, utils_1.deferredPromise)();
+                const assetsManifestReady = deferredPromise();
                 promises.push(assetsManifestReady.promise);
                 assetsManifestPlugin.hooks.done.tap('app-builder', assetsManifestReady.resolve);
             }
         }
-        const manifestReady = (0, utils_1.deferredPromise)();
+        const manifestReady = deferredPromise();
         promises.push(manifestReady.promise);
         if (isRspackCompiler(currentCompiler)) {
-            const { afterEmit } = (0, rspack_manifest_plugin_1.getCompilerHooks)(currentCompiler);
+            const { afterEmit } = getRspackCompilerHooks(currentCompiler);
             afterEmit.tap('app-builder', manifestReady.resolve);
         }
         else {
-            const { afterEmit } = (0, webpack_manifest_plugin_1.getCompilerHooks)(currentCompiler);
+            const { afterEmit } = getCompilerHooks(currentCompiler);
             afterEmit.tap('app-builder', manifestReady.resolve);
         }
     }

package/dist/commands/dev/index.js

@@ -1,61 +1,40 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const path = __importStar(require("node:path"));
-const nodemon_1 = __importDefault(require("nodemon"));
-const signal_exit_1 = require("signal-exit");
-const rimraf_1 = require("rimraf");
-const utils_1 = require("../../common/utils");
-const logger_1 = __importDefault(require("../../common/logger"));
-const paths_1 = __importDefault(require("../../common/paths"));
-async function default_1(config) {
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import nodemon from 'nodemon';
+import { onExit } from 'signal-exit';
+import { rimraf } from 'rimraf';
+import { getAppRunPath, shouldCompileTarget } from '../../common/utils';
+import logger from '../../common/logger';
+import paths from '../../common/paths';
+export default async function (config) {
     process.env.NODE_ENV = 'development';
-    const shouldCompileClient = (0, utils_1.shouldCompileTarget)(config.target, 'client');
-    const shouldCompileServer = (0, utils_1.shouldCompileTarget)(config.target, 'server');
+    const shouldCompileClient = shouldCompileTarget(config.target, 'client');
+    const shouldCompileServer = shouldCompileTarget(config.target, 'server');
+    const appRunPath = getAppRunPath(config);
     if (shouldCompileClient && shouldCompileServer) {
-        rimraf_1.rimraf.sync(paths_1.default.appRun);
+        try {
+            fs.accessSync(appRunPath, fs.constants.W_OK | fs.constants.X_OK); // eslint-disable-line no-bitwise
+            rimraf.sync(appRunPath);
+        }
+        catch (error) {
+            logger.warning(`Failed to remove appRun path [${appRunPath}]: ${error}`);
+        }
     }
     let clientCompiled = !shouldCompileClient;
     let serverCompiled = !shouldCompileServer;
     let needToStartNodemon = shouldCompileServer;
-    const serverPath = path.resolve(paths_1.default.appDist, 'server');
+    const serverPath = path.resolve(paths.appDist, 'server');
     const { inspect, inspectBrk } = config.server;
     const startNodemon = () => {
         if (needToStartNodemon && serverCompiled && clientCompiled) {
-            logger_1.default.message('Starting application at', serverPath);
+            logger.message('Starting application at', serverPath);
             const nodeArgs = ['--enable-source-maps'];
             if (inspect || inspectBrk) {
                 nodeArgs.push(`--${inspect ? 'inspect' : 'inspect-brk'}=:::${inspect || inspectBrk}`);
             }
             const serverWatch = config.server.watch ?? [];
             const delay = config.server.watchThrottle;
-            const nodemonInstance = (0, nodemon_1.default)({
+            const nodemonInstance = nodemon({
                 ext: 'js json',
                 script: `${serverPath}/index.js`,
                 args: ['--dev', config.server.port ? `--port=${config.server.port}` : ''],
@@ -85,24 +64,24 @@ async function default_1(config) {
     if (shouldCompileClient) {
         const { watchClientCompilation } = await import('./client.js');
         clientCompilation = await watchClientCompilation(config, () => {
-            logger_1.default.success('Manifest was compiled successfully');
+            logger.success('Manifest was compiled successfully');
             clientCompiled = true;
             startNodemon();
         });
     }
     process.on('SIGINT', async () => {
-        logger_1.default.success('\nCleaning up...');
+        logger.success('\nCleaning up...');
         await serverCompilation?.stop('SIGINT');
         await clientCompilation?.stop();
         process.exit(1);
     });
     process.on('SIGTERM', async () => {
-        logger_1.default.success('\nCleaning up...');
+        logger.success('\nCleaning up...');
         await serverCompilation?.stop('SIGTERM');
         await clientCompilation?.stop();
         process.exit(1);
     });
-    (0, signal_exit_1.onExit)((_code, signal) => {
+    onExit((_code, signal) => {
         serverCompilation?.stop(signal);
         clientCompilation?.stop();
     });