@tramvai/cli 5.53.80 → 6.62.0

package/src/library/babel/plugins/lazy-component/legacy-universal-replace.ts

@@ -1,88 +0,0 @@
-import type { Identifier } from '@babel/types';
-import type { Plugin } from '../types.h';
-
-interface InnerState {
-  legacyImport: string;
-  lazyIdentifier: Identifier;
-  file: {
-    opts: {
-      filename: string;
-    };
-  };
-}
-
-export const legacyUniversalReplace: Plugin<InnerState> = (api) => {
-  const { types: t } = api;
-
-  return {
-    visitor: {
-      // находим импорты `import universal from 'react-universal-component'` или `import async from '/decorators/asyncUniversal`
-      ImportDeclaration(path) {
-        const { filename } = this.file.opts;
-
-        const isTramvaiReact = /tramvai\/react/.test(filename);
-
-        const { value: source } = path.get('source').node;
-        if (
-          source === 'react-universal-component' ||
-          /\/decorators\/asyncUniversal(\.js)?$/.test(source)
-        ) {
-          const specifiers = path.get('specifiers');
-
-          if (isTramvaiReact) {
-            path.replaceWith(
-              t.importDeclaration(
-                [t.importDefaultSpecifier(t.identifier('universal'))],
-                t.stringLiteral('@loadable/component')
-              )
-            );
-
-            return;
-          }
-
-          for (const specifier of specifiers) {
-            if (t.isImportDefaultSpecifier(specifier.node)) {
-              this.legacyImport = specifier.node.local.name;
-            }
-          }
-
-          if (this.legacyImport) {
-            const oldImport = path.node;
-
-            this.lazyIdentifier = path.scope.generateUidIdentifier('lazy');
-
-            path.replaceWith(
-              t.importDeclaration(
-                [t.importSpecifier(this.lazyIdentifier, t.identifier('lazy'))],
-                t.stringLiteral('@tramvai/react')
-              )
-            );
-
-            if (specifiers.length > 1) {
-              // возвращаем старый импорт на место, если вдруг используются другие импорты из legacy файла
-              path.insertBefore(oldImport);
-            }
-          }
-        }
-      },
-      CallExpression(path) {
-        if (!this.legacyImport) {
-          // если импорт не был найден, то нет смысла работать с файлом дальше
-          return;
-        }
-
-        if (path.get('callee').isIdentifier({ name: this.legacyImport })) {
-          const impPath = path.get('arguments')[0];
-
-          if (impPath.isCallExpression() && impPath.get('callee').isImport()) {
-            path.replaceWith(
-              t.callExpression(this.lazyIdentifier, [t.arrowFunctionExpression([], impPath.node)])
-            );
-          }
-        }
-      },
-    },
-  };
-};
-
-export default legacyUniversalReplace;

package/src/library/babel/plugins/lazy-component/properties/chunkName.ts

