@gravity-ui/app-builder 0.0.1

package/dist/common/s3-upload/upload.js

@@ -0,0 +1,117 @@
+"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.uploadFiles = void 0;
+const path = __importStar(require("path"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const s3_client_js_1 = require("./s3-client.js");
+const compress_js_1 = require("./compress.js");
+function uploadFiles(files, config) {
+    var _a;
+    const s3Client = (0, s3_client_js_1.getS3Client)(config.s3);
+    const queue = new p_queue_1.default({
+        concurrency: (_a = config.concurrency) !== null && _a !== void 0 ? _a : 512,
+    });
+    const processFile = fileProcessor(config.options);
+    return Promise.all(files.flatMap((filePath) => {
+        const relativeFilePath = path.isAbsolute(filePath)
+            ? path.relative(config.options.sourcePath, filePath)
+            : filePath;
+        return processFile(relativeFilePath);
+    }));
+    function doesExist(bucket, key) {
+        return queue
+            .add(() => s3Client.headObject(bucket, key))
+            .then(() => true)
+            .catch(() => false);
+    }
+    function uploadFile(bucket, sourceFilePath, targetFilePath, options) {
+        return queue.add(() => s3Client.uploadFile(bucket, sourceFilePath, targetFilePath, options));
+    }
+    function fileUploader(options) {
+        return async (relativeFilePath) => {
+            const sourceFilePath = path.join(options.sourcePath, relativeFilePath);
+            const targetFilePath = path.join(options.targetPath || '', relativeFilePath);
+            console.info(`Uploading file ${relativeFilePath} ...`);
+            const exists = await doesExist(options.bucket, targetFilePath);
+            if (exists) {
+                switch (options.existsBehavior) {
+                    case 'overwrite': {
+                        console.info(`File ${targetFilePath} will be overwritten.`);
+                        break;
+                    }
+                    case 'throw': {
+                        throw new Error(`File ${targetFilePath} already exists in ${options.bucket}`);
+                    }
+                    default: {
+                        console.info(`Nothing todo with '${relativeFilePath}'`);
+                        return Promise.resolve(relativeFilePath);
+                    }
+                }
+            }
+            return uploadFile(options.bucket, sourceFilePath, targetFilePath)
+                .then(() => {
+                console.info(`  ${relativeFilePath} => ${targetFilePath}`);
+                return relativeFilePath;
+            })
+                .catch((error) => {
+                console.error(`Failed to upload file ${relativeFilePath}`);
+                if (error instanceof Error) {
+                    console.error(`msg: ${error.message}`);
+                }
+                throw error;
+            });
+        };
+    }
+    function compress(sourcePath) {
+        return [queue.add(() => (0, compress_js_1.gzip)(sourcePath)), queue.add(() => (0, compress_js_1.brotli)(sourcePath))];
+    }
+    function fileProcessor(options) {
+        return (relativeFilePath) => {
+            const upload = fileUploader(options);
+            const filesPromises = [upload(relativeFilePath)];
+            if (config.compress && shouldCompress(relativeFilePath)) {
+                const sourcePath = path.join(options.sourcePath, relativeFilePath);
+                filesPromises.push(...compress(sourcePath).map((promise) => {
+                    return promise.then((compressedFile) => {
+                        const relativeCompressedFilePath = path.relative(options.sourcePath, compressedFile);
+                        return upload(relativeCompressedFilePath);
+                    });
+                }));
+            }
+            return filesPromises;
+        };
+    }
+}
+exports.uploadFiles = uploadFiles;
+const NOT_COMPRESS = ['png', 'zip', 'gz', 'br'];
+function shouldCompress(filePath) {
+    const fileName = path.basename(filePath);
+    const extension = fileName.split('.').pop();
+    return !NOT_COMPRESS.includes(extension);
+}

package/dist/common/s3-upload/webpack-plugin.d.ts

@@ -0,0 +1,18 @@
+import { UploadOptions } from './upload.js';
+import type { Compiler } from 'webpack';
+import type { S3ClientOptions } from './s3-client.js';
+interface S3UploadPluginOptions {
+    include?: Rule | Rule[];
+    exclude?: Rule | Rule[];
+    compress?: boolean;
+    s3ClientOptions: S3ClientOptions;
+    s3UploadOptions: Pick<UploadOptions, 'bucket' | 'targetPath' | 'existsBehavior'>;
+}
+export declare class S3UploadPlugin {
+    private options;
+    constructor(options: S3UploadPluginOptions);
+    apply(compiler: Compiler): void;
+    private isIncludeAndNotExclude;
+}
+type Rule = RegExp | string | ((s: string) => boolean);
+export {};

package/dist/common/s3-upload/webpack-plugin.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3UploadPlugin = void 0;
+const webpack_1 = require("webpack");
+const upload_js_1 = require("./upload.js");
+class S3UploadPlugin {
+    constructor(options) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.done.tapPromise('S3UploadPlugin', async ({ compilation }) => {
+            var _a;
+            const fileNames = Object.keys(compilation.assets).filter((name) => {
+                const fullPath = compilation.outputOptions.path + '/' + name;
+                return this.isIncludeAndNotExclude(fullPath);
+            });
+            try {
+                await (0, upload_js_1.uploadFiles)(fileNames, {
+                    s3: this.options.s3ClientOptions,
+                    compress: this.options.compress,
+                    options: Object.assign(Object.assign({}, this.options.s3UploadOptions), { sourcePath: (_a = compilation.outputOptions.path) !== null && _a !== void 0 ? _a : '' }),
+                });
+            }
+            catch (e) {
+                const error = new webpack_1.WebpackError(`${e instanceof Error ? e.message : e}`);
+                compilation.errors.push(error);
+            }
+        });
+    }
+    isIncludeAndNotExclude(fileName) {
+        const { include, exclude } = this.options;
+        const isInclude = include ? testRule(include, fileName) : true;
+        const isExclude = exclude ? testRule(exclude, fileName) : false;
+        return isInclude && !isExclude;
+    }
+}
+exports.S3UploadPlugin = S3UploadPlugin;
+function testRule(rule, source) {
+    if (rule instanceof RegExp) {
+        return rule.test(source);
+    }
+    if (typeof rule === 'function') {
+        return Boolean(rule(source));
+    }
+    if (typeof rule === 'string') {
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        return new RegExp(rule).test(source);
+    }
+    if (Array.isArray(rule)) {
+        return rule.some((condition) => testRule(condition, source));
+    }
+    throw new Error('Unknown type of rule');
+}

package/dist/common/tempData.d.ts

@@ -0,0 +1,13 @@
+import type { Entities, LinkedPackage } from './models';
+interface TempData {
+    linkedPackages?: Entities<LinkedPackage>;
+}
+declare class TempDataUtils {
+    private state;
+    constructor();
+    saveSettings(newSettings?: Partial<TempData>): boolean;
+    getSettings(): Partial<TempData>;
+    clearSetting(settingName: keyof TempData): void;
+}
+declare const _default: TempDataUtils;
+export default _default;

package/dist/common/tempData.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = __importDefault(require("./paths"));
+const logger_1 = __importDefault(require("./logger"));
+const tempDataPath = path_1.default.resolve(paths_1.default.appNodeModules, '.app-builder.temp.json');
+class TempDataUtils {
+    constructor() {
+        try {
+            const settingsJson = fs_1.default.readFileSync(tempDataPath, 'utf-8');
+            this.state = JSON.parse(settingsJson);
+        }
+        catch (e) {
+            this.state = {};
+        }
+    }
+    saveSettings(newSettings = {}) {
+        this.state = Object.assign(Object.assign({}, this.state), newSettings);
+        if (fs_1.default.existsSync(tempDataPath)) {
+            fs_1.default.unlinkSync(tempDataPath);
+        }
+        try {
+            fs_1.default.writeFileSync(tempDataPath, JSON.stringify(this.state), 'utf-8');
+            return true;
+        }
+        catch (e) {
+            logger_1.default.logError(e);
+            return false;
+        }
+    }
+    getSettings() {
+        return this.state;
+    }
+    clearSetting(settingName) {
+        delete this.state[settingName];
+        this.saveSettings();
+    }
+}
+exports.default = new TempDataUtils();

package/dist/common/typescript/compile.d.ts

@@ -0,0 +1,5 @@
+import type Typescript from 'typescript';
+import type { Logger } from '../logger';
+export declare function compile(ts: typeof Typescript, projectPath: string, { logger }: {
+    logger: Logger;
+}): void;

package/dist/common/typescript/compile.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+const utils_1 = require("./utils");
+const transformers_1 = require("./transformers");
+const pretty_time_1 = require("../logger/pretty-time");
+const diagnostic_1 = require("./diagnostic");
+function compile(ts, projectPath, { logger }) {
+    const start = process.hrtime.bigint();
+    logger.message('Start compilation');
+    logger.message(`Typescript v${ts.version}`);
+    logger.verbose(`Searching for the tsconfig.json in ${projectPath}`);
+    const configPath = (0, utils_1.getProjectConfig)(ts, projectPath);
+    const formatHost = {
+        getCanonicalFileName: (path) => path,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: () => ts.sys.newLine,
+    };
+    const parseConfigFileHost = {
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+        readDirectory: ts.sys.readDirectory,
+        fileExists: ts.sys.fileExists,
+        readFile: ts.sys.readFile,
+        onUnRecoverableConfigFileDiagnostic: reportDiagnostic,
+    };
+    const parsedConfig = ts.getParsedCommandLineOfConfigFile(configPath, { noEmitOnError: true }, parseConfigFileHost);
+    if (!parsedConfig) {
+        throw new Error("Invalid 'tsconfig.json'");
+    }
+    logger.verbose('Config found and parsed');
+    logger.verbose("We're about to create the program");
+    const compilerHost = ts.createCompilerHost(parsedConfig.options);
+    compilerHost.readFile = (0, utils_1.displayFilename)(compilerHost.readFile, 'Reading', logger);
+    // @ts-ignore
+    compilerHost.readFile.enableDisplay();
+    const program = ts.createProgram(parsedConfig.fileNames, parsedConfig.options, compilerHost);
+    // @ts-ignore
+    const filesCount = compilerHost.readFile.disableDisplay();
+    const allDiagnostics = ts.getPreEmitDiagnostics(program).slice();
+    logger.verbose(`Program created, read ${filesCount} files`);
+    if (!hasErrors(allDiagnostics)) {
+        logger.verbose('We finished making the program! Emitting...');
+        const transformPathsToLocalModules = (0, transformers_1.createTransformPathsToLocalModules)(ts);
+        const emitResult = program.emit(undefined, undefined, undefined, undefined, {
+            after: [transformPathsToLocalModules],
+            afterDeclarations: [transformPathsToLocalModules],
+        });
+        logger.verbose('Emit complete!');
+        allDiagnostics.push(...emitResult.diagnostics);
+    }
+    allDiagnostics.forEach(reportDiagnostic);
+    if (hasErrors(allDiagnostics)) {
+        logger.error(`Error compile, elapsed time ${(0, pretty_time_1.elapsedTime)(start)}`);
+        process.exit(1);
+    }
+    else {
+        logger.success(`Compiled successfully in ${(0, pretty_time_1.elapsedTime)(start)}`);
+    }
+    function reportDiagnostic(diagnostic) {
+        if (logger.isVerbose) {
+            logger.message(ts.formatDiagnosticsWithColorAndContext([diagnostic], formatHost));
+        }
+        else {
+            logger.message((0, diagnostic_1.formatDiagnosticBrief)(ts, diagnostic, formatHost));
+        }
+    }
+    function hasErrors(diagnostics) {
+        return diagnostics.some(({ category }) => category === ts.DiagnosticCategory.Error);
+    }
+}
+exports.compile = compile;

package/dist/common/typescript/diagnostic.d.ts

@@ -0,0 +1,2 @@
+import type Typescript from 'typescript';
+export declare function formatDiagnosticBrief(ts: typeof Typescript, diagnostic: Typescript.Diagnostic, host: Typescript.FormatDiagnosticsHost): string;

package/dist/common/typescript/diagnostic.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDiagnosticBrief = void 0;
+const path_1 = __importDefault(require("path"));
+const colors_1 = require("../logger/colors");
+function formatDiagnosticBrief(ts, diagnostic, host) {
+    let output = '';
+    if (diagnostic.file) {
+        const { file, start } = diagnostic;
+        output += formatLocation(file, start !== null && start !== void 0 ? start : 0);
+        output += ' - ';
+    }
+    output += categoryColor(diagnostic.category)(ts.DiagnosticCategory[diagnostic.category]);
+    output += colors_1.colors.grey(` TS${diagnostic.code}: `);
+    output += ts.flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine());
+    return output;
+    function formatLocation(file, start) {
+        const { line, character } = ts.getLineAndCharacterOfPosition(file, start);
+        const filePath = path_1.default.relative(process.cwd(), file.fileName);
+        return (colors_1.colors.cyanBright(filePath) +
+            ':' +
+            colors_1.colors.yellowBright(line + 1) +
+            ':' +
+            colors_1.colors.yellowBright(character + 1));
+    }
+    function categoryColor(category) {
+        switch (category) {
+            case ts.DiagnosticCategory.Error: {
+                return colors_1.colors.redBright;
+            }
+            case ts.DiagnosticCategory.Warning: {
+                return colors_1.colors.yellowBright;
+            }
+            case ts.DiagnosticCategory.Suggestion: {
+                return colors_1.colors.magentaBright;
+            }
+            default: {
+                return colors_1.colors;
+            }
+        }
+    }
+}
+exports.formatDiagnosticBrief = formatDiagnosticBrief;

