@itcase/lint 1.1.75 → 1.1.78

package/dist/eslint.js

@@ -0,0 +1,342 @@
+import { fixupPluginRules } from '@eslint/compat';
+import eslintJs from '@eslint/js';
+import eslintMarkdown from '@eslint/markdown';
+import eslintHtml from 'eslint-plugin-html';
+import eslintImport from 'eslint-plugin-import';
+import eslintJson from 'eslint-plugin-json';
+import eslintPerfectionist from 'eslint-plugin-perfectionist';
+import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
+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_rTLrktP3.js';
+
+const createRule = ESLintUtils.RuleCreator(() => {
+    return ``;
+});
+const ruleName = 'data-test-id';
+const pluginName = 'eslint-data-test-id-plugin';
+const defaultOptions = [];
+
+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) => {
+    // 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 = ELEMENT_NAMES_TO_IGNORE.includes(elementName);
+    // Ignore elements that are in the ignore list
+    assert(!isIgnoredElement);
+    const isLowerCasedName = elementName[0] === elementName[0].toLowerCase();
+    const isElementToCheck = ELEMENT_NAMES_TO_CHECK.includes(elementName);
+    const isAllElementsToCheck = ELEMENT_NAMES_TO_CHECK.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) => {
+    return {
+        // Iterate over all return statements
+        [AST_NODE_TYPES.ReturnStatement]: (node) => {
+            try {
+                handleReturnStatement(context, node);
+            }
+            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: [],
+};
+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 pluginWithoutConfigs = {
+    ...plugin,
+    configs: {
+        recommended: {
+            languageOptions: {
+                ecmaVersion: 'latest',
+                parser: parser,
+            },
+            plugins: {
+                [pluginName]: plugin,
+            },
+            rules: {
+                // By default this rule is disabled, enable only for required paths
+                [`${pluginName}/${ruleName}`]: 'off',
+            },
+        },
+    },
+};
+
+/* eslint-disable perfectionist/sort-objects */
+const eslintConfig = [
+    eslintJs.configs.recommended,
+    ...eslintTypeScript.configs.recommended,
+    //...eslintStorybook.configs['flat/recommended'],
+    eslintPluginPrettierRecommended,
+    pluginWithoutConfigs.configs.recommended,
+    {
+        languageOptions: {
+            globals: {
+                ...globals.browser,
+                ...globals.node,
+            },
+        },
+    },
+    {
+        plugins: {
+            react: eslintReact,
+            // eslint-plugin-react-hooks already supports flat config, but fixupPluginRules
+            // is used for compatibility. Type assertion is needed due to type incompatibility.
+            'react-hooks': fixupPluginRules(eslintReactHooks),
+            html: eslintHtml,
+            import: eslintImport,
+            perfectionist: eslintPerfectionist,
+        },
+    },
+    {
+        ignores: ['dist', 'node_modules', 'eslint.config.mjs'],
+    },
+    {
+        files: ['**/*.json'],
+        ...eslintJson.configs['recommended'],
+    },
+    {
+        files: ['**/*.md', '**/*.mdx'],
+        ...eslintMarkdown.configs.recommended,
+    },
+    {
+        files: ['**/*.{js,jsx,mjs,cjs,ts,tsx}'],
+        rules: {
+            // react-hooks configs recommended rules
+            ...eslintReactHooks.configs.recommended.rules,
+            'react/jsx-fragments': ['error', 'element'],
+            // @typescript-eslint
+            '@typescript-eslint/ban-ts-comment': 'off',
+            '@typescript-eslint/no-explicit-any': 'off',
+            '@typescript-eslint/no-unused-vars': 'warn',
+            // Sometimes you need an empty one, for example when extends
+            '@typescript-eslint/no-empty-object-type': 'off',
+            '@typescript-eslint/no-unused-expressions': 'off',
+            // react
+            // TODO: make rule "react/prop-types" as error only for JS(x) files
+            'react/prop-types': 'off',
+            'react/react-in-jsx-scope': 'off',
+            // react-hooks
+            'react-hooks/exhaustive-deps': 'warn',
+            'react-hooks/rules-of-hooks': 'error',
+            // disables the requirement to format ternary operators in multiline form
+            'multiline-ternary': 'off',
+            // shorthand for methods and properties of objects
+            'object-shorthand': ['warn', 'consistent'],
+            // import
+            'import/no-default-export': 'warn',
+            // Perfectionist
+            'perfectionist/sort-classes': 'off',
+            'perfectionist/sort-enums': sortEnums,
+            'perfectionist/sort-interfaces': sortInterfaces,
+            'perfectionist/sort-intersection-types': sortIntersectionTypes,
+            'perfectionist/sort-jsx-props': sortJSXProps,
+            'perfectionist/sort-maps': sortMaps,
+            'perfectionist/sort-named-exports': sortNamedExports,
+            'perfectionist/sort-exports': sortExports,
+            'perfectionist/sort-objects': sortObjects,
+            'perfectionist/sort-object-types': sortObjectTypes,
+            'perfectionist/sort-union-types': sortUnionTypes,
+        },
+    },
+    // Allow default exports in .page.* files
+    {
+        files: ['**/*.page.{ts,tsx,js,jsx}'],
+        rules: {
+            'import/no-default-export': 'off',
+        },
+    },
+];
+
+export { eslintConfig as default };

package/dist/prettier/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @see https://prettier.io/docs/configuration.html
+ * @type {import("prettier").Config}
+ */
+declare const _default: {
+    arrowParens: string;
+    importOrder: string[];
+    importOrderSortSpecifiers: boolean;
+    plugins: string[];
+    printWidth: number;
+    semi: boolean;
+    singleQuote: boolean;
+    tabWidth: number;
+};
+export default _default;

package/dist/prettier/react-native/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @see https://prettier.io/docs/configuration.html
+ * @type {import("prettier").Config}
+ */
+declare const _default: {
+    importOrder: string[];
+    printWidth: number;
+};
+export default _default;

package/dist/prettier/react-native.js

@@ -0,0 +1,68 @@
+/**
+ * @see https://prettier.io/docs/configuration.html
+ * @type {import("prettier").Config}
+ */
+var index = {
+    importOrder: [
+        '^react$',
+        '^react-native$',
+        '',
+        '^@expo$',
+        '^@expo/(.*)$',
+        '^expo$',
+        '^expo-(.*)$',
+        '',
+        '^mobx$',
+        '^mobx-react-lite$',
+        '^mobx-persist-store$',
+        '',
+        '^@react-navigation/(.*)$',
+        '^@react-native-community/(.*)$',
+        '^react-native-(.*)$',
+        '',
+        '^@itcase/(.*)$',
+        '',
+        '<THIRD_PARTY_MODULES>',
+        '',
+        '^src/enums$',
+        '^src/enums/(.*)$',
+        '^src/interfaces$',
+        '^src/interfaces/(.*)$',
+        '^src/swagger$',
+        '^src/swagger/(.*)$',
+        '^src/constants$',
+        '^src/constants/(.*)$',
+        '^src/config$',
+        '^src/config/(.*)$',
+        '^src/modules$',
+        '^src/modules/(.*)$',
+        '^src/providers$',
+        '^src/providers/(.*)$',
+        '^src/navigation$',
+        '^src/navigation/(.*)$',
+        '^src/dictionaries$',
+        '^src/dictionaries/(.*)$',
+        '^src/forms$',
+        '^src/forms/(.*)$',
+        '^src/stores$',
+        '^src/stores/(.*)$',
+        '^src/screens$',
+        '^src/screens/(.*)$',
+        '^src/components$',
+        '^src/components/(.*)$',
+        '^src/screenCompoments$',
+        '^src/screenCompoments/(.*)$',
+        '^src/hooks$',
+        '^src/hooks/(.*)$',
+        '^src/utils$',
+        '^src/utils/(.*)$',
+        '^src/styles$',
+        '^src/styles/(.*)$',
+        '',
+        '^../(.*)$',
+        '^./(.*)$',
+    ],
+    printWidth: 100,
+};
+
+export { index as default };

package/dist/prettier.js

@@ -0,0 +1,34 @@
+/**
+ * @see https://prettier.io/docs/configuration.html
+ * @type {import("prettier").Config}
+ */
+var index = {
+    arrowParens: 'always',
+    importOrder: [
+        '^react$',
+        '^react-native$',
+        '^prop-types$',
+        '',
+        '<THIRD_PARTY_MODULES>',
+        '',
+        '^@itcase/(.*)$',
+        '',
+        '^(?!.*[.]css)src/(?!icons)(?!stores)(.*)$',
+        '^src/stores/(.*)$',
+        '^src/stores$',
+        '^(?!.*[.]css)[.]',
+        '',
+        '^src/icons$',
+        '^src/icons/(.*)$',
+        '(.*).css$',
+        '',
+    ],
+    importOrderSortSpecifiers: true,
+    plugins: ['@ianvs/prettier-plugin-sort-imports'],
+    printWidth: 80,
+    semi: false,
+    singleQuote: true,
+    tabWidth: 2,
+};
+
+export { index as default };