@@ -1,185 +0,0 @@
-import type { NodePath } from '@babel/core';
-import type {
-  BinaryExpression,
-  CallExpression,
-  Expression,
-  StringLiteral,
-  TemplateElement,
-  TemplateLiteral,
-} from '@babel/types';
-import type { ImportPath, PropertyFactory } from './types';
-import type { WebpackComments } from './utils/webpackComments';
-import { generateWebpackComments, parseWebpackComments } from './utils/webpackComments';
-
-const JS_PATH_REGEXP = /^[./]+|(\.js$)/g;
-const MATCH_LEFT_HYPHENS_REPLACE_REGEX = /^-/g;
-const WEBPACK_CHUNK_NAME_REGEXP = /webpackChunkName/;
-const WEBPACK_PATH_NAME_NORMALIZE_REPLACE_REGEX = /[^a-zA-Z0-9_!§$()=\-^°]+/g;
-const WEBPACK_MATCH_PADDED_HYPHENS_REPLACE_REGEX = /^-|-$/g;
-
-const getChunkNameComment = (importArg: NodePath) => {
-  const comments = importArg.node.leadingComments;
-
-  if (!comments) return null;
-
-  return comments.find((comment) => comment.value.match(WEBPACK_CHUNK_NAME_REGEXP));
-};
-
-const getRawChunkNameFromComments = (importArg: NodePath) => {
-  const chunkNameComment = getChunkNameComment(importArg);
-
-  if (!chunkNameComment) return null;
-
-  return parseWebpackComments(chunkNameComment.value);
-};
-
-const moduleToChunk = (str?: string) => {
-  if (typeof str !== 'string') return '';
-
-  return str
-    .replace(JS_PATH_REGEXP, '')
-    .replace(WEBPACK_PATH_NAME_NORMALIZE_REPLACE_REGEX, '-')
-    .replace(WEBPACK_MATCH_PADDED_HYPHENS_REPLACE_REGEX, '');
-};
-
-const replaceQuasi = (str: string, stripLeftHyphen: boolean) => {
-  if (!str) return '';
-  const result = str.replace(WEBPACK_PATH_NAME_NORMALIZE_REPLACE_REGEX, '-');
-  if (!stripLeftHyphen) return result;
-  return result.replace(MATCH_LEFT_HYPHENS_REPLACE_REGEX, '');
-};
-
-const getChunkNamePrefix = (chunkName?: string) => {
-  if (typeof chunkName !== 'string') return '';
-  const match = chunkName.match(/(.+?)\[(request|index)\]$/);
-  return match ? match[1] : '';
-};
-
-const getImportArg = (importPath: ImportPath) => {
-  const arg = importPath.get('arguments')[0];
-
-  if (arg.isStringLiteral() || arg.isTemplateLiteral()) {
-    return arg;
-  }
-};
-
-// высчитывает имя чанка, учитывая разные кейсы нейминга и использование динамических испортов на основании пропсов
-// также добавляет комментарий для webpack чтобы это имя чанка использовалось для файла
-export const chunkNameMethod: PropertyFactory = ({ types: t }) => {
-  const transformQuasi = (quasi: TemplateElement, first: boolean, single: boolean) => {
-    return t.templateElement(
-      {
-        raw: single ? moduleToChunk(quasi.value.raw) : replaceQuasi(quasi.value.raw, first),
-        cooked: single
-          ? moduleToChunk(quasi.value.cooked)
-          : replaceQuasi(quasi.value.cooked, first),
-      },
-      quasi.tail
-    );
-  };
-
-  const sanitizeChunkNameTemplateLiteral = (node: Expression) => {
-    return t.callExpression(t.memberExpression(node, t.identifier('replace')), [
-      t.regExpLiteral(WEBPACK_PATH_NAME_NORMALIZE_REPLACE_REGEX.source, 'g'),
-      t.stringLiteral('-'),
-    ]);
-  };
-
-  const combineExpressions = (node: TemplateLiteral) => {
-    const expressions = node.expressions as Expression[];
-    const { length } = expressions;
-
-    if (length === 1) {
-      return expressions[0];
-    }
-
-    return expressions.slice(1).reduce((r, p) => t.binaryExpression('+', r, p), expressions[0]);
-  };
-
-  const generateChunkNameNode = (importPath: ImportPath, prefix?: string) => {
-    const importArg = getImportArg(importPath);
-    if (importArg.isTemplateLiteral()) {
-      return prefix
-        ? t.binaryExpression(
-            '+',
-            t.stringLiteral(prefix),
-            sanitizeChunkNameTemplateLiteral(combineExpressions(importArg.node))
-          )
-        : t.templateLiteral(
-            importArg.node.quasis.map((quasi, index) =>
-              transformQuasi(quasi, index === 0, importArg.node.quasis.length === 1)
-            ),
-            importArg.node.expressions
-          );
-    }
-    return t.stringLiteral(moduleToChunk(importArg.node.value));
-  };
-
-  const getExistingChunkNameComment = (importPath: ImportPath) => {
-    const importArg = getImportArg(importPath);
-    const values = getRawChunkNameFromComments(importArg);
-
-    return values;
-  };
-
-  const isAggressiveImport = (importPath: ImportPath) => {
-    const importArg = getImportArg(importPath);
-
-    return importArg.isTemplateLiteral() && importArg.node.expressions.length > 0;
-  };
-
-  const addOrReplaceChunkNameComment = (importPath: ImportPath, values: WebpackComments) => {
-    const importArg = getImportArg(importPath);
-    const chunkNameComment = getChunkNameComment(importArg);
-
-    if (chunkNameComment) {
-      t.removeComments(importArg.node);
-    }
-
-    importArg.addComment('leading', generateWebpackComments(values));
-  };
-
-  const chunkNameFromTemplateLiteral = (node: TemplateLiteral) => {
-    const [q1] = node.quasis;
-    const v1 = q1 ? q1.value.cooked : '';
-
-    if (!node.expressions.length) return v1;
-
-    return `${v1}[request]`;
-  };
-
-  const replaceChunkName = (importPath: ImportPath) => {
-    const aggressiveImport = isAggressiveImport(importPath);
-    const values = getExistingChunkNameComment(importPath);
-    let { webpackChunkName } = values || {};
-
-    if (!aggressiveImport && values) {
-      addOrReplaceChunkNameComment(importPath, values);
-      return t.stringLiteral(webpackChunkName);
-    }
-
-    let chunkNameNode: CallExpression | TemplateLiteral | StringLiteral | BinaryExpression =
-      generateChunkNameNode(importPath, getChunkNamePrefix(webpackChunkName));
-
-    if (t.isTemplateLiteral(chunkNameNode)) {
-      webpackChunkName = chunkNameFromTemplateLiteral(chunkNameNode);
-      chunkNameNode = sanitizeChunkNameTemplateLiteral(chunkNameNode);
-    } else if (t.isStringLiteral(chunkNameNode)) {
-      webpackChunkName = chunkNameNode.value;
-    }
-
-    addOrReplaceChunkNameComment(importPath, { ...values, webpackChunkName });
-    return chunkNameNode;
-  };
-
-  return ({ funcPath, importPath }) => {
-    const chunkName = replaceChunkName(importPath);
-
-    return t.objectMethod(
-      'method',
-      t.identifier('chunkName'),
-      funcPath.node.params,
-      t.blockStatement([t.returnStatement(chunkName)])
-    );
-  };
-};

