@gravity-ui/app-builder 0.13.0 → 0.13.2

package/dist/commands/dev/index.js

@@ -49,6 +49,10 @@ async function default_1(config) {
     const startNodemon = () => {
         if (needToStartNodemon && serverCompiled && clientCompiled) {
             logger_1.default.message('Starting application at', serverPath);
+            const nodeArgs = ['--enable-source-maps'];
+            if (inspect || inspectBrk) {
+                nodeArgs.push(`--${inspect ? 'inspect' : 'inspect-brk'}=:::${inspect || inspectBrk}`);
+            }
             const serverWatch = config.server.watch ?? [];
             const delay = config.server.watchThrottle;
             const nodemonInstance = (0, nodemon_1.default)({
@@ -58,9 +62,7 @@ async function default_1(config) {
                 env: {
                     ...(config.server.port ? { APP_PORT: config.server.port } : undefined),
                 },
-                nodeArgs: inspect || inspectBrk
-                    ? [`--${inspect ? 'inspect' : 'inspect-brk'}=:::${inspect || inspectBrk}`]
-                    : undefined,
+                nodeArgs,
                 watch: [serverPath, ...serverWatch],
                 delay,
             });

package/dist/common/typescript/compile.js

@@ -10,24 +10,11 @@ function compile(ts, { projectPath, configFileName = 'tsconfig.json', optionsToE
     logger.message('Start compilation');
     logger.message(`Typescript v${ts.version}`);
     logger.verbose(`Searching for the ${configFileName} in ${projectPath}`);
-    const configPath = (0, utils_1.getProjectConfig)(ts, projectPath, configFileName);
-    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, { noEmit: false, noEmitOnError: true, ...optionsToExtend }, parseConfigFileHost);
-    if (!parsedConfig) {
-        throw new Error(`Invalid '${configFileName}'`);
-    }
+    const parsedConfig = (0, utils_1.getTsProjectConfig)(ts, projectPath, configFileName, {
+        noEmit: false,
+        noEmitOnError: true,
+        ...optionsToExtend,
+    });
     logger.verbose('Config found and parsed');
     logger.verbose("We're about to create the program");
     const compilerHost = ts.createCompilerHost(parsedConfig.options);
@@ -57,6 +44,11 @@ function compile(ts, { projectPath, configFileName = 'tsconfig.json', optionsToE
     else {
         logger.success(`Compiled successfully in ${(0, pretty_time_1.elapsedTime)(start)}`);
     }
+    const formatHost = {
+        getCanonicalFileName: (path) => path,
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        getNewLine: () => ts.sys.newLine,
+    };
     function reportDiagnostic(diagnostic) {
         if (logger.isVerbose) {
             logger.message(ts.formatDiagnosticsWithColorAndContext([diagnostic], formatHost));

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

@@ -1,6 +1,7 @@
 import type Typescript from 'typescript';
 import type { Logger } from '../logger';
-export declare function getProjectConfig(ts: typeof Typescript, projectPath: string, filename?: string): string;
+export declare function getTsProjectConfigPath(ts: typeof Typescript, projectPath: string, filename?: string): string;
+export declare function getTsProjectConfig(ts: typeof Typescript, projectPath: string, filename?: string, optionsToExtend?: Typescript.CompilerOptions): Typescript.ParsedCommandLine;
 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;

package/dist/common/typescript/utils.js

@@ -3,19 +3,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getProjectConfig = getProjectConfig;
+exports.getTsProjectConfigPath = getTsProjectConfigPath;
+exports.getTsProjectConfig = getTsProjectConfig;
 exports.displayFilename = displayFilename;
 exports.onHostEvent = onHostEvent;
 exports.resolveTypescript = resolveTypescript;
 const node_path_1 = __importDefault(require("node:path"));
 const paths_1 = __importDefault(require("../paths"));
-function getProjectConfig(ts, projectPath, filename = 'tsconfig.json') {
+function getTsProjectConfigPath(ts, projectPath, filename = 'tsconfig.json') {
     const configPath = ts.findConfigFile(projectPath, ts.sys.fileExists, filename);
     if (!configPath) {
         throw new Error(`Could not find a valid '${filename}'.`);
     }
     return configPath;
 }
+function getTsProjectConfig(ts, projectPath, filename = 'tsconfig.json', optionsToExtend) {
+    const configPath = getTsProjectConfigPath(ts, projectPath, filename);
+    const parseConfigFileHost = {
+        getCurrentDirectory: ts.sys.getCurrentDirectory,
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+        readDirectory: ts.sys.readDirectory,
+        fileExists: ts.sys.fileExists,
+        readFile: ts.sys.readFile,
+        // this is required in types but not used
+        onUnRecoverableConfigFileDiagnostic: () => { },
+    };
+    const parsedConfig = ts.getParsedCommandLineOfConfigFile(configPath, optionsToExtend, parseConfigFileHost);
+    if (!parsedConfig) {
+        throw new Error(`Invalid config file '${configPath}'`);
+    }
+    return parsedConfig;
+}
 function displayFilename(originalFunc, operationName, logger) {
     let displayEnabled = false;
     let count = 0;

package/dist/common/typescript/watch.js

@@ -7,7 +7,7 @@ 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 configPath = (0, utils_1.getTsProjectConfigPath)(ts, projectPath);
     const createProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram;
     const formatHost = {
         getCanonicalFileName: (path) => path,

package/dist/common/webpack/config.js

@@ -174,7 +174,7 @@ function configureResolve({ isEnvProduction, config }) {
         alias['react-dom$'] = 'react-dom/profiling';
         alias['scheduler/tracing'] = 'scheduler/tracing-profiling';
     }
-    const { aliases, modules = [] } = (0, utils_1.resolveTsconfigPathsToAlias)(path.resolve(paths_1.default.appClient, 'tsconfig.json')) || {};
+    const { aliases, modules = [] } = (0, utils_1.resolveTsConfigPathsToAlias)(paths_1.default.appClient);
     return {
         alias: {
             ...aliases,
@@ -308,22 +308,23 @@ function createWorkerRule(options) {
     };
 }
 function createSassStylesRule(options) {
-    const loaders = getCssLoaders(options);
-    loaders.push({
-        loader: require.resolve('resolve-url-loader'),
-        options: {
-            sourceMap: !options.config.disableSourceMapGeneration,
+    const loaders = getCssLoaders(options, [
+        {
+            loader: require.resolve('resolve-url-loader'),
+            options: {
+                sourceMap: !options.config.disableSourceMapGeneration,
+            },
         },
-    });
-    loaders.push({
-        loader: require.resolve('sass-loader'),
-        options: {
-            sourceMap: true, // must be always true for work with resolve-url-loader
-            sassOptions: {
-                loadPaths: [paths_1.default.appClient],
+        {
+            loader: require.resolve('sass-loader'),
+            options: {
+                sourceMap: true, // must be always true for work with resolve-url-loader
+                sassOptions: {
+                    loadPaths: [paths_1.default.appClient],
+                },
             },
         },
-    });
+    ]);
     return {
         test: /\.scss$/,
         sideEffects: options.isEnvProduction ? true : undefined,
@@ -338,22 +339,32 @@ function createStylesRule(options) {
         use: loaders,
     };
 }
-function getCssLoaders({ isEnvDevelopment, isEnvProduction, config }) {
+function getCssLoaders({ isEnvDevelopment, isEnvProduction, config }, additionalRules) {
     const loaders = [];
-    if (isEnvProduction) {
-        loaders.push(mini_css_extract_plugin_1.default.loader);
-    }
-    if (isEnvDevelopment) {
+    if (!config.transformCssWithLightningCss) {
         loaders.push({
-            loader: require.resolve('style-loader'),
+            loader: require.resolve('postcss-loader'),
+            options: {
+                sourceMap: !config.disableSourceMapGeneration,
+                postcssOptions: {
+                    config: false,
+                    plugins: [
+                        [require.resolve('postcss-preset-env'), { enableClientSidePolyfills: false }],
+                    ],
+                },
+            },
         });
     }
-    loaders.push({
+    if (Array.isArray(additionalRules) && additionalRules.length > 0) {
+        loaders.push(...additionalRules);
+    }
+    const importLoaders = loaders.length;
+    loaders.unshift({
         loader: require.resolve('css-loader'),
         options: {
             esModule: false,
             sourceMap: !config.disableSourceMapGeneration,
-            importLoaders: 2,
+            importLoaders,
             modules: {
                 auto: true,
                 localIdentName: '[name]__[local]--[hash:base64:5]',
@@ -361,18 +372,12 @@ function getCssLoaders({ isEnvDevelopment, isEnvProduction, config }) {
             },
         },
     });
-    if (!config.transformCssWithLightningCss) {
-        loaders.push({
-            loader: require.resolve('postcss-loader'),
-            options: {
-                sourceMap: !config.disableSourceMapGeneration,
-                postcssOptions: {
-                    config: false,
-                    plugins: [
-                        [require.resolve('postcss-preset-env'), { enableClientSidePolyfills: false }],
-                    ],
-                },
-            },
+    if (isEnvProduction) {
+        loaders.unshift(mini_css_extract_plugin_1.default.loader);
+    }
+    if (isEnvDevelopment) {
+        loaders.unshift({
+            loader: require.resolve('style-loader'),
         });
     }
     return loaders;

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

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

package/dist/common/webpack/utils.js

@@ -24,10 +24,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webpackCompilerHandlerFactory = webpackCompilerHandlerFactory;
-exports.resolveTsconfigPathsToAlias = resolveTsconfigPathsToAlias;
+exports.resolveTsConfigPathsToAlias = resolveTsConfigPathsToAlias;
 const path = __importStar(require("node:path"));
-const fs = __importStar(require("node:fs"));
+const ts = __importStar(require("typescript"));
 const pretty_time_1 = require("../logger/pretty-time");
+const utils_1 = require("../typescript/utils");
 function webpackCompilerHandlerFactory(logger, onCompilationEnd) {
     return async (err, stats) => {
         if (err) {
@@ -60,15 +61,22 @@ function webpackCompilerHandlerFactory(logger, onCompilationEnd) {
     };
 }
 const endStarRe = /\/?\*$/;
-function resolveTsconfigPathsToAlias(tsConfigPath) {
-    if (!fs.existsSync(tsConfigPath) || !fs.statSync(tsConfigPath).isFile) {
-        return undefined;
+function resolveTsConfigPathsToAlias(projectPath, filename = 'tsconfig.json') {
+    let parsed;
+    try {
+        parsed = (0, utils_1.getTsProjectConfig)(ts, projectPath, filename);
+    }
+    catch {
+        return {};
     }
-    const { paths = {}, baseUrl } = readJsonConfig(tsConfigPath).compilerOptions || {};
+    if (parsed.errors.length > 0) {
+        return {};
+    }
+    const { paths = {}, baseUrl } = parsed.options;
     if (!baseUrl) {
-        return undefined;
+        return {};
     }
-    const basePath = path.resolve(path.dirname(tsConfigPath), baseUrl);
+    const basePath = path.resolve(path.dirname(projectPath), baseUrl);
     const aliases = {};
     const modules = [basePath];
     for (const [key, value] of Object.entries(paths)) {
@@ -84,14 +92,3 @@ function resolveTsconfigPathsToAlias(tsConfigPath) {
     }
     return { aliases, modules };
 }
-function readJsonConfig(pathname) {
-    try {
-        const json = fs.readFileSync(pathname, 'utf-8');
-        return {
-            ...JSON.parse(json),
-        };
-    }
-    catch {
-        throw new Error(`Couldn't read config ${pathname}`);
-    }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/app-builder",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Develop and build your React client-server projects, powered by typescript and webpack",
   "license": "MIT",
   "type": "commonjs",