package/dist/common/typescript/transformers.d.ts

@@ -0,0 +1,2 @@
+import type Typescript from 'typescript';
+export declare function createTransformPathsToLocalModules(ts: typeof Typescript): <T extends Typescript.Node>(context: Typescript.TransformationContext) => (sourceFileOrBundle: T) => T;

package/dist/common/typescript/transformers.js

@@ -0,0 +1,114 @@
+"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.createTransformPathsToLocalModules = void 0;
+const path = __importStar(require("path"));
+function createTransformPathsToLocalModules(ts) {
+    function resolveModule(module, sourceFileName, options) {
+        if (module.startsWith('.')) {
+            return undefined;
+        }
+        const resolve = ts.resolveModuleName(module, sourceFileName, options, ts.sys);
+        if (resolve.resolvedModule && !resolve.resolvedModule.isExternalLibraryImport) {
+            const relativePath = path.relative(path.dirname(sourceFileName), resolve.resolvedModule.resolvedFileName);
+            const parsed = path.parse(relativePath);
+            const newFilePath = path.join(parsed.dir, parsed.name === 'index' ? '' : parsed.name);
+            return newFilePath.startsWith('.') ? newFilePath : `./${newFilePath}`;
+        }
+        return undefined;
+    }
+    function isDynamicImport(node) {
+        return ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword;
+    }
+    function isRequire(node) {
+        return (ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === 'require');
+    }
+    function transformFile(sourceFile, context) {
+        const options = context.getCompilerOptions();
+        return ts.visitNode(sourceFile, visitor);
+        function visitor(node) {
+            let modulePath;
+            if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+                node.moduleSpecifier &&
+                ts.isStringLiteral(node.moduleSpecifier)) {
+                modulePath = node.moduleSpecifier.text;
+            }
+            else if ((isDynamicImport(node) || isRequire(node)) &&
+                node.arguments[0] &&
+                ts.isStringLiteral(node.arguments[0])) {
+                modulePath = node.arguments[0].text;
+            }
+            else if (ts.isImportTypeNode(node) &&
+                ts.isLiteralTypeNode(node.argument) &&
+                ts.isStringLiteral(node.argument.literal)) {
+                modulePath = node.argument.literal.text;
+            }
+            if (modulePath) {
+                const resolvedPath = resolveModule(modulePath, sourceFile.fileName, options);
+                if (resolvedPath) {
+                    if (ts.isImportDeclaration(node)) {
+                        const newStatement = context.factory.updateImportDeclaration(node, node.decorators, node.modifiers, node.importClause, context.factory.createStringLiteral(resolvedPath), node.assertClause);
+                        ts.setSourceMapRange(newStatement, ts.getSourceMapRange(node));
+                        return newStatement;
+                    }
+                    if (ts.isExportDeclaration(node)) {
+                        const newStatement = context.factory.updateExportDeclaration(node, node.decorators, node.modifiers, node.isTypeOnly, node.exportClause, context.factory.createStringLiteral(resolvedPath), node.assertClause);
+                        ts.setSourceMapRange(newStatement, ts.getSourceMapRange(node));
+                        return newStatement;
+                    }
+                    if (isDynamicImport(node) || isRequire(node)) {
+                        const newStatement = context.factory.updateCallExpression(node, node.expression, node.typeArguments, context.factory.createNodeArray([
+                            context.factory.createStringLiteral(resolvedPath),
+                        ]));
+                        ts.setSourceMapRange(newStatement, ts.getSourceMapRange(node));
+                        return newStatement;
+                    }
+                    if (ts.isImportTypeNode(node)) {
+                        const newNode = context.factory.updateImportTypeNode(node, context.factory.createLiteralTypeNode(context.factory.createStringLiteral(resolvedPath)), node.qualifier, node.typeArguments, node.isTypeOf);
+                        ts.setSourceMapRange(newNode, ts.getSourceMapRange(node));
+                        return newNode;
+                    }
+                }
+                return node;
+            }
+            return ts.visitEachChild(node, visitor, context);
+        }
+    }
+    return function transformPathsToLocalModules(context) {
+        return (sourceFileOrBundle) => {
+            if (ts.isSourceFile(sourceFileOrBundle)) {
+                return transformFile(sourceFileOrBundle, context);
+            }
+            if (ts.isBundle(sourceFileOrBundle)) {
+                // don't transform bundles yet
+                return sourceFileOrBundle;
+            }
+            return sourceFileOrBundle;
+        };
+    };
+}
+exports.createTransformPathsToLocalModules = createTransformPathsToLocalModules;

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