package/src/library/babel/plugins/lazy-component/properties/importAsync.ts

@@ -1,8 +0,0 @@
-import type { PropertyFactory } from './types';
-
-// просто оставляет импорт как есть + добавляет автоматически указание имени чанка для вебпака
-export const importAsyncMethod: PropertyFactory = ({ types: t }) => {
-  return ({ funcPath }) => {
-    return t.objectProperty(t.identifier('importAsync'), funcPath.node);
-  };
-};

package/src/library/babel/plugins/lazy-component/properties/isReady.ts

@@ -1,19 +0,0 @@
-import type { Statement } from '@babel/types';
-import type { PropertyFactory } from './types';
-
-// проверяет на клиенте что нужный чанк загружен и его можно заполучить синхронно
-export const isReadyMethod: PropertyFactory = ({ types: t, template }) => {
-  const statements = template.ast(`
-    const key=this.resolve(props);
-
-    return !!(__webpack_modules__[key]);
-  `);
-
-  return () =>
-    t.objectMethod(
-      'method',
-      t.identifier('isReady'),
-      [t.identifier('props')],
-      t.blockStatement(statements as Statement[])
-    );
-};

package/src/library/babel/plugins/lazy-component/properties/requireAsync.ts

@@ -1,20 +0,0 @@
-import type { Statement } from '@babel/types';
-import type { PropertyFactory } from './types';
-
-export const requireAsyncMethod: PropertyFactory = ({ types: t, template }) => {
-  const tracking = template.ast(`
-    const key = this.resolve(props);
-
-    return this.importAsync(props).then(resolved => {
-     return resolved;
-    });
-  `);
-
-  return () =>
-    t.objectMethod(
-      'method',
-      t.identifier('requireAsync'),
-      [t.identifier('props')],
-      t.blockStatement(tracking as Statement[])
-    );
-};

package/src/library/babel/plugins/lazy-component/properties/requireSync.ts

@@ -1,21 +0,0 @@
-import type { PropertyFactory } from './types';
-
-// позволяет загрузить модуль синхронно - нужно на сервере и чтобы не выполнять повторную загрузку,
-// если чанк уже был загружен ранее на клиенте
-export const requireSyncMethod: PropertyFactory = ({ types: t, template }) => {
-  return () =>
-    t.objectMethod(
-      'method',
-      t.identifier('requireSync'),
-      [t.identifier('props')],
-      t.blockStatement([
-        t.returnStatement(
-          t.callExpression(t.identifier('__webpack_require__'), [
-            t.callExpression(t.memberExpression(t.thisExpression(), t.identifier('resolve')), [
-              t.identifier('props'),
-            ]),
-          ])
-        ),
-      ])
-    );
-};

package/src/library/babel/plugins/lazy-component/properties/resolve.ts

