@alexlit/lint-kit 127.0.0 → 127.2.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-regex-spaces.js

@@ -1,197 +0,0 @@
-/**
- * @fileoverview Rule to count multiple spaces in regular expressions
- * @author Matt DuVall <http://www.mattduvall.com/>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-const regexpp = require("@eslint-community/regexpp");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const regExpParser = new regexpp.RegExpParser();
-const DOUBLE_SPACE = / {2}/u;
-
-/**
- * Check if node is a string
- * @param {ASTNode} node node to evaluate
- * @returns {boolean} True if its a string
- * @private
- */
-function isString(node) {
-    return node && node.type === "Literal" && typeof node.value === "string";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow multiple spaces in regular expressions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-regex-spaces"
-        },
-
-        schema: [],
-        fixable: "code",
-
-        messages: {
-            multipleSpaces: "Spaces are hard to count. Use {{{length}}}."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Validate regular expression
-         * @param {ASTNode} nodeToReport Node to report.
-         * @param {string} pattern Regular expression pattern to validate.
-         * @param {string} rawPattern Raw representation of the pattern in the source code.
-         * @param {number} rawPatternStartRange Start range of the pattern in the source code.
-         * @param {string} flags Regular expression flags.
-         * @returns {void}
-         * @private
-         */
-        function checkRegex(nodeToReport, pattern, rawPattern, rawPatternStartRange, flags) {
-
-            // Skip if there are no consecutive spaces in the source code, to avoid reporting e.g., RegExp(' \ ').
-            if (!DOUBLE_SPACE.test(rawPattern)) {
-                return;
-            }
-
-            const characterClassNodes = [];
-            let regExpAST;
-
-            try {
-                regExpAST = regExpParser.parsePattern(pattern, 0, pattern.length, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") });
-            } catch {
-
-                // Ignore regular expressions with syntax errors
-                return;
-            }
-
-            regexpp.visitRegExpAST(regExpAST, {
-                onCharacterClassEnter(ccNode) {
-                    characterClassNodes.push(ccNode);
-                }
-            });
-
-            const spacesPattern = /( {2,})(?: [+*{?]|[^+*{?]|$)/gu;
-            let match;
-
-            while ((match = spacesPattern.exec(pattern))) {
-                const { 1: { length }, index } = match;
-
-                // Report only consecutive spaces that are not in character classes.
-                if (
-                    characterClassNodes.every(({ start, end }) => index < start || end <= index)
-                ) {
-                    context.report({
-                        node: nodeToReport,
-                        messageId: "multipleSpaces",
-                        data: { length },
-                        fix(fixer) {
-                            if (pattern !== rawPattern) {
-                                return null;
-                            }
-                            return fixer.replaceTextRange(
-                                [rawPatternStartRange + index, rawPatternStartRange + index + length],
-                                ` {${length}}`
-                            );
-                        }
-                    });
-
-                    // Report only the first occurrence of consecutive spaces
-                    return;
-                }
-            }
-        }
-
-        /**
-         * Validate regular expression literals
-         * @param {ASTNode} node node to validate
-         * @returns {void}
-         * @private
-         */
-        function checkLiteral(node) {
-            if (node.regex) {
-                const pattern = node.regex.pattern;
-                const rawPattern = node.raw.slice(1, node.raw.lastIndexOf("/"));
-                const rawPatternStartRange = node.range[0] + 1;
-                const flags = node.regex.flags;
-
-                checkRegex(
-                    node,
-                    pattern,
-                    rawPattern,
-                    rawPatternStartRange,
-                    flags
-                );
-            }
-        }
-
-        /**
-         * Validate strings passed to the RegExp constructor
-         * @param {ASTNode} node node to validate
-         * @returns {void}
-         * @private
-         */
-        function checkFunction(node) {
-            const scope = sourceCode.getScope(node);
-            const regExpVar = astUtils.getVariableByName(scope, "RegExp");
-            const shadowed = regExpVar && regExpVar.defs.length > 0;
-            const patternNode = node.arguments[0];
-
-            if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(patternNode) && !shadowed) {
-                const pattern = patternNode.value;
-                const rawPattern = patternNode.raw.slice(1, -1);
-                const rawPatternStartRange = patternNode.range[0] + 1;
-                let flags;
-
-                if (node.arguments.length < 2) {
-
-                    // It has no flags.
-                    flags = "";
-                } else {
-                    const flagsNode = node.arguments[1];
-
-                    if (isString(flagsNode)) {
-                        flags = flagsNode.value;
-                    } else {
-
-                        // The flags cannot be determined.
-                        return;
-                    }
-                }
-
-                checkRegex(
-                    node,
-                    pattern,
-                    rawPattern,
-                    rawPatternStartRange,
-                    flags
-                );
-            }
-        }
-
-        return {
-            Literal: checkLiteral,
-            CallExpression: checkFunction,
-            NewExpression: checkFunction
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-restricted-exports.js

@@ -1,204 +0,0 @@
-/**
- * @fileoverview Rule to disallow specified names in exports
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow specified names in exports",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-restricted-exports"
-        },
-
-        schema: [{
-            anyOf: [
-                {
-                    type: "object",
-                    properties: {
-                        restrictedNamedExports: {
-                            type: "array",
-                            items: {
-                                type: "string"
-                            },
-                            uniqueItems: true
-                        },
-                        restrictedNamedExportsPattern: { type: "string" }
-                    },
-                    additionalProperties: false
-                },
-                {
-                    type: "object",
-                    properties: {
-                        restrictedNamedExports: {
-                            type: "array",
-                            items: {
-                                type: "string",
-                                pattern: "^(?!default$)"
-                            },
-                            uniqueItems: true
-                        },
-                        restrictedNamedExportsPattern: { type: "string" },
-                        restrictDefaultExports: {
-                            type: "object",
-                            properties: {
-
-                                // Allow/Disallow `export default foo; export default 42; export default function foo() {}` format
-                                direct: {
-                                    type: "boolean"
-                                },
-
-                                // Allow/Disallow `export { foo as default };` declarations
-                                named: {
-                                    type: "boolean"
-                                },
-
-                                //  Allow/Disallow `export { default } from "mod"; export { default as default } from "mod";` declarations
-                                defaultFrom: {
-                                    type: "boolean"
-                                },
-
-                                //  Allow/Disallow `export { foo as default } from "mod";` declarations
-                                namedFrom: {
-                                    type: "boolean"
-                                },
-
-                                //  Allow/Disallow `export * as default from "mod"`; declarations
-                                namespaceFrom: {
-                                    type: "boolean"
-                                }
-                            },
-                            additionalProperties: false
-                        }
-                    },
-                    additionalProperties: false
-                }
-            ]
-        }],
-
-        messages: {
-            restrictedNamed: "'{{name}}' is restricted from being used as an exported name.",
-            restrictedDefault: "Exporting 'default' is restricted."
-        }
-    },
-
-    create(context) {
-
-        const restrictedNames = new Set(context.options[0] && context.options[0].restrictedNamedExports);
-        const restrictedNamePattern = context.options[0] && context.options[0].restrictedNamedExportsPattern;
-        const restrictDefaultExports = context.options[0] && context.options[0].restrictDefaultExports;
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Checks and reports given exported name.
-         * @param {ASTNode} node exported `Identifier` or string `Literal` node to check.
-         * @returns {void}
-         */
-        function checkExportedName(node) {
-            const name = astUtils.getModuleExportName(node);
-
-            let matchesRestrictedNamePattern = false;
-
-            if (restrictedNamePattern && name !== "default") {
-                const patternRegex = new RegExp(restrictedNamePattern, "u");
-
-                matchesRestrictedNamePattern = patternRegex.test(name);
-            }
-
-            if (matchesRestrictedNamePattern || restrictedNames.has(name)) {
-                context.report({
-                    node,
-                    messageId: "restrictedNamed",
-                    data: { name }
-                });
-                return;
-            }
-
-            if (name === "default") {
-                if (node.parent.type === "ExportAllDeclaration") {
-                    if (restrictDefaultExports && restrictDefaultExports.namespaceFrom) {
-                        context.report({
-                            node,
-                            messageId: "restrictedDefault"
-                        });
-                    }
-
-                } else { // ExportSpecifier
-                    const isSourceSpecified = !!node.parent.parent.source;
-                    const specifierLocalName = astUtils.getModuleExportName(node.parent.local);
-
-                    if (!isSourceSpecified && restrictDefaultExports && restrictDefaultExports.named) {
-                        context.report({
-                            node,
-                            messageId: "restrictedDefault"
-                        });
-                        return;
-                    }
-
-                    if (isSourceSpecified && restrictDefaultExports) {
-                        if (
-                            (specifierLocalName === "default" && restrictDefaultExports.defaultFrom) ||
-                            (specifierLocalName !== "default" && restrictDefaultExports.namedFrom)
-                        ) {
-                            context.report({
-                                node,
-                                messageId: "restrictedDefault"
-                            });
-                        }
-                    }
-                }
-            }
-        }
-
-        return {
-            ExportAllDeclaration(node) {
-                if (node.exported) {
-                    checkExportedName(node.exported);
-                }
-            },
-
-            ExportDefaultDeclaration(node) {
-                if (restrictDefaultExports && restrictDefaultExports.direct) {
-                    context.report({
-                        node,
-                        messageId: "restrictedDefault"
-                    });
-                }
-            },
-
-            ExportNamedDeclaration(node) {
-                const declaration = node.declaration;
-
-                if (declaration) {
-                    if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
-                        checkExportedName(declaration.id);
-                    } else if (declaration.type === "VariableDeclaration") {
-                        sourceCode.getDeclaredVariables(declaration)
-                            .map(v => v.defs.find(d => d.parent === declaration))
-                            .map(d => d.name) // Identifier nodes
-                            .forEach(checkExportedName);
-                    }
-                } else {
-                    node.specifiers
-                        .map(s => s.exported)
-                        .forEach(checkExportedName);
-                }
-            }
-        };
-    }
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-restricted-globals.js

@@ -1,124 +0,0 @@
-/**
- * @fileoverview Restrict usage of specified globals.
- * @author Benoît Zugmeyer
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow specified global variables",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-restricted-globals"
-        },
-
-        schema: {
-            type: "array",
-            items: {
-                oneOf: [
-                    {
-                        type: "string"
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            name: { type: "string" },
-                            message: { type: "string" }
-                        },
-                        required: ["name"],
-                        additionalProperties: false
-                    }
-                ]
-            },
-            uniqueItems: true,
-            minItems: 0
-        },
-
-        messages: {
-            defaultMessage: "Unexpected use of '{{name}}'.",
-            // eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-            customMessage: "Unexpected use of '{{name}}'. {{customMessage}}"
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        // If no globals are restricted, we don't need to do anything
-        if (context.options.length === 0) {
-            return {};
-        }
-
-        const restrictedGlobalMessages = context.options.reduce((memo, option) => {
-            if (typeof option === "string") {
-                memo[option] = null;
-            } else {
-                memo[option.name] = option.message;
-            }
-
-            return memo;
-        }, {});
-
-        /**
-         * Report a variable to be used as a restricted global.
-         * @param {Reference} reference the variable reference
-         * @returns {void}
-         * @private
-         */
-        function reportReference(reference) {
-            const name = reference.identifier.name,
-                customMessage = restrictedGlobalMessages[name],
-                messageId = customMessage
-                    ? "customMessage"
-                    : "defaultMessage";
-
-            context.report({
-                node: reference.identifier,
-                messageId,
-                data: {
-                    name,
-                    customMessage
-                }
-            });
-        }
-
-        /**
-         * Check if the given name is a restricted global name.
-         * @param {string} name name of a variable
-         * @returns {boolean} whether the variable is a restricted global or not
-         * @private
-         */
-        function isRestricted(name) {
-            return Object.hasOwn(restrictedGlobalMessages, name);
-        }
-
-        return {
-            Program(node) {
-                const scope = sourceCode.getScope(node);
-
-                // Report variables declared elsewhere (ex: variables defined as "global" by eslint)
-                scope.variables.forEach(variable => {
-                    if (!variable.defs.length && isRestricted(variable.name)) {
-                        variable.references.forEach(reportReference);
-                    }
-                });
-
-                // Report variables not declared at all
-                scope.through.forEach(reference => {
-                    if (isRestricted(reference.identifier.name)) {
-                        reportReference(reference);
-                    }
-                });
-
-            }
-        };
-    }
-};