xo 0.46.2 → 0.48.0

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/schema.js

@@ -0,0 +1,259 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA = void 0;
+const enums_1 = require("./enums");
+const util = __importStar(require("../../util"));
+const UNDERSCORE_SCHEMA = {
+    type: 'string',
+    enum: util.getEnumNames(enums_1.UnderscoreOptions),
+};
+const PREFIX_SUFFIX_SCHEMA = {
+    type: 'array',
+    items: {
+        type: 'string',
+        minLength: 1,
+    },
+    additionalItems: false,
+};
+const MATCH_REGEX_SCHEMA = {
+    type: 'object',
+    properties: {
+        match: { type: 'boolean' },
+        regex: { type: 'string' },
+    },
+    required: ['match', 'regex'],
+};
+const FORMAT_OPTIONS_PROPERTIES = {
+    format: {
+        oneOf: [
+            {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: util.getEnumNames(enums_1.PredefinedFormats),
+                },
+                additionalItems: false,
+            },
+            {
+                type: 'null',
+            },
+        ],
+    },
+    custom: MATCH_REGEX_SCHEMA,
+    leadingUnderscore: UNDERSCORE_SCHEMA,
+    trailingUnderscore: UNDERSCORE_SCHEMA,
+    prefix: PREFIX_SUFFIX_SCHEMA,
+    suffix: PREFIX_SUFFIX_SCHEMA,
+    failureMessage: {
+        type: 'string',
+    },
+};
+function selectorSchema(selectorString, allowType, modifiers) {
+    const selector = {
+        filter: {
+            oneOf: [
+                {
+                    type: 'string',
+                    minLength: 1,
+                },
+                MATCH_REGEX_SCHEMA,
+            ],
+        },
+        selector: {
+            type: 'string',
+            enum: [selectorString],
+        },
+    };
+    if (modifiers && modifiers.length > 0) {
+        selector.modifiers = {
+            type: 'array',
+            items: {
+                type: 'string',
+                enum: modifiers,
+            },
+            additionalItems: false,
+        };
+    }
+    if (allowType) {
+        selector.types = {
+            type: 'array',
+            items: {
+                type: 'string',
+                enum: util.getEnumNames(enums_1.TypeModifiers),
+            },
+            additionalItems: false,
+        };
+    }
+    return [
+        {
+            type: 'object',
+            properties: Object.assign(Object.assign({}, FORMAT_OPTIONS_PROPERTIES), selector),
+            required: ['selector', 'format'],
+            additionalProperties: false,
+        },
+    ];
+}
+function selectorsSchema() {
+    return {
+        type: 'object',
+        properties: Object.assign(Object.assign({}, FORMAT_OPTIONS_PROPERTIES), {
+            filter: {
+                oneOf: [
+                    {
+                        type: 'string',
+                        minLength: 1,
+                    },
+                    MATCH_REGEX_SCHEMA,
+                ],
+            },
+            selector: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: [
+                        ...util.getEnumNames(enums_1.MetaSelectors),
+                        ...util.getEnumNames(enums_1.Selectors),
+                    ],
+                },
+                additionalItems: false,
+            },
+            modifiers: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: util.getEnumNames(enums_1.Modifiers),
+                },
+                additionalItems: false,
+            },
+            types: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: util.getEnumNames(enums_1.TypeModifiers),
+                },
+                additionalItems: false,
+            },
+        }),
+        required: ['selector', 'format'],
+        additionalProperties: false,
+    };
+}
+const SCHEMA = {
+    type: 'array',
+    items: {
+        oneOf: [
+            selectorsSchema(),
+            ...selectorSchema('default', false, util.getEnumNames(enums_1.Modifiers)),
+            ...selectorSchema('variableLike', false, ['unused']),
+            ...selectorSchema('variable', true, [
+                'const',
+                'destructured',
+                'exported',
+                'global',
+                'unused',
+            ]),
+            ...selectorSchema('function', false, ['exported', 'global', 'unused']),
+            ...selectorSchema('parameter', true, ['destructured', 'unused']),
+            ...selectorSchema('memberLike', false, [
+                'abstract',
+                'private',
+                'protected',
+                'public',
+                'readonly',
+                'requiresQuotes',
+                'static',
+            ]),
+            ...selectorSchema('classProperty', true, [
+                'abstract',
+                'private',
+                'protected',
+                'public',
+                'readonly',
+                'requiresQuotes',
+                'static',
+            ]),
+            ...selectorSchema('objectLiteralProperty', true, [
+                'public',
+                'requiresQuotes',
+            ]),
+            ...selectorSchema('typeProperty', true, [
+                'public',
+                'readonly',
+                'requiresQuotes',
+            ]),
+            ...selectorSchema('parameterProperty', true, [
+                'private',
+                'protected',
+                'public',
+                'readonly',
+            ]),
+            ...selectorSchema('property', true, [
+                'abstract',
+                'private',
+                'protected',
+                'public',
+                'readonly',
+                'requiresQuotes',
+                'static',
+            ]),
+            ...selectorSchema('classMethod', false, [
+                'abstract',
+                'private',
+                'protected',
+                'public',
+                'requiresQuotes',
+                'static',
+            ]),
+            ...selectorSchema('objectLiteralMethod', false, [
+                'public',
+                'requiresQuotes',
+            ]),
+            ...selectorSchema('typeMethod', false, ['public', 'requiresQuotes']),
+            ...selectorSchema('method', false, [
+                'abstract',
+                'private',
+                'protected',
+                'public',
+                'requiresQuotes',
+                'static',
+            ]),
+            ...selectorSchema('accessor', true, [
+                'abstract',
+                'private',
+                'protected',
+                'public',
+                'requiresQuotes',
+                'static',
+            ]),
+            ...selectorSchema('enumMember', false, ['requiresQuotes']),
+            ...selectorSchema('typeLike', false, ['abstract', 'exported', 'unused']),
+            ...selectorSchema('class', false, ['abstract', 'exported', 'unused']),
+            ...selectorSchema('interface', false, ['exported', 'unused']),
+            ...selectorSchema('typeAlias', false, ['exported', 'unused']),
+            ...selectorSchema('enum', false, ['exported', 'unused']),
+            ...selectorSchema('typeParameter', false, ['unused']),
+        ],
+    },
+    additionalItems: false,
+};
+exports.SCHEMA = SCHEMA;
+//# sourceMappingURL=schema.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/schema.ts"],"names":[],"mappings":"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"}

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/shared.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMethodOrPropertySelector = exports.isMetaSelector = exports.selectorTypeToMessageString = void 0;
+const enums_1 = require("./enums");
+function selectorTypeToMessageString(selectorType) {
+    const notCamelCase = selectorType.replace(/([A-Z])/g, ' $1');
+    return notCamelCase.charAt(0).toUpperCase() + notCamelCase.slice(1);
+}
+exports.selectorTypeToMessageString = selectorTypeToMessageString;
+function isMetaSelector(selector) {
+    return selector in enums_1.MetaSelectors;
+}
+exports.isMetaSelector = isMetaSelector;
+function isMethodOrPropertySelector(selector) {
+    return (selector === enums_1.MetaSelectors.method || selector === enums_1.MetaSelectors.property);
+}
+exports.isMethodOrPropertySelector = isMethodOrPropertySelector;
+//# sourceMappingURL=shared.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/shared.ts"],"names":[],"mappings":";;;AAAA,mCAMiB;AAEjB,SAAS,2BAA2B,CAAC,YAA6B;IAChE,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IAC7D,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACtE,CAAC;AAiBC,kEAA2B;AAf7B,SAAS,cAAc,CACrB,QAAsE;IAEtE,OAAO,QAAQ,IAAI,qBAAa,CAAC;AACnC,CAAC;AAYC,wCAAc;AAVhB,SAAS,0BAA0B,CACjC,QAAsE;IAEtE,OAAO,CACL,QAAQ,KAAK,qBAAa,CAAC,MAAM,IAAI,QAAQ,KAAK,qBAAa,CAAC,QAAQ,CACzE,CAAC;AACJ,CAAC;AAKC,gEAA0B"}

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/rules/naming-convention-utils/types.ts"],"names":[],"mappings":""}

