@trackunit/eslint-plugin-trackunit 0.6.157 → 0.6.159

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.6.159 (2026-09-30)
+
+### 🧱 Updated Dependencies
+
+- Updated css-classname-utils to 0.0.60
+- Updated shared-utils to 1.17.4
+
+## 0.6.158 (2026-09-30)
+
+### 🧱 Updated Dependencies
+
+- Updated css-classname-utils to 0.0.59
+- Updated shared-utils to 1.17.3
+
 ## 0.6.157 (2026-09-29)
 
 ### 🧱 Updated Dependencies

package/README.md

@@ -98,6 +98,7 @@ project.
 | `@trackunit/storybook/require-folder-landing-page`    | error                  | no       | Requires a `*.docs.mdx` landing page (`<Meta title="...">`) for every ancestor folder implied by a story's `title` — including titles read from CSF factory `<binding>.meta({...})` calls. Without a landing page, Storybook renders an empty grouping node in the sidebar. |
 | `@trackunit/require-storybook-folder-landing-page`    | not enabled by default | no       | Deprecated alias of `@trackunit/storybook/require-folder-landing-page` — same rule implementation, kept only so configs still referencing the pre-namespace id keep working. Neither the published `react` preset nor the internal `storybook` preset enables it; a consumer must re-enable it explicitly. |
 | `@trackunit/storybook/require-csf-factory`            | warn                   | no       | Detection-only: flags story files in the legacy `export default {...}` shape (`oldFormat`), files mixing that shape with a factory `.meta({...})` call (`mixedFormat`), and files with neither signal (`missingMeta`). Stays silent on files already in the CSF **factory** format (`<binding>.meta({...})` + `<meta>.story({...})`). |
+| `@trackunit/storybook/no-local-meta-component`        | error                  | no       | Detection-only: flags a meta `component` (in `export default {...}`, `const meta = {...}; export default meta`, or any `<binding>.meta({...})`) that resolves to a function/class declared in the story file, an inline component, a wrapper call around a local (`memo(Local)`), or an import from another `*.stories` module. Docgen skips `*.stories.*`, so Controls loses JSDoc prop descriptions and "Show code" names a story-only identifier. Fix by pointing at the real component (`component: MultiSelectField<Option>` for generics) or moving the demo into a sibling `*.demo.tsx`. |
 | `storybook/*` (upstream `eslint-plugin-storybook@^10.3.5` `flat/recommended`) | per-rule (upstream defaults), with `storybook/default-exports` forced `off` | per-rule | Upstream Storybook lint rules, spread only by the internal `storybook` preset — never by the published `react` preset. `storybook/default-exports` is turned back off immediately after the spread because it contradicts the CSF factory format's implicit default export via the `meta` object; `require-csf-factory` above already reports a story file with no meta/default export at all, so no detection guarantee is lost by disabling it. |
 
 **External consumers opt in themselves.** The published `react` preset registers the
