@dartess/eslint-plugin 0.0.1

package/dist/configs/vendor-rules/typescript-disablings.js

@@ -0,0 +1,13 @@
+// This file contains code from the `eslint-config-airbnb-typescript` project
+// Original author: Matt Turnbull <matt@iamturns.com> (https://iamturns.com)
+// License: MIT (see LICENSE-eslint-config-airbnb-typescript.md file)
+// Permalink: https://github.com/iamturns/eslint-config-airbnb-typescript/blob/303e346214847385bee4016367ff3b1b9978e337/lib/shared.js
+const rules = {
+    // The following rules are enabled in Airbnb config, but are already checked (more thoroughly) by the TypeScript compiler
+    // Some of the rules also fail in TypeScript files, for example: https://github.com/typescript-eslint/typescript-eslint/issues/662#issuecomment-507081586
+    // Rules are inspired by: https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/configs/eslint-recommended.ts
+    'valid-typeof': 'off',
+    // Disable `import/no-unresolved`, see README.md for details
+    'import-x/no-unresolved': 'off',
+};
+export default rules;

package/dist/configs/vendor-rules/typescript.d.ts

@@ -0,0 +1,40 @@
+declare const rules: {
+    'default-param-last': "off";
+    '@typescript-eslint/default-param-last': "error";
+    'no-empty-function': "off";
+    '@typescript-eslint/no-empty-function': ["error", {
+        allow: string[];
+    }];
+    'no-loop-func': "off";
+    '@typescript-eslint/no-loop-func': "error";
+    'no-shadow': "off";
+    '@typescript-eslint/no-shadow': "error";
+    'no-unused-vars': "off";
+    '@typescript-eslint/no-unused-vars': ["error", {
+        vars: string;
+        args: string;
+        ignoreRestSiblings: boolean;
+    }];
+    'no-use-before-define': "off";
+    '@typescript-eslint/no-use-before-define': ["error", {
+        functions: boolean;
+        classes: boolean;
+        variables: boolean;
+    }];
+    'require-await': "off";
+    '@typescript-eslint/require-await': "off";
+    'no-return-await': "off";
+    '@typescript-eslint/return-await': ["error", string];
+    'import-x/extensions': ["error", string, {
+        ts: string;
+        tsx: string;
+        js: string;
+        mjs: string;
+        jsx: string;
+    }];
+    'import-x/no-extraneous-dependencies': ["error", {
+        devDependencies: string[];
+        optionalDependencies: boolean;
+    }];
+};
+export default rules;

package/dist/configs/vendor-rules/typescript.js