package/node_modules/@typescript-eslint/eslint-plugin/dist/rules/naming-convention-utils/validator.js

@@ -0,0 +1,371 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidator = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const enums_1 = require("./enums");
+const format_1 = require("./format");
+const shared_1 = require("./shared");
+const util = __importStar(require("../../util"));
+function createValidator(type, context, allConfigs) {
+    // make sure the "highest priority" configs are checked first
+    const selectorType = enums_1.Selectors[type];
+    const configs = allConfigs
+        // gather all of the applicable selectors
+        .filter(c => (c.selector & selectorType) !== 0 ||
+        c.selector === enums_1.MetaSelectors.default)
+        .sort((a, b) => {
+        if (a.selector === b.selector) {
+            // in the event of the same selector, order by modifier weight
+            // sort descending - the type modifiers are "more important"
+            return b.modifierWeight - a.modifierWeight;
+        }
+        const aIsMeta = (0, shared_1.isMetaSelector)(a.selector);
+        const bIsMeta = (0, shared_1.isMetaSelector)(b.selector);
+        // non-meta selectors should go ahead of meta selectors
+        if (aIsMeta && !bIsMeta) {
+            return 1;
+        }
+        if (!aIsMeta && bIsMeta) {
+            return -1;
+        }
+        const aIsMethodOrProperty = (0, shared_1.isMethodOrPropertySelector)(a.selector);
+        const bIsMethodOrProperty = (0, shared_1.isMethodOrPropertySelector)(b.selector);
+        // for backward compatibility, method and property have higher precedence than other meta selectors
+        if (aIsMethodOrProperty && !bIsMethodOrProperty) {
+            return -1;
+        }
+        if (!aIsMethodOrProperty && bIsMethodOrProperty) {
+            return 1;
+        }
+        // both aren't meta selectors
+        // sort descending - the meta selectors are "least important"
+        return b.selector - a.selector;
+    });
+    return (node, modifiers = new Set()) => {
+        var _a, _b, _c;
+        const originalName = node.type === utils_1.AST_NODE_TYPES.Identifier ||
+            node.type === utils_1.AST_NODE_TYPES.PrivateIdentifier
+            ? node.name
+            : `${node.value}`;
+        // return will break the loop and stop checking configs
+        // it is only used when the name is known to have failed or succeeded a config.
+        for (const config of configs) {
+            if (((_a = config.filter) === null || _a === void 0 ? void 0 : _a.regex.test(originalName)) !== ((_b = config.filter) === null || _b === void 0 ? void 0 : _b.match)) {
+                // name does not match the filter
+                continue;
+            }
+            if ((_c = config.modifiers) === null || _c === void 0 ? void 0 : _c.some(modifier => !modifiers.has(modifier))) {
+                // does not have the required modifiers
+                continue;
+            }
+            if (!isCorrectType(node, config, context, selectorType)) {
+                // is not the correct type
+                continue;
+            }
+            let name = originalName;
+            name = validateUnderscore('leading', config, name, node, originalName);
+            if (name === null) {
+                // fail
+                return;
+            }
+            name = validateUnderscore('trailing', config, name, node, originalName);
+            if (name === null) {
+                // fail
+                return;
+            }
+            name = validateAffix('prefix', config, name, node, originalName);
+            if (name === null) {
+                // fail
+                return;
+            }
+            name = validateAffix('suffix', config, name, node, originalName);
+            if (name === null) {
+                // fail
+                return;
+            }
+            if (!validateCustom(config, name, node, originalName)) {
+                // fail
+                return;
+            }
+            if (!validatePredefinedFormat(config, name, node, originalName)) {
+                // fail
+                return;
+            }
+            // it's valid for this config, so we don't need to check any more configs
+            return;
+        }
+    };
+    // centralizes the logic for formatting the report data
+    function formatReportData({ affixes, formats, originalName, processedName, position, custom, count, }) {
+        var _a;
+        return {
+            type: (0, shared_1.selectorTypeToMessageString)(type),
+            name: originalName,
+            processedName,
+            position,
+            count,
+            affixes: affixes === null || affixes === void 0 ? void 0 : affixes.join(', '),
+            formats: formats === null || formats === void 0 ? void 0 : formats.map(f => enums_1.PredefinedFormats[f]).join(', '),
+            regex: (_a = custom === null || custom === void 0 ? void 0 : custom.regex) === null || _a === void 0 ? void 0 : _a.toString(),
+            regexMatch: (custom === null || custom === void 0 ? void 0 : custom.match) === true
+                ? 'match'
+                : (custom === null || custom === void 0 ? void 0 : custom.match) === false
+                    ? 'not match'
+                    : null,
+        };
+    }
+    /**
+     * @returns the name with the underscore removed, if it is valid according to the specified underscore option, null otherwise
+     */
+    function validateUnderscore(position, config, name, node, originalName) {
+        const option = position === 'leading'
+            ? config.leadingUnderscore
+            : config.trailingUnderscore;
+        if (!option) {
+            return name;
+        }
+        const hasSingleUnderscore = position === 'leading'
+            ? () => name.startsWith('_')
+            : () => name.endsWith('_');
+        const trimSingleUnderscore = position === 'leading'
+            ? () => name.slice(1)
+            : () => name.slice(0, -1);
+        const hasDoubleUnderscore = position === 'leading'
+            ? () => name.startsWith('__')
+            : () => name.endsWith('__');
+        const trimDoubleUnderscore = position === 'leading'
+            ? () => name.slice(2)
+            : () => name.slice(0, -2);
+        switch (option) {
+            // ALLOW - no conditions as the user doesn't care if it's there or not
+            case enums_1.UnderscoreOptions.allow: {
+                if (hasSingleUnderscore()) {
+                    return trimSingleUnderscore();
+                }
+                return name;
+            }
+            case enums_1.UnderscoreOptions.allowDouble: {
+                if (hasDoubleUnderscore()) {
+                    return trimDoubleUnderscore();
+                }
+                return name;
+            }
+            case enums_1.UnderscoreOptions.allowSingleOrDouble: {
+                if (hasDoubleUnderscore()) {
+                    return trimDoubleUnderscore();
+                }
+                if (hasSingleUnderscore()) {
+                    return trimSingleUnderscore();
+                }
+                return name;
+            }
+            // FORBID
+            case enums_1.UnderscoreOptions.forbid: {
+                if (hasSingleUnderscore()) {
+                    context.report({
+                        node,
+                        messageId: 'unexpectedUnderscore',
+                        data: formatReportData({
+                            originalName,
+                            position,
+                            count: 'one',
+                        }),
+                    });
+                    return null;
+                }
+                return name;
+            }
+            // REQUIRE
+            case enums_1.UnderscoreOptions.require: {
+                if (!hasSingleUnderscore()) {
+                    context.report({
+                        node,
+                        messageId: 'missingUnderscore',
+                        data: formatReportData({
+                            originalName,
+                            position,
+                            count: 'one',
+                        }),
+                    });
+                    return null;
+                }
+                return trimSingleUnderscore();
+            }
+            case enums_1.UnderscoreOptions.requireDouble: {
+                if (!hasDoubleUnderscore()) {
+                    context.report({
+                        node,
+                        messageId: 'missingUnderscore',
+                        data: formatReportData({
+                            originalName,
+                            position,
+                            count: 'two',
+                        }),
+                    });
+                    return null;
+                }
+                return trimDoubleUnderscore();
+            }
+        }
+    }
+    /**
+     * @returns the name with the affix removed, if it is valid according to the specified affix option, null otherwise
+     */
+    function validateAffix(position, config, name, node, originalName) {
+        const affixes = config[position];
+        if (!affixes || affixes.length === 0) {
+            return name;
+        }
+        for (const affix of affixes) {
+            const hasAffix = position === 'prefix' ? name.startsWith(affix) : name.endsWith(affix);
+            const trimAffix = position === 'prefix'
+                ? () => name.slice(affix.length)
+                : () => name.slice(0, -affix.length);
+            if (hasAffix) {
+                // matches, so trim it and return
+                return trimAffix();
+            }
+        }
+        context.report({
+            node,
+            messageId: 'missingAffix',
+            data: formatReportData({
+                originalName,
+                position,
+                affixes,
+            }),
+        });
+        return null;
+    }
+    /**
+     * @returns true if the name is valid according to the `regex` option, false otherwise
+     */
+    function validateCustom(config, name, node, originalName) {
+        const custom = config.custom;
+        if (!custom) {
+            return true;
+        }
+        const result = custom.regex.test(name);
+        if (custom.match && result) {
+            return true;
+        }
+        if (!custom.match && !result) {
+            return true;
+        }
+        context.report({
+            node,
+            messageId: 'satisfyCustom',
+            data: formatReportData({
+                originalName,
+                custom,
+            }),
+        });
+        return false;
+    }
+    /**
+     * @returns true if the name is valid according to the `format` option, false otherwise
+     */
+    function validatePredefinedFormat(config, name, node, originalName) {
+        const formats = config.format;
+        if (formats === null || formats.length === 0) {
+            return true;
+        }
+        for (const format of formats) {
+            const checker = format_1.PredefinedFormatToCheckFunction[format];
+            if (checker(name)) {
+                return true;
+            }
+        }
+        context.report({
+            node,
+            messageId: originalName === name
+                ? 'doesNotMatchFormat'
+                : 'doesNotMatchFormatTrimmed',
+            data: formatReportData({
+                originalName,
+                processedName: name,
+                formats,
+            }),
+        });
+        return false;
+    }
+}
+exports.createValidator = createValidator;
+const SelectorsAllowedToHaveTypes = enums_1.Selectors.variable |
+    enums_1.Selectors.parameter |
+    enums_1.Selectors.classProperty |
+    enums_1.Selectors.objectLiteralProperty |
+    enums_1.Selectors.typeProperty |
+    enums_1.Selectors.parameterProperty |
+    enums_1.Selectors.accessor;
+function isCorrectType(node, config, context, selector) {
+    if (config.types === null) {
+        return true;
+    }
+    if ((SelectorsAllowedToHaveTypes & selector) === 0) {
+        return true;
+    }
+    const { esTreeNodeToTSNodeMap, program } = util.getParserServices(context);
+    const checker = program.getTypeChecker();
+    const tsNode = esTreeNodeToTSNodeMap.get(node);
+    const type = checker
+        .getTypeAtLocation(tsNode)
+        // remove null and undefined from the type, as we don't care about it here
+        .getNonNullableType();
+    for (const allowedType of config.types) {
+        switch (allowedType) {
+            case enums_1.TypeModifiers.array:
+                if (isAllTypesMatch(type, t => checker.isArrayType(t) || checker.isTupleType(t))) {
+                    return true;
+                }
+                break;
+            case enums_1.TypeModifiers.function:
+                if (isAllTypesMatch(type, t => t.getCallSignatures().length > 0)) {
+                    return true;
+                }
+                break;
+            case enums_1.TypeModifiers.boolean:
+            case enums_1.TypeModifiers.number:
+            case enums_1.TypeModifiers.string: {
+                const typeString = checker.typeToString(
+                // this will resolve things like true => boolean, 'a' => string and 1 => number
+                checker.getWidenedType(checker.getBaseTypeOfLiteralType(type)));
+                const allowedTypeString = enums_1.TypeModifiers[allowedType];
+                if (typeString === allowedTypeString) {
+                    return true;
+                }
+                break;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * @returns `true` if the type (or all union types) in the given type return true for the callback
+ */
+function isAllTypesMatch(type, cb) {
+    if (type.isUnion()) {
+        return type.types.every(t => cb(t));
+    }
+    return cb(type);
+}
+//# sourceMappingURL=validator.js.map