@@ -113,14 +114,12 @@ module.exports = [
     rules: {
       "@trackunit/storybook/require-folder-landing-page": "error",
       "@trackunit/storybook/require-csf-factory": "warn",
+      "@trackunit/storybook/no-local-meta-component": "error",
     },
   },
 ];
 ```
 
-> **Planned:** A `no-local-meta-component` rule is expected to join the
-> `@trackunit/storybook/*` namespace once it's written; it does not exist yet.
-
 ### Localization
 
 | Rule                                    | Severity | Auto-fix | Description                                                                                                                            |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/eslint-plugin-trackunit",
-  "version": "0.6.157",
+  "version": "0.6.159",
   "license": "SEE LICENSE IN LICENSE.txt",
   "repository": "https://github.com/Trackunit/manager",
   "engines": {
@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@nx/eslint-plugin": "23.1.0",
-    "@trackunit/css-classname-utils": "0.0.58",
+    "@trackunit/css-classname-utils": "0.0.60",
     "@typescript-eslint/eslint-plugin": "8.58.1",
     "@typescript-eslint/utils": "8.58.1",
     "eslint-config-prettier": "^10.1.8",

package/src/lib/config/index.d.ts

@@ -611,6 +611,9 @@ export declare const configs: {
                     "require-csf-factory": import("@typescript-eslint/utils/ts-eslint").RuleModule<"oldFormat" | "mixedFormat" | "missingMeta", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
                         name: string;
                     };
+                    "no-local-meta-component": import("@typescript-eslint/utils/ts-eslint").RuleModule<"localMetaComponent", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+                        name: string;
+                    };
                 };
             };
             "@typescript-eslint": {

package/src/lib/config/plugins.d.ts

@@ -138,6 +138,9 @@ export declare const storybookPlugin: {
         "require-csf-factory": import("@typescript-eslint/utils/ts-eslint").RuleModule<"oldFormat" | "mixedFormat" | "missingMeta", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        "no-local-meta-component": import("@typescript-eslint/utils/ts-eslint").RuleModule<"localMetaComponent", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
     };
 };
 export { eslintConfigPrettier, globals, importPlugin, jest, jsdoc, jsoncParser, noNull, nx, react, reactHooks, testingLibrary, tsParser, typescriptEslint, };

package/src/lib/config/plugins.js

@@ -37,9 +37,10 @@ const globals = tslib_1.__importStar(require("globals"));
 exports.globals = globals;
 const jsoncParser = tslib_1.__importStar(require("jsonc-eslint-parser"));
 exports.jsoncParser = jsoncParser;
+const rules_map_1 = require("../rules-map");
+const no_local_meta_component_1 = require("../rules/no-local-meta-component/no-local-meta-component");
 const require_csf_factory_1 = require("../rules/require-csf-factory/require-csf-factory");
 const require_storybook_folder_landing_page_1 = require("../rules/require-storybook-folder-landing-page/require-storybook-folder-landing-page");
-const rules_map_1 = require("../rules-map");
 exports.localRulesPlugin = { rules: rules_map_1.rulesMap };
 /**
  * Shared plugin object for the `@trackunit/storybook` namespace. Rule code stays in this
@@ -54,6 +55,7 @@ exports.storybookPlugin = {
     rules: {
         "require-folder-landing-page": require_storybook_folder_landing_page_1.requireFolderLandingPage,
         "require-csf-factory": require_csf_factory_1.requireCsfFactory,
+        "no-local-meta-component": no_local_meta_component_1.noLocalMetaComponent,
     },
 };
 //# sourceMappingURL=plugins.js.map

package/src/lib/config/presets/react.d.ts

@@ -110,6 +110,9 @@ export declare const reactPreset: (import("eslint").Linter.Config<import("eslint
                 "require-csf-factory": import("@typescript-eslint/utils/ts-eslint").RuleModule<"oldFormat" | "mixedFormat" | "missingMeta", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
                     name: string;
                 };
+                "no-local-meta-component": import("@typescript-eslint/utils/ts-eslint").RuleModule<"localMetaComponent", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+                    name: string;
+                };
             };
         };
         "@typescript-eslint": {

package/src/lib/rules/no-local-meta-component/no-local-meta-component.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Error when a Storybook meta's `component` is declared inside a `*.stories.*` file.
+ *
+ * Architecture: per-story-file rule, syntax-only AST + ESLint scope analysis (no TypeScript type
+ * information). The meta object is read from any of:
+ * - `export default { component, ... }` (including a `satisfies` / `as` wrapper),
+ * - `const meta = { component, ... } satisfies Meta<...>; export default meta;` (or `as`, or a
+ *   plain type annotation: `const meta: Meta<...> = { component, ... };`),
+ * - any `<x>.meta({ component, ... })` member call (covers `preview.meta({...})` and
+ *   `preview.type<...>().meta({...})`).
+ *
+ * The `component` value is unwrapped (`satisfies`, `as`, instantiation expressions such as
+ * `MultiSelectField<Option>`) and resolved through scope. It is reported when it resolves to:
+ * - a function/arrow/class expression written inline or declared in this file,
+ * - a call (`memo(Local)`, `forwardRef(Local)`, any call) whose wrapped component resolves locally.
+ *   The wrapped component is the first traceable argument, skipping literal options and inline
+ *   functions after the first position — `memo(Widget, areEqual)` wraps `Widget`,
+ *   `memo(Local, isEqual)` wraps `Local`,
+ * - member access on, destructuring from, or a `const` alias of, something that resolves locally
+ *   (for an object literal, only the accessed or destructured property is checked, following
+ *   spreads into their source; a computed member or a nested/unresolvable destructuring pattern
+ *   is untraced rather than checked against every sibling),
+ * - an import from another `*.stories` module.
+ * Imports from non-story modules (and aliases / member access / instantiations of them) pass.
+ *
+ * Metas without `component`, non-story files, and locally declared components that are not the
+ * meta component (e.g. example-only demos used in `render`) are never checked.
+ *
+ * This is a **detection-only** rule: no autofix and no suggestions — the fix is either importing
+ * the real component or moving the demo into a sibling `*.demo.tsx` file, both of which need
+ * developer intent and cross-file edits.
+ *
+ * See README.md for incorrect/correct examples.
+ */
+import { ESLintUtils } from "@typescript-eslint/utils";
+/** Canonical permalink to this rule's README, embedded in the message. */
+export declare const NO_LOCAL_META_COMPONENT_DOCS_URL = "https://github.com/Trackunit/manager/blob/master/libs/eslint/plugin-trackunit/src/lib/rules/no-local-meta-component/README.md";
+export declare const noLocalMetaComponent: ESLintUtils.RuleModule<"localMetaComponent", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/src/lib/rules/no-local-meta-component/no-local-meta-component.js