@@ -0,0 +1,69 @@
+// This file contains code from the `eslint-config-airbnb-typescript` project
+// Original author: Matt Turnbull <matt@iamturns.com> (https://iamturns.com)
+// License: MIT (see LICENSE-eslint-config-airbnb-typescript.md file)
+// Permalink: https://github.com/iamturns/eslint-config-airbnb-typescript/blob/303e346214847385bee4016367ff3b1b9978e337/lib/shared.js
+import baseBestPracticesRules from "./best-practices.js";
+import baseVariablesRules from "./variables.js";
+import baseImportsRules from "./imports.js";
+const rules = {
+    // Replace Airbnb 'default-param-last' rule with '@typescript-eslint' version
+    // https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/docs/rules/default-param-last.md
+    'default-param-last': 'off',
+    '@typescript-eslint/default-param-last': baseBestPracticesRules['default-param-last'],
+    // Replace Airbnb 'no-empty-function' rule with '@typescript-eslint' version
+    // https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-empty-function.md
+    'no-empty-function': 'off',
+    '@typescript-eslint/no-empty-function': baseBestPracticesRules['no-empty-function'],
+    // Replace Airbnb 'no-loop-func' rule with '@typescript-eslint' version
+    // https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-loop-func.md
+    'no-loop-func': 'off',
+    '@typescript-eslint/no-loop-func': baseBestPracticesRules['no-loop-func'],
+    // Replace Airbnb 'no-shadow' rule with '@typescript-eslint' version
+    // https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-shadow.md
+    'no-shadow': 'off',
+    '@typescript-eslint/no-shadow': baseVariablesRules['no-shadow'],
+    // Replace Airbnb 'no-unused-vars' rule with '@typescript-eslint' version
+    // https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-unused-vars.md
+    'no-unused-vars': 'off',
+    '@typescript-eslint/no-unused-vars': baseVariablesRules['no-unused-vars'],
+    // Replace Airbnb 'no-use-before-define' rule with '@typescript-eslint' version
+    // https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/no-use-before-define.md
+    'no-use-before-define': 'off',
+    '@typescript-eslint/no-use-before-define': baseVariablesRules['no-use-before-define'],
+    // Replace Airbnb 'require-await' rule with '@typescript-eslint' version
+    // https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/require-await.md
+    'require-await': 'off',
+    '@typescript-eslint/require-await': baseBestPracticesRules['require-await'],
+    // Replace Airbnb 'no-return-await' rule with '@typescript-eslint' version
+    // https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/return-await.md
+    'no-return-await': 'off',
+    '@typescript-eslint/return-await': ['error', 'in-try-catch'],
+    // Append 'ts' and 'tsx' to Airbnb 'import-x/extensions' rule
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/extensions.md
+    'import-x/extensions': [
+        baseImportsRules['import-x/extensions'][0],
+        baseImportsRules['import-x/extensions'][1],
+        {
+            ...baseImportsRules['import-x/extensions'][2],
+            ts: 'never',
+            tsx: 'never',
+        },
+    ],
+    // Append 'ts' and 'tsx' extensions to Airbnb 'import-x/no-extraneous-dependencies' rule
+    // https://github.com/benmosher/eslint-plugin-import/blob/master/docs/rules/no-extraneous-dependencies.md
+    'import-x/no-extraneous-dependencies': [
+        baseImportsRules['import-x/no-extraneous-dependencies'][0],
+        {
+            ...baseImportsRules['import-x/no-extraneous-dependencies'][1],
+            devDependencies: baseImportsRules['import-x/no-extraneous-dependencies'][1].devDependencies.reduce((result, devDep) => {
+                const toAppend = [devDep];
+                const devDepWithTs = devDep.replace(/\bjs(x?)\b/g, 'ts$1');
+                if (devDepWithTs !== devDep) {
+                    toAppend.push(devDepWithTs);
+                }
+                return [...result, ...toAppend];
+            }, []),
+        },
+    ],
+};
+export default rules;

package/dist/configs/vendor-rules/variables.d.ts

@@ -0,0 +1,28 @@
+declare const rules: {
+    'no-delete-var': "error";
+    'no-label-var': "error";
+    'no-restricted-globals': ["error", {
+        name: string;
+        message: string;
+    }, {
+        name: string;
+        message: string;
+    }, ...{
+        name: "name" | "length" | "find" | "parent" | "menubar" | "self" | "addEventListener" | "blur" | "close" | "closed" | "confirm" | "defaultStatus" | "defaultstatus" | "event" | "external" | "focus" | "frameElement" | "frames" | "history" | "innerHeight" | "innerWidth" | "location" | "locationbar" | "moveBy" | "moveTo" | "onblur" | "onerror" | "onfocus" | "onload" | "onresize" | "onunload" | "open" | "opener" | "opera" | "outerHeight" | "outerWidth" | "pageXOffset" | "pageYOffset" | "print" | "removeEventListener" | "resizeBy" | "resizeTo" | "screen" | "screenLeft" | "screenTop" | "screenX" | "screenY" | "scroll" | "scrollbars" | "scrollBy" | "scrollTo" | "scrollX" | "scrollY" | "status" | "statusbar" | "stop" | "toolbar" | "top";
+        message: string;
+    }[]];
+    'no-shadow': "error";
+    'no-shadow-restricted-names': "error";
+    'no-undef-init': "error";
+    'no-unused-vars': ["error", {
+        vars: string;
+        args: string;
+        ignoreRestSiblings: boolean;
+    }];
+    'no-use-before-define': ["error", {
+        functions: boolean;
+        classes: boolean;
+        variables: boolean;
+    }];
+};
+export default rules;

package/dist/configs/vendor-rules/variables.js

