eslint-plugin-formatjs 4.2.0 → 4.2.2

package/rules/no-multiple-plurals.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+class MultiplePlurals extends Error {
+    constructor() {
+        super(...arguments);
+        this.message = 'Cannot specify more than 1 plural rules';
+    }
+}
+function verifyAst(ast, pluralCount = { count: 0 }) {
+    for (const el of ast) {
+        if ((0, icu_messageformat_parser_1.isPluralElement)(el)) {
+            pluralCount.count++;
+            if (pluralCount.count > 1) {
+                throw new MultiplePlurals();
+            }
+            const { options } = el;
+            for (const selector of Object.keys(options)) {
+                verifyAst(options[selector].value, pluralCount);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    const settings = (0, util_1.getSettings)(context);
+    const msgs = (0, util_1.extractMessages)(node, settings);
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst((0, icu_messageformat_parser_1.parse)(defaultMessage, {
+                ignoreTag: settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow multiple plural rules in the same message',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-multiple-plurals',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/no-multiple-whitespaces.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-multiple-whitespaces.d.ts.map

package/rules/no-multiple-whitespaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-multiple-whitespaces.d.ts","sourceRoot":"","sources":["no-multiple-whitespaces.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAyJ3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA+BhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-multiple-whitespaces.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+const util_1 = require("../util");
+function isAstValid(ast) {
+    for (const element of ast) {
+        switch (element.type) {
+            case icu_messageformat_parser_1.TYPE.literal:
+                if (/\s{2,}/gm.test(element.value)) {
+                    return false;
+                }
+                break;
+            case icu_messageformat_parser_1.TYPE.argument:
+            case icu_messageformat_parser_1.TYPE.date:
+            case icu_messageformat_parser_1.TYPE.literal:
+            case icu_messageformat_parser_1.TYPE.number:
+            case icu_messageformat_parser_1.TYPE.pound:
+            case icu_messageformat_parser_1.TYPE.tag:
+            case icu_messageformat_parser_1.TYPE.time:
+                break;
+            case icu_messageformat_parser_1.TYPE.plural:
+            case icu_messageformat_parser_1.TYPE.select: {
+                for (const option of Object.values(element.options)) {
+                    if (!isAstValid(option.value)) {
+                        return false;
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return true;
+}
+function trimMultiWhitespaces(message, ast) {
+    const literalElements = [];
+    const collectLiteralElements = (elements) => {
+        for (const element of elements) {
+            switch (element.type) {
+                case icu_messageformat_parser_1.TYPE.literal:
+                    literalElements.push(element);
+                    break;
+                case icu_messageformat_parser_1.TYPE.argument:
+                case icu_messageformat_parser_1.TYPE.date:
+                case icu_messageformat_parser_1.TYPE.literal:
+                case icu_messageformat_parser_1.TYPE.number:
+                case icu_messageformat_parser_1.TYPE.pound:
+                case icu_messageformat_parser_1.TYPE.tag:
+                case icu_messageformat_parser_1.TYPE.time:
+                    break;
+                case icu_messageformat_parser_1.TYPE.plural:
+                case icu_messageformat_parser_1.TYPE.select: {
+                    for (const option of Object.values(element.options)) {
+                        collectLiteralElements(option.value);
+                    }
+                    break;
+                }
+            }
+        }
+    };
+    collectLiteralElements(ast);
+    // Surgically trim whitespaces in the literal element ranges.
+    // This is to preserve the original whitespaces and newlines info that are lost to parsing.
+    let trimmedFragments = [];
+    let currentOffset = 0;
+    for (const literal of literalElements) {
+        const { start, end } = literal.location;
+        const startOffset = start.offset;
+        const endOffset = end.offset;
+        trimmedFragments.push(message.slice(currentOffset, startOffset));
+        trimmedFragments.push(message.slice(startOffset, endOffset).replace(/\s{2,}/gm, ' '));
+        currentOffset = endOffset;
+    }
+    trimmedFragments.push(message.slice(currentOffset));
+    return trimmedFragments.join('');
+}
+function checkNode(context, node) {
+    const msgs = (0, util_1.extractMessages)(node, (0, util_1.getSettings)(context));
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        let ast;
+        try {
+            ast = (0, icu_messageformat_parser_1.parse)(defaultMessage, { captureLocation: true });
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e instanceof Error ? e.message : String(e),
+            });
+            return;
+        }
+        if (!isAstValid(ast)) {
+            const reportObject = {
+                node: messageNode,
+                message: 'Multiple consecutive whitespaces are not allowed',
+            };
+            if (messageNode.type === 'Literal' &&
+                messageNode.value &&
+                typeof messageNode.value === 'string') {
+                reportObject.fix = function (fixer) {
+                    return fixer.replaceText(messageNode, JSON.stringify(trimMultiWhitespaces(messageNode.value, ast)));
+                };
+            }
+            else if (messageNode.type === 'TemplateLiteral' &&
+                messageNode.quasis.length === 1 &&
+                messageNode.expressions.length === 0) {
+                reportObject.fix = function (fixer) {
+                    return fixer.replaceText(messageNode, '`' +
+                        trimMultiWhitespaces(messageNode.quasis[0].value.cooked, ast)
+                            .replace(/\\/g, '\\\\')
+                            .replace(/`/g, '\\`') +
+                        '`');
+                };
+            }
+            context.report(reportObject);
+        }
+    }
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevents usage of multiple consecutive whitespaces in message',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-multiple-whitespaces',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/rules/no-offset.d.ts

@@ -0,0 +1,4 @@
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
+//# sourceMappingURL=no-offset.d.ts.map

package/rules/no-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-offset.d.ts","sourceRoot":"","sources":["no-offset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAuD3B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,UA8BhB,CAAA;AAED,eAAe,IAAI,CAAA"}

package/rules/no-offset.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+class NoOffsetError extends Error {
+    constructor() {
+        super(...arguments);
+        this.message = 'offset are not allowed in plural rules';
+    }
+}
+function verifyAst(ast) {
+    for (const el of ast) {
+        if ((0, icu_messageformat_parser_1.isPluralElement)(el)) {
+            if (el.offset) {
+                throw new NoOffsetError();
+            }
+            const { options } = el;
+            for (const selector of Object.keys(options)) {
+                verifyAst(options[selector].value);
+            }
+        }
+    }
+}
+function checkNode(context, node) {
+    const settings = (0, util_1.getSettings)(context);
+    const msgs = (0, util_1.extractMessages)(node, settings);
+    for (const [{ message: { defaultMessage }, messageNode, },] of msgs) {
+        if (!defaultMessage || !messageNode) {
+            continue;
+        }
+        try {
+            verifyAst((0, icu_messageformat_parser_1.parse)(defaultMessage, {
+                ignoreTag: settings.ignoreTag,
+            }));
+        }
+        catch (e) {
+            context.report({
+                node: messageNode,
+                message: e.message,
+            });
+        }
+    }
+}
+const rule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow offset in plural rules',
+            category: 'Errors',
+            recommended: false,
+            url: 'https://formatjs.io/docs/tooling/linter#no-offset',
+        },
+        fixable: 'code',
+    },
+    create(context) {
+        const callExpressionVisitor = (node) => checkNode(context, node);
+        if (context.parserServices.defineTemplateBodyVisitor) {
+            return context.parserServices.defineTemplateBodyVisitor({
+                CallExpression: callExpressionVisitor,
+            }, {
+                CallExpression: callExpressionVisitor,
+            });
+        }
+        return {
+            JSXOpeningElement: (node) => checkNode(context, node),
+            CallExpression: callExpressionVisitor,
+        };
+    },
+};
+exports.default = rule;

package/util.d.ts

@@ -0,0 +1,24 @@
+import { Rule } from 'eslint';
+import { TSESTree } from '@typescript-eslint/typescript-estree';
+export interface MessageDescriptor {
+    id?: string;
+    defaultMessage?: string;
+    description?: string | object;
+}
+export interface Settings {
+    excludeMessageDeclCalls?: boolean;
+    additionalFunctionNames?: string[];
+    additionalComponentNames?: string[];
+    ignoreTag?: boolean;
+}
+export interface MessageDescriptorNodeInfo {
+    message: MessageDescriptor;
+    messageNode?: TSESTree.Property['value'] | TSESTree.JSXAttribute['value'];
+    messagePropNode?: TSESTree.Property | TSESTree.JSXAttribute;
+    descriptionNode?: TSESTree.Property['value'] | TSESTree.JSXAttribute['value'];
+    idValueNode?: TSESTree.Property['value'] | TSESTree.JSXAttribute['value'];
+    idPropNode?: TSESTree.Property | TSESTree.JSXAttribute;
+}
+export declare function getSettings({ settings }: Rule.RuleContext): Settings;
+export declare function extractMessages(node: TSESTree.Node, { additionalComponentNames, additionalFunctionNames, excludeMessageDeclCalls, }?: Settings): Array<[MessageDescriptorNodeInfo, TSESTree.Expression | undefined]>;
+//# sourceMappingURL=util.d.ts.map

package/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,QAAQ,CAAA;AAC3B,OAAO,EAAC,QAAQ,EAAC,MAAM,sCAAsC,CAAA;AAE7D,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC9B;AAMD,MAAM,WAAW,QAAQ;IACvB,uBAAuB,CAAC,EAAE,OAAO,CAAA;IACjC,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAA;IAClC,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAA;IACnC,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AACD,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,iBAAiB,CAAA;IAC1B,WAAW,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,CAAA;IACzE,eAAe,CAAC,EAAE,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAA;IAC3D,eAAe,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,CAAA;IAC7E,WAAW,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,CAAA;IACzE,UAAU,CAAC,EAAE,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAA;CACvD;AAED,wBAAgB,WAAW,CAAC,EAAC,QAAQ,EAAC,EAAE,IAAI,CAAC,WAAW,GAAG,QAAQ,CAElE;AA4ND,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,CAAC,IAAI,EACnB,EACE,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,GACxB,GAAE,QAAa,GACf,KAAK,CAAC,CAAC,yBAAyB,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,CAiDrE"}

package/util.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMessages = exports.getSettings = void 0;
+const FORMAT_FUNCTION_NAMES = new Set(['$formatMessage', 'formatMessage']);
+const COMPONENT_NAMES = new Set(['FormattedMessage']);
+const DECLARATION_FUNCTION_NAMES = new Set(['defineMessage']);
+function getSettings({ settings }) {
+    return settings.formatjs ?? settings;
+}
+exports.getSettings = getSettings;
+function isStringLiteral(node) {
+    return node.type === 'Literal' && typeof node.value === 'string';
+}
+function isTemplateLiteralWithoutVar(node) {
+    return node.type === 'TemplateLiteral' && node.quasis.length === 1;
+}
+function staticallyEvaluateStringConcat(node) {
+    if (!isStringLiteral(node.right)) {
+        return ['', false];
+    }
+    if (isStringLiteral(node.left)) {
+        return [String(node.left.value) + node.right.value, true];
+    }
+    if (node.left.type === 'BinaryExpression') {
+        const [result, isStaticallyEvaluatable] = staticallyEvaluateStringConcat(node.left);
+        return [result + node.right.value, isStaticallyEvaluatable];
+    }
+    return ['', false];
+}
+function isIntlFormatMessageCall(node) {
+    return (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.object.type === 'Identifier' &&
+        node.callee.object.name === 'intl' &&
+        node.callee.property.type === 'Identifier' &&
+        node.callee.property.name === 'formatMessage' &&
+        node.arguments.length >= 1 &&
+        node.arguments[0].type === 'ObjectExpression');
+}
+function isSingleMessageDescriptorDeclaration(node, functionNames) {
+    return (node.type === 'CallExpression' &&
+        node.callee.type === 'Identifier' &&
+        functionNames.has(node.callee.name));
+}
+function isMultipleMessageDescriptorDeclaration(node) {
+    return (node.type === 'CallExpression' &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'defineMessages');
+}
+function extractMessageDescriptor(node) {
+    if (!node || node.type !== 'ObjectExpression') {
+        return;
+    }
+    const result = {
+        message: {},
+        messageNode: undefined,
+        messagePropNode: undefined,
+        descriptionNode: undefined,
+        idValueNode: undefined,
+    };
+    for (const prop of node.properties) {
+        if (prop.type !== 'Property' || prop.key.type !== 'Identifier') {
+            continue;
+        }
+        const valueNode = prop.value;
+        let value = undefined;
+        if (isStringLiteral(valueNode)) {
+            value = valueNode.value;
+        }
+        else if (isTemplateLiteralWithoutVar(valueNode)) {
+            value = valueNode.quasis[0].value.cooked;
+        }
+        else if (valueNode.type === 'BinaryExpression') {
+            const [result, isStatic] = staticallyEvaluateStringConcat(valueNode);
+            if (isStatic) {
+                value = result;
+            }
+        }
+        switch (prop.key.name) {
+            case 'defaultMessage':
+                result.messagePropNode = prop;
+                result.messageNode = valueNode;
+                result.message.defaultMessage = value;
+                break;
+            case 'description':
+                result.descriptionNode = valueNode;
+                result.message.description = value;
+                break;
+            case 'id':
+                result.message.id = value;
+                result.idValueNode = valueNode;
+                result.idPropNode = prop;
+                break;
+        }
+    }
+    return result;
+}
+function extractMessageDescriptorFromJSXElement(node) {
+    if (!node || !node.attributes) {
+        return;
+    }
+    let values;
+    const result = {
+        message: {},
+        messageNode: undefined,
+        messagePropNode: undefined,
+        descriptionNode: undefined,
+        idValueNode: undefined,
+        idPropNode: undefined,
+    };
+    let hasSpreadAttribute = false;
+    for (const prop of node.attributes) {
+        // We can't analyze spread attr
+        if (prop.type === 'JSXSpreadAttribute') {
+            hasSpreadAttribute = true;
+        }
+        if (prop.type !== 'JSXAttribute' || prop.name.type !== 'JSXIdentifier') {
+            continue;
+        }
+        const key = prop.name;
+        let valueNode = prop.value;
+        let value = undefined;
+        if (valueNode) {
+            if (isStringLiteral(valueNode)) {
+                value = valueNode.value;
+            }
+            else if (valueNode?.type === 'JSXExpressionContainer') {
+                const { expression } = valueNode;
+                if (expression.type === 'BinaryExpression') {
+                    const [result, isStatic] = staticallyEvaluateStringConcat(expression);
+                    if (isStatic) {
+                        value = result;
+                    }
+                }
+                else if (isTemplateLiteralWithoutVar(expression)) {
+                    value = expression.quasis[0].value.cooked;
+                }
+            }
+        }
+        switch (key.name) {
+            case 'defaultMessage':
+                result.messagePropNode = prop;
+                result.messageNode = valueNode;
+                if (value) {
+                    result.message.defaultMessage = value;
+                }
+                break;
+            case 'description':
+                result.descriptionNode = valueNode;
+                if (value) {
+                    result.message.description = value;
+                }
+                break;
+            case 'id':
+                result.idValueNode = valueNode;
+                result.idPropNode = prop;
+                if (value) {
+                    result.message.id = value;
+                }
+                break;
+            case 'values':
+                if (valueNode?.type === 'JSXExpressionContainer' &&
+                    valueNode.expression.type === 'ObjectExpression') {
+                    values = valueNode.expression;
+                }
+                break;
+        }
+    }
+    if (!result.messagePropNode &&
+        !result.descriptionNode &&
+        !result.idPropNode &&
+        hasSpreadAttribute) {
+        return;
+    }
+    return [result, values];
+}
+function extractMessageDescriptors(node) {
+    if (!node || node.type !== 'ObjectExpression' || !node.properties.length) {
+        return [];
+    }
+    const msgs = [];
+    for (const prop of node.properties) {
+        if (prop.type !== 'Property') {
+            continue;
+        }
+        const msg = prop.value;
+        if (msg.type !== 'ObjectExpression') {
+            continue;
+        }
+        const nodeInfo = extractMessageDescriptor(msg);
+        if (nodeInfo) {
+            msgs.push(nodeInfo);
+        }
+    }
+    return msgs;
+}
+function extractMessages(node, { additionalComponentNames, additionalFunctionNames, excludeMessageDeclCalls, } = {}) {
+    const allFormatFunctionNames = Array.isArray(additionalFunctionNames)
+        ? new Set([
+            ...Array.from(FORMAT_FUNCTION_NAMES),
+            ...additionalFunctionNames,
+        ])
+        : FORMAT_FUNCTION_NAMES;
+    const allComponentNames = Array.isArray(additionalComponentNames)
+        ? new Set([...Array.from(COMPONENT_NAMES), ...additionalComponentNames])
+        : COMPONENT_NAMES;
+    if (node.type === 'CallExpression') {
+        const expr = node;
+        const args0 = expr.arguments[0];
+        const args1 = expr.arguments[1];
+        // We can't really analyze spread element
+        if (!args0 || args0.type === 'SpreadElement') {
+            return [];
+        }
+        if ((!excludeMessageDeclCalls &&
+            isSingleMessageDescriptorDeclaration(node, DECLARATION_FUNCTION_NAMES)) ||
+            isIntlFormatMessageCall(node) ||
+            isSingleMessageDescriptorDeclaration(node, allFormatFunctionNames)) {
+            const msgDescriptorNodeInfo = extractMessageDescriptor(args0);
+            if (msgDescriptorNodeInfo && (!args1 || args1.type !== 'SpreadElement')) {
+                return [[msgDescriptorNodeInfo, args1]];
+            }
+        }
+        else if (!excludeMessageDeclCalls &&
+            isMultipleMessageDescriptorDeclaration(node)) {
+            return extractMessageDescriptors(args0).map(msg => [msg, undefined]);
+        }
+    }
+    else if (node.type === 'JSXOpeningElement' &&
+        node.name &&
+        node.name.type === 'JSXIdentifier' &&
+        allComponentNames.has(node.name.name)) {
+        const msgDescriptorNodeInfo = extractMessageDescriptorFromJSXElement(node);
+        if (msgDescriptorNodeInfo) {
+            return [msgDescriptorNodeInfo];
+        }
+    }
+    return [];
+}
+exports.extractMessages = extractMessages;

package/BUILD

@@ -1,89 +0,0 @@
-load("@aspect_bazel_lib//lib:write_source_files.bzl", "write_source_files")
-load("@aspect_rules_js//npm/private:npm_package.bzl", "npm_package")
-load("@npm//:defs.bzl", "npm_link_all_packages")
-load("//tools:index.bzl", "check_format", "package_json_test", "ts_compile_node")
-load("//tools:jest.bzl", "jest_test")
-
-npm_link_all_packages(name = "node_modules")
-
-PACKAGE_NAME = "eslint-plugin-formatjs"
-
-npm_package(
-    name = PACKAGE_NAME,
-    srcs = [
-        "LICENSE.md",
-        "README.md",
-        "package.json",
-        ":dist",
-    ],
-    package = PACKAGE_NAME,
-    visibility = ["//visibility:public"],
-)
-
-SRCS = glob(["rules/*.ts"]) + [
-    "index.ts",
-    "util.ts",
-]
-
-SRC_DEPS = [
-    "//:node_modules/@types/eslint",
-    "//:node_modules/@types/estree",
-    "//:node_modules/@types/node",
-    "//:node_modules/@types/picomatch",
-    "//:node_modules/@typescript-eslint/typescript-estree",
-    "//:node_modules/emoji-regex",
-    "//:node_modules/eslint",
-    "//:node_modules/picomatch",
-    "//:node_modules/typescript",
-    ":node_modules/@formatjs/icu-messageformat-parser",
-    ":node_modules/@formatjs/ts-transformer",
-]
-
-ts_compile_node(
-    name = "dist",
-    srcs = SRCS,
-    package = PACKAGE_NAME,
-    deps = SRC_DEPS,
-)
-
-TESTS_BASE_SRCS = SRCS + glob(
-    [
-        "tests/*.ts",
-    ],
-    exclude = ["tests/*.test.ts"],
-)
-
-TEST_FILES = glob([
-    "tests/*.test.ts",
-])
-
-[jest_test(
-    name = "unit-%s" % f[6:f.index(".test.ts")],
-    srcs = TESTS_BASE_SRCS + [f],
-    deps = [
-        "//:node_modules/@typescript-eslint/parser",
-        "//:node_modules/vue-eslint-parser",
-    ] + SRC_DEPS,
-) for f in TEST_FILES]
-
-write_source_files(
-    name = "tsconfig_json",
-    files = {"tsconfig.json": "//tools:tsconfig.golden.json"},
-)
-
-check_format(
-    name = "prettier",
-    srcs = glob(
-        [
-            "**/*",
-        ],
-        exclude = [
-            "CHANGELOG.md",
-        ],
-    ),
-)
-
-package_json_test(
-    name = "package_json_test",
-    deps = SRC_DEPS,
-)