@tramvai/cli 5.49.1 → 6.59.0

package/src/library/babel/plugins/lazy-component/lazy-component.spec.ts

@@ -1,47 +0,0 @@
-import path from 'path';
-import pluginTester from 'babel-plugin-tester';
-import babelConfig from '../../index';
-
-pluginTester({
-  plugin: {}, // плагин уже есть в основном конфиге, если подключить ещё тут то babel упадёт
-  pluginName: 'lazy-component',
-  filename: path.join(__dirname, '..', '__fixtures__', 'lazy-component', 'test'),
-  babelOptions: babelConfig({
-    typescript: true,
-    generateDataQaTag: false,
-    loader: false,
-    hot: true,
-    actualTarget: 'modern',
-    browsersListTargets: ['defaults'],
-  }),
-  tests: {
-    'not lazy': {
-      fixture: 'not-lazy.ts',
-      snapshot: true,
-    },
-    'tramvai react but not lazy': {
-      fixture: 'not-lazy-import.ts',
-      snapshot: true,
-    },
-    base: {
-      fixture: 'base.ts',
-      snapshot: true,
-    },
-    'long import': {
-      fixture: 'long-import.ts',
-      snapshot: true,
-    },
-    dynamic: {
-      fixture: 'dynamic.ts',
-      snapshot: true,
-    },
-    comments: {
-      fixture: 'comments.ts',
-      snapshot: true,
-    },
-    hmr: {
-      fixture: 'lazy+hmr.ts',
-      snapshot: true,
-    },
-  },
-});

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

@@ -1,91 +0,0 @@
-import type { NodePath } from '@babel/traverse';
-import type { CallExpression, Import } from '@babel/types';
-import type { Plugin } from '../types.h';
-import { resolveMethod } from './properties/resolve';
-import { requireSyncMethod } from './properties/requireSync';
-import { isReadyMethod } from './properties/isReady';
-import { importAsyncMethod } from './properties/importAsync';
-import { requireAsyncMethod } from './properties/requireAsync';
-import { chunkNameMethod } from './properties/chunkName';
-
-interface InnerState {
-  tramvaiReactLazyLocal: string;
-}
-
-export const lazyComponentPlugin: Plugin<InnerState> = (api) => {
-  const { types: t } = api;
-
-  return {
-    pre() {
-      this.tramvaiReactLazyLocal = null;
-    },
-    visitor: {
-      // находим импорты `import { lazy } from '@tramvai/react'` т.к. будем преобразовывать импорты только для них
-      ImportDeclaration(path) {
-        if (path.get('source').node.value === '@tramvai/react') {
-          const specifiers = path.get('specifiers');
-
-          for (const specifier of specifiers) {
-            if (
-              t.isImportSpecifier(specifier.node) &&
-              t.isIdentifier(specifier.node.imported) &&
-              specifier.node.imported.name === 'lazy'
-            ) {
-              // учитываем что локальная переменная в файле может быть названа по-другому
-              this.tramvaiReactLazyLocal = specifier.node.local.name;
-              break;
-            }
-          }
-        }
-      },
-      CallExpression(path) {
-        if (!this.tramvaiReactLazyLocal) {
-          // если импорт lazy не был найден, то нет смысла работать с файлом дальше
-          return;
-        }
-
-        // проверяет только вызовы lazy
-        if (path.get('callee').isIdentifier({ name: this.tramvaiReactLazyLocal })) {
-          const imports: NodePath<Import>[] = [];
-
-          // ищем импорты внутри вызова lazy
-          path.traverse({
-            Import(importPath) {
-              imports.push(importPath);
-            },
-          });
-
-          if (imports.length !== 1) {
-            return;
-          }
-
-          // локальное имя для lazy из @tramvai/react
-          const lazyCallPath = path;
-          // ссылка на вызов импорта - чтобы можно было получить аргументы импорта
-          const importPath = imports[0].parentPath as NodePath<CallExpression>;
-          // ссылка на функцию, которая была передана в lazy
-          const funcPath = importPath.parentPath;
-
-          if (!funcPath.isFunctionExpression() && !funcPath.isArrowFunctionExpression()) {
-            return;
-          }
-
-          const properties = [
-            chunkNameMethod,
-            requireSyncMethod,
-            isReadyMethod,
-            importAsyncMethod,
-            requireAsyncMethod,
-            resolveMethod,
-          ].map((init) => init(api));
-
-          const opts = { lazyCallPath, funcPath, importPath };
-
-          funcPath.replaceWith(t.objectExpression(properties.map((factory) => factory(opts))));
-        }
-      },
-    },
-  };
-};
-
-export default lazyComponentPlugin;

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

@@ -1,34 +0,0 @@
-import path from 'path';
-import pluginTester from 'babel-plugin-tester';
-import babelConfig from '../../index';
-
-pluginTester({
-  plugin: {}, // плагин уже есть в основном конфиге, если подключить ещё тут то babel упадёт
-  pluginName: 'legacy-universal-replace',
-  filename: path.join(__dirname, '..', '__fixtures__', 'legacy-universal-replace', 'test'),
-  babelOptions: babelConfig({
-    typescript: true,
-    generateDataQaTag: false,
-    loader: false,
-    actualTarget: 'modern',
-    browsersListTargets: ['defaults'],
-  }),
-  tests: {
-    'not universal': {
-      fixture: 'not-universal.ts',
-      snapshot: true,
-    },
-    'react-universal': {
-      fixture: 'react-universal.ts',
-      snapshot: true,
-    },
-    'platform legacy': {
-      fixture: 'platform-legacy.ts',
-      snapshot: true,
-    },
-    'tramvai-react': {
-      fixture: 'tramvai/react/index.es.ts',
-      snapshot: true,
-    },
-  },
-});

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,
-    },
-  },
-});