@@ -0,0 +1,39 @@
+// This file contains code from the `eslint-config-airbnb` project
+// Original author: Jake Teton-Landis (https://twitter.com/@jitl)
+// License: MIT (see LICENSE-eslint-config-airbnb.md file)
+// Permalink: https://github.com/airbnb/javascript/blob/c25bce83be4db06e6a221d79686c485cd2ed5d5d/packages/eslint-config-airbnb-base/rules/variables.js
+import confusingBrowserGlobals from 'confusing-browser-globals';
+const rules = {
+    // disallow deletion of variables
+    'no-delete-var': 'error',
+    // disallow labels that share a name with a variable
+    // https://eslint.org/docs/rules/no-label-var
+    'no-label-var': 'error',
+    // disallow specific globals
+    'no-restricted-globals': [
+        'error',
+        {
+            name: 'isFinite',
+            message: 'Use Number.isFinite instead https://github.com/airbnb/javascript#standard-library--isfinite',
+        },
+        {
+            name: 'isNaN',
+            message: 'Use Number.isNaN instead https://github.com/airbnb/javascript#standard-library--isnan',
+        },
+        ...confusingBrowserGlobals.map(g => ({
+            name: g,
+            message: `Use window.${g} instead. https://github.com/facebook/create-react-app/blob/HEAD/packages/confusing-browser-globals/README.md`,
+        })),
+    ],
+    // disallow declaration of variables already declared in the outer scope
+    'no-shadow': 'error',
+    // disallow shadowing of names such as arguments
+    'no-shadow-restricted-names': 'error',
+    // disallow use of undefined when initializing variables
+    'no-undef-init': 'error',
+    // disallow declaration of variables that are not used in the code
+    'no-unused-vars': ['error', { vars: 'all', args: 'after-used', ignoreRestSiblings: true }],
+    // disallow use of variables before they are defined
+    'no-use-before-define': ['error', { functions: true, classes: true, variables: true }],
+};
+export default rules;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { ESLint } from 'eslint';
+declare const plugin: ESLint.Plugin;
+export default plugin;

package/dist/index.js

@@ -0,0 +1,25 @@
+import packageJson from '../package.json' with { type: 'json' };
+import ruleJsxTextAsChildFrom from "./rules/jsx-text-as-child.js";
+import rulePreventMixingExternalAndInternalClasses from "./rules/prevent-mixing-external-and-internal-classes.js";
+import ruleStoriesExportMeta from "./rules/stories-export-meta.js";
+import ruleStoriesExportTyped from "./rules/stories-export-typed.js";
+import ruleStrictObservableComponentsDeclaration from "./rules/strict-observable-components-declaration.js";
+import ruleRequireObserver from "./rules/require-observer.js";
+import ruleMaxParentImportDepth from "./rules/max-parent-import-depth.js";
+const plugin = {
+    meta: {
+        name: packageJson.name,
+        version: packageJson.version,
+    },
+    processors: {},
+    rules: {
+        'jsx-text-as-child': ruleJsxTextAsChildFrom,
+        'prevent-mixing-external-and-internal-classes': rulePreventMixingExternalAndInternalClasses,
+        'stories-export-meta': ruleStoriesExportMeta,
+        'stories-export-typed': ruleStoriesExportTyped,
+        'strict-observable-components-declaration': ruleStrictObservableComponentsDeclaration,
+        'require-observer': ruleRequireObserver,
+        'max-parent-import-depth': ruleMaxParentImportDepth,
+    },
+};
+export default plugin;

package/dist/rules/jsx-text-as-child.d.ts

@@ -0,0 +1,13 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+type Options = [
+    {
+        allowDigits?: boolean;
+        allowEmoji?: boolean;
+        allowSpecialSymbols?: boolean;
+        allowExtraStrings?: Array<string>;
+        disallowedSymbols?: Array<string>;
+    }
+];
+type MessageIds = 'textAsChild' | 'disallowedSymbols';
+declare const _default: ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener>;
+export default _default;

package/dist/rules/jsx-text-as-child.js

