@blumintinc/eslint-plugin-blumint 1.14.0 → 1.16.0

package/lib/rules/react-memoize-literals.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reactMemoizeLiterals = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const LITERAL_DESCRIPTOR_BY_TYPE = {
     [utils_1.AST_NODE_TYPES.ObjectExpression]: {
         literalType: 'object literal',
@@ -39,7 +40,28 @@ const SAFE_HOOK_ARGUMENTS = new Set([
     'useDeferredValue',
     'useTransition',
     'useId',
+    'useLatestCallback',
+    'useDeepCompareMemo',
+    'useDeepCompareCallback',
+    'useDeepCompareEffect',
+    'useProgressionCallback',
 ]);
+/**
+ * Hooks where any literal defined inside their arguments is safe because
+ * the hook either doesn't use the identity for comparison or provides its
+ * own stability.
+ */
+const HOOKS_ALLOWING_NESTED_LITERALS = new Set([
+    'useState',
+    'useReducer',
+    'useRef',
+]);
+/**
+ * JSX attribute names whose values are style descriptors consumed by the
+ * library (not via referential equality), so inline object literals are safe.
+ * MUI's `sx` and the standard `style` prop both fall into this category.
+ */
+const STYLE_JSX_ATTRIBUTE_NAMES = new Set(['sx', 'style']);
 const MEMOIZATION_DEPS_TODO_PLACEHOLDER = '__TODO_MEMOIZATION_DEPENDENCIES__';
 const TODO_DEPS_COMMENT = `/* ${MEMOIZATION_DEPS_TODO_PLACEHOLDER} */`;
 const PARENTHESIZED_EXPRESSION_TYPE = utils_1.AST_NODE_TYPES.ParenthesizedExpression ??
@@ -228,17 +250,26 @@ function findEnclosingComponentOrHook(node) {
 function isInsideAllowedHookCallback(node) {
     let current = node;
     while (current) {
-        if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
-            current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
-            let parent = current.parent;
-            while (parent && isExpressionWrapper(parent)) {
-                parent = parent.parent;
+        if (isFunctionNode(current)) {
+            if (current.async && current !== node) {
+                return true;
             }
-            if (parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                const hookName = getHookNameFromCallee(parent.callee);
-                const matchesCallback = parent.arguments.some((arg) => unwrapNestedExpressions(arg) === current);
-                if (hookName && SAFE_HOOK_ARGUMENTS.has(hookName) && matchesCallback) {
-                    return true;
+            if (current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                let parent = current.parent;
+                // Skip through TypeScript type assertions and parentheses to find
+                // the actual CallExpression that invokes the hook.
+                while (parent && isExpressionWrapper(parent)) {
+                    parent = parent.parent;
+                }
+                if (parent?.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    const hookName = getHookNameFromCallee(parent.callee);
+                    const matchesCallback = parent.arguments.some((arg) => unwrapNestedExpressions(arg) === current);
+                    if (hookName &&
+                        SAFE_HOOK_ARGUMENTS.has(hookName) &&
+                        matchesCallback) {
+                        return true;
+                    }
                 }
             }
         }
@@ -394,6 +425,66 @@ function buildMemoSuggestions(node, descriptor, sourceCode) {
         },
     ];
 }
+/**
+ * Returns true when the node's value resolves to a JSX attribute that carries
+ * style data consumed by a library rather than compared by reference (MUI `sx`
+ * or the standard `style` prop).
+ *
+ * Walks up from the literal only through positions where it remains the
+ * attribute's resolved value: conditional branches (`sx={c ? {…} : {…}}`),
+ * logical fallbacks (`sx={c && {…}}`), array entries (MUI accepts `sx` arrays),
+ * and expression wrappers (`{…} as const`, parentheses). Any other parent — a
+ * function call, an object property, a spread — means the reference is observed
+ * or transformed before reaching the attribute, so the walk stops and the
+ * literal stays reported. This keeps the exemption tied to genuine style values
+ * without silencing unrelated literals that merely appear deeper in the tree.
+ */
+function isStyleJSXAttributeValue(node) {
+    let current = node;
+    let parent = current.parent;
+    while (parent) {
+        switch (parent.type) {
+            case utils_1.AST_NODE_TYPES.JSXExpressionContainer: {
+                if (parent.expression !== current) {
+                    return false;
+                }
+                const attribute = parent.parent;
+                if (!attribute || attribute.type !== utils_1.AST_NODE_TYPES.JSXAttribute) {
+                    return false;
+                }
+                const { name } = attribute;
+                return (name.type === utils_1.AST_NODE_TYPES.JSXIdentifier &&
+                    STYLE_JSX_ATTRIBUTE_NAMES.has(name.name));
+            }
+            case utils_1.AST_NODE_TYPES.ConditionalExpression: {
+                if (parent.consequent !== current && parent.alternate !== current) {
+                    return false;
+                }
+                break;
+            }
+            case utils_1.AST_NODE_TYPES.LogicalExpression: {
+                if (parent.left !== current && parent.right !== current) {
+                    return false;
+                }
+                break;
+            }
+            case utils_1.AST_NODE_TYPES.ArrayExpression: {
+                if (!parent.elements.some((element) => element === current)) {
+                    return false;
+                }
+                break;
+            }
+            default: {
+                if (!isExpressionWrapper(parent) || parent.expression !== current) {
+                    return false;
+                }
+            }
+        }
+        current = parent;
+        parent = current.parent;
+    }
+    return false;
+}
 /**
  * Formats a readable label for diagnostics based on the owning function.
  * @param fn Owning component or hook function.
@@ -427,20 +518,134 @@ exports.reactMemoizeLiterals = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const sourceCode = context.getSourceCode();
+        /**
+         * Checks whether a VariableDeclarator's sole usage is being thrown
+         * in the same function scope.
+         */
+        function isVariableAlwaysThrown(declarator) {
+            const variables = ASTHelpers_1.ASTHelpers.getDeclaredVariables(context, declarator);
+            if (variables.length === 0) {
+                return false;
+            }
+            const variable = variables[0];
+            const usages = variable.references.filter((ref) => !ref.init);
+            // Variables with no usages (dead code) don't bypass memoization checks
+            // because we can't prove the literal is thrown.
+            if (usages.length === 0) {
+                return false;
+            }
+            const owningFunction = findOwningFunction(declarator);
+            return usages.every((ref) => {
+                let refParent = ref.identifier
+                    .parent;
+                while (refParent) {
+                    if (isFunctionNode(refParent)) {
+                        // Stop at function boundaries: throws inside nested functions don't
+                        // abort the outer render cycle, so they don't make the literal terminal
+                        // from the perspective of the declaring function.
+                        return false;
+                    }
+                    if (refParent.type === utils_1.AST_NODE_TYPES.ThrowStatement) {
+                        // Found a throw in the same lexical scope as the usage.
+                        // Verify the throw is in the same function where the variable was declared
+                        // to ensure the throw terminates the render before memoization matters.
+                        let throwCheckParent = refParent.parent;
+                        while (throwCheckParent) {
+                            if (isFunctionNode(throwCheckParent)) {
+                                return throwCheckParent === owningFunction;
+                            }
+                            throwCheckParent =
+                                throwCheckParent.parent;
+                        }
+                        return owningFunction === null;
+                    }
+                    if (refParent === declarator) {
+                        break;
+                    }
+                    refParent = refParent.parent;
+                }
+                return false;
+            });
+        }
+        /**
+         * Checks whether a literal is destined to be thrown, making referential
+         * stability irrelevant.
+         */
+        function isTerminalUsage(node) {
+            let current = node.parent;
+            // Tracks whether the literal passed through a node that represents non-container usage.
+            // Once true, any throw we encounter won't count as "terminal" because the literal
+            // is already used in an expression that might need memoization.
+            let hasPassedForbiddenNode = false;
+            while (current) {
+                if (current.type === utils_1.AST_NODE_TYPES.ThrowStatement) {
+                    return !hasPassedForbiddenNode;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    current.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    current.init) {
+                    if (!hasPassedForbiddenNode && isVariableAlwaysThrown(current)) {
+                        return true;
+                    }
+                }
+                // Stop at function boundaries as throws across functions are not "terminal"
+                // in the same render cycle sense for the current component/hook.
+                if (isFunctionNode(current)) {
+                    break;
+                }
+                // We distinguish between "containers" (nodes that build up an error value
+                // or wrap an expression) and "usages" (nodes where the value is consumed
+                // in a way that might benefit from memoization).
+                //
+                // Containers (NewExpression for errors, wrappers, or object/array builders)
+                // are allowed because they are part of the path to a 'throw'.
+                // Other nodes (like function calls or being a prop) mark the literal as
+                // having a non-terminal usage.
+                //
+                // Note: AST_NODE_TYPES.CallExpression is intentionally excluded from allowed
+                // containers. Passing a literal into a CallExpression allows the callee to
+                // observe or store the reference, making its identity relevant even if
+                // the result is eventually thrown (e.g., const err = fn({ ... }); throw err;).
+                if (current.type !== utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    current.type !== utils_1.AST_NODE_TYPES.Property &&
+                    current.type !== utils_1.AST_NODE_TYPES.ArrayExpression &&
+                    current.type !== utils_1.AST_NODE_TYPES.NewExpression &&
+                    current.type !== utils_1.AST_NODE_TYPES.ConditionalExpression &&
+                    current.type !== utils_1.AST_NODE_TYPES.LogicalExpression &&
+                    !isExpressionWrapper(current)) {
+                    hasPassedForbiddenNode = true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
         function reportLiteral(node) {
             const descriptor = getLiteralDescriptor(node);
             if (!descriptor)
                 return;
+            const owner = findEnclosingComponentOrHook(node);
+            if (!owner)
+                return;
             if (isInsideAllowedHookCallback(node)) {
                 return;
             }
-            const owner = findEnclosingComponentOrHook(node);
-            if (!owner)
+            if (isTerminalUsage(node)) {
                 return;
+            }
+            // Inline literals that resolve to a style JSX attribute (sx, style),
+            // whether directly or via conditional/logical/array wrappers, are
+            // consumed by the library without reference equality checks, so
+            // memoization adds no stability benefit.
+            if (isStyleJSXAttributeValue(node)) {
+                return;
+            }
             const hookCall = findEnclosingHookCall(node);
             if (hookCall) {
-                if (hookCall.isDirectArgument) {
+                if (hookCall.isDirectArgument ||
+                    HOOKS_ALLOWING_NESTED_LITERALS.has(hookCall.hookName)) {
                     // Top-level literal passed directly to a hook argument is allowed.
+                    // Also allow nested literals for hooks that don't rely on argument
+                    // reference stability for memoization (e.g. useState, useReducer).
                     return;
                 }
                 context.report({

package/lib/rules/require-https-error-cause.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireHttpsErrorCause = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
 const isHttpsErrorCallee = (callee) => {
     if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -42,17 +43,8 @@ exports.requireHttpsErrorCause = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
         const catchStack = [];
-        // ESLint 9 moves getScope onto sourceCode; ESLint 8 exposes context.getScope().
-        // This shim keeps the rule compatible until the codebase drops ESLint 8 support.
-        const getScopeForNode = (node) => {
-            const sourceCodeWithScope = sourceCode;
-            if (typeof sourceCodeWithScope.getScope === 'function') {
-                return sourceCodeWithScope.getScope(node);
-            }
-            return context.getScope();
-        };
         const reportMissingCause = (node, catchName) => {
             context.report({
                 node,
@@ -76,7 +68,7 @@ exports.requireHttpsErrorCause = (0, createRule_1.createRule)({
             if (!frame.paramName || identifier.name !== frame.paramName) {
                 return false;
             }
-            const variable = findVariableInScopeChain(getScopeForNode(identifier), identifier.name);
+            const variable = findVariableInScopeChain(ASTHelpers_1.ASTHelpers.getScope(context, identifier), identifier.name);
             return (variable?.defs.some((definition) => definition.type === 'CatchClause' && definition.node === frame.node) ?? false);
         };
         const validateHttpsError = (node) => {
@@ -95,6 +87,33 @@ exports.requireHttpsErrorCause = (0, createRule_1.createRule)({
                 return;
             }
             const catchName = activeCatch.paramName;
+            // HttpsError accepts both positional and object-based constructors. This signature
+            // is supported for compatibility with HttpsError overloads, ensuring the rule
+            // can validate the 'cause' property within a settings object to preserve
+            // error chaining for better diagnostics.
+            if (node.arguments.length === 1 &&
+                node.arguments[0].type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                const settingsObj = node.arguments[0];
+                const causeProp = settingsObj.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
+                    !prop.computed &&
+                    ((prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        prop.key.name === 'cause') ||
+                        (prop.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                            prop.key.value === 'cause')));
+                if (!causeProp) {
+                    reportMissingCause(node, catchName);
+                    return;
+                }
+                const causeValue = causeProp.value;
+                if (causeValue.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    reportWrongCause(causeValue, catchName, sourceCode.getText(causeValue));
+                    return;
+                }
+                if (!isCatchBindingReference(causeValue, activeCatch)) {
+                    reportWrongCause(causeValue, catchName, sourceCode.getText(causeValue));
+                }
+                return;
+            }
             if (node.arguments.length < 4) {
                 reportMissingCause(node, catchName);
                 return;

package/lib/rules/require-memo.js

@@ -8,21 +8,25 @@ const ASTHelpers_1 = require("../utils/ASTHelpers");
 const isComponentExplicitlyUnmemoized = (componentName) => componentName.toLowerCase().includes('unmemoized');
 function isFunction(node) {
     return (node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
-        node.type === utils_1.AST_NODE_TYPES.FunctionExpression);
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration);
 }
-function isHigherOrderFunctionReturningJSX(node) {
+function isHigherOrderFunctionReturningJSX(node, context) {
     if (isFunction(node)) {
-        // Check if function takes another function as an argument
-        const hasFunctionParam = 'params' in node && node.params.some(isFunction);
         if (node.body && node.body.type === 'BlockStatement') {
             for (const statement of node.body.body) {
                 if (statement.type === 'ReturnStatement' && statement.argument) {
-                    const returnsJSX = ASTHelpers_1.ASTHelpers.returnsJSX(statement.argument);
+                    const returnsJSX = ASTHelpers_1.ASTHelpers.returnsJSX(statement.argument, context);
                     const returnsFunction = isFunction(statement.argument);
-                    return (hasFunctionParam || returnsFunction) && returnsJSX;
+                    return returnsFunction && returnsJSX;
                 }
             }
         }
+        else if (node.body && isFunction(node.body)) {
+            // Shorthand arrow HOC: (Comp) => (props) => <Comp {...props} />
+            // Here node.body is the inner function; check if it returns JSX.
+            return ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context);
+        }
     }
     return false;
 }
@@ -52,14 +56,15 @@ function checkFunction(context, node) {
     if (!fileName.endsWith('.tsx')) {
         return;
     }
-    if (isHigherOrderFunctionReturningJSX(node)) {
+    if (isHigherOrderFunctionReturningJSX(node, context)) {
         return;
     }
     const parentNode = node.parent;
     if (node.parent.type === 'CallExpression') {
         return;
     }
-    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body) && ASTHelpers_1.ASTHelpers.hasParameters(node)) {
+    if (ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context) &&
+        ASTHelpers_1.ASTHelpers.hasParameters(node)) {
         const results = [
             isUnmemoizedArrowFunction,
             isUnmemoizedFunctionComponent,
@@ -79,6 +84,9 @@ function checkFunction(context, node) {
                 },
                 fix: results[2] || results[1]
                     ? function fix(fixer) {
+                        if (node.async || node.generator) {
+                            return null;
+                        }
                         const sourceCode = context.sourceCode;
                         let importFix = null;
                         // Search for memo import statement
@@ -118,7 +126,7 @@ function checkFunction(context, node) {
                         const functionNameReplacement = `function ${node.id.name}Unmemoized`;
                         const fixes = [
                             fixer.replaceTextRange(functionKeywordRange, functionKeywordReplacement),
-                            fixer.insertTextAfterRange([node.range[1], node.range[1]], ')'),
+                            fixer.insertTextAfterRange([node.range[1], node.range[1]], ');'),
                             fixer.replaceTextRange([node.id.range[0] - 1, node.id.range[1]], functionNameReplacement),
                         ];
                         if (importFix) {

package/lib/rules/require-migration-script-metadata.d.ts

@@ -0,0 +1,9 @@
+type MessageIds = 'missingMetadata' | 'metadataAfterStatement' | 'missingMigrationTag' | 'invalidMigrationTag' | 'missingPhaseTag' | 'invalidPhaseTag' | 'missingDependenciesTag' | 'invalidDependenciesTag' | 'missingDescriptionTag' | 'extensionInDependencies' | 'noneCasing' | 'legacyHeaderNotAllowed' | 'multipleMetadataBlocks';
+type Options = [
+    {
+        targetGlobs?: string[];
+        allowLegacyHeader?: boolean;
+    }
+];
+export declare const requireMigrationScriptMetadata: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/require-migration-script-metadata.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireMigrationScriptMetadata = void 0;
+const minimatch_1 = require("minimatch");
+const createRule_1 = require("../utils/createRule");
+const DEFAULT_OPTIONS = {
+    targetGlobs: ['**/functions/src/callable/scripts/**/*.f.ts'],
+    allowLegacyHeader: true,
+};
+exports.requireMigrationScriptMetadata = (0, createRule_1.createRule)({
+    name: 'require-migration-script-metadata',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce JSDoc migration metadata in callable scripts',
+            recommended: 'error',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    targetGlobs: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                    allowLegacyHeader: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            missingMetadata: 'Missing migration metadata JSDoc block → Release tooling cannot determine participation or ordering, which can skip or misorder migrations → Add a top-of-file JSDoc block with `@migration` true/false; when true include `@migrationPhase`, `@migrationDependencies` (or NONE), and `@migrationDescription`.',
+            metadataAfterStatement: 'Migration metadata appears after code/imports → The release scanner only reads the top-of-file block and will miss this metadata → Move the metadata JSDoc above all imports/statements (legacy header allowed only when configured).',
+            missingMigrationTag: 'Metadata block is missing `@migration` → Without an explicit true/false, automation cannot decide whether to run this script → Add `@migration` true or `@migration` false to the metadata block.',
+            invalidMigrationTag: 'Invalid `@migration` value → Only true/false is supported so automation can branch deterministically → Replace with `@migration` true or `@migration` false.',
+            missingPhaseTag: 'Missing `@migrationPhase` while `@migration` is true → Release ordering cannot place this script → Add `@migrationPhase` before or after.',
+            invalidPhaseTag: 'Invalid `@migrationPhase` value → Release ordering only understands before/after → Use `@migrationPhase` before or `@migrationPhase` after.',
+            missingDependenciesTag: 'Missing `@migrationDependencies` while `@migration` is true → Dependency ordering cannot be computed → Add `@migrationDependencies` NONE or a comma-separated list of script names.',
+            invalidDependenciesTag: 'Invalid `@migrationDependencies` list → Empty or whitespace entries break dependency resolution → Provide a comma-separated list of non-empty names or NONE.',
+            missingDescriptionTag: 'Missing `@migrationDescription` while `@migration` is true → Release reports lose context and reviewers cannot assess impact → Add a brief `@migrationDescription`.',
+            extensionInDependencies: 'Dependency "{{name}}" includes a file extension → Dependencies are script identifiers, and extensions cause mismatches → Remove the ".f.ts" extension from "{{name}}".',
+            noneCasing: 'Invalid `@migrationDependencies` casing → Automation expects exactly "NONE" in all-caps to signal no dependencies → Change to uppercase "NONE".',
+            legacyHeaderNotAllowed: 'Legacy header/comment appears before metadata → The metadata block must be the first file-level block to keep linting deterministic → Remove leading comments or enable allowLegacyHeader.',
+            multipleMetadataBlocks: 'Multiple metadata blocks found → Conflicting `@migration` tags make automation ambiguous → Keep exactly one JSDoc block with `@migration`.',
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [options]) {
+        const rawFilename = context.filename ?? context.getFilename();
+        const filename = rawFilename.replace(/\\/g, '/');
+        const { targetGlobs, allowLegacyHeader } = {
+            ...DEFAULT_OPTIONS,
+            ...options,
+        };
+        // Only run on files matching targetGlobs
+        const isTargetFile = targetGlobs?.some((glob) => (0, minimatch_1.minimatch)(filename, glob, { dot: true, matchBase: true }));
+        if (!isTargetFile) {
+            return {};
+        }
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const comments = sourceCode.getAllComments();
+        const firstToken = sourceCode.getFirstToken(sourceCode.ast, {
+            includeComments: false,
+        });
+        return {
+            Program() {
+                const metadataCandidates = comments
+                    .filter((comment) => comment.type === 'Block' && comment.value.startsWith('*'))
+                    .map((comment) => ({ comment, tags: parseJSDocTags(comment.value) }))
+                    .filter(({ tags }) => Object.keys(tags).some((tag) => tag.startsWith('migration')));
+                if (metadataCandidates.length > 1) {
+                    for (const extra of metadataCandidates.slice(1)) {
+                        context.report({
+                            node: extra.comment,
+                            messageId: 'multipleMetadataBlocks',
+                        });
+                    }
+                }
+                const migrationMetadata = metadataCandidates[0] ?? null;
+                if (!migrationMetadata) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        messageId: 'missingMetadata',
+                    });
+                    return;
+                }
+                const { comment, tags } = migrationMetadata;
+                if (!allowLegacyHeader) {
+                    const hasLeadingComment = comments.some((c) => c.type === 'Block' && c.range[0] < comment.range[0]);
+                    if (hasLeadingComment) {
+                        context.report({
+                            node: comment,
+                            messageId: 'legacyHeaderNotAllowed',
+                        });
+                    }
+                }
+                // Check if metadata appears after the first statement/import
+                if (firstToken && comment.range[0] > firstToken.range[0]) {
+                    context.report({
+                        node: comment,
+                        messageId: 'metadataAfterStatement',
+                    });
+                }
+                if (!('migration' in tags)) {
+                    context.report({
+                        node: comment,
+                        messageId: 'missingMigrationTag',
+                    });
+                    return;
+                }
+                const migration = tags.migration;
+                if (migration !== 'true' && migration !== 'false') {
+                    context.report({
+                        node: comment,
+                        messageId: 'invalidMigrationTag',
+                    });
+                    return;
+                }
+                if (migration === 'true') {
+                    // Check phase
+                    if (!tags.migrationPhase) {
+                        context.report({
+                            node: comment,
+                            messageId: 'missingPhaseTag',
+                        });
+                    }
+                    else if (tags.migrationPhase !== 'before' &&
+                        tags.migrationPhase !== 'after') {
+                        context.report({
+                            node: comment,
+                            messageId: 'invalidPhaseTag',
+                        });
+                    }
+                    // Check dependencies
+                    if (!tags.migrationDependencies) {
+                        context.report({
+                            node: comment,
+                            messageId: 'missingDependenciesTag',
+                        });
+                    }
+                    else {
+                        const deps = tags.migrationDependencies
+                            .split(',')
+                            .map((d) => d.trim());
+                        const hasNone = deps.some((d) => d.toUpperCase() === 'NONE');
+                        if (deps.some((d) => d === '')) {
+                            context.report({
+                                node: comment,
+                                messageId: 'invalidDependenciesTag',
+                            });
+                        }
+                        else if (hasNone && deps.length > 1) {
+                            context.report({
+                                node: comment,
+                                messageId: 'invalidDependenciesTag',
+                            });
+                        }
+                        else if (hasNone && deps[0] !== 'NONE') {
+                            context.report({
+                                node: comment,
+                                messageId: 'noneCasing',
+                            });
+                        }
+                        else if (hasNone && deps[0] === 'NONE') {
+                            // Valid: exactly NONE
+                        }
+                        else {
+                            for (const dep of deps) {
+                                if (dep.endsWith('.f.ts')) {
+                                    context.report({
+                                        node: comment,
+                                        messageId: 'extensionInDependencies',
+                                        data: { name: dep },
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    // Check description
+                    if (!tags.migrationDescription) {
+                        context.report({
+                            node: comment,
+                            messageId: 'missingDescriptionTag',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+function parseJSDocTags(commentValue) {
+    const tags = {};
+    const lines = commentValue.split('\n');
+    for (const line of lines) {
+        const trimmedLine = line.trim().replace(/^\*+\s*/, '');
+        const match = trimmedLine.match(/^@(\w+)(?:\s+(.*))?$/);
+        if (match) {
+            const [, tagName, tagValue] = match;
+            tags[tagName] = (tagValue ?? '').trim();
+        }
+    }
+    return tags;
+}
+//# sourceMappingURL=require-migration-script-metadata.js.map

package/lib/rules/warn-https-error-message-user-friendly.d.ts

@@ -0,0 +1 @@
+export declare const warnHttpsErrorMessageUserFriendly: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"warnHttpsErrorMessageUserFriendly", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;