@@ -1,21 +0,0 @@
-import type { PropertyFactory } from './types';
-
-// позволяет получить в рантайме id модуля, который нужно загрузить. В деве это обычно путь к файлу и в @loadable
-// это свойство используется преимущественно для логов
-export const resolveMethod: PropertyFactory = ({ types: t }) => {
-  return ({ importPath, funcPath }) => {
-    return t.objectMethod(
-      'method',
-      t.identifier('resolve'),
-      funcPath.node.params ?? [],
-      t.blockStatement([
-        t.returnStatement(
-          t.callExpression(
-            t.memberExpression(t.identifier('require'), t.identifier('resolveWeak')),
-            [importPath.get('arguments')[0].node]
-          )
-        ),
-      ])
-    );
-  };
-};

package/src/library/babel/plugins/lazy-component/properties/types.ts

@@ -1,20 +0,0 @@
-import type { types, template, NodePath } from '@babel/core';
-import type {
-  FunctionExpression,
-  CallExpression,
-  ObjectMember,
-  ArrowFunctionExpression,
-} from '@babel/types';
-
-export type LazyCallPath = NodePath<CallExpression>;
-export type FuncPath = NodePath<FunctionExpression | ArrowFunctionExpression>;
-export type ImportPath = NodePath<CallExpression>;
-
-export type PropertyFactory = (arg: {
-  types: typeof types;
-  template: typeof template;
-}) => (arg: {
-  lazyCallPath: LazyCallPath;
-  funcPath: FuncPath;
-  importPath: ImportPath;
-}) => ObjectMember;

package/src/library/babel/plugins/lazy-component/properties/utils/webpackComments.ts

