auto-cr-rules 1.0.13 → 2.0.2

package/dist/imports.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectImportReferences = void 0;
+var isSwcNode = function (value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    if (!('type' in value)) {
+        return false;
+    }
+    return typeof value.type === 'string';
+};
+var traverse = function (value, visitor) {
+    if (Array.isArray(value)) {
+        for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
+            var element = value_1[_i];
+            traverse(element, visitor);
+        }
+        return;
+    }
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+    if (isSwcNode(value)) {
+        visitor(value);
+    }
+    var record = value;
+    for (var _a = 0, _b = Object.values(record); _a < _b.length; _a++) {
+        var child = _b[_a];
+        if (typeof child === 'object' && child !== null) {
+            traverse(child, visitor);
+        }
+    }
+};
+var isImportDeclaration = function (node) { return node.type === 'ImportDeclaration'; };
+var isCallExpression = function (node) { return node.type === 'CallExpression'; };
+var collectImportReferences = function (module) {
+    var results = [];
+    traverse(module, function (node) {
+        if (isImportDeclaration(node)) {
+            results.push({
+                kind: 'static',
+                value: node.source.value,
+                span: node.source.span,
+            });
+            return;
+        }
+        if (isCallExpression(node)) {
+            var reference = extractFromCallExpression(node);
+            if (reference) {
+                results.push(reference);
+            }
+        }
+    });
+    return results;
+};
+exports.collectImportReferences = collectImportReferences;
+var extractFromCallExpression = function (node) {
+    if (!node.arguments.length) {
+        return null;
+    }
+    var firstArgument = node.arguments[0];
+    if (!firstArgument || isSpread(firstArgument)) {
+        return null;
+    }
+    var literal = getStringLiteral(firstArgument);
+    if (!literal) {
+        return null;
+    }
+    if (node.callee.type === 'Import') {
+        return createImportReference('dynamic', literal);
+    }
+    if (isRequireIdentifier(node.callee) || isRequireMember(node.callee)) {
+        return createImportReference('require', literal);
+    }
+    return null;
+};
+var createImportReference = function (kind, literal) { return ({
+    kind: kind,
+    value: literal.value,
+    span: literal.span,
+}); };
+var isSpread = function (argument) { return Boolean(argument.spread); };
+var getStringLiteral = function (argument) {
+    if (argument.expression.type === 'StringLiteral') {
+        return argument.expression;
+    }
+    return null;
+};
+var isRequireIdentifier = function (expression) {
+    return expression.type === 'Identifier' && expression.value === 'require';
+};
+var isRequireMember = function (expression) {
+    return (expression.type === 'MemberExpression' &&
+        expression.object.type === 'Identifier' &&
+        expression.object.value === 'require');
+};

package/dist/index.js

@@ -1,8 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rules = void 0;
-var NoDeepRelativeImports_1 = __importDefault(require("./rules/NoDeepRelativeImports"));
-exports.rules = [NoDeepRelativeImports_1.default];
+exports.noDeepRelativeImports = exports.builtinRules = exports.createRuleContext = exports.toRule = exports.isRule = exports.defineRule = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "defineRule", { enumerable: true, get: function () { return types_1.defineRule; } });
+Object.defineProperty(exports, "isRule", { enumerable: true, get: function () { return types_1.isRule; } });
+Object.defineProperty(exports, "toRule", { enumerable: true, get: function () { return types_1.toRule; } });
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "createRuleContext", { enumerable: true, get: function () { return runtime_1.createRuleContext; } });
+var rules_1 = require("./rules");
+Object.defineProperty(exports, "builtinRules", { enumerable: true, get: function () { return rules_1.builtinRules; } });
+Object.defineProperty(exports, "noDeepRelativeImports", { enumerable: true, get: function () { return rules_1.noDeepRelativeImports; } });

package/dist/messages.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuleMessages = void 0;
+var ruleTranslations = {
+    zh: {
+        noDeepRelativeImports: function (_a) {
+            var value = _a.value, maxDepth = _a.maxDepth;
+            return "\u5BFC\u5165\u8DEF\u5F84 \"".concat(value, "\" \u4E0D\u80FD\u8D85\u8FC7\u6700\u5927\u5C42\u7EA7").concat(maxDepth);
+        },
+    },
+    en: {
+        noDeepRelativeImports: function (_a) {
+            var value = _a.value, maxDepth = _a.maxDepth;
+            return "Import path \"".concat(value, "\" must not exceed max depth ").concat(maxDepth);
+        },
+    },
+};
+Object.values(ruleTranslations).forEach(function (messages) { return Object.freeze(messages); });
+var createRuleMessages = function (language) {
+    var _a;
+    return (_a = ruleTranslations[language]) !== null && _a !== void 0 ? _a : ruleTranslations.zh;
+};
+exports.createRuleMessages = createRuleMessages;

