@gravity-ui/app-builder 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.0.1 (2022-12-06)
+
+
+### Features
+
+* add client and server keys to confg ([79d968f](https://github.com/gravity-ui/app-builder/commit/79d968f275b972d7376c90dba1b6cacfe05e4310))
+* upload to s3 ([e6e5fbc](https://github.com/gravity-ui/app-builder/commit/e6e5fbc89e402ad595db8b1aee8c17f7adb41e2c))
+
+
+### chore
+
+* release 0.0.1 ([3d58428](https://github.com/gravity-ui/app-builder/commit/3d58428c4df316f098c23dbc7264219cf2e08bf7))

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 YANDEX LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @gravity-ui/app-builder · [![npm package](https://img.shields.io/npm/v/@gravity-ui/app-builder)](https://www.npmjs.com/package/@gravity-ui/app-builder) [![CI](https://img.shields.io/github/workflow/status/gravity-ui/app-builder/CI/main?label=CI&logo=github)](https://github.com/gravity-ui/app-builder/actions/workflows/ci.yml?query=branch:main)
+
+## Install
+
+```shell
+npm install --save-dev @gravity-ui/app-builder
+```
+
+## Usage

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import './common/env';
+export type { ProjectConfig } from './common/models';

package/dist/cli.js

@@ -0,0 +1,46 @@
+#!/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");
+const MIN_NODE_VERSION = '14.15.0';
+const { version } = process;
+if (!semver_1.default.satisfies(version, `>=${MIN_NODE_VERSION}`, {
+    includePrerelease: true,
+})) {
+    logger_1.default.panic((0, common_tags_1.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)(`
+            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
+    if (!(reason instanceof Error)) {
+        reason = new Error(util_1.default.format(reason));
+    }
+    logger_1.default.panic('UNHANDLED REJECTION', reason);
+});
+process.on('uncaughtException', (error) => {
+    logger_1.default.panic('UNHANDLED EXCEPTION', error);
+});
+process.on('exit', (code) => {
+    logger_1.default.message(`Exit with code: ${code}`);
+});
+(0, create_cli_1.createCli)(process.argv);

package/dist/commands/build/build-lib.d.ts

@@ -0,0 +1,2 @@
+import type { LibraryConfig } from '../../common/models';
+export default function (config: LibraryConfig): Promise<unknown>;

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

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const signal_exit_1 = __importDefault(require("signal-exit"));
+const controllable_script_1 = require("../../common/child-process/controllable-script");
+function default_1(config) {
+    return new Promise((resolve, reject) => {
+        const build = new controllable_script_1.ControllableScript(`
+        const {buildLibrary} = require(${JSON.stringify(require.resolve('../../common/library'))});
+        buildLibrary({
+            lib: ${JSON.stringify(config.lib)},
+            newJsxTransform: ${JSON.stringify(config.newJsxTransform)}
+        });
+        `, null);
+        build.start();
+        build.onExit((code) => {
+            if (code) {
+                reject(new Error('Error build library'));
+            }
+            else {
+                resolve(true);
+            }
+        });
+        process.on('SIGINT', async () => {
+            await build.stop('SIGINT');
+            process.exit(1);
+        });
+        process.on('SIGTERM', async () => {
+            await build.stop('SIGTERM');
+            process.exit(1);
+        });
+        (0, signal_exit_1.default)((_code, signal) => {
+            build.stop(signal);
+        });
+    });
+}
+exports.default = default_1;

package/dist/commands/build/build-service/client.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedServiceConfig } from '../../../common/models';
+export declare function buildClient(config: NormalizedServiceConfig): Promise<void>;

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildClient = void 0;
+const compile_1 = require("../../../common/webpack/compile");
+function buildClient(config) {
+    return (0, compile_1.webpackCompile)(config.client);
+}
+exports.buildClient = buildClient;

package/dist/commands/build/build-service/index.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedServiceConfig } from '../../../common/models';
+export default function (config: NormalizedServiceConfig): Promise<void[]>;

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

@@ -0,0 +1,46 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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');
+    const compilations = [];
+    if (shouldCompileClient) {
+        compilations.push((async () => {
+            const { buildClient } = await Promise.resolve().then(() => __importStar(require('./client')));
+            return buildClient(config);
+        })());
+    }
+    if (shouldCompileServer) {
+        compilations.push((async () => {
+            const { buildServer } = await Promise.resolve().then(() => __importStar(require('./server')));
+            return buildServer(config);
+        })());
+    }
+    // createRunFolder();
+    return Promise.all(compilations);
+}
+exports.default = default_1;

package/dist/commands/build/build-service/server.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedServiceConfig } from '../../../common/models';
+export declare function buildServer(config: NormalizedServiceConfig): Promise<void>;

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

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildServer = void 0;
+const signal_exit_1 = __importDefault(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");
+function buildServer(config) {
+    (0, utils_1.createRunFolder)();
+    return new Promise((resolve, reject) => {
+        const build = new controllable_script_1.ControllableScript(`
+        const ts = require('typescript');
+        const {Logger} = require(${JSON.stringify(require.resolve('../../../common/logger'))});
+        const {compile} = require(${JSON.stringify(require.resolve('../../../common/typescript/compile'))});
+
+        const logger = new Logger('server', ${config.verbose});
+        compile(ts, ${JSON.stringify(paths_1.default.appServer)}, {logger});
+    `, null);
+        build.start();
+        build.onExit((code) => {
+            if (code) {
+                reject(new Error('Error compile server'));
+            }
+            else {
+                resolve();
+            }
+        });
+        process.on('SIGINT', async () => {
+            await build.stop('SIGINT');
+            process.exit(1);
+        });
+        process.on('SIGTERM', async () => {
+            await build.stop('SIGTERM');
+            process.exit(1);
+        });
+        (0, signal_exit_1.default)((_code, signal) => {
+            build.stop(signal);
+        });
+    });
+}
+exports.buildServer = buildServer;

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

@@ -0,0 +1,2 @@
+import type { ProjectConfig } from '../../common/models';
+export default function (config: ProjectConfig): Promise<any>;

package/dist/commands/build/index.js

@@ -0,0 +1,33 @@
+"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 _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const models_1 = require("../../common/models");
+async function default_1(config) {
+    process.env.NODE_ENV = 'production';
+    const { default: build } = await (_a = (0, models_1.isLibraryConfig)(config) ? './build-lib' : './build-service', Promise.resolve().then(() => __importStar(require(_a))));
+    return build(config);
+}
+exports.default = default_1;

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

@@ -0,0 +1,3 @@
+import WebpackDevServer from 'webpack-dev-server';
+import type { NormalizedServiceConfig } from '../../common/models';
+export declare function watchClientCompilation(config: NormalizedServiceConfig, onCompilationEnd: () => void): Promise<WebpackDevServer>;

package/dist/commands/dev/client.js

@@ -0,0 +1,98 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchClientCompilation = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("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 paths_1 = __importDefault(require("../../common/paths"));
+const logger_1 = require("../../common/logger");
+const config_1 = require("../../common/webpack/config");
+async function watchClientCompilation(config, onCompilationEnd) {
+    const clientCompilation = await buildWebpackServer(config);
+    const { afterEmit } = (0, webpack_manifest_plugin_1.getCompilerHooks)(clientCompilation.compiler);
+    afterEmit.tap('app-builder: afterEmit', onCompilationEnd);
+    return clientCompilation;
+}
+exports.watchClientCompilation = watchClientCompilation;
+async function buildWebpackServer(config) {
+    const logger = new logger_1.Logger('webpack', config.verbose);
+    const _a = config.client.devServer || {}, { webSocketPath = path_1.default.normalize(`/${config.client.publicPathPrefix}/build/sockjs-node`) } = _a, devServer = __rest(_a, ["webSocketPath"]);
+    const normalizedConfig = Object.assign(Object.assign({}, config.client), { devServer: Object.assign(Object.assign({}, devServer), { webSocketPath }) });
+    const webpackConfig = (0, config_1.webpackConfigFactory)("development" /* WebpackMode.Dev */, normalizedConfig, { logger });
+    const options = Object.assign({ static: path_1.default.resolve(paths_1.default.appDist, 'public'), devMiddleware: {
+            publicPath: path_1.default.normalize(config.client.publicPathPrefix + '/build/'),
+            stats: 'errors-warnings',
+        }, liveReload: false, hot: true, client: {
+            webSocketURL: { pathname: webSocketPath },
+            overlay: {
+                warnings: config.verbose,
+            },
+        }, webSocketServer: {
+            options: {
+                path: webSocketPath,
+            },
+        }, host: '0.0.0.0', allowedHosts: 'all', headers: {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
+            'Access-Control-Allow-Headers': 'X-Requested-With, content-type, Authorization',
+        } }, devServer);
+    let listenOn = options.port || options.ipc;
+    if (!listenOn) {
+        listenOn = path_1.default.resolve(paths_1.default.appDist, 'run/client.sock');
+        options.ipc = listenOn;
+    }
+    if (config.client.lazyCompilation) {
+        options.proxy = Object.assign(Object.assign({}, options.proxy), { '/build/lazy': {
+                target: `http://localhost:${config.client.lazyCompilation.port}`,
+                pathRewrite: { '^/build/lazy': '' },
+            } });
+    }
+    if (config.server.port) {
+        options.proxy = Object.assign(Object.assign({}, options.proxy), { '/': {
+                target: `http://localhost:${config.server.port}`,
+                bypass: (req) => {
+                    if (req.method !== 'GET' && req.method !== 'HEAD') {
+                        return null;
+                    }
+                    const pathname = req.path.replace(/^\//, '');
+                    const filepath = path_1.default.resolve(paths_1.default.appDist, 'public', pathname);
+                    if (!fs_1.default.existsSync(filepath)) {
+                        return null;
+                    }
+                    const stat = fs_1.default.statSync(filepath);
+                    if (!stat.isFile()) {
+                        return null;
+                    }
+                    return req.path;
+                },
+            } });
+    }
+    const compiler = (0, webpack_1.default)(webpackConfig);
+    const server = new webpack_dev_server_1.default(options, compiler);
+    try {
+        await server.start();
+    }
+    catch (e) {
+        logger.logError(e);
+    }
+    if (options.ipc && typeof options.ipc === 'string') {
+        fs_1.default.chmod(options.ipc, 0o666, (e) => logger.logError('', e));
+    }
+    return server;
+}

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

@@ -0,0 +1,2 @@
+import type { NormalizedServiceConfig } from '../../common/models';
+export default function (config: NormalizedServiceConfig): Promise<void>;

package/dist/commands/dev/index.js

@@ -0,0 +1,101 @@
+"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 });
+const nodemon_1 = __importDefault(require("nodemon"));
+const path_1 = __importDefault(require("path"));
+const signal_exit_1 = __importDefault(require("signal-exit"));
+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) {
+    process.env.NODE_ENV = 'development';
+    const shouldCompileClient = (0, utils_1.shouldCompileTarget)(config.target, 'client');
+    const shouldCompileServer = (0, utils_1.shouldCompileTarget)(config.target, 'server');
+    let clientCompiled = !shouldCompileClient;
+    let serverCompiled = !shouldCompileServer;
+    let needToStartNodemon = shouldCompileServer;
+    const serverPath = path_1.default.resolve(paths_1.default.appDist, 'server');
+    const { inspect, inspectBrk } = config.server;
+    const startNodemon = () => {
+        var _a;
+        if (needToStartNodemon && serverCompiled && clientCompiled) {
+            logger_1.default.message('Starting application at', serverPath);
+            const serverWatch = (_a = config.server.watch) !== null && _a !== void 0 ? _a : [];
+            const delay = config.server.watchThrottle;
+            const nodemonInstance = (0, nodemon_1.default)({
+                ext: 'js json',
+                script: `${serverPath}/index.js`,
+                args: ['--dev', config.server.port ? `--port=${config.server.port}` : ''],
+                nodeArgs: inspect || inspectBrk
+                    ? [`--${inspect ? 'inspect' : 'inspect-brk'}=:::${inspect || inspectBrk}`]
+                    : undefined,
+                watch: [serverPath, ...serverWatch],
+                delay,
+            });
+            nodemonInstance.on('quit', () => process.exit());
+            needToStartNodemon = false;
+        }
+    };
+    let serverCompilation;
+    if (shouldCompileServer) {
+        const { watchServerCompilation } = await Promise.resolve().then(() => __importStar(require('./server')));
+        serverCompilation = watchServerCompilation(config);
+        serverCompilation.onMessage((msg) => {
+            if (msg.type === 'Emitted') {
+                serverCompiled = true;
+                startNodemon();
+            }
+        });
+    }
+    let clientCompilation;
+    if (shouldCompileClient) {
+        const { watchClientCompilation } = await Promise.resolve().then(() => __importStar(require('./client')));
+        clientCompilation = await watchClientCompilation(config, () => {
+            logger_1.default.success('Manifest was compiled successfully');
+            clientCompiled = true;
+            startNodemon();
+        });
+    }
+    process.on('SIGINT', async () => {
+        logger_1.default.success('\nCleaning up...');
+        await (serverCompilation === null || serverCompilation === void 0 ? void 0 : serverCompilation.stop('SIGINT'));
+        await (clientCompilation === null || clientCompilation === void 0 ? void 0 : clientCompilation.stop());
+        process.exit(1);
+    });
+    process.on('SIGTERM', async () => {
+        logger_1.default.success('\nCleaning up...');
+        await (serverCompilation === null || serverCompilation === void 0 ? void 0 : serverCompilation.stop('SIGTERM'));
+        await (clientCompilation === null || clientCompilation === void 0 ? void 0 : clientCompilation.stop());
+        process.exit(1);
+    });
+    (0, signal_exit_1.default)((_code, signal) => {
+        serverCompilation === null || serverCompilation === void 0 ? void 0 : serverCompilation.stop(signal);
+        clientCompilation === null || clientCompilation === void 0 ? void 0 : clientCompilation.stop();
+    });
+}
+exports.default = default_1;

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

@@ -0,0 +1,3 @@
+import { ControllableScript } from '../../common/child-process/controllable-script';
+import type { NormalizedServiceConfig } from '../../common/models';
+export declare function watchServerCompilation(config: NormalizedServiceConfig): ControllableScript;

package/dist/commands/dev/server.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchServerCompilation = void 0;
+const path_1 = __importDefault(require("path"));
+const rimraf_1 = __importDefault(require("rimraf"));
+const controllable_script_1 = require("../../common/child-process/controllable-script");
+const utils_1 = require("../../common/utils");
+const paths_1 = __importDefault(require("../../common/paths"));
+function watchServerCompilation(config) {
+    const serverPath = path_1.default.resolve(paths_1.default.appDist, 'server');
+    rimraf_1.default.sync(serverPath);
+    rimraf_1.default.sync(paths_1.default.appRun);
+    (0, utils_1.createRunFolder)();
+    const build = new controllable_script_1.ControllableScript(`
+        const ts = require('typescript');
+        const {Logger} = require(${JSON.stringify(require.resolve('../../common/logger'))});
+        const {watch} = require(${JSON.stringify(require.resolve('../../common/typescript/watch'))});
+
+        const logger = new Logger('server', ${config.verbose});
+        watch(
+            ts,
+            ${JSON.stringify(paths_1.default.appServer)},
+            {
+                logger,
+                onAfterFilesEmitted: () => {
+                    process.send({type: 'Emitted'});
+                },
+                enableSourceMap: ${config.server.inspect || config.server.inspectBrk ? 'true' : 'false'}
+            }
+        );
+        `, null);
+    build.start();
+    return build;
+}
+exports.watchServerCompilation = watchServerCompilation;

package/dist/common/babel/index.d.ts

@@ -0,0 +1,15 @@
+export declare function babelPreset(config: {
+    newJsxTransform?: boolean;
+}): (string | {
+    env: {
+        modules: boolean;
+        bugfixes: boolean;
+    };
+    runtime: {
+        version: string;
+    };
+    typescript: boolean;
+    react: {
+        runtime: string;
+    };
+})[];

package/dist/common/babel/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.babelPreset = void 0;
+function babelPreset(config) {
+    return [
+        require.resolve('./ui-preset'),
+        {
+            env: { modules: false, bugfixes: true },
+            runtime: { version: '^7.13.10' },
+            typescript: true,
+            react: {
+                runtime: config.newJsxTransform ? 'automatic' : 'classic',
+            },
+        },
+    ];
+}
+exports.babelPreset = babelPreset;

package/dist/common/babel/ui-preset.d.ts

@@ -0,0 +1 @@
+declare function getOption<T>(value: T, defaultValue: T): T;

package/dist/common/babel/ui-preset.js

@@ -0,0 +1,71 @@
+"use strict";
+function getOption(value, defaultValue) {
+    if (typeof value === 'undefined') {
+        return defaultValue;
+    }
+    return value;
+}
+module.exports = function (_context, options = {}) {
+    const env = process.env.BABEL_ENV || process.env.NODE_ENV || 'development';
+    const isEnvDevelopment = env === 'development';
+    const isEnvProduction = env === 'production';
+    const isEnvTest = env === 'test';
+    const envOptions = getOption(options.env, {});
+    const runtimeOptions = getOption(options.runtime, {});
+    const isTypeScriptEnabled = getOption(options.typescript, false);
+    const reactOptions = getOption(options.react, {});
+    const presets = [
+        // Latest stable ECMAScript features
+        (isEnvDevelopment || isEnvProduction) && [require.resolve('@babel/preset-env'), envOptions],
+        // ES features necessary for current Node version
+        isEnvTest && [
+            require.resolve('@babel/preset-env'),
+            Object.assign({}, envOptions, {
+                targets: {
+                    node: 'current',
+                },
+            }),
+        ],
+        // JSX
+        [
+            require.resolve('@babel/preset-react'),
+            Object.assign({}, reactOptions, {
+                development: isEnvDevelopment || isEnvTest,
+                useBuiltIns: true,
+            }),
+        ],
+        isTypeScriptEnabled && [
+            require.resolve('@babel/preset-typescript'),
+            {
+                allowDeclareFields: true,
+                optimizeConstEnums: true,
+            },
+        ],
+    ].filter(Boolean);
+    const plugins = [
+        isTypeScriptEnabled && [
+            require.resolve('@babel/plugin-proposal-decorators'),
+            {
+                // @decorator
+                // export class Foo {}
+                decoratorsBeforeExport: true,
+            },
+        ],
+        // Polyfills the runtime needed for async/await and generators
+        [require.resolve('@babel/plugin-transform-runtime'), runtimeOptions],
+        isEnvProduction && [
+            require.resolve('babel-plugin-transform-react-remove-prop-types'),
+            {
+                removeImport: true,
+            },
+        ],
+    ].filter(Boolean);
+    return {
+        assumptions: {
+            setPublicClassFields: true,
+            privateFieldsAsProperties: true,
+        },
+        presets,
+        plugins,
+    };
+};