@gravity-ui/app-builder 0.0.1

package/dist/common/webpack/progress-plugin.js

@@ -0,0 +1,64 @@
+"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 });
+exports.ProgressPlugin = void 0;
+const webpack = __importStar(require("webpack"));
+const pretty_time_1 = require("../logger/pretty-time");
+class ProgressPlugin extends webpack.ProgressPlugin {
+    constructor({ logger }) {
+        super();
+        this._state = {};
+        this.handler = (percent, message, ...details) => {
+            const progress = Math.floor(percent * 100);
+            this._logger.status(`${this._logger.colors.green(`${progress}%`)} - ${this._logger.colors.yellow(message)}${details.length > 0 ? `: ${this._logger.colors.dim(...details)}` : ''}`);
+        };
+        this._logger = logger;
+    }
+    apply(compiler) {
+        super.apply(compiler);
+        hook(compiler, 'compile', () => {
+            this._logger.message('Start compilation');
+            this._logger.message(`Webpack v${compiler.webpack.version}`);
+            this._state.start = process.hrtime.bigint();
+        });
+        hook(compiler, 'invalid', (fileName, changeTime) => {
+            this._logger.verbose(`Invalidate file: ${fileName} at ${changeTime}`);
+        });
+        hook(compiler, 'done', (stats) => {
+            const time = this._state.start ? ' in ' + (0, pretty_time_1.elapsedTime)(this._state.start) : '';
+            const hasErrors = stats.hasErrors();
+            if (hasErrors) {
+                this._logger.error('Compiled with some errors' + time);
+            }
+            else {
+                this._logger.success('Compiled successfully' + time);
+            }
+        });
+    }
+}
+exports.ProgressPlugin = ProgressPlugin;
+function hook(compiler, hookName, callback) {
+    compiler.hooks[hookName].tap(`app-builder: ${hookName}`, callback);
+}

package/dist/common/webpack/public-path.d.ts

@@ -0,0 +1 @@
+declare let __webpack_public_path__: string;

package/dist/common/webpack/public-path.js

@@ -0,0 +1,2 @@
+"use strict";
+__webpack_public_path__ = window.__PUBLIC_PATH__;

package/dist/common/webpack/storybook.d.ts

@@ -0,0 +1,13 @@
+import { WebpackMode } from './config';
+import type { ClientConfig } from '../models';
+import type * as Webpack from 'webpack';
+type Mode = `${WebpackMode}`;
+export declare function configureServiceWebpackConfig(mode: Mode, storybookConfig: Webpack.Configuration): Promise<Webpack.Configuration>;
+export declare function configureWebpackConfigForStorybook(mode: Mode, userConfig?: ClientConfig): Promise<{
+    module: {
+        rules: Webpack.RuleSetRule[];
+    };
+    resolve: Webpack.ResolveOptions;
+    plugins: (((this: Webpack.Compiler, compiler: Webpack.Compiler) => void) | Webpack.WebpackPluginInstance)[];
+}>;
+export {};