package/dist/rules/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noDeepRelativeImports = exports.builtinRules = void 0;
+var noDeepRelativeImports_1 = require("./noDeepRelativeImports");
+Object.defineProperty(exports, "noDeepRelativeImports", { enumerable: true, get: function () { return noDeepRelativeImports_1.noDeepRelativeImports; } });
+exports.builtinRules = [noDeepRelativeImports_1.noDeepRelativeImports];

package/dist/rules/noDeepRelativeImports.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noDeepRelativeImports = void 0;
+var types_1 = require("../types");
+var MAX_DEPTH = 2;
+exports.noDeepRelativeImports = (0, types_1.defineRule)('no-deep-relative-imports', { tag: 'base' }, function (_a) {
+    var helpers = _a.helpers, messages = _a.messages;
+    for (var _i = 0, _b = helpers.imports; _i < _b.length; _i++) {
+        var reference = _b[_i];
+        if (!helpers.isRelativePath(reference.value)) {
+            continue;
+        }
+        var depth = helpers.relativeDepth(reference.value);
+        if (depth > MAX_DEPTH) {
+            helpers.reportViolation(messages.noDeepRelativeImports({ value: reference.value, maxDepth: MAX_DEPTH }), reference.span);
+        }
+    }
+});

package/dist/runtime.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuleContext = void 0;
+var imports_1 = require("./imports");
+var messages_1 = require("./messages");
+var createRuleContext = function (_a) {
+    var ast = _a.ast, filePath = _a.filePath, source = _a.source, reporter = _a.reporter, language = _a.language;
+    var imports = (0, imports_1.collectImportReferences)(ast);
+    var messages = (0, messages_1.createRuleMessages)(language);
+    var helpers = Object.freeze(createRuleHelpers(reporter, imports));
+    return Object.freeze({
+        ast: ast,
+        filePath: filePath,
+        source: source,
+        language: language,
+        reporter: reporter,
+        helpers: helpers,
+        messages: messages,
+    });
+};
+exports.createRuleContext = createRuleContext;
+var createRuleHelpers = function (reporter, imports) {
+    var isRelativePath = function (value) { return value.startsWith('.'); };
+    var relativeDepth = function (value) {
+        return (value.match(/\.\.\//g) || []).length;
+    };
+    var reportViolation = function (message, span) {
+        if (span) {
+            reporter.errorAtSpan(span, message);
+            return;
+        }
+        reporter.error(message);
+    };
+    return {
+        imports: imports,
+        isRelativePath: isRelativePath,
+        relativeDepth: relativeDepth,
+        reportViolation: reportViolation,
+    };
+};

package/dist/types/imports.d.ts

@@ -0,0 +1,3 @@
+import type { Module } from '@swc/types';
+import type { ImportReference } from './types';
+export declare const collectImportReferences: (module: Module) => ImportReference[];

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export type { ImportReference, Language, Rule, RuleMetadata, RuleContext, RuleHelpers, RuleMessages, RuleReporter, } from './types';
+export { defineRule, isRule, toRule } from './types';
+export { createRuleContext } from './runtime';
+export type { RuleContextOptions } from './runtime';
+export { builtinRules, noDeepRelativeImports } from './rules';

package/dist/types/messages.d.ts

@@ -0,0 +1,2 @@
+import type { Language, RuleMessages } from './types';
+export declare const createRuleMessages: (language: Language) => RuleMessages;

package/dist/types/rules/index.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from '../types';
+import { noDeepRelativeImports } from './noDeepRelativeImports';
+export declare const builtinRules: Rule[];
+export { noDeepRelativeImports };

package/dist/types/rules/noDeepRelativeImports.d.ts

@@ -0,0 +1 @@
+export declare const noDeepRelativeImports: import("../types").Rule;

package/dist/types/runtime.d.ts

@@ -0,0 +1,10 @@
+import type { Module } from '@swc/types';
+import type { Language, RuleContext, RuleReporter } from './types';
+export interface RuleContextOptions {
+    ast: Module;
+    filePath: string;
+    source: string;
+    reporter: RuleReporter;
+    language: Language;
+}
+export declare const createRuleContext: ({ ast, filePath, source, reporter, language, }: RuleContextOptions) => RuleContext;

package/dist/types/types.d.ts

@@ -0,0 +1,45 @@
+import type { Module, Span } from '@swc/types';
+export type Language = 'zh' | 'en';
+export interface RuleReporter {
+    error(message: string): void;
+    errorAtSpan(span: Span | undefined, message: string): void;
+    errorAtLine(line: number | undefined, message: string): void;
+}
+export interface ImportReference {
+    kind: 'static' | 'dynamic' | 'require';
+    value: string;
+    span?: Span;
+}
+export interface RuleMessages {
+    noDeepRelativeImports(params: {
+        value: string;
+        maxDepth: number;
+    }): string;
+}
+export interface RuleHelpers {
+    readonly imports: ReadonlyArray<ImportReference>;
+    isRelativePath(value: string): boolean;
+    relativeDepth(value: string): number;
+    reportViolation(message: string, span?: Span): void;
+}
+export interface RuleContext {
+    readonly filePath: string;
+    readonly source: string;
+    readonly language: Language;
+    readonly reporter: RuleReporter;
+    readonly ast: Module;
+    readonly helpers: RuleHelpers;
+    readonly messages: RuleMessages;
+}
+export interface RuleMetadata {
+    tag?: string;
+}
+export interface Rule {
+    name: string;
+    tag?: string;
+    run(context: RuleContext): void | Promise<void>;
+}
+export declare function defineRule(name: string, runner: (context: RuleContext) => void | Promise<void>): Rule;
+export declare function defineRule(name: string, metadata: RuleMetadata, runner: (context: RuleContext) => void | Promise<void>): Rule;
+export declare const isRule: (value: unknown) => value is Rule;
+export declare const toRule: (value: unknown, origin: string) => Rule | null;

package/dist/types.js

@@ -1,2 +1,46 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRule = exports.isRule = void 0;
+exports.defineRule = defineRule;
+function defineRule(name, metadataOrRunner, maybeRunner) {
+    var metadata = typeof metadataOrRunner === 'function' ? {} : metadataOrRunner;
+    var runner = typeof metadataOrRunner === 'function' ? metadataOrRunner : maybeRunner;
+    if (!runner) {
+        throw new Error('defineRule requires a rule runner function');
+    }
+    return __assign(__assign({ name: name }, metadata), { run: runner });
+}
+var isRule = function (value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.name === 'string' &&
+        typeof value.run === 'function' &&
+        (typeof value.tag === 'undefined' ||
+            typeof value.tag === 'string'));
+};
+exports.isRule = isRule;
+var toRule = function (value, origin) {
+    if ((0, exports.isRule)(value)) {
+        return value;
+    }
+    if (typeof value === 'function') {
+        var fn = value;
+        return {
+            name: fn.name || origin,
+            run: fn,
+        };
+    }
+    return null;
+};
+exports.toRule = toRule;

package/package.json

@@ -1,33 +1,35 @@
 {
   "name": "auto-cr-rules",
-  "version": "1.0.13",
-  "description": "旨在帮助开发团队在代码合并或提交时快速进行智能化审查，提升代码质量与开发效率。",
-  "type": "commonjs", 
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts", 
-  "module": "./dist/index.js",
+  "version": "2.0.2",
+  "description": "Extensible static analysis rule set for the auto-cr automated code review toolkit",
+  "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
   "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
+    "dist"
   ],
   "scripts": {
-    "build": "tsc"
+    "build": "tsc --build tsconfig.json",
+    "build:force": "tsc --build tsconfig.json --force",
+    "prepublishOnly": "pnpm run build",
+    "publish": "pnpm run build && npm publish --access public"
   },
   "keywords": [
-    "rules"
+    "auto-cr",
+    "code-review",
+    "static-analysis",
+    "lint-rules",
+    "typescript",
+    "javascript",
+    "swc",
+    "developer-tools"
   ],
-  "author": "wangweiwei",
   "license": "MIT",
   "sideEffects": false,
-  "packageManager": "pnpm@10.15.1",
+  "dependencies": {
+    "@swc/types": "^0.1.25"
+  },
   "devDependencies": {
-    "@babel/types": "^7.28.4",
-    "@types/babel__core": "^7.20.5",
-    "@types/babel__traverse": "^7.28.0",
+    "tslib": "^2.8.1",
     "typescript": "^5.9.2"
-  },
-  "dependencies": {
-    "@babel/core": "^7.28.4"
   }
-}
+}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import NoDeepRelativeImports from './rules/NoDeepRelativeImports';
-export declare const rules: (typeof NoDeepRelativeImports)[];