@@ -0,0 +1,90 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+/**
+ * @fileoverview Disallows text as child in JSX elements, except specified characters like emojis, digits, special symbols and extra strings
+ * @author Sergey Kozlov
+ */
+import emojiRegex from 'emoji-regex';
+export default ESLintUtils.RuleCreator(() => '')({
+    name: 'jsx-text-as-child',
+    defaultOptions: [{}],
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow JSX elements to have text as a child, except for specified allowed characters',
+        },
+        messages: {
+            textAsChild: 'JSX elements should not have text without translation; disable for file and add TODO to comment during development.',
+            disallowedSymbols: 'According to the disallowedSymbols option, some symbols are prohibited. Check the option and choose an alternative.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowExtraStrings: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    allowEmoji: {
+                        type: 'boolean',
+                    },
+                    allowDigits: {
+                        type: 'boolean',
+                    },
+                    allowSpecialSymbols: {
+                        type: 'boolean',
+                    },
+                    disallowedSymbols: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        ],
+    },
+    create(context) {
+        const allowedRegexpParts = [' '];
+        const [options] = context.options;
+        if (options?.allowDigits) {
+            allowedRegexpParts.push('[0-9]');
+        }
+        if (options?.allowEmoji) {
+            allowedRegexpParts.push(`(${emojiRegex().source})`);
+        }
+        if (options?.allowSpecialSymbols) {
+            allowedRegexpParts.push(...'`-=[];\\\',./~!@#$%^&*()_+{}|:"<>?№–≈—…'.split('').map(c => `\\${c}`));
+        }
+        if (options?.allowExtraStrings) {
+            allowedRegexpParts.push(...options.allowExtraStrings.map(str => `(${str})`));
+        }
+        const allowedRegexp = new RegExp(`^(${allowedRegexpParts.join('|')})+$`);
+        const disallowedRegexp = options?.disallowedSymbols
+            ? new RegExp(`(${options.disallowedSymbols.join('|')})+`)
+            : null;
+        const checkChildren = (children) => {
+            children
+                .filter((node) => node.type === AST_NODE_TYPES.JSXText)
+                .map(node => ({ node, text: node.value.trim() }))
+                .filter(({ text }) => text !== '')
+                .forEach(({ node, text }) => {
+                if (!allowedRegexp.test(text)) {
+                    context.report({ node, messageId: 'textAsChild' });
+                }
+                if (disallowedRegexp?.test(text)) {
+                    context.report({ node, messageId: 'disallowedSymbols' });
+                }
+            });
+        };
+        return {
+            JSXElement(node) {
+                checkChildren(node.children);
+            },
+            JSXFragment(node) {
+                checkChildren(node.children);
+            },
+        };
+    },
+});

package/dist/rules/max-parent-import-depth.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"tooDeep", [], unknown, ESLintUtils.RuleListener>;
+export default _default;

package/dist/rules/max-parent-import-depth.js

@@ -0,0 +1,50 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+export default ESLintUtils.RuleCreator(() => '')({
+    name: 'max-parent-import-depth',
+    defaultOptions: [],
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow relative imports going up more than a specified number of parent directories.',
+        },
+        messages: {
+            tooDeep: 'Import from {{ level }} parent levels is not allowed. Maximum allowed is {{ maxParentImportLevels }}.',
+        },
+        schema: [],
+    },
+    create(context) {
+        const { maxParentImportLevels = 2 } = context.settings;
+        const checkSource = (node, source) => {
+            const importPath = source.value;
+            if (!importPath.startsWith('../')) {
+                return;
+            }
+            const level = importPath.split('../').length - 1;
+            if (level > maxParentImportLevels) {
+                context.report({
+                    node: source,
+                    messageId: 'tooDeep',
+                    data: { level, maxParentImportLevels },
+                });
+            }
+        };
+        return {
+            ImportDeclaration(node) {
+                checkSource(node, node.source);
+            },
+            ExportAllDeclaration(node) {
+                checkSource(node, node.source);
+            },
+            ExportNamedDeclaration(node) {
+                if (node.source) {
+                    checkSource(node, node.source);
+                }
+            },
+            ImportExpression(node) {
+                if (node.source.type === AST_NODE_TYPES.Literal) {
+                    checkSource(node, node.source);
+                }
+            },
+        };
+    },
+});

package/dist/rules/prevent-mixing-external-and-internal-classes.d.ts

@@ -0,0 +1,13 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+/**
+ * @fileoverview Prevent mixing of outer and inner classes to avoid dependency on style order
+ * @author Sergey Kozlov
+ */
+type Options = [
+    {
+        libName?: string;
+    }
+];
+type MessageIds = 'avoidMix' | 'avoidRenaming';
+declare const _default: ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener>;
+export default _default;