@@ -0,0 +1,10 @@
+import type Typescript from 'typescript';
+import type { Logger } from '../logger';
+export declare function getProjectConfig(ts: typeof Typescript, projectPath: string): string;
+export declare function displayFilename(originalFunc: (path: string, encoding?: string) => string | undefined, operationName: string, logger: Logger): {
+    (path: string, encoding?: string | undefined): string | undefined;
+    originalFunc: (path: string, encoding?: string) => string | undefined;
+    enableDisplay(): void;
+    disableDisplay(): number;
+};
+export declare function onHostEvent(host: any, functionName: any, before?: (...args: any[]) => void, after?: (...args: any[]) => void): void;

package/dist/common/typescript/utils.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onHostEvent = exports.displayFilename = exports.getProjectConfig = void 0;
+function getProjectConfig(ts, projectPath) {
+    const configPath = ts.findConfigFile(projectPath, ts.sys.fileExists, 'tsconfig.json');
+    if (!configPath) {
+        throw new Error("Could not find a valid 'tsconfig.json'.");
+    }
+    return configPath;
+}
+exports.getProjectConfig = getProjectConfig;
+function displayFilename(originalFunc, operationName, logger) {
+    let displayEnabled = false;
+    let count = 0;
+    function displayFunction(...args) {
+        count++;
+        if (displayEnabled) {
+            const fileName = args[0];
+            logger.status(logger.colors.dim(`${operationName}: ${fileName}`));
+        }
+        return originalFunc(...args);
+    }
+    displayFunction.originalFunc = originalFunc;
+    displayFunction.enableDisplay = () => {
+        count = 0;
+        if (process.stdout.isTTY && logger.isVerbose) {
+            displayEnabled = true;
+        }
+    };
+    displayFunction.disableDisplay = () => {
+        if (displayEnabled) {
+            displayEnabled = false;
+            logger.clearLine();
+        }
+        return count;
+    };
+    return displayFunction;
+}
+exports.displayFilename = displayFilename;
+function onHostEvent(host, functionName, before, after) {
+    const originalFunction = host[functionName];
+    host[functionName] = (...args) => {
+        if (before) {
+            before(...args);
+        }
+        const result = originalFunction && originalFunction(...args);
+        if (after) {
+            after(result);
+        }
+        return result;
+    };
+}
+exports.onHostEvent = onHostEvent;