@@ -0,0 +1,352 @@
+"use strict";
+/**
+ * Error when a Storybook meta's `component` is declared inside a `*.stories.*` file.
+ *
+ * Architecture: per-story-file rule, syntax-only AST + ESLint scope analysis (no TypeScript type
+ * information). The meta object is read from any of:
+ * - `export default { component, ... }` (including a `satisfies` / `as` wrapper),
+ * - `const meta = { component, ... } satisfies Meta<...>; export default meta;` (or `as`, or a
+ *   plain type annotation: `const meta: Meta<...> = { component, ... };`),
+ * - any `<x>.meta({ component, ... })` member call (covers `preview.meta({...})` and
+ *   `preview.type<...>().meta({...})`).
+ *
+ * The `component` value is unwrapped (`satisfies`, `as`, instantiation expressions such as
+ * `MultiSelectField<Option>`) and resolved through scope. It is reported when it resolves to:
+ * - a function/arrow/class expression written inline or declared in this file,
+ * - a call (`memo(Local)`, `forwardRef(Local)`, any call) whose wrapped component resolves locally.
+ *   The wrapped component is the first traceable argument, skipping literal options and inline
+ *   functions after the first position — `memo(Widget, areEqual)` wraps `Widget`,
+ *   `memo(Local, isEqual)` wraps `Local`,
+ * - member access on, destructuring from, or a `const` alias of, something that resolves locally
+ *   (for an object literal, only the accessed or destructured property is checked, following
+ *   spreads into their source; a computed member or a nested/unresolvable destructuring pattern
+ *   is untraced rather than checked against every sibling),
+ * - an import from another `*.stories` module.
+ * Imports from non-story modules (and aliases / member access / instantiations of them) pass.
+ *
+ * Metas without `component`, non-story files, and locally declared components that are not the
+ * meta component (e.g. example-only demos used in `render`) are never checked.
+ *
+ * This is a **detection-only** rule: no autofix and no suggestions — the fix is either importing
+ * the real component or moving the demo into a sibling `*.demo.tsx` file, both of which need
+ * developer intent and cross-file edits.
+ *
+ * See README.md for incorrect/correct examples.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noLocalMetaComponent = exports.NO_LOCAL_META_COMPONENT_DOCS_URL = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const { DefinitionType } = utils_1.TSESLint.Scope;
+const createRule = utils_1.ESLintUtils.RuleCreator(name => `https://github.com/trackunit/manager/blob/master/libs/eslint/plugin-trackunit/src/lib/rules/${name}/${name}.ts`);
+/** Canonical permalink to this rule's README, embedded in the message. */
+exports.NO_LOCAL_META_COMPONENT_DOCS_URL = "https://github.com/Trackunit/manager/blob/master/libs/eslint/plugin-trackunit/src/lib/rules/no-local-meta-component/README.md";
+const STORY_FILE_REGEX = /\.stories\.(js|jsx|ts|tsx)$/;
+// Import sources are usually extensionless (`./Other.stories`), so the extension is optional.
+const STORY_IMPORT_SOURCE_REGEX = /\.stories(\.(js|jsx|ts|tsx))?$/;
+/** Unwrap `satisfies` / `as` wrappers and instantiation expressions (`MultiSelectField<Option>`). */
+const unwrapExpression = (node) => {
+    let current = node;
+    while (current.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        current.type === utils_1.AST_NODE_TYPES.TSInstantiationExpression) {
+        current = current.expression;
+    }
+    return current;
+};
+const getComponentValue = (object) => {
+    for (const property of object.properties) {
+        if (property.type === utils_1.AST_NODE_TYPES.Property &&
+            !property.computed &&
+            property.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+            property.key.name === "component") {
+            return property.value;
+        }
+    }
+    return null;
+};
+const isInlineComponent = (node) => node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+    node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+    node.type === utils_1.AST_NODE_TYPES.ClassExpression;
+const create = context => {
+    if (!STORY_FILE_REGEX.test(context.filename)) {
+        return {};
+    }
+    /**
+     * `name`'s key and default in `const { key: name = default } = ...`. `null` when `name` isn't a
+     * direct property of `pattern` — a nested pattern (`{ a: { b: name } }`) or a computed key
+     * (`{ [k]: name }`) — since which property that is can't be read syntactically.
+     */
+    const getDestructuredKey = (pattern, name) => {
+        for (const property of pattern.properties) {
+            if (property.type !== utils_1.AST_NODE_TYPES.Property ||
+                property.computed ||
+                property.key.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                continue;
+            }
+            if (property.value.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                if (property.value.left === name) {
+                    return { key: property.key.name, default: property.value.right };
+                }
+                continue;
+            }
+            if (property.value === name) {
+                return { key: property.key.name, default: null };
+            }
+        }
+        return null;
+    };
+    /**
+     * The object literal `node` evaluates to, following `const` aliases (`alias = widgets`), member
+     * access (`ns.widgets`) and destructuring (`const { inner } = ...`); `null` when it can't be traced.
+     *
+     * `path` holds the nodes currently being resolved, so only a real cycle (`const A = B; const B = A;`)
+     * is cut; a node reached again by another route is resolved normally.
+     */
+    const resolveObjectLiteral = (node, path) => {
+        const expression = unwrapExpression(node);
+        if (expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+            return expression;
+        }
+        if (path.has(expression)) {
+            return null;
+        }
+        path.add(expression);
+        try {
+            switch (expression.type) {
+                case utils_1.AST_NODE_TYPES.MemberExpression: {
+                    if (expression.computed || expression.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                        return null;
+                    }
+                    const value = findPropertyValue(expression.object, expression.property.name, path);
+                    return value ? resolveObjectLiteral(value, path) : null;
+                }
+                case utils_1.AST_NODE_TYPES.Identifier: {
+                    const definition = utils_1.ASTUtils.findVariable(context.sourceCode.getScope(expression), expression)?.defs[0];
+                    if (definition?.type !== DefinitionType.Variable || definition.node.init === null) {
+                        return null;
+                    }
+                    if (definition.node.id.type !== utils_1.AST_NODE_TYPES.ObjectPattern) {
+                        return resolveObjectLiteral(definition.node.init, path);
+                    }
+                    const destructured = getDestructuredKey(definition.node.id, definition.name);
+                    if (destructured === null) {
+                        return null;
+                    }
+                    const value = findPropertyValue(definition.node.init, destructured.key, path);
+                    if (value === undefined) {
+                        return null;
+                    }
+                    const resolved = value ?? destructured.default;
+                    return resolved ? resolveObjectLiteral(resolved, path) : null;
+                }
+                default:
+                    return null;
+            }
+        }
+        finally {
+            path.delete(expression);
+        }
+    };
+    /**
+     * The node that provides `object[key]` when `object` traces to an object literal: the property
+     * value, or the source of an untraceable spread that may provide it. `null` when the literal has
+     * no such key; `undefined` when `object` isn't a traceable object literal.
+     *
+     * Properties are read last to first, so a later key overrides an earlier spread; a spread whose
+     * source is a literal without the key falls through to earlier properties. A literal already on
+     * `path` is a spread cycle (`const a = { ...b }; const b = { ...a };`) and provides nothing.
+     */
+    const findPropertyValue = (object, key, path) => {
+        const literal = resolveObjectLiteral(object, path);
+        if (literal === null) {
+            return undefined;
+        }
+        if (path.has(literal)) {
+            return null;
+        }
+        path.add(literal);
+        try {
+            for (const property of [...literal.properties].reverse()) {
+                if (property.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    const spreadValue = findPropertyValue(property.argument, key, path);
+                    if (spreadValue === undefined) {
+                        return property.argument;
+                    }
+                    if (spreadValue !== null) {
+                        return spreadValue;
+                    }
+                    continue;
+                }
+                if (!property.computed && property.key.type === utils_1.AST_NODE_TYPES.Identifier && property.key.name === key) {
+                    return property.value;
+                }
+            }
+            return null;
+        }
+        finally {
+            path.delete(literal);
+        }
+    };
+    /**
+     * Classifies `object[key]`; checks only the accessed property when `object` traces to an object
+     * literal, falling back to `defaultNode` (a destructuring default) when the literal lacks `key`.
+     *
+     * `key === null` means the accessed property can't be read syntactically — a computed member
+     * (`bag[k]`) or an unresolvable destructuring pattern. When `object` traces to an object literal,
+     * this is untraced (`null`) rather than classifying every sibling, which would flag e.g. an
+     * imported `widgets.Widget` merely because `widgets` also has a local `Demo`. When `object` isn't
+     * a traceable literal (e.g. a namespace import, `Ns.Widget`), `object` itself is classified.
+     */
+    const classifyProperty = (object, key, defaultNode, visited) => {
+        if (key === null) {
+            return resolveObjectLiteral(object, new Set()) === null ? classify(object, visited) : null;
+        }
+        const value = findPropertyValue(object, key, new Set());
+        if (value === undefined) {
+            return classify(object, visited);
+        }
+        if (value === null) {
+            return defaultNode ? classify(defaultNode, visited) : null;
+        }
+        return classify(value, visited);
+    };
+    /**
+     * Arguments that can't be the wrapped component: literal options and, after the first position,
+     * inline callbacks (`memo`'s comparator).
+     */
+    const isNonComponentArgument = (argument, index) => {
+        const expression = unwrapExpression(argument);
+        switch (expression.type) {
+            case utils_1.AST_NODE_TYPES.ObjectExpression:
+            case utils_1.AST_NODE_TYPES.ArrayExpression:
+            case utils_1.AST_NODE_TYPES.Literal:
+            case utils_1.AST_NODE_TYPES.TemplateLiteral:
+                return true;
+            default:
+                return index > 0 && isInlineComponent(expression);
+        }
+    };
+    const classifyDefinition = (def, visited) => {
+        switch (def.type) {
+            case DefinitionType.FunctionName:
+            case DefinitionType.ClassName:
+                return "local";
+            case DefinitionType.Variable:
+                if (def.node.init === null) {
+                    return null;
+                }
+                if (def.node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    const destructured = getDestructuredKey(def.node.id, def.name);
+                    return classifyProperty(def.node.init, destructured?.key ?? null, destructured?.default ?? null, visited);
+                }
+                return classify(def.node.init, visited);
+            case DefinitionType.ImportBinding:
+                if (def.parent.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                    return null;
+                }
+                return STORY_IMPORT_SOURCE_REGEX.test(def.parent.source.value) ? "local" : "external";
+            default:
+                return null;
+        }
+    };
+    /**
+     * `"local"` when `node` resolves to something declared in a story file, `"external"` when it
+     * resolves to an import from a non-story module, `null` when it can't be traced.
+     */
+    const classify = (node, visited) => {
+        const expression = unwrapExpression(node);
+        // Guards alias cycles such as `const A = B; const B = A;`.
+        if (visited.has(expression)) {
+            return null;
+        }
+        visited.add(expression);
+        if (isInlineComponent(expression)) {
+            return "local";
+        }
+        switch (expression.type) {
+            case utils_1.AST_NODE_TYPES.CallExpression: {
+                // The wrapped component is the first traceable argument that could be one; later arguments
+                // are its callbacks and options, so they can't outvote it (`memo(Local, isEqual)`,
+                // `memo(Widget, areEqual)`, `withTheme({ strict: true }, Local)`).
+                for (const [index, argument] of expression.arguments.entries()) {
+                    if (isNonComponentArgument(argument, index)) {
+                        continue;
+                    }
+                    const origin = classify(argument, visited);
+                    if (origin !== null) {
+                        return origin;
+                    }
+                }
+                return null;
+            }
+            case utils_1.AST_NODE_TYPES.MemberExpression:
+                return classifyProperty(expression.object, !expression.computed && expression.property.type === utils_1.AST_NODE_TYPES.Identifier
+                    ? expression.property.name
+                    : null, null, visited);
+            case utils_1.AST_NODE_TYPES.ObjectExpression:
+                return expression.properties.some(property => property.type === utils_1.AST_NODE_TYPES.Property && classify(property.value, visited) === "local")
+                    ? "local"
+                    : null;
+            case utils_1.AST_NODE_TYPES.Identifier: {
+                const variable = utils_1.ASTUtils.findVariable(context.sourceCode.getScope(expression), expression);
+                const origins = variable?.defs.map(def => classifyDefinition(def, visited)) ?? [];
+                return origins.includes("local") ? "local" : (origins.find(origin => origin !== null) ?? null);
+            }
+            default:
+                return null;
+        }
+    };
+    const checkMetaObject = (object) => {
+        const component = getComponentValue(object);
+        if (component && classify(component, new Set()) === "local") {
+            context.report({ node: component, messageId: "localMetaComponent" });
+        }
+    };
+    return {
+        ExportDefaultDeclaration(node) {
+            const declaration = unwrapExpression(node.declaration);
+            if (declaration.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                checkMetaObject(declaration);
+                return;
+            }
+            if (declaration.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const variable = utils_1.ASTUtils.findVariable(context.sourceCode.getScope(node), declaration);
+                const definition = variable?.defs[0];
+                if (definition?.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator && definition.node.init) {
+                    const initializer = unwrapExpression(definition.node.init);
+                    if (initializer.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                        checkMetaObject(initializer);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            const { callee } = node;
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                callee.property.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                callee.property.name !== "meta") {
+                return;
+            }
+            const [firstArgument] = node.arguments;
+            if (firstArgument?.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                checkMetaObject(firstArgument);
+            }
+        },
+    };
+};
+exports.noLocalMetaComponent = createRule({
+    name: "no-local-meta-component",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow a Storybook meta `component` that is declared inside a story file",
+        },
+        schema: [],
+        messages: {
+            localMetaComponent: `[no-local-meta-component] The meta \`component\` is declared in a story file. Storybook's docgen enricher skips \`*.stories.*\` files, so Controls loses the component's JSDoc prop descriptions, and "Show code" names an identifier that only exists inside the story. Either point \`component\` at the real component (specialise a generic with an instantiation expression, e.g. \`component: MultiSelectField<Option>\`), or move the documented demo into a sibling \`*.demo.tsx\` file and import it from there. See ${exports.NO_LOCAL_META_COMPONENT_DOCS_URL}.`,
+        },
+    },
+    defaultOptions: [],
+    create,
+});
+//# sourceMappingURL=no-local-meta-component.js.map