package/dist/common/webpack/storybook.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureWebpackConfigForStorybook = exports.configureServiceWebpackConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const react_refresh_webpack_plugin_1 = __importDefault(require("@pmmmwh/react-refresh-webpack-plugin"));
+const mini_css_extract_plugin_1 = __importDefault(require("mini-css-extract-plugin"));
+const css_minimizer_webpack_plugin_1 = __importDefault(require("css-minimizer-webpack-plugin"));
+const config_1 = require("./config");
+const config_2 = require("../config");
+const models_1 = require("../models");
+async function configureServiceWebpackConfig(mode, storybookConfig) {
+    var _a, _b, _c, _d, _e;
+    const serviceConfig = await (0, config_2.getProjectConfig)(mode === "production" /* WebpackMode.Prod */ ? 'build' : 'dev', {});
+    if (!(0, models_1.isServiceConfig)(serviceConfig)) {
+        throw new Error('configureServiceWebpackConfig can be used only for services, but got the library config');
+    }
+    const webpackConfig = await configureWebpackConfigForStorybook(mode, serviceConfig.client);
+    return Object.assign(Object.assign({}, storybookConfig), { plugins: [...((_a = storybookConfig.plugins) !== null && _a !== void 0 ? _a : []), ...webpackConfig.plugins], resolve: Object.assign(Object.assign(Object.assign({}, storybookConfig.resolve), webpackConfig.resolve), { alias: Object.assign(Object.assign({}, (_b = storybookConfig.resolve) === null || _b === void 0 ? void 0 : _b.alias), webpackConfig.resolve.alias), modules: [
+                ...(((_c = storybookConfig.resolve) === null || _c === void 0 ? void 0 : _c.modules) || []),
+                ...(webpackConfig.resolve.modules || []),
+            ], extensions: [
+                ...((_e = (_d = storybookConfig.resolve) === null || _d === void 0 ? void 0 : _d.extensions) !== null && _e !== void 0 ? _e : []),
+                ...(webpackConfig.resolve.extensions || []),
+            ] }), module: Object.assign(Object.assign({}, storybookConfig.module), { rules: webpackConfig.module.rules }) });
+}
+exports.configureServiceWebpackConfig = configureServiceWebpackConfig;
+async function configureWebpackConfigForStorybook(mode, userConfig = {}) {
+    var _a;
+    const isEnvDevelopment = mode === "development" /* WebpackMode.Dev */;
+    const isEnvProduction = mode === "production" /* WebpackMode.Prod */;
+    const config = await (0, config_2.normalizeConfig)({
+        client: Object.assign(Object.assign({}, userConfig), { includes: ((_a = userConfig.includes) !== null && _a !== void 0 ? _a : []).concat(['.storybook']) }),
+    });
+    const helperOptions = {
+        isEnvDevelopment,
+        isEnvProduction,
+        config: config.client,
+    };
+    return {
+        module: {
+            rules: (0, config_1.configureModuleRules)(helperOptions),
+        },
+        resolve: (0, config_1.configureResolve)(helperOptions),
+        plugins: configurePlugins(helperOptions),
+    };
+}
+exports.configureWebpackConfigForStorybook = configureWebpackConfigForStorybook;
+function configurePlugins({ isEnvDevelopment, isEnvProduction, config }) {
+    const plugins = [];
+    if (config.definitions) {
+        // eslint-disable-next-line security/detect-non-literal-require
+        const webpack = require(path_1.default.resolve(process.cwd(), 'node_modules/webpack'));
+        plugins.push(new webpack.DefinePlugin(Object.assign({}, config.definitions)));
+    }
+    if (config.monaco) {
+        const MonacoEditorWebpackPlugin = require('monaco-editor-webpack-plugin');
+        plugins.push(new MonacoEditorWebpackPlugin(Object.assign(Object.assign({}, config.monaco), { 
+            // currently, workers located on cdn are not working properly, so we are enforcing loading workers from
+            // service instead
+            publicPath: '/' })));
+    }
+    if (isEnvDevelopment) {
+        plugins.push(new react_refresh_webpack_plugin_1.default());
+    }
+    if (isEnvProduction) {
+        plugins.push(new mini_css_extract_plugin_1.default({
+            filename: 'css/[name].[contenthash:8].css',
+            chunkFilename: 'css/[name].[contenthash:8].chunk.css',
+            ignoreOrder: true,
+        }));
+        plugins.push(new css_minimizer_webpack_plugin_1.default({
+            minimizerOptions: {
+                preset: [
+                    'default',
+                    {
+                        svgo: false,
+                    },
+                ],
+            },
+        }));
+    }
+    return plugins;
+}

package/dist/common/webpack/utils.d.ts

@@ -0,0 +1,7 @@
+import type webpack from 'webpack';
+import type { Logger } from '../logger';
+export declare function webpackCompilerHandlerFactory(logger: Logger, onCompilationEnd?: () => void): (err?: Error, stats?: webpack.Stats) => Promise<void>;
+export declare function resolveTsconfigPathsToAlias(tsConfigPath: string): {
+    aliases: Record<string, string[]>;
+    modules: string[];
+} | undefined;