@@ -1,61 +0,0 @@
-export interface WebpackComments {
-  webpackChunk?: string;
-  [key: string]: string;
-}
-
-const quotesRegex = /["']/g;
-
-/**
- * Expect string with specific magic comments here - `webpackChunkName`.
- * Objects can be here - https://webpack.js.org/api/module-methods/#magic-comments:~:text=This%20is%20wrapped%20in%20a%20JavaScript%20object%20and%20executed%20using%20node%20VM
- * But vm.runInThisContext is slow, and we can cover only simple case here, while use this helper only in `chunkName.ts`
- *
- * @param str - example: ' webpackChunkName: "any_chunk_name" '
- */
-export const parseWebpackComments = (str: string): WebpackComments => {
-  try {
-    const rawValues = str.trim().split(',');
-    const values: WebpackComments = {};
-
-    rawValues.forEach((comment) => {
-      const [key, rawValue] = comment.trim().split(':');
-      let value: any = rawValue.trim();
-
-      switch (value) {
-        case 'true': {
-          value = true;
-          break;
-        }
-        case 'false': {
-          value = false;
-          break;
-        }
-        case 'null': {
-          value = null;
-          break;
-        }
-        default: {
-          value = value.replace(quotesRegex, '');
-        }
-      }
-
-      values[key] = value;
-    });
-
-    return values;
-  } catch (e) {
-    throw Error(`compilation error while processing: /*${str}*/: ${e.message}`);
-  }
-};
-
-export const generateWebpackComments = (values: WebpackComments) => {
-  try {
-    const str = Object.keys(values)
-      .map((key) => `${key}: ${JSON.stringify(values[key])}`)
-      .join(', ');
-
-    return ` ${str} `;
-  } catch (e) {
-    throw Error(`compilation error while processing: /*${values}*/: ${e.message}`);
-  }
-};

package/src/library/babel/plugins/provider-stack.spec.ts

@@ -1,55 +0,0 @@
-import path from 'path';
-import pluginTester from 'babel-plugin-tester';
-import { providerStackPlugin } from './provider-stack';
-import babelConfig from '../index';
-
-pluginTester({
-  plugin: providerStackPlugin,
-  pluginName: 'provider-stack',
-  filename: path.join(__dirname, '__fixtures__', 'provider-stack', 'test'),
-  babelOptions: babelConfig({
-    typescript: true,
-    generateDataQaTag: false,
-    loader: false,
-  }),
-  tests: {
-    'do nothing': {
-      fixture: 'do-nothing.ts',
-      snapshot: true,
-    },
-    'add __stack property to module decorator providers': {
-      fixture: 'module-decorator.ts',
-      snapshot: true,
-    },
-    'add __stack property external providers': {
-      fixture: 'add-stack.ts',
-      snapshot: true,
-    },
-    'add __stack property if Error in scope': {
-      fixture: 'error-in-scope.ts',
-      snapshot: true,
-    },
-    'inside await': {
-      fixture: 'inside-await.ts',
-      snapshot: true,
-    },
-  },
-});
-
-pluginTester({
-  plugin: providerStackPlugin,
-  pluginName: 'provider-stack',
-  filename: path.join(__dirname, '__fixtures__', 'provider-stack', 'test'),
-  babelOptions: babelConfig({
-    typescript: true,
-    generateDataQaTag: false,
-    loader: false,
-    excludesPresetEnv: ['transform-function-name'],
-  }),
-  tests: {
-    'check function naming': {
-      fixture: 'check-function-name.ts',
-      snapshot: true,
-    },
-  },
-});

package/src/library/babel/plugins/provider-stack.ts

@@ -1,88 +0,0 @@
-import type { Identifier, Expression, ObjectExpression } from '@babel/types';
-import type { NodePath } from '@babel/traverse';
-import type { Plugin } from './types.h';
-
-const INNER_COMMENT = '__tramvai_stack_provider__';
-
-export const providerStackPlugin: Plugin = ({ types: t }) => {
-  const isProvider = (path: NodePath<ObjectExpression>) => {
-    const { properties } = path.node;
-    let hasProvideKey = false;
-    let hasUseKey = false;
-
-    for (const prop of properties) {
-      if (t.isObjectProperty(prop)) {
-        const { key } = prop;
-
-        if (
-          t.isIdentifier(key, { name: 'useValue' }) ||
-          t.isIdentifier(key, { name: 'useFactory' }) ||
-          t.isIdentifier(key, { name: 'useClass' })
-        ) {
-          hasUseKey = true;
-        }
-
-        if (t.isIdentifier(key, { name: 'provide' })) {
-          hasProvideKey = true;
-        }
-
-        if (hasProvideKey && hasUseKey) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  };
-
-  const generateStack = (path: NodePath<ObjectExpression>) => {
-    if (path.scope.hasBinding('Error', true)) {
-      path.scope.rename('Error');
-    }
-
-    return t.memberExpression(t.newExpression(t.identifier('Error'), []), t.identifier('stack'));
-  };
-
-  const defineProperty = (id: Identifier, value: Expression) => {
-    return t.callExpression(
-      t.memberExpression(t.identifier('Object'), t.identifier('defineProperty')),
-      [
-        id,
-        t.stringLiteral('__stack'),
-        t.objectExpression([
-          t.objectProperty(t.identifier('enumerable'), t.booleanLiteral(false)),
-          t.objectProperty(t.identifier('value'), value),
-        ]),
-      ]
-    );
-  };
-
-  return {
-    visitor: {
-      ObjectExpression(path) {
-        if (
-          isProvider(path) &&
-          !path.node.leadingComments?.find((comment) => comment.value === INNER_COMMENT)
-        ) {
-          const ref = path.scope.generateDeclaredUidIdentifier('ref');
-
-          const newNode = t.addComment(
-            t.objectExpression(path.node.properties),
-            'leading',
-            INNER_COMMENT
-          );
-
-          path.replaceWith(
-            t.sequenceExpression([
-              t.assignmentExpression('=', ref, newNode),
-              defineProperty(ref, generateStack(path)),
-              ref,
-            ])
-          );
-        }
-      },
-    },
-  };
-};
-
-export default providerStackPlugin;

package/src/library/babel/plugins/react-compiler.ts

@@ -1,39 +0,0 @@
-import { resolveReactVersion } from '../../../utils/resolveReactVersion';
-import type { ReactCompilerOptions } from '../../../typings/configEntry/cli';
-
-type ReactCompilerTarget = '17' | '18' | '19';
-
-const resolveTarget = (): ReactCompilerTarget => {
-  const resolved = resolveReactVersion();
-  const major = resolved.major.toString() as ReactCompilerTarget;
-
-  if (['17', '18', '19'].includes(major)) {
-    return major;
-  }
-
-  throw new Error(
-    `Resolved React version is ${resolved.version} which is not supported. Supported versions are 17, 18 and 19.`
-  );
-};
-
-export const getReactCompilerPlugin = ({
-  options,
-  isServer,
-}: {
-  options: boolean | ReactCompilerOptions;
-  isServer: boolean;
-}) => {
-  if (!options || isServer) {
-    return undefined;
-  }
-
-  const compilerOptions = typeof options === 'boolean' ? {} : options;
-
-  return [
-    'babel-plugin-react-compiler',
-    {
-      ...compilerOptions,
-      target: resolveTarget(),
-    },
-  ];
-};