@itcase/lint 1.1.98 → 1.1.99

package/dist/eslint.js

@@ -11,288 +11,17 @@ import eslintReact from 'eslint-plugin-react';
 import eslintReactHooks from 'eslint-plugin-react-hooks';
 import globals from 'globals';
 import eslintTypeScript from 'typescript-eslint';
-import parser from '@typescript-eslint/parser';
-import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { s as sortUnionTypes, a as sortObjectTypes, b as sortObjects, c as sortExports, d as sortNamedExports, e as sortMaps, f as sortJSXProps, g as sortIntersectionTypes, h as sortInterfaces, i as sortEnums } from './sortUnionTypes_G8w5Oj3O.js';
+import parser from '@typescript-eslint/parser';
+import { i as itcaseLintPlugin, p as pluginName, r as ruleName, s as storybookConfig } from './index_CChA61aj.js';
+import { noRestrictedSyntaxRestrictWords } from './eslint/restrictWords.js';
 export { default as eslintFigma } from './eslint/figma.js';
+import 'eslint-plugin-storybook';
+import '@typescript-eslint/utils';
 import '@figma/eslint-plugin-figma-plugins';
 
-const createRule = ESLintUtils.RuleCreator(() => {
-    return ``;
-});
-const ruleName = 'data-test-id';
-const pluginName = 'data-test-id-plugin';
-const defaultOptions = [
-    {
-        appendElementNamesToCheck: null,
-        overrideElementNamesToCheck: null,
-        overrideElementNamesToIgnore: null,
-    },
-];
-
-const MESSAGE_IDS = {
-    missingAttribute: 'missingAttribute',
-    missingAttributeValue: 'missingAttributeValue',
-};
-const MESSAGES = {
-    [MESSAGE_IDS.missingAttribute]: 'JSX element is missing the required "{{propName}}" attribute.',
-    [MESSAGE_IDS.missingAttributeValue]: 'JSX element has a "{{propName}}" attribute with a missing value.',
-};
-const ASSERT_DEFAULT_MESSAGE = 'Assert violation';
-/**
- * Property name to check for in JSX elements.
- */
-const PROP_TO_CHECK_BY_COMPONENT_TYPE = {
-    CUSTOM: {
-        name: 'dataTestId'},
-    HTML: {
-        name: 'data-test-id'},
-};
-/**
- * Custom element names to which the rule should apply.
- * If the array is empty, the rule applies to all JSX elements.
- */
-const ELEMENT_NAMES_TO_CHECK = [
-    'Group',
-    'Modal',
-    'Drawer',
-    'ModalSheetBottom',
-    'Grid',
-    'Flex',
-];
-/**
- * Custom element names to ignore by the rule.
- */
-const ELEMENT_NAMES_TO_IGNORE = [
-    // Element to ignore for testing purposes
-    'IgnoredElement',
-    // Html element from Next.js
-    'Html',
-];
-
-/** Throw an error if the condition is falsy */
-function assert(condition) {
-    if (!condition) {
-        throw new Error(ASSERT_DEFAULT_MESSAGE);
-    }
-}
-/** Extract name from a string or Identifier node */
-function extractNameFromPossibleIdentifier(nodeOrName) {
-    if (typeof nodeOrName === 'string') {
-        return nodeOrName;
-    }
-    return nodeOrName.name;
-}
-/** Get name items of functions and variables that wraps the given node */
-const getFunctionOrVariableAncestorNameItems = (context, node) => {
-    const ancestorNodes = context.sourceCode.getAncestors(node);
-    const functionOrVariableNodes = ancestorNodes.filter((ancestor) => {
-        return (ancestor.type === AST_NODE_TYPES.FunctionExpression ||
-            ancestor.type === AST_NODE_TYPES.FunctionDeclaration ||
-            ancestor.type === AST_NODE_TYPES.VariableDeclaration);
-    });
-    const nullableNameItems = functionOrVariableNodes.map((node) => {
-        if (node.type === AST_NODE_TYPES.FunctionDeclaration ||
-            node.type === AST_NODE_TYPES.FunctionExpression) {
-            if (node.id !== null) {
-                return {
-                    name: node.id.name,
-                    kind: 'function',
-                };
-            }
-        }
-        if (node.type === AST_NODE_TYPES.VariableDeclaration) {
-            const firstDeclaration = node.declarations[0];
-            if (firstDeclaration.id.type === AST_NODE_TYPES.Identifier) {
-                return {
-                    name: firstDeclaration.id.name,
-                    kind: 'variable',
-                };
-            }
-        }
-        return null;
-    });
-    const nameItems = nullableNameItems.filter((item) => item !== null);
-    return nameItems;
-};
-
-const handleReturnStatement = (context, returnStatementNode, options) => {
-    const { elementNamesToCheck, elementNamesToIgnore } = options;
-    // We only care about return statements that return JSX elements
-    assert(returnStatementNode.argument);
-    assert(returnStatementNode.argument.type === AST_NODE_TYPES.JSXElement);
-    const openingElement = returnStatementNode.argument.openingElement;
-    // Something is wrong if it's not a JSXIdentifier
-    assert(openingElement.name.type === AST_NODE_TYPES.JSXIdentifier);
-    const elementName = openingElement.name.name;
-    const isIgnoredElement = elementNamesToIgnore.includes(elementName);
-    // Ignore elements that are in the ignore list
-    assert(!isIgnoredElement);
-    const isLowerCasedName = elementName[0] === elementName[0].toLowerCase();
-    const isElementToCheck = elementNamesToCheck.includes(elementName);
-    const isAllElementsToCheck = elementNamesToCheck.length === 0;
-    // We only care about lowercase elements or specific Elements
-    assert(isLowerCasedName || isElementToCheck || isAllElementsToCheck);
-    // Determine which prop name we are looking for
-    const propNameWeLookingFor = isLowerCasedName
-        ? PROP_TO_CHECK_BY_COMPONENT_TYPE.HTML
-        : PROP_TO_CHECK_BY_COMPONENT_TYPE.CUSTOM;
-    // Try to find the prop we are looking for
-    const propNodeWeLookingFor = openingElement.attributes.find((attr) => {
-        // Ignore spread attributes
-        if (attr.type === AST_NODE_TYPES.JSXAttribute) {
-            const attributeName = extractNameFromPossibleIdentifier(attr.name.name);
-            return propNameWeLookingFor.name === attributeName;
-        }
-    });
-    const ancestorNameItems = getFunctionOrVariableAncestorNameItems(context, returnStatementNode);
-    // Get the nearest ancestor name as the component name
-    const parentComponentNameItem = ancestorNameItems.at(-1);
-    // Something is wrong if there is no component name
-    assert(parentComponentNameItem);
-    if (!propNodeWeLookingFor) {
-        // If we reach here - the prop is missing - report it
-        context.report({
-            messageId: MESSAGE_IDS.missingAttribute,
-            fix: (fixer) => {
-                const propName = propNameWeLookingFor.name;
-                const parentName = parentComponentNameItem.name;
-                // Insert the missing prop
-                if (parentComponentNameItem.kind === 'function') {
-                    return fixer.insertTextAfter(openingElement.name, ' ' + `${propName}={${parentName}.name}`);
-                }
-                if (parentComponentNameItem.kind === 'variable') {
-                    return fixer.insertTextAfter(openingElement.name, ' ' + `${propName}="${parentName}"`);
-                }
-                assert(false);
-            },
-            data: {
-                propName: propNameWeLookingFor.name,
-            },
-            node: openingElement,
-        });
-        assert(false);
-    }
-    // At this moment we only care about prop without value
-    assert(!propNodeWeLookingFor.value);
-    // If we reach here - the prop exists but has no value - report it
-    context.report({
-        messageId: MESSAGE_IDS.missingAttributeValue,
-        fix: (fixer) => {
-            const propName = propNameWeLookingFor.name;
-            const parentName = parentComponentNameItem.name;
-            // Replace incomplete prop with complete one
-            if (parentComponentNameItem.kind === 'function') {
-                return fixer.replaceText(propNodeWeLookingFor, `${propName}={${parentName}.name}`);
-            }
-            if (parentComponentNameItem.kind === 'variable') {
-                return fixer.replaceText(propNodeWeLookingFor, `${propName}="${parentName}"`);
-            }
-            assert(false);
-        },
-        data: {
-            propName: propNameWeLookingFor.name,
-        },
-        node: openingElement,
-    });
-};
-const ruleVisitors = (context, optionsWithDefault) => {
-    const [options] = optionsWithDefault;
-    const { appendElementNamesToCheck, overrideElementNamesToCheck, overrideElementNamesToIgnore, } = options;
-    let elementNamesToCheck = ELEMENT_NAMES_TO_CHECK.slice();
-    let elementNamesToIgnore = ELEMENT_NAMES_TO_IGNORE.slice();
-    // Override default element names
-    if (overrideElementNamesToCheck) {
-        elementNamesToCheck = overrideElementNamesToCheck.slice();
-    }
-    // Override default element names
-    if (overrideElementNamesToIgnore) {
-        elementNamesToIgnore = overrideElementNamesToIgnore.slice();
-    }
-    // Append additional element names
-    if (appendElementNamesToCheck) {
-        elementNamesToCheck.push(...appendElementNamesToCheck);
-    }
-    return {
-        // Iterate over all return statements
-        [AST_NODE_TYPES.ReturnStatement]: (node) => {
-            try {
-                handleReturnStatement(context, node, {
-                    elementNamesToCheck,
-                    elementNamesToIgnore,
-                });
-            }
-            catch (error) {
-                // Only log errors that are not from assert checks.
-                // Assert errors are used for early exit.
-                if (error instanceof Error &&
-                    error.message === ASSERT_DEFAULT_MESSAGE) {
-                    // Ignore assert errors
-                    return;
-                }
-                // Log other errors
-                console.log(`${pluginName} visitor error:`, error);
-            }
-        },
-    };
-};
-
-const ruleMeta = {
-    type: 'suggestion',
-    messages: MESSAGES,
-    docs: {
-        description: '',
-    },
-    fixable: 'code',
-    schema: [
-        {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                appendElementNamesToCheck: {
-                    anyOf: [
-                        { type: 'array', items: { type: 'string' } },
-                        { type: 'null' },
-                    ],
-                    default: defaultOptions[0].appendElementNamesToCheck,
-                },
-                overrideElementNamesToCheck: {
-                    anyOf: [
-                        { type: 'array', items: { type: 'string' } },
-                        { type: 'null' },
-                    ],
-                    default: defaultOptions[0].overrideElementNamesToCheck,
-                },
-                overrideElementNamesToIgnore: {
-                    anyOf: [
-                        { type: 'array', items: { type: 'string' } },
-                        { type: 'null' },
-                    ],
-                    default: defaultOptions[0].overrideElementNamesToIgnore,
-                },
-            },
-        },
-    ],
-};
-const rule = createRule({
-    name: ruleName,
-    create: ruleVisitors,
-    defaultOptions: defaultOptions,
-    meta: ruleMeta,
-});
-
-const plugin = {
-    meta: {
-        name: pluginName,
-        version: '1.0.0',
-    },
-    processors: {},
-    rules: {
-        [ruleName]: rule,
-    },
-};
 const pluginWithConfigs = {
-    ...plugin,
+    ...itcaseLintPlugin,
     configs: {
         recommended: {
             languageOptions: {
@@ -300,7 +29,7 @@ const pluginWithConfigs = {
                 parser: parser,
             },
             plugins: {
-                [pluginName]: plugin,
+                [pluginName]: itcaseLintPlugin,
             },
             rules: {
                 // By default this rule is disabled, enable only for required paths
@@ -381,6 +110,8 @@ const eslintConfig = [
             // react-hooks
             'react-hooks/exhaustive-deps': 'warn',
             'react-hooks/rules-of-hooks': 'error',
+            // Запрет определённых слов в качестве идентификаторов (список в restrictWords/config.ts)
+            'no-restricted-syntax': noRestrictedSyntaxRestrictWords,
             // disables the requirement to format ternary operators in multiline form
             'multiline-ternary': 'off',
             // shorthand for methods and properties of objects
@@ -413,6 +144,7 @@ const eslintConfig = [
             'import/no-default-export': 'off',
         },
     },
+    ...storybookConfig,
 ];
 
 export { eslintConfig as default };