package/dist/common/typescript/watch.d.ts

@@ -0,0 +1,7 @@
+import type Typescript from 'typescript';
+import type { Logger } from '../logger';
+export declare function watch(ts: typeof Typescript, projectPath: string, { logger, onAfterFilesEmitted, enableSourceMap, }: {
+    logger: Logger;
+    onAfterFilesEmitted?: () => void;
+    enableSourceMap?: boolean;
+}): void;

package/dist/common/typescript/watch.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watch = void 0;
+const transformers_1 = require("./transformers");
+const utils_1 = require("./utils");
+const diagnostic_1 = require("./diagnostic");
+function watch(ts, projectPath, { logger, onAfterFilesEmitted, enableSourceMap, }) {
+    logger.message('Start compilation in watch mode');
+    logger.message(`Typescript v${ts.version}`);
+    const configPath = (0, utils_1.getProjectConfig)(ts, projectPath);
+    const createProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram;
+    const formatHost = {
+        getCanonicalFileName: (path) => path,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: () => ts.sys.newLine,
+    };
+    const host = ts.createWatchCompilerHost(configPath, { noEmitOnError: false, inlineSourceMap: enableSourceMap, inlineSources: enableSourceMap }, ts.sys, createProgram, reportDiagnostic, reportWatchStatusChanged);
+    host.readFile = (0, utils_1.displayFilename)(host.readFile, 'Reading', logger);
+    (0, utils_1.onHostEvent)(host, 'createProgram', () => {
+        logger.verbose("We're about to create the program");
+        // @ts-ignore
+        host.readFile.enableDisplay();
+    }, () => {
+        // @ts-ignore
+        const count = host.readFile.disableDisplay();
+        logger.verbose(`Program created, read ${count} files`);
+    });
+    (0, utils_1.onHostEvent)(host, 'afterProgramCreate', (program) => {
+        logger.verbose('We finished making the program! Emitting...');
+        const transformPathsToLocalModules = (0, transformers_1.createTransformPathsToLocalModules)(ts);
+        program.emit(undefined, undefined, undefined, undefined, {
+            after: [transformPathsToLocalModules],
+            afterDeclarations: [transformPathsToLocalModules],
+        });
+        logger.verbose('Emit completed!');
+    }, () => {
+        onAfterFilesEmitted === null || onAfterFilesEmitted === void 0 ? void 0 : onAfterFilesEmitted();
+    });
+    // `createWatchProgram` creates an initial program, watches files, and updates
+    // the program over time.
+    ts.createWatchProgram(host);
+    function reportDiagnostic(diagnostic) {
+        if (logger.isVerbose) {
+            logger.message(ts.formatDiagnosticsWithColorAndContext([diagnostic], formatHost));
+        }
+        else {
+            logger.message((0, diagnostic_1.formatDiagnosticBrief)(ts, diagnostic, formatHost));
+        }
+    }
+    /*
+     * Prints a diagnostic every time the watch status changes.
+     * This is mainly for messages like "Starting compilation" or "Compilation completed".
+     */
+    function reportWatchStatusChanged(diagnostic) {
+        if (diagnostic.messageText) {
+            logger.message(ts.flattenDiagnosticMessageText(diagnostic.messageText, formatHost.getNewLine()));
+        }
+    }
+}
+exports.watch = watch;

package/dist/common/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function createRunFolder(): void;
+export declare function shouldCompileTarget(target: 'client' | 'server' | undefined, targetName: string): boolean;

package/dist/common/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldCompileTarget = exports.createRunFolder = void 0;
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = __importDefault(require("./paths"));
+function createRunFolder() {
+    const runPath = paths_1.default.appRun;
+    if (!fs_1.default.existsSync(runPath)) {
+        fs_1.default.mkdirSync(runPath, { recursive: true });
+    }
+}
+exports.createRunFolder = createRunFolder;
+function shouldCompileTarget(target, targetName) {
+    return target === undefined || target === targetName;
+}
+exports.shouldCompileTarget = shouldCompileTarget;

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

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