package/dist/rules/prevent-mixing-external-and-internal-classes.js

@@ -0,0 +1,72 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+export default ESLintUtils.RuleCreator(() => '')({
+    name: 'prevent-mixing-external-and-internal-classes',
+    defaultOptions: [{}],
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow passing the className prop to components from outside to enforce encapsulation of styles and prevent unintended styling overrides.',
+        },
+        messages: {
+            avoidMix: 'Avoid mixing outer and inner classes on the same element. The import order of the style is not guaranteed, so the order in which the style is applied is also not guaranteed.',
+            avoidRenaming: "'{{ libName }}' must be imported as 'cn'",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    libName: {
+                        type: 'string',
+                    },
+                },
+                required: ['libName'],
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const [options] = context.options;
+        const libName = options?.libName;
+        if (!libName || typeof libName !== 'string') {
+            throw new Error('libName option is required and must be a string');
+        }
+        const isClassLike = (string) => /class/i.exec(string);
+        return {
+            CallExpression(node) {
+                if (!('name' in node.callee) || node.callee.name !== 'cn') {
+                    return;
+                }
+                const hasStylesItem = node.arguments.some(arg => arg.type === AST_NODE_TYPES.MemberExpression &&
+                    'name' in arg.object &&
+                    arg.object.name === 'styles');
+                const hasClassLikeItem = node.arguments.some(arg => {
+                    const isClassLikeIdentifier = arg.type === AST_NODE_TYPES.Identifier && isClassLike(arg.name);
+                    const isClassLikeProp = arg.type === AST_NODE_TYPES.MemberExpression &&
+                        (!('name' in arg.object) || arg.object.name !== 'styles') &&
+                        'name' in arg.property &&
+                        isClassLike(arg.property.name);
+                    return Boolean(isClassLikeIdentifier || isClassLikeProp);
+                });
+                if (hasStylesItem && hasClassLikeItem) {
+                    context.report({
+                        node,
+                        messageId: 'avoidMix',
+                    });
+                }
+            },
+            ImportDeclaration(node) {
+                if (node.source.value !== libName) {
+                    return;
+                }
+                if (node.specifiers[0].local.name === 'cn') {
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'avoidRenaming',
+                    data: { libName },
+                });
+            },
+        };
+    },
+});

package/dist/rules/require-observer.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"requireObserver", [], unknown, ESLintUtils.RuleListener>;
+export default _default;

package/dist/rules/require-observer.js