package/dist/common/webpack/utils.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTsconfigPathsToAlias = exports.webpackCompilerHandlerFactory = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const pretty_time_1 = require("../logger/pretty-time");
+function webpackCompilerHandlerFactory(logger, onCompilationEnd) {
+    return async (err, stats) => {
+        if (err) {
+            logger.panic(err.message, err);
+        }
+        if (stats) {
+            logger.message('Stats:\n' +
+                stats.toString({
+                    preset: 'errors-warnings',
+                    colors: process.stdout.isTTY,
+                    assets: logger.isVerbose,
+                    modules: logger.isVerbose,
+                    entrypoints: logger.isVerbose,
+                    timings: logger.isVerbose,
+                }));
+            if (stats.hasErrors()) {
+                process.exit(1);
+            }
+        }
+        if (onCompilationEnd) {
+            await onCompilationEnd();
+        }
+        const time = (stats === null || stats === void 0 ? void 0 : stats.endTime) - (stats === null || stats === void 0 ? void 0 : stats.startTime);
+        logger.success(`Client was successfully compiled in ${(0, pretty_time_1.prettyTime)(BigInt(time) * BigInt(1000000))}`);
+    };
+}
+exports.webpackCompilerHandlerFactory = webpackCompilerHandlerFactory;
+const endStarRe = /\/?\*$/;
+function resolveTsconfigPathsToAlias(tsConfigPath) {
+    if (!fs_1.default.existsSync(tsConfigPath) || !fs_1.default.statSync(tsConfigPath).isFile) {
+        return undefined;
+    }
+    const { paths = {}, baseUrl } = readJsonConfig(tsConfigPath).compilerOptions || {};
+    if (!baseUrl) {
+        return undefined;
+    }
+    const basePath = path_1.default.resolve(path_1.default.dirname(tsConfigPath), baseUrl);
+    const aliases = {};
+    const modules = [];
+    for (const [key, value] of Object.entries(paths)) {
+        if (!Array.isArray(value) || value.length === 0) {
+            continue;
+        }
+        const name = key.replace(endStarRe, '');
+        if (name === '' || name === '.') {
+            modules.push(...value.map((v) => path_1.default.resolve(basePath, `${v}`.replace(endStarRe, ''))));
+            continue;
+        }
+        aliases[name] = value.map((v) => path_1.default.resolve(basePath, `${v}`.replace(endStarRe, '')));
+    }
+    return { aliases, modules };
+}
+exports.resolveTsconfigPathsToAlias = resolveTsconfigPathsToAlias;
+function readJsonConfig(pathname) {
+    try {
+        const json = fs_1.default.readFileSync(pathname, 'utf-8');
+        return Object.assign({}, JSON.parse(json));
+    }
+    catch (_a) {
+        throw new Error(`Couldn't read config ${pathname}`);
+    }
+}

package/dist/create-cli.d.ts

@@ -0,0 +1,54 @@
+export type CliArgs = Awaited<ReturnType<typeof createCli>>;
+export declare function createCli(argv: string[]): {
+    [x: string]: unknown;
+    verbose: boolean;
+    inspect: number | undefined;
+    target: "client" | "server" | undefined;
+    c: unknown;
+    env: string[] | undefined;
+    inspectBrk: number | undefined;
+    "inspect-brk": number | undefined;
+    entryFilter: string[] | undefined;
+    "entry-filter": string[] | undefined;
+    disableReactRefresh: boolean | undefined;
+    "disable-react-refresh": boolean | undefined;
+    lazyCompilation: boolean | undefined;
+    "lazy-compilation": boolean | undefined;
+    reactProfiling: boolean | undefined;
+    "react-profiling": boolean | undefined;
+    analyzeBundle: "true" | "statoscope" | undefined;
+    "analyze-bundle": "true" | "statoscope" | undefined;
+    disableForkTsChecker: boolean | undefined;
+    "disable-fork-ts-checker": boolean | undefined;
+    disableSourceMapGeneration: boolean | undefined;
+    "disable-source-map-generation": boolean | undefined;
+    cdn: "false" | undefined;
+    _: (string | number)[];
+    $0: string;
+} | Promise<{
+    [x: string]: unknown;
+    verbose: boolean;
+    inspect: number | undefined;
+    target: "client" | "server" | undefined;
+    c: unknown;
+    env: string[] | undefined;
+    inspectBrk: number | undefined;
+    "inspect-brk": number | undefined;
+    entryFilter: string[] | undefined;
+    "entry-filter": string[] | undefined;
+    disableReactRefresh: boolean | undefined;
+    "disable-react-refresh": boolean | undefined;
+    lazyCompilation: boolean | undefined;
+    "lazy-compilation": boolean | undefined;
+    reactProfiling: boolean | undefined;
+    "react-profiling": boolean | undefined;
+    analyzeBundle: "true" | "statoscope" | undefined;
+    "analyze-bundle": "true" | "statoscope" | undefined;
+    disableForkTsChecker: boolean | undefined;
+    "disable-fork-ts-checker": boolean | undefined;
+    disableSourceMapGeneration: boolean | undefined;
+    "disable-source-map-generation": boolean | undefined;
+    cdn: "false" | undefined;
+    _: (string | number)[];
+    $0: string;
+}>;

