@gravity-ui/app-builder 0.0.1

package/dist/common/child-process/controllable-script.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+interface IDebugInfo {
+    break?: boolean;
+    port?: number;
+}
+export declare class ControllableScript {
+    isRunning: boolean;
+    private process?;
+    private script;
+    private tmpFileName;
+    private debugInfo;
+    constructor(script: string, debugInfo: IDebugInfo | null);
+    start(): void;
+    stop(signal?: NodeJS.Signals | null, code?: number): Promise<void>;
+    onMessage(callback: (msg: any) => void): void;
+    onExit(callback: (code: number | null, signal: NodeJS.Signals | null) => void): void;
+    send(msg: any): void;
+}
+export {};

package/dist/common/child-process/controllable-script.js

@@ -0,0 +1,125 @@
+"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.ControllableScript = void 0;
+const utils_1 = require("./utils");
+const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("fs-extra"));
+const execa = __importStar(require("execa"));
+class ControllableScript {
+    constructor(script, debugInfo) {
+        this.isRunning = false;
+        this.script = '';
+        this.tmpFileName = '';
+        this.script = script;
+        this.debugInfo = debugInfo;
+    }
+    start() {
+        const args = [];
+        this.tmpFileName = (0, utils_1.tmpNameSync)(path_1.default.join(process.cwd(), 'node_modules'));
+        fs.outputFileSync(this.tmpFileName, this.script);
+        this.isRunning = true;
+        // Passing --inspect isn't necessary for the child process to launch a port, but it allows some editors to automatically attach
+        if (this.debugInfo) {
+            if (this.debugInfo.break) {
+                args.push(`--inspect-brk=${this.debugInfo.port}`);
+            }
+            else {
+                args.push(`--inspect=${this.debugInfo.port}`);
+            }
+        }
+        this.process = execa.node(this.tmpFileName, args, {
+            env: Object.assign({}, process.env),
+            stdio: [`inherit`, `inherit`, `inherit`, `ipc`],
+            nodeOptions: ['--unhandled-rejections=strict'],
+        });
+        this.process.on('unhandledRejection', () => {
+            this.stop('SIGABRT');
+        });
+    }
+    async stop(signal = null, code) {
+        if (!this.process) {
+            throw new Error(`Trying to stop the process before starting it`);
+        }
+        this.isRunning = false;
+        try {
+            if (signal) {
+                this.process.kill(signal);
+            }
+            else {
+                this.process.send({
+                    type: `COMMAND`,
+                    action: {
+                        type: `EXIT`,
+                        payload: code,
+                    },
+                }, () => {
+                    // The try/catch won't suffice for this process.send
+                    // So use the callback to manually catch the Error, otherwise it'll be thrown
+                    // Ref: https://nodejs.org/api/child_process.html#child_process_subprocess_send_message_sendhandle_options_callback
+                });
+            }
+        }
+        catch (err) {
+            // Ignore error if process has crashed or already quit.
+        }
+        return new Promise((resolve) => {
+            if (!this.process) {
+                throw new Error(`Trying to stop the process before starting it`);
+            }
+            this.process.on(`exit`, () => {
+                if (this.process) {
+                    this.process.removeAllListeners();
+                }
+                this.process = undefined;
+                fs.unlinkSync(this.tmpFileName);
+                resolve();
+            });
+        });
+    }
+    onMessage(callback) {
+        if (!this.process) {
+            throw new Error(`Trying to attach message handler before process started`);
+        }
+        this.process.on(`message`, callback);
+    }
+    onExit(callback) {
+        if (!this.process) {
+            throw new Error(`Trying to attach exit handler before process started`);
+        }
+        this.process.on(`exit`, callback);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    send(msg) {
+        if (!this.process) {
+            throw new Error(`Trying to send a message before process started`);
+        }
+        this.process.send(msg);
+    }
+}
+exports.ControllableScript = ControllableScript;

package/dist/common/child-process/utils.d.ts

@@ -0,0 +1 @@
+export declare function tmpNameSync(tmpDir: string, retries?: number): string;

package/dist/common/child-process/utils.js

@@ -0,0 +1,68 @@
+"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.tmpNameSync = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
+const fs = __importStar(require("fs-extra"));
+const RANDOM_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+function randomChars(howMany) {
+    var _a, _b;
+    const value = [];
+    let rnd = null;
+    // make sure that we do not fail because we ran out of entropy
+    try {
+        rnd = crypto_1.default.randomBytes(howMany);
+    }
+    catch (e) {
+        // eslint-disable-next-line security/detect-pseudoRandomBytes
+        rnd = crypto_1.default.pseudoRandomBytes(howMany);
+    }
+    for (let i = 0; i < howMany; i++) {
+        value.push((_b = RANDOM_CHARS[((_a = rnd[i]) !== null && _a !== void 0 ? _a : 0) % RANDOM_CHARS.length]) !== null && _b !== void 0 ? _b : '0');
+    }
+    return value.join('');
+}
+function generateTmpName(tmpDir) {
+    const name = ['tmp', '-', process.pid, '-', randomChars(12)].join('');
+    return path_1.default.join(tmpDir, name);
+}
+function tmpNameSync(tmpDir, retries = 3) {
+    let tries = retries;
+    do {
+        const name = generateTmpName(tmpDir);
+        try {
+            fs.statSync(name);
+        }
+        catch (e) {
+            return name;
+        }
+    } while (tries-- > 0);
+    throw new Error('Could not get a unique tmp filename, max tries reached');
+}
+exports.tmpNameSync = tmpNameSync;

package/dist/common/command.d.ts

@@ -0,0 +1,4 @@
+export declare const enum Command {
+    Build = "build",
+    Dev = "dev"
+}

package/dist/common/command.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/common/config.d.ts

@@ -0,0 +1,5 @@
+import type { NormalizedServiceConfig, ServiceConfig, LibraryConfig } from './models';
+import type { CliArgs } from '../create-cli';
+export declare function getProjectConfig(command: string, { env, ...argv }: Partial<CliArgs>): Promise<NormalizedServiceConfig>;
+export declare function normalizeConfig(userConfig: ServiceConfig, mode?: 'dev' | 'build' | string): Promise<NormalizedServiceConfig>;
+export declare function normalizeConfig(userConfig: LibraryConfig, mode?: 'dev' | 'build' | string): Promise<LibraryConfig>;

package/dist/common/config.js

@@ -0,0 +1,155 @@
+"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.normalizeConfig = exports.getProjectConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const lodash_1 = __importDefault(require("lodash"));
+const cosmiconfig_1 = require("cosmiconfig");
+const cosmiconfig_typescript_loader_1 = require("cosmiconfig-typescript-loader");
+const get_port_1 = __importDefault(require("get-port"));
+const models_1 = require("./models");
+function splitPaths(paths) {
+    return (Array.isArray(paths) ? paths : [paths]).flatMap((p) => p.split(','));
+}
+function remapPaths(paths) {
+    return splitPaths(paths).map((p) => path_1.default.resolve(process.cwd(), p));
+}
+function omitUndefined(obj) {
+    return lodash_1.default.omitBy(obj, lodash_1.default.isUndefined);
+}
+async function getProjectConfig(command, _a) {
+    var { env } = _a, argv = __rest(_a, ["env"]);
+    function getLoader(loader) {
+        return async (pathname, content) => {
+            const config = loader(pathname, content);
+            if (typeof config === 'function') {
+                return await config(command, env);
+            }
+            return config;
+        };
+    }
+    const tsLoader = getLoader((0, cosmiconfig_typescript_loader_1.TypeScriptLoader)());
+    const moduleName = 'app-builder';
+    const explorer = (0, cosmiconfig_1.cosmiconfigSync)(moduleName, {
+        cache: false,
+        stopDir: process.cwd(),
+        searchPlaces: [
+            'package.json',
+            `.${moduleName}rc`,
+            `.${moduleName}rc.json`,
+            `.${moduleName}rc.yaml`,
+            `.${moduleName}rc.yml`,
+            `.${moduleName}rc.js`,
+            `.${moduleName}rc.ts`,
+            `.${moduleName}rc.cjs`,
+            `${moduleName}.config.js`,
+            `${moduleName}.config.ts`,
+            `${moduleName}.config.cjs`,
+        ],
+        loaders: {
+            '.js': tsLoader,
+            '.cjs': tsLoader,
+            '.ts': tsLoader,
+        },
+    });
+    let cfg;
+    if (argv.config && typeof argv.config === 'string') {
+        cfg = explorer.load(argv.config);
+    }
+    else {
+        cfg = explorer.search();
+    }
+    const client = {
+        analyzeBundle: argv.analyzeBundle,
+        disableForkTsChecker: argv.disableForkTsChecker,
+        disableReactRefresh: argv.disableReactRefresh,
+        disableSourceMapGeneration: argv.disableSourceMapGeneration,
+        entryFilter: argv.entryFilter,
+        lazyCompilation: argv.lazyCompilation,
+        reactProfiling: argv.reactProfiling,
+    };
+    const server = {
+        inspect: argv.inspect,
+        inspectBrk: argv.inspectBrk,
+    };
+    const config = Object.assign({}, (await (cfg === null || cfg === void 0 ? void 0 : cfg.config)));
+    const projectConfig = Object.assign(Object.assign(Object.assign({}, config), omitUndefined({ target: argv.target, verbose: argv.verbose })), { client: Object.assign(Object.assign(Object.assign({}, config.client), omitUndefined(client)), (argv.cdn === 'false' ? { cdn: undefined } : undefined)), server: Object.assign(Object.assign({}, config.server), omitUndefined(server)) });
+    return normalizeConfig(projectConfig, command);
+}
+exports.getProjectConfig = getProjectConfig;
+async function normalizeConfig(userConfig, mode) {
+    var _a;
+    if ((0, models_1.isServiceConfig)(userConfig)) {
+        const config = lodash_1.default.cloneDeep(userConfig);
+        const client = typeof config.client === 'object' ? config.client : (config.client = {});
+        await normalizeClientConfig(client, mode);
+        client.verbose = userConfig.verbose;
+        const server = typeof config.server === 'object' ? config.server : (config.server = {});
+        server.watch = server.watch && remapPaths(server.watch);
+        server.verbose = userConfig.verbose;
+        if (mode === 'dev') {
+            if (server.port === true) {
+                server.port = await (0, get_port_1.default)({ port: 3000 });
+            }
+        }
+        return config;
+    }
+    const config = lodash_1.default.cloneDeep(userConfig);
+    config.newJsxTransform = (_a = config.newJsxTransform) !== null && _a !== void 0 ? _a : true;
+    return config;
+}
+exports.normalizeConfig = normalizeConfig;
+async function normalizeClientConfig(client, mode) {
+    var _a, _b, _c, _d, _e, _f;
+    client.newJsxTransform = (_a = client.newJsxTransform) !== null && _a !== void 0 ? _a : true;
+    client.publicPathPrefix = client.publicPathPrefix || '';
+    client.modules = client.modules && remapPaths(client.modules);
+    client.includes = client.includes && remapPaths(client.includes);
+    client.images = client.images && remapPaths(client.images);
+    client.hiddenSourceMap = (_b = client.hiddenSourceMap) !== null && _b !== void 0 ? _b : true;
+    client.svgr = (_c = client.svgr) !== null && _c !== void 0 ? _c : {};
+    client.entryFilter = client.entryFilter && splitPaths(client.entryFilter);
+    if (mode === 'dev') {
+        if (client.lazyCompilation) {
+            if (client.lazyCompilation === true) {
+                client.lazyCompilation = {
+                    port: await (0, get_port_1.default)({ port: 6000 }),
+                };
+            }
+            else if (!client.lazyCompilation.port) {
+                client.lazyCompilation.port = await (0, get_port_1.default)({ port: 6000 });
+            }
+        }
+        const devServer = ((_d = client.devServer) === null || _d === void 0 ? void 0 : _d.port)
+            ? {
+                port: client.devServer.port === true
+                    ? await (0, get_port_1.default)({ port: 8000 })
+                    : client.devServer.port,
+                ipc: undefined,
+            }
+            : { port: undefined, ipc: (_e = client.devServer) === null || _e === void 0 ? void 0 : _e.ipc };
+        const _g = (_f = client.devServer) !== null && _f !== void 0 ? _f : {}, { type, options } = _g, other = __rest(_g, ["type", "options"]);
+        client.devServer = Object.assign(Object.assign(Object.assign({}, other), devServer), { server: {
+                type,
+                options,
+            } });
+        delete client.cdn;
+    }
+    else {
+        delete client.devServer;
+        delete client.lazyCompilation;
+    }
+}

package/dist/common/env.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/common/env.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const dotenv_1 = require("dotenv");
+(0, dotenv_1.config)({ path: (0, path_1.resolve)(process.cwd(), '.env') });

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

@@ -0,0 +1,2 @@
+import type { LibraryConfig } from '../models';
+export declare function buildLibrary(config: LibraryConfig): void;