@@ -0,0 +1,138 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+function isCustomHook(fn) {
+    if (fn.type === AST_NODE_TYPES.FunctionDeclaration && fn.id?.name.startsWith('use')) {
+        return true;
+    }
+    const { parent } = fn;
+    if ((fn.type === AST_NODE_TYPES.FunctionExpression ||
+        fn.type === AST_NODE_TYPES.ArrowFunctionExpression) &&
+        parent?.type === AST_NODE_TYPES.VariableDeclarator &&
+        parent.id.type === AST_NODE_TYPES.Identifier &&
+        parent.id.name.startsWith('use')) {
+        return true;
+    }
+    return false;
+}
+export default ESLintUtils.RuleCreator(() => '')({
+    name: 'require-observer',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require that React components using specified store hooks are wrapped in observer().',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            requireObserver: 'Components using hooks [{{hooks}}] must be wrapped in observer().',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const mobxSettings = context.settings.mobx;
+        const hooks = Array.isArray(mobxSettings?.storeHooks) ? mobxSettings.storeHooks : [];
+        if (hooks.length === 0) {
+            throw new Error('Please fill settings.mobx.storeHooks');
+        }
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        const hasObserverImport = program.body.some(node => node.type === AST_NODE_TYPES.ImportDeclaration &&
+            node.specifiers.some(spec => spec.type === AST_NODE_TYPES.ImportSpecifier &&
+                (spec.imported.type === AST_NODE_TYPES.Identifier
+                    ? spec.imported.name
+                    : spec.imported.value) === 'observer'));
+        const hooksUsed = new Map();
+        const wrappedNames = new Set();
+        const wrappedFns = new WeakSet();
+        return {
+            CallExpression(node) {
+                if (node.callee.type === AST_NODE_TYPES.Identifier && hooks.includes(node.callee.name)) {
+                    const ancestors = sourceCode.getAncestors(node);
+                    const fn = ancestors
+                        .slice()
+                        .reverse()
+                        .find(anc => anc.type === AST_NODE_TYPES.FunctionDeclaration ||
+                        anc.type === AST_NODE_TYPES.FunctionExpression ||
+                        anc.type === AST_NODE_TYPES.ArrowFunctionExpression);
+                    if (fn && !isCustomHook(fn)) {
+                        const set = hooksUsed.get(fn) ?? new Set();
+                        set.add(node.callee.name);
+                        hooksUsed.set(fn, set);
+                    }
+                }
+                if (node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === 'observer') {
+                    for (const arg of node.arguments) {
+                        if (arg.type === AST_NODE_TYPES.Identifier) {
+                            wrappedNames.add(arg.name);
+                        }
+                        else if (arg.type === AST_NODE_TYPES.FunctionExpression ||
+                            arg.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+                            wrappedFns.add(arg);
+                        }
+                    }
+                }
+            },
+            'Program:exit': function () {
+                for (const [fn, used] of hooksUsed) {
+                    if (isCustomHook(fn)) {
+                        continue;
+                    }
+                    let isWrapped = false;
+                    if (fn.type === AST_NODE_TYPES.FunctionDeclaration &&
+                        fn.id &&
+                        wrappedNames.has(fn.id.name)) {
+                        isWrapped = true;
+                    }
+                    if ((fn.type === AST_NODE_TYPES.FunctionExpression ||
+                        fn.type === AST_NODE_TYPES.ArrowFunctionExpression) &&
+                        wrappedFns.has(fn)) {
+                        isWrapped = true;
+                    }
+                    if (isWrapped) {
+                        continue;
+                    }
+                    context.report({
+                        node: fn,
+                        messageId: 'requireObserver',
+                        data: { hooks: Array.from(used).join(', ') },
+                        fix(fixer) {
+                            const fixes = [];
+                            if (!hasObserverImport) {
+                                fixes.push(fixer.insertTextBefore(program.body[0], "import { observer } from 'mobx-react-lite';\n"));
+                            }
+                            const paramsText = fn.params.map(p => sourceCode.getText(p)).join(', ');
+                            const bodyText = sourceCode.getText(fn.body);
+                            const ancestors = sourceCode.getAncestors(fn);
+                            const exportDecl = ancestors.find(a => a.type === AST_NODE_TYPES.ExportNamedDeclaration ||
+                                a.type === AST_NODE_TYPES.ExportDefaultDeclaration);
+                            const varDecl = fn.parent?.type === AST_NODE_TYPES.VariableDeclarator ? fn.parent.parent : null;
+                            if (fn.type === AST_NODE_TYPES.FunctionDeclaration && fn.id) {
+                                // function declaration -> const assignment
+                                const { name } = fn.id;
+                                const original = sourceCode.getText(fn);
+                                const replacement = `const ${name} = observer(${original});`;
+                                fixes.push(fixer.replaceText(fn, replacement));
+                            }
+                            else if (varDecl && varDecl.type === AST_NODE_TYPES.VariableDeclaration) {
+                                // const Name = () => {} or function expression
+                                const id = fn.parent.id;
+                                const { name } = id;
+                                const isExport = exportDecl?.type === AST_NODE_TYPES.ExportNamedDeclaration;
+                                const funcExpression = `function ${name}(${paramsText}) ${bodyText}`;
+                                const replacementNodeText = `${isExport ? 'export ' : ''}const ${name} = observer(${funcExpression});`;
+                                fixes.push(fixer.replaceText(exportDecl || varDecl, replacementNodeText));
+                            }
+                            else {
+                                // default export or unnamed
+                                const isDefault = exportDecl?.type === AST_NODE_TYPES.ExportDefaultDeclaration;
+                                const funcExpression = `function(${paramsText}) ${bodyText}`;
+                                const replacementNodeText = `${isDefault ? 'export default ' : ''}observer(${funcExpression});`;
+                                fixes.push(fixer.replaceText(exportDecl || fn, replacementNodeText));
+                            }
+                            return fixes;
+                        },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/stories-export-meta.d.ts

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"exportDefaultTypeCheck", [], unknown, ESLintUtils.RuleListener>;
+export default _default;