package/dist/create-cli.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCli = void 0;
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const path_1 = __importDefault(require("path"));
+const logger_1 = __importDefault(require("./common/logger"));
+const config_1 = require("./common/config");
+const models_1 = require("./common/models");
+function createCli(argv) {
+    const cli = (0, yargs_1.default)(argv).parserConfiguration({
+        'boolean-negation': false,
+    });
+    cli.scriptName('app-builder')
+        .usage('Usage: $0 <command> [options]')
+        .env('APP_BUILDER')
+        .alias('h', 'help')
+        .alias('v', 'version');
+    try {
+        cli.version('version', 'Show the version of the app-builder CLI package in the current project', getVersionInfo());
+    }
+    catch (e) {
+        // ignore
+    }
+    return cli
+        .option('verbose', {
+        default: false,
+        type: 'boolean',
+        describe: 'Turn on verbose output',
+        global: true,
+    })
+        .option('c', {
+        alias: 'config',
+        describe: 'Configuration file to use',
+    })
+        .option('env', {
+        describe: 'Environment passed to the configuration when it is a function.',
+        type: 'array',
+        string: true,
+        coerce: (args) => {
+            if (!args) {
+                return {};
+            }
+            return args.reduce((values, value) => {
+                if (value.endsWith('=')) {
+                    value = value.concat('""');
+                }
+                // This ensures we're only splitting by the first `=`
+                const [allKeys, val] = value.split(/[=](.+)/, 2);
+                if (typeof allKeys === 'string') {
+                    const splitKeys = allKeys.split(/\.(?!$)/);
+                    let prevRef = values;
+                    splitKeys.forEach((someKey, index) => {
+                        if (!prevRef[someKey]) {
+                            prevRef[someKey] = {};
+                        }
+                        if (typeof prevRef[someKey] === 'string') {
+                            prevRef[someKey] = {};
+                        }
+                        if (index === splitKeys.length - 1) {
+                            if (typeof val === 'string') {
+                                prevRef[someKey] = val;
+                            }
+                            else {
+                                prevRef[someKey] = true;
+                            }
+                        }
+                        prevRef = prevRef[someKey];
+                    });
+                }
+                return values;
+            }, {});
+        },
+    })
+        .command({
+        command: 'dev',
+        describe: 'Start development server. Watches files, rebuilds, and hot reloads if something changes',
+        builder: (_) => _.option('target', {
+            describe: 'Select compilation unit',
+            choices: ['client', 'server'],
+        })
+            .option('inspect', {
+            group: 'Server',
+            type: 'number',
+            describe: 'Opens a port for debugging',
+        })
+            .option('inspect-brk', {
+            group: 'Server',
+            type: 'number',
+            describe: 'Opens a port for debugging. Will block until debugger is attached',
+        })
+            .option('entry-filter', {
+            group: 'Client',
+            type: 'string',
+            describe: 'Filters entries from src/ui/entries/* included in webpack bundle',
+            array: true,
+        })
+            .option('disable-fork-ts-checker', {
+            group: 'Client',
+            describe: 'Disable typescript checks',
+            type: 'boolean',
+        })
+            .option('disable-react-refresh', {
+            group: 'Client',
+            describe: 'Disable react-refresh',
+            type: 'boolean',
+        })
+            .option('lazy-compilation', {
+            group: 'Client',
+            type: 'boolean',
+            describe: 'Enable lazy compilation',
+        }),
+        handler: handlerP(getCommandHandler('dev', (args, cmd) => {
+            if ((0, models_1.isLibraryConfig)(args)) {
+                throw new Error('dev command can be used only for services, but got the library config');
+            }
+            process.env.NODE_ENV = process.env.NODE_ENV || 'development';
+            if (args.server) {
+                if (args.server.inspect !== undefined) {
+                    args.server.inspect = args.server.inspect || 9229;
+                }
+                if (args.server.inspectBrk !== undefined) {
+                    args.server.inspectBrk = args.server.inspectBrk || 9229;
+                }
+            }
+            cmd(args);
+            // Return an empty promise to prevent handlerP from exiting early.
+            // The development server shouldn't ever exit until the user directly
+            // kills it so this is fine.
+            return new Promise(() => { });
+        })),
+    })
+        .command({
+        command: 'build',
+        describe: 'Make production build',
+        builder: (_) => _.option('target', {
+            describe: 'Select compilation unit',
+            choices: ['client', 'server'],
+        })
+            .option('entry-filter', {
+            group: 'Client',
+            type: 'string',
+            describe: 'Filters entries from src/ui/entries/* included in webpack bundle',
+            array: true,
+        })
+            .option('react-profiling', {
+            group: 'Client',
+            describe: 'Enable react profiling',
+            type: 'boolean',
+        })
+            .option('analyze-bundle', {
+            group: 'Client',
+            describe: 'Analyze bundle',
+            choices: ['true', 'statoscope'],
+        })
+            .option('disable-fork-ts-checker', {
+            group: 'Client',
+            describe: 'Disable typescript checks',
+            type: 'boolean',
+        })
+            .option('disable-source-map-generation', {
+            group: 'Client',
+            describe: 'Disable source map generation',
+            type: 'boolean',
+        })
+            .option('cdn', {
+            group: 'Client',
+            describe: 'Disable upload files to CDN',
+            choices: ['false'],
+        }),
+        handler: handlerP(getCommandHandler('build')),
+    })
+        .wrap(cli.terminalWidth())
+        .strict()
+        .demandCommand(1, `Pass --help to see all available commands and options.`)
+        .recommendCommands()
+        .parse((0, helpers_1.hideBin)(argv));
+}
+exports.createCli = createCli;
+function getVersionInfo() {
+    const { version } = require('../package.json');
+    return `app-builder CLI version: ${version}`;
+}
+function handlerP(fn) {
+    return (args) => {
+        Promise.resolve(fn(args)).then(() => process.exit(0), (err) => logger_1.default.panic(err));
+    };
+}
+function getCommandHandler(command, handler) {
+    return async (argv) => {
+        logger_1.default.setVerbose(Boolean(argv.verbose));
+        const config = await (0, config_1.getProjectConfig)(command, argv);
+        const args = Object.assign(Object.assign({}, config), { logger: logger_1.default });
+        const localCmd = resolveLocalCommand(command);
+        logger_1.default.verbose(`running command: ${command}`);
+        return handler ? handler(args, localCmd) : localCmd(args);
+    };
+}
+function resolveLocalCommand(command) {
+    try {
+        const cmdPath = path_1.default.resolve(__dirname, `commands/${command}`);
+        if (!cmdPath)
+            return logger_1.default.panic(`There was a problem loading the ${command} command.`);
+        logger_1.default.verbose(`loading command from: ${cmdPath}`);
+        // eslint-disable-next-line security/detect-non-literal-require
+        let cmd = require(cmdPath);
+        if (cmd.__esModule) {
+            cmd = cmd.default;
+        }
+        if (cmd instanceof Function) {
+            return cmd;
+        }
+        return logger_1.default.panic(`Handler for command "${command}" is not a function.`);
+    }
+    catch (err) {
+        return logger_1.default.panic(`There was a problem loading the "${command}" command.`, err);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { configureWebpackConfigForStorybook, configureServiceWebpackConfig, } from './common/webpack/storybook';
+export { createTransformPathsToLocalModules } from './common/typescript/transformers';
+export type { ProjectConfig, ServiceConfig, LibraryConfig } from './common/models';

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformPathsToLocalModules = exports.configureServiceWebpackConfig = exports.configureWebpackConfigForStorybook = void 0;
+var storybook_1 = require("./common/webpack/storybook");
+Object.defineProperty(exports, "configureWebpackConfigForStorybook", { enumerable: true, get: function () { return storybook_1.configureWebpackConfigForStorybook; } });
+Object.defineProperty(exports, "configureServiceWebpackConfig", { enumerable: true, get: function () { return storybook_1.configureServiceWebpackConfig; } });
+var transformers_1 = require("./common/typescript/transformers");
+Object.defineProperty(exports, "createTransformPathsToLocalModules", { enumerable: true, get: function () { return transformers_1.createTransformPathsToLocalModules; } });