@itcase/lint 1.1.97 → 1.1.99

package/dist/index_CChA61aj.js

@@ -0,0 +1,434 @@
+import eslintStorybook from 'eslint-plugin-storybook';
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+const DOC_BASE = 'https://github.com/ITCase/itcase-lint/tree/main/src/eslint';
+function createRuleCreator(pluginPath) {
+    return ESLintUtils.RuleCreator((name) => pluginPath ? `${DOC_BASE}/${pluginPath}#${name}` : '');
+}
+
+const createRule$1 = createRuleCreator('react/dataTestIdPlugin');
+const ruleName$1 = 'react-data-test-id';
+// Use a shared namespace for our custom rules.
+const pluginName$1 = 'itcase-lint';
+const defaultOptions$1 = [
+    {
+        appendElementNamesToCheck: null,
+        overrideElementNamesToCheck: null,
+        overrideElementNamesToIgnore: null,
+    },
+];
+
+const MESSAGE_IDS$1 = {
+    missingAttribute: 'missingAttribute',
+    missingAttributeValue: 'missingAttributeValue',
+};
+const MESSAGES$1 = {
+    [MESSAGE_IDS$1.missingAttribute]: 'JSX element is missing the required "{{propName}}" attribute.',
+    [MESSAGE_IDS$1.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$1.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$1.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$1 = (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$1} visitor error:`, error);
+            }
+        },
+    };
+};
+
+const ruleMeta$1 = {
+    type: 'suggestion',
+    messages: MESSAGES$1,
+    docs: {
+        description: '',
+    },
+    fixable: 'code',
+    schema: [
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                appendElementNamesToCheck: {
+                    anyOf: [
+                        { type: 'array', items: { type: 'string' } },
+                        { type: 'null' },
+                    ],
+                    default: defaultOptions$1[0].appendElementNamesToCheck,
+                },
+                overrideElementNamesToCheck: {
+                    anyOf: [
+                        { type: 'array', items: { type: 'string' } },
+                        { type: 'null' },
+                    ],
+                    default: defaultOptions$1[0].overrideElementNamesToCheck,
+                },
+                overrideElementNamesToIgnore: {
+                    anyOf: [
+                        { type: 'array', items: { type: 'string' } },
+                        { type: 'null' },
+                    ],
+                    default: defaultOptions$1[0].overrideElementNamesToIgnore,
+                },
+            },
+        },
+    ],
+};
+const rule$1 = createRule$1({
+    name: ruleName$1,
+    create: ruleVisitors$1,
+    defaultOptions: defaultOptions$1,
+    meta: ruleMeta$1,
+});
+
+const createRule = createRuleCreator('storybook/metaParametersDesign');
+const ruleName = 'storybook-meta-parameters-design';
+const pluginName = 'itcase-lint';
+const defaultOptions = [];
+
+const MESSAGE_IDS = {
+    missingOrEmptyUrl: 'missingOrEmptyUrl',
+    typeMustBeFigma: 'typeMustBeFigma',
+    urlMustContainFigma: 'urlMustContainFigma',
+};
+const MESSAGES = {
+    [MESSAGE_IDS.missingOrEmptyUrl]: 'parameters.design.url обязателен и не должен быть пустым.',
+    [MESSAGE_IDS.typeMustBeFigma]: 'parameters.design.type должен быть "figma".',
+    [MESSAGE_IDS.urlMustContainFigma]: 'parameters.design.url должен содержать ссылку на figma.com.',
+};
+
+function getPropertyName(key) {
+    if (key.type === AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (key.type === AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+        return key.value;
+    }
+    return undefined;
+}
+function findProperty(node, name) {
+    return node.properties.find((prop) => {
+        if (prop.type !== AST_NODE_TYPES.Property)
+            return false;
+        return getPropertyName(prop.key) === name;
+    });
+}
+function getStringLiteralValue(node) {
+    if (node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string') {
+        return node.value;
+    }
+    return undefined;
+}
+function resolveMetaObject(declaration, sourceCode) {
+    if (declaration.type === AST_NODE_TYPES.ObjectExpression) {
+        return declaration;
+    }
+    if (declaration.type === AST_NODE_TYPES.Identifier) {
+        const name = declaration.name;
+        for (const statement of sourceCode.body) {
+            if (statement.type === AST_NODE_TYPES.VariableDeclaration) {
+                for (const decl of statement.declarations) {
+                    const init = decl.init;
+                    if (decl.id.type === AST_NODE_TYPES.Identifier &&
+                        decl.id.name === name &&
+                        init != null &&
+                        init.type === AST_NODE_TYPES.ObjectExpression) {
+                        return init;
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+
+const FIGMA_DOMAIN = 'figma.com';
+const ruleVisitors = (context, optionsWithDefault) => {
+    const sourceCode = context.sourceCode.ast;
+    return {
+        ExportDefaultDeclaration(node) {
+            const metaObject = resolveMetaObject(node.declaration, sourceCode);
+            if (!metaObject)
+                return;
+            const parametersProp = findProperty(metaObject, 'parameters');
+            if (!parametersProp)
+                return;
+            const parametersValue = parametersProp.value;
+            if (parametersValue.type !== AST_NODE_TYPES.ObjectExpression)
+                return;
+            const designProp = findProperty(parametersValue, 'design');
+            if (!designProp) {
+                context.report({
+                    messageId: MESSAGE_IDS.missingOrEmptyUrl,
+                    node: parametersProp,
+                });
+                return;
+            }
+            const designValue = designProp.value;
+            if (designValue.type !== AST_NODE_TYPES.ObjectExpression) {
+                context.report({
+                    messageId: MESSAGE_IDS.missingOrEmptyUrl,
+                    node: designProp,
+                });
+                return;
+            }
+            const typeProp = findProperty(designValue, 'type');
+            const typeStr = typeProp
+                ? getStringLiteralValue(typeProp.value)
+                : undefined;
+            if (typeStr !== 'figma') {
+                context.report({
+                    messageId: MESSAGE_IDS.typeMustBeFigma,
+                    node: designProp,
+                });
+                return;
+            }
+            const urlProp = findProperty(designValue, 'url');
+            const urlStr = urlProp ? getStringLiteralValue(urlProp.value) : undefined;
+            if (urlStr === undefined || urlStr.trim() === '') {
+                context.report({
+                    messageId: MESSAGE_IDS.missingOrEmptyUrl,
+                    node: designProp,
+                });
+                return;
+            }
+            if (!urlStr.includes(FIGMA_DOMAIN)) {
+                context.report({
+                    messageId: MESSAGE_IDS.urlMustContainFigma,
+                    node: urlProp ?? designProp,
+                });
+            }
+        },
+    };
+};
+
+const ruleMeta = {
+    type: 'suggestion',
+    messages: MESSAGES,
+    docs: {
+        description: 'Require parameters.design.url to be non-empty and contain a figma.com link.',
+    },
+    schema: [],
+};
+const rule = createRule({
+    name: ruleName,
+    create: ruleVisitors,
+    defaultOptions: defaultOptions,
+    meta: ruleMeta,
+});
+
+const itcaseLintPlugin = {
+    meta: {
+        name: pluginName$1,
+        version: '1.0.0',
+    },
+    processors: {},
+    rules: {
+        [ruleName$1]: rule$1,
+        [ruleName]: rule,
+    },
+};
+
+// eslint-disable-next-line import/no-default-export
+var storybookConfig = [
+    {
+        files: ['**/*.stories.@(ts|tsx|js|jsx|mjs|cjs)'],
+        plugins: {
+            [pluginName]: itcaseLintPlugin,
+            storybook: eslintStorybook,
+        },
+        rules: {
+            [`${pluginName}/${ruleName}`]: 'warn',
+        },
+    },
+];
+
+export { itcaseLintPlugin as i, pluginName$1 as p, ruleName$1 as r, storybookConfig as s };

package/dist/stylelint.js

@@ -214,7 +214,7 @@ var index = {
         'plugin/no-unsupported-browser-features': [
             true,
             {
-                ignore: ['css-nesting', 'prefers-color-scheme'],
+                ignore: ['css-variables', 'css-nesting', 'prefers-color-scheme'],
                 severity: 'warning',
             },
         ],

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@itcase/lint",
-  "version": "1.1.97",
+  "version": "1.1.99",
   "author": "ITCase",
   "description": "Code style linter configuration presets",
   "engines": {
-    "node": ">=20.12.0"
+    "node": ">=22"
   },
   "scripts": {
     "build": "npm run build-js",
@@ -14,7 +14,7 @@
     "prepack": "NODE_ENV=production npm run build",
     "pre-commit": "npm run typecheck",
     "semantic-release": "semantic-release",
-    "test": "npx tsx --test --test-reporter=dot src/**/*.test.ts",
+    "test": "npx tsx --test --test-reporter=spec src/**/*.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "type": "module",
@@ -51,11 +51,11 @@
     "@figma/eslint-plugin-figma-plugins": "^1.0.0",
     "@eslint/js": "^10.0.1",
     "@eslint/markdown": "^7.5.1",
-    "@html-eslint/eslint-plugin": "^0.54.2",
-    "@html-eslint/parser": "^0.54.0",
+    "@html-eslint/eslint-plugin": "^0.58.0",
+    "@html-eslint/parser": "^0.58.0",
     "@ianvs/prettier-plugin-sort-imports": "^4.7.1",
-    "@typescript-eslint/eslint-plugin": "^8.55.0",
-    "@typescript-eslint/parser": "^8.55.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
     "eslint": "9.39.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-alias": "^1.1.2",
@@ -63,49 +63,52 @@
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-json": "^4.0.1",
     "eslint-plugin-mobx": "^0.0.13",
-    "eslint-plugin-n": "^17.23.2",
+    "eslint-plugin-n": "^17.24.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-perfectionist": "^5.5.0",
+    "eslint-plugin-perfectionist": "^5.6.0",
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-native": "^5.0.0",
-    "eslint-plugin-react-refresh": "^0.5.0",
-    "eslint-plugin-storybook": "^10.2.8",
-    "expo-modules-autolinking": "^3.0.24",
-    "globals": "^17.3.0",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "eslint-plugin-storybook": "^10.2.15",
+    "expo-modules-autolinking": "^55.0.8",
+    "globals": "^17.4.0",
     "prettier": "^3.8.1",
-    "stylelint": "^17.2.0",
+    "stylelint": "^17.4.0",
     "stylelint-config-standard": "^40.0.0",
     "stylelint-no-unsupported-browser-features": "^8.1.1",
     "stylelint-order": "^7.0.1",
     "stylelint-prettier": "^5.0.3",
-    "typescript-eslint": "^8.55.0"
+    "typescript-eslint": "^8.56.1"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.4.1",
-    "@commitlint/config-conventional": "^20.4.1",
-    "@itcase/config": "^1.6.49",
+    "@commitlint/cli": "^20.4.3",
+    "@commitlint/config-conventional": "^20.4.3",
+    "@itcase/config": "^1.6.52",
     "@rollup/plugin-alias": "^6.0.0",
-    "@rollup/plugin-babel": "^6.1.0",
+    "@rollup/plugin-babel": "^7.0.0",
     "@rollup/plugin-image": "^3.0.3",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-terser": "^1.0.0",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@types/node": "^25.2.3",
-    "@typescript-eslint/rule-tester": "^8.55.0",
-    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "@types/node": "^25.3.3",
+    "@types/react": "^18.3.0",
+    "@typescript-eslint/rule-tester": "^8.56.1",
+    "conventional-changelog-conventionalcommits": "^9.3.0",
     "del-cli": "^7.0.0",
     "husky": "^9.1.7",
-    "lint-staged": "^16.2.7",
-    "rollup": "4.57.1",
+    "lint-staged": "^16.3.2",
+    "rollup": "4.59.0",
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-dts": "^6.3.0",
     "rollup-plugin-peer-deps-external": "^2.2.4",
+    "react": "^18.3.0",
     "rollup-preserve-directives": "^1.1.3",
     "semantic-release": "^25.0.3",
+    "storybook": "^10.2.15",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }

package/dist/eslint/customPlugins/dataTestIdPlugin/extra.d.ts

@@ -1,18 +0,0 @@
-import { ESLintUtils, TSESLint } from '@typescript-eslint/utils';
-import { type MessageIds } from './constants';
-declare const createRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
-    name: string;
-};
-declare const ruleName = "data-test-id";
-declare const pluginName = "data-test-id-plugin";
-type Options = [
-    {
-        appendElementNamesToCheck?: string[] | null;
-        overrideElementNamesToCheck?: string[] | null;
-        overrideElementNamesToIgnore?: string[] | null;
-    }
-];
-declare const defaultOptions: Options;
-type Context = Readonly<TSESLint.RuleContext<keyof MessageIds, Options>>;
-type RuleVisitors = (context: Context, optionsWithDefault: Readonly<Options>) => TSESLint.RuleListener;
-export { type Context, createRule, defaultOptions, type Options, pluginName, ruleName, type RuleVisitors, };

package/dist/eslint/customPlugins/dataTestIdPlugin/plugin.d.ts

@@ -1,40 +0,0 @@
-import parser from '@typescript-eslint/parser';
-import { TSESLint } from '@typescript-eslint/utils';
-declare const pluginWithConfigs: {
-    configs: {
-        recommended: {
-            languageOptions: {
-                ecmaVersion: "latest";
-                parser: typeof parser;
-            };
-            plugins: {
-                "data-test-id-plugin": {
-                    meta: {
-                        name: string;
-                        version: string;
-                    };
-                    processors: {};
-                    rules: {
-                        "data-test-id": TSESLint.RuleModule<"missingAttribute" | "missingAttributeValue", import("./extra").Options, unknown, TSESLint.RuleListener> & {
-                            name: string;
-                        };
-                    };
-                };
-            };
-            rules: {
-                "data-test-id-plugin/data-test-id": "off";
-            };
-        };
-    };
-    meta: {
-        name: string;
-        version: string;
-    };
-    processors: {};
-    rules: {
-        "data-test-id": TSESLint.RuleModule<"missingAttribute" | "missingAttributeValue", import("./extra").Options, unknown, TSESLint.RuleListener> & {
-            name: string;
-        };
-    };
-};
-export default pluginWithConfigs;