package/dist/rules/NoDeepRelativeImports.d.ts

@@ -1,13 +0,0 @@
-import BabelCore from '@babel/core';
-import type { CallExpression, ExportAllDeclaration, ExportNamedDeclaration, ImportDeclaration } from '@babel/types';
-import type { NodePath } from '@babel/traverse';
-import { PluginOptions } from '../types';
-export default function (api: typeof BabelCore, options: PluginOptions): {
-    name: string;
-    visitor: {
-        ImportDeclaration(path: NodePath<ImportDeclaration>): void;
-        CallExpression(path: NodePath<CallExpression>): void;
-        ExportNamedDeclaration(path: NodePath<ExportNamedDeclaration>): void;
-        ExportAllDeclaration(path: NodePath<ExportAllDeclaration>): void;
-    };
-};

package/dist/rules/NoDeepRelativeImports.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-/**
- * 检查相对路径的深度，如果超过最大允许深度则报告错误
- * @param sourceValue - 导入源路径
- * @param path - Babel AST path 对象
- * @param report - 报告函数
- * @param maxDepth - 最大允许的深度
- */
-function checkRelativePath(sourceValue, path, maxDepth, report) {
-    // 只检查相对路径
-    if (sourceValue.startsWith('.')) {
-        // 计算路径深度：通过计算 "../" 的出现次数
-        var depth = (sourceValue.match(/\.\.\//g) || []).length;
-        if (depth > maxDepth) {
-            report(path, "\u5BFC\u5165/\u5BFC\u51FA\u8DEF\u5F84 \"".concat(sourceValue, "\" \u4E0D\u80FD\u8D85\u8FC7\u6700\u5927\u5C42\u7EA7\uFF08").concat(maxDepth, "\uFF1A\u5C42\uFF09"));
-        }
-    }
-}
-// 导出Babel插件函数
-function default_1(api, options) {
-    var t = api.types;
-    var maxDepth = 2;
-    // 从插件参数中获取 report 方法，如果没有提供则使用默认的 console.error
-    var report = options.report;
-    return {
-        name: 'no-deep-relative-imports',
-        visitor: {
-            // 处理静态导入语句
-            ImportDeclaration: function (path) {
-                var sourceValue = path.node.source.value;
-                if (typeof sourceValue === 'string') {
-                    checkRelativePath(sourceValue, path, maxDepth, report);
-                }
-            },
-            // 处理动态 import() 语句和 require() 调用
-            CallExpression: function (path) {
-                // 检查是否是 import() 调用
-                if (t.isImport(path.node.callee)) {
-                    var firstArg = path.node.arguments[0];
-                    // 确保第一个参数是字符串字面量
-                    if (firstArg && t.isStringLiteral(firstArg)) {
-                        var sourceValue = firstArg.value;
-                        checkRelativePath(sourceValue, path, maxDepth, report);
-                    }
-                }
-                // 检查是否是 require() 调用
-                else if (t.isIdentifier(path.node.callee, { name: 'require' }) ||
-                    (t.isMemberExpression(path.node.callee) &&
-                        t.isIdentifier(path.node.callee.object, { name: 'require' }))) {
-                    var firstArg = path.node.arguments[0];
-                    // 确保第一个参数是字符串字面量
-                    if (firstArg && t.isStringLiteral(firstArg)) {
-                        var sourceValue = firstArg.value;
-                        checkRelativePath(sourceValue, path, maxDepth, report);
-                    }
-                }
-            },
-            // 处理命名导出（export { ... } from 'module'）
-            ExportNamedDeclaration: function (path) {
-                if (path.node.source) {
-                    var sourceValue = path.node.source.value;
-                    if (typeof sourceValue === 'string') {
-                        checkRelativePath(sourceValue, path, maxDepth, report);
-                    }
-                }
-            },
-            // 处理全部导出（export * from 'module'）
-            ExportAllDeclaration: function (path) {
-                var sourceValue = path.node.source.value;
-                if (typeof sourceValue === 'string') {
-                    checkRelativePath(sourceValue, path, maxDepth, report);
-                }
-            }
-        },
-    };
-}

package/dist/types.d.ts

@@ -1,7 +0,0 @@
-import { type NodePath } from '@babel/traverse';
-import type { AnyTypeAnnotation, ArgumentPlaceholder, ArrayExpression, ArrayPattern, ArrayTypeAnnotation, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BigIntLiteral, BinaryExpression, BindExpression, BlockStatement, BooleanLiteral, BooleanLiteralTypeAnnotation, BooleanTypeAnnotation, BreakStatement, CallExpression, CatchClause, ClassAccessorProperty, ClassBody, ClassDeclaration, ClassExpression, ClassImplements, ClassMethod, ClassPrivateMethod, ClassPrivateProperty, ClassProperty, ConditionalExpression, ContinueStatement, DebuggerStatement, DecimalLiteral, DeclareClass, DeclaredPredicate, DeclareExportAllDeclaration, DeclareExportDeclaration, DeclareFunction, DeclareInterface, DeclareModule, DeclareModuleExports, DeclareOpaqueType, DeclareTypeAlias, DeclareVariable, Decorator, Directive, DirectiveLiteral, DoExpression, DoWhileStatement, EmptyStatement, EmptyTypeAnnotation, EnumBooleanBody, EnumBooleanMember, EnumDeclaration, EnumDefaultedMember, EnumNumberBody, EnumNumberMember, EnumStringBody, EnumStringMember, EnumSymbolBody, ExistsTypeAnnotation, ExportAllDeclaration, ExportDefaultDeclaration, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, ExpressionStatement, File, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeAnnotation, FunctionTypeParam, GenericTypeAnnotation, Identifier, IfStatement, Import, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier, IndexedAccessType, InferredPredicate, InterfaceDeclaration, InterfaceExtends, InterfaceTypeAnnotation, InterpreterDirective, IntersectionTypeAnnotation, JSXAttribute, JSXClosingElement, JSXClosingFragment, JSXElement, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXIdentifier, JSXMemberExpression, JSXNamespacedName, JSXOpeningElement, JSXOpeningFragment, JSXSpreadAttribute, JSXSpreadChild, JSXText, LabeledStatement, LogicalExpression, MemberExpression, MetaProperty, MixedTypeAnnotation, ModuleExpression, NewExpression, Noop, NullableTypeAnnotation, NullLiteral, NullLiteralTypeAnnotation, NumberLiteralTypeAnnotation, NumberTypeAnnotation, NumericLiteral, ObjectExpression, ObjectMethod, ObjectPattern, ObjectProperty, ObjectTypeAnnotation, ObjectTypeCallProperty, ObjectTypeIndexer, ObjectTypeInternalSlot, ObjectTypeProperty, ObjectTypeSpreadProperty, OpaqueType, OptionalCallExpression, OptionalIndexedAccessType, OptionalMemberExpression, ParenthesizedExpression, PipelineBareFunction, PipelinePrimaryTopicReference, PipelineTopicExpression, Placeholder, PrivateName, Program, QualifiedTypeIdentifier, RecordExpression, RegExpLiteral, RestElement, ReturnStatement, SequenceExpression, SpreadElement, StaticBlock, StringLiteral, StringLiteralTypeAnnotation, StringTypeAnnotation, Super, SwitchCase, SwitchStatement, SymbolTypeAnnotation, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThisTypeAnnotation, ThrowStatement, TopicReference, TryStatement, TSAnyKeyword, TSArrayType, TSAsExpression, TSBigIntKeyword, TSBooleanKeyword, TSCallSignatureDeclaration, TSConditionalType, TSConstructorType, TSConstructSignatureDeclaration, TSDeclareFunction, TSDeclareMethod, TSEnumBody, TSEnumDeclaration, TSEnumMember, TSExportAssignment, TSExpressionWithTypeArguments, TSExternalModuleReference, TSFunctionType, TSImportEqualsDeclaration, TSImportType, TSIndexedAccessType, TSIndexSignature, TSInferType, TSInstantiationExpression, TSInterfaceBody, TSInterfaceDeclaration, TSIntersectionType, TSIntrinsicKeyword, TSLiteralType, TSMappedType, TSMethodSignature, TSModuleBlock, TSModuleDeclaration, TSNamedTupleMember, TSNamespaceExportDeclaration, TSNeverKeyword, TSNonNullExpression, TSNullKeyword, TSNumberKeyword, TSObjectKeyword, TSOptionalType, TSParameterProperty, TSParenthesizedType, TSPropertySignature, TSQualifiedName, TSRestType, TSSatisfiesExpression, TSStringKeyword, TSSymbolKeyword, TSTemplateLiteralType, TSThisType, TSTupleType, TSTypeAliasDeclaration, TSTypeAnnotation, TSTypeAssertion, TSTypeLiteral, TSTypeOperator, TSTypeParameter, TSTypeParameterDeclaration, TSTypeParameterInstantiation, TSTypePredicate, TSTypeQuery, TSTypeReference, TSUndefinedKeyword, TSUnionType, TSUnknownKeyword, TSVoidKeyword, TupleExpression, TupleTypeAnnotation, TypeAlias, TypeAnnotation, TypeCastExpression, TypeofTypeAnnotation, TypeParameter, TypeParameterDeclaration, TypeParameterInstantiation, UnaryExpression, UnionTypeAnnotation, UpdateExpression, V8IntrinsicIdentifier, VariableDeclaration, VariableDeclarator, Variance, VoidPattern, VoidTypeAnnotation, WhileStatement, WithStatement, YieldExpression } from '@babel/types';
-type Node = AnyTypeAnnotation | ArgumentPlaceholder | ArrayExpression | ArrayPattern | ArrayTypeAnnotation | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BigIntLiteral | BinaryExpression | BindExpression | BlockStatement | BooleanLiteral | BooleanLiteralTypeAnnotation | BooleanTypeAnnotation | BreakStatement | CallExpression | CatchClause | ClassAccessorProperty | ClassBody | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | ContinueStatement | DebuggerStatement | DecimalLiteral | DeclareClass | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | DeclaredPredicate | Decorator | Directive | DirectiveLiteral | DoExpression | DoWhileStatement | EmptyStatement | EmptyTypeAnnotation | EnumBooleanBody | EnumBooleanMember | EnumDeclaration | EnumDefaultedMember | EnumNumberBody | EnumNumberMember | EnumStringBody | EnumStringMember | EnumSymbolBody | ExistsTypeAnnotation | ExportAllDeclaration | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportSpecifier | ExpressionStatement | File | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | Identifier | IfStatement | Import | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportExpression | ImportNamespaceSpecifier | ImportSpecifier | IndexedAccessType | InferredPredicate | InterfaceDeclaration | InterfaceExtends | InterfaceTypeAnnotation | InterpreterDirective | IntersectionTypeAnnotation | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LabeledStatement | LogicalExpression | MemberExpression | MetaProperty | MixedTypeAnnotation | ModuleExpression | NewExpression | Noop | NullLiteral | NullLiteralTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | NumericLiteral | ObjectExpression | ObjectMethod | ObjectPattern | ObjectProperty | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalCallExpression | OptionalIndexedAccessType | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelinePrimaryTopicReference | PipelineTopicExpression | Placeholder | PrivateName | Program | QualifiedTypeIdentifier | RecordExpression | RegExpLiteral | RestElement | ReturnStatement | SequenceExpression | SpreadElement | StaticBlock | StringLiteral | StringLiteralTypeAnnotation | StringTypeAnnotation | Super | SwitchCase | SwitchStatement | SymbolTypeAnnotation | TSAnyKeyword | TSArrayType | TSAsExpression | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSConditionalType | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexSignature | TSIndexedAccessType | TSInferType | TSInstantiationExpression | TSInterfaceBody | TSInterfaceDeclaration | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSParenthesizedType | TSPropertySignature | TSQualifiedName | TSRestType | TSSatisfiesExpression | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | TaggedTemplateExpression | TemplateElement | TemplateLiteral | ThisExpression | ThisTypeAnnotation | ThrowStatement | TopicReference | TryStatement | TupleExpression | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | TypeofTypeAnnotation | UnaryExpression | UnionTypeAnnotation | UpdateExpression | V8IntrinsicIdentifier | VariableDeclaration | VariableDeclarator | Variance | VoidPattern | VoidTypeAnnotation | WhileStatement | WithStatement | YieldExpression;
-export interface PluginOptions {
-    report: <T extends Node>(issue: NodePath<T>, message: string) => void;
-}
-export {};