@blumintinc/eslint-plugin-blumint 1.20.147 → 1.20.149

package/lib/rules/parallelize-async-operations.js

@@ -379,6 +379,31 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
          * from that instance (`super.users` versus `this.posts`) stay distinct.
          */
         const INSTANCE_RECEIVER_KEY = 'this';
+        /**
+         * Strips the wrappers that punctuate an expression without changing which
+         * value it denotes, so one path is recognized however it is spelled
+         * (`a.b`, `a?.b`, `a!.b`, `(a as T).b`).
+         */
+        function unwrapExpression(node) {
+            let current = node;
+            while (current.type === utils_1.AST_NODE_TYPES.ChainExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSNonNullExpression ||
+                current.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
+                current = current.expression;
+            }
+            return current;
+        }
+        /**
+         * Walks a member chain down to the expression it is rooted at: the binding,
+         * the instance, or whatever else the chain starts from.
+         */
+        function getPathRoot(node) {
+            let root = unwrapExpression(node);
+            while (root.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                root = unwrapExpression(root.object);
+            }
+            return root;
+        }
         /**
          * Builds a stable textual key for the object a method is invoked on, so two
          * awaits can be compared for "same receiver" by string equality.
@@ -548,6 +573,104 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             visit(node);
             return keys;
         }
+        /**
+         * Collects the member paths an expression DEREFERENCES: the object of a
+         * member access that is itself a member access, keyed the same way a
+         * receiver is.
+         *
+         * Depth is what makes the path a REQUIREMENT rather than a mere read.
+         * Evaluating `store.data.id` demands that `store.data` already hold an
+         * object, and throws when it does not; evaluating `store.data` demands
+         * nothing, since an unfilled slot yields `undefined` and passing `undefined`
+         * onward is silent. Only the former can turn the Promise.all rewrite into a
+         * crash, so only the former mints a key here.
+         *
+         * The traversal stops at function boundaries, the opposite of
+         * getInstancePathKeys: the hazard is eager evaluation at array-literal
+         * construction, and a path inside a callback handed to the operation is
+         * dereferenced when that callback runs, which the rewrite does not move.
+         *
+         * The root node travels with the key because the two questions the barrier
+         * asks of a path -- which slot it names, and where its root is bound -- are
+         * answered by different things.
+         */
+        function getDereferencedPaths(node) {
+            const paths = [];
+            const visit = (current) => {
+                if (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    const object = unwrapExpression(current.object);
+                    if (object.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        const key = getReceiverKey(object);
+                        if (key !== null) {
+                            paths.push({ key, root: getPathRoot(object) });
+                        }
+                    }
+                }
+                if (FUNCTION_BOUNDARY_TYPES.has(current.type)) {
+                    return;
+                }
+                for (const key in current) {
+                    if (key === 'parent' || key === 'range' || key === 'loc')
+                        continue;
+                    const child = current[key];
+                    if (!child || typeof child !== 'object')
+                        continue;
+                    if (Array.isArray(child)) {
+                        for (const item of child) {
+                            if (item && typeof item === 'object' && 'type' in item) {
+                                visit(item);
+                            }
+                        }
+                    }
+                    else if ('type' in child) {
+                        visit(child);
+                    }
+                }
+            };
+            visit(node);
+            return paths;
+        }
+        /**
+         * Reports whether a path is rooted at state an opaque call could reach
+         * without ever being handed it: a module-scope binding (a module-level
+         * `const`, or an import), or a name that resolves nowhere and is therefore
+         * an implicit global.
+         *
+         * A function-local root fails the test. A parameter or a local `const` is
+         * not visible to a callee that receives neither, so a bare-identifier call
+         * cannot rebind it, and reading a slot beneath it after that call is not the
+         * hazard this barrier answers.
+         *
+         * The instance fails it too: `this` names an object a free function was not
+         * given, so an instance path can only be written through code the run
+         * itself shows -- which the closure-write barrier already reads.
+         */
+        function isAmbientlyReachableRoot(path, root, declaredNames) {
+            if (root.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return false;
+            }
+            if (isInstancePathKey(path) || declaredNames.has(root.name)) {
+                return false;
+            }
+            const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, root), root.name);
+            if (!variable) {
+                return true;
+            }
+            return (variable.scope.type === utils_1.TSESLint.Scope.ScopeType.module ||
+                variable.scope.type === utils_1.TSESLint.Scope.ScopeType.global);
+        }
+        /**
+         * Reports whether an awaited expression is a call through a bare identifier
+         * (`hydrate()`, `initAnalytics()`), the one callee shape that names no
+         * receiver at all. Such a call's effects are reachable only through the
+         * module scope it closes over, so nothing in the run describes what it
+         * touches. Handles optional-call ChainExpressions.
+         */
+        function hasBareIdentifierCallee(awaitExpr) {
+            const argument = unwrapExpression(awaitExpr.argument);
+            return (argument.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                unwrapExpression(argument.callee).type === utils_1.AST_NODE_TYPES.Identifier);
+        }
         /**
          * Extracts the receiver key of an awaited *named-method* call: the key of
          * the `object` of a `MemberExpression` callee, when the accessed member is
@@ -584,6 +707,105 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             }
             return getReceiverKey(callee.object);
         }
+        /**
+         * Finds the function a class declares for a member name, searching the
+         * class body that encloses a node. Both spellings of a method-valued member
+         * qualify: a `MethodDefinition` and a `PropertyDefinition` initialized with
+         * a function.
+         *
+         * The NEAREST enclosing class body is the one searched. A method reached
+         * through `super` resolves against a base class, and an inner class shadows
+         * an outer one, so the answer can name a function other than the one that
+         * actually runs -- but the caller only ever ADDS the resolved body's writes
+         * to the writes it already sees, so a wrong answer can only introduce a
+         * barrier, the direction this rule's trade-off prefers.
+         */
+        function findClassMethodFunction(node, memberName) {
+            let current = node;
+            while (current && current.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+                current = current.parent;
+            }
+            if (!current) {
+                return null;
+            }
+            for (const member of current.body) {
+                if (member.type !== utils_1.AST_NODE_TYPES.MethodDefinition &&
+                    member.type !== utils_1.AST_NODE_TYPES.PropertyDefinition) {
+                    continue;
+                }
+                if (member.computed) {
+                    continue;
+                }
+                const key = member.key;
+                const name = key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier
+                    ? `#${key.name}`
+                    : key.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? key.name
+                        : null;
+                if (name !== memberName) {
+                    continue;
+                }
+                const value = member.value;
+                if (value && FUNCTION_BOUNDARY_TYPES.has(value.type)) {
+                    return value;
+                }
+            }
+            return null;
+        }
+        /**
+         * Resolves an awaited call to the function this file DECLARES for its
+         * callee: a hoisted `function` declaration, a binding initialized with a
+         * function, or a method of the enclosing class reached through
+         * `this`/`super`.
+         *
+         * The body is where an operation's ordering constraint usually lives.
+         * `await hydrate()` discards its result and mentions nothing it touches, so
+         * every barrier keyed on the run's own text reads it as independent, while
+         * the body assigns the very state the next await dereferences. Reading the
+         * body turns that guess into a fact wherever the file supplies one.
+         *
+         * Only one level is followed, so a write reached through a helper's own
+         * helper stays invisible. A callee that resolves nowhere -- an import, a
+         * parameter, a method on some other object -- yields null and leaves the
+         * syntactic barriers to answer for it.
+         */
+        function resolveCalleeFunction(awaitExpr) {
+            const argument = unwrapExpression(awaitExpr.argument);
+            if (argument.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+                return null;
+            }
+            const callee = unwrapExpression(argument.callee);
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, callee), callee.name);
+                if (!variable) {
+                    return null;
+                }
+                for (const definition of variable.defs) {
+                    const declaration = definition.node;
+                    if (declaration.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+                        return declaration;
+                    }
+                    if (declaration.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        declaration.init &&
+                        FUNCTION_BOUNDARY_TYPES.has(declaration.init.type)) {
+                        return declaration.init;
+                    }
+                }
+                return null;
+            }
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return null;
+            }
+            const object = unwrapExpression(callee.object);
+            if (object.type !== utils_1.AST_NODE_TYPES.ThisExpression &&
+                object.type !== utils_1.AST_NODE_TYPES.Super) {
+                return null;
+            }
+            const memberName = getMemberSegment(callee);
+            return memberName === null
+                ? null
+                : findClassMethodFunction(awaitExpr, memberName);
+        }
         /**
          * Matches the `Promise` combinators that take an array of promises and
          * return a single promise standing in for the whole group. Awaiting one of
@@ -1196,11 +1418,32 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             // a write to `this.alpha` leaves a later `this.beta` parallelizable while
             // a write to `this.state` still blocks a later `this.state.mutator`.
             // (#1924)
+            //
+            // A write inside the awaited call's own BODY reaches the enclosing scope
+            // exactly as a write inside a callback does -- `await hydrate()`, where
+            // `hydrate` assigns `store.state`, publishes that slot by the time it
+            // settles. The body is not part of the awaited expression, so the
+            // traversal above cannot see it; wherever the file declares the callee,
+            // its writes are read from there and joined to the ones spelled out in
+            // the run. (#1989)
             const assignedState = awaitNodes.map((node) => {
                 const awaitExpr = getAwaitExpression(node);
-                return awaitExpr
-                    ? getAssignedState(awaitExpr.argument)
-                    : { names: new Set(), instancePaths: new Set() };
+                if (!awaitExpr) {
+                    return { names: new Set(), instancePaths: new Set() };
+                }
+                const written = getAssignedState(awaitExpr.argument);
+                const calleeFunction = resolveCalleeFunction(awaitExpr);
+                if (!calleeFunction) {
+                    return written;
+                }
+                const calleeWritten = getAssignedState(calleeFunction);
+                return {
+                    names: new Set([...written.names, ...calleeWritten.names]),
+                    instancePaths: new Set([
+                        ...written.instancePaths,
+                        ...calleeWritten.instancePaths,
+                    ]),
+                };
             });
             const readInstancePaths = awaitNodes.map((node) => {
                 const awaitExpr = getAwaitExpression(node);
@@ -1249,6 +1492,75 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                     return true;
                 }
             }
+            // 12. Deferred-dereference barrier. A statement AFTER an await occupies a
+            // deferred position: it is evaluated only once the preceding promise
+            // settles. The rewrite splices its awaited operand into a `Promise.all`
+            // ARRAY LITERAL, whose elements evaluate eagerly at construction. Any slot
+            // the later operand must dereference is therefore read BEFORE the earlier
+            // operation runs, so a slot that operation installs is read while still
+            // `undefined` and the element throws a TypeError -- code that returned a
+            // value before the fix crashes after it. The two awaits are genuinely
+            // ordered, so the run is not a latency mistake and the rule declines to
+            // report it rather than merely declining the fix. (#1989)
+            //
+            // The write itself is invisible: it happens inside the awaited call's own
+            // BODY, so no value flows out of the await, no variable is declared, and
+            // no assignment appears anywhere the closure-write barrier looks. What the
+            // run does show is REACH -- whether the earlier operation could have
+            // installed the slot at all -- and only a discarded-result await qualifies
+            // as the writer, since a captured result is a value dependency the
+            // identifier comparison already sees.
+            //
+            // Reach comes in two shapes, and only these two, so that sibling slots
+            // under a shared namespace (`api.users.getAll()` then
+            // `api.posts.getRecent()`) stay parallelizable:
+            //
+            //   (a) The earlier call is invoked ON a receiver that CONTAINS the slot
+            //       (`this.connect()` then `this.client.send()`, `store.load()` then
+            //       `send(store.data.id)`). A method can fill any slot beneath its own
+            //       receiver, which is what makes such a pair ordered. This widens the
+            //       shared-receiver barrier from equality to containment: barrier 7
+            //       compares two receivers, whereas here the earlier receiver is
+            //       compared against a path the later operand merely reads.
+            //
+            //   (b) The earlier call goes through a bare identifier (`hydrate()`,
+            //       `initAnalytics()`) and the slot hangs off module-scope state. Such
+            //       a call names no receiver, so the run says nothing about what it
+            //       touches, while module-scope state is reachable from inside it
+            //       without ever being passed in. Function-local roots and instance
+            //       paths are excluded: a free function handed neither cannot rebind
+            //       them, so writes that reach them are visible in the run and belong
+            //       to the closure-write barrier.
+            const dereferencedPaths = awaitNodes.map((node) => {
+                const awaitExpr = getAwaitExpression(node);
+                return awaitExpr ? getDereferencedPaths(awaitExpr.argument) : [];
+            });
+            for (let i = 1; i < awaitNodes.length; i++) {
+                const paths = dereferencedPaths[i];
+                if (paths.length === 0)
+                    continue;
+                for (let j = 0; j < i; j++) {
+                    if (awaitNodes[j].type !== utils_1.AST_NODE_TYPES.ExpressionStatement) {
+                        continue;
+                    }
+                    const priorExpr = getAwaitExpression(awaitNodes[j]);
+                    if (!priorExpr)
+                        continue;
+                    const priorReceiver = receiverKeys[j];
+                    for (const path of paths) {
+                        if (priorReceiver !== null &&
+                            (path.key === priorReceiver ||
+                                path.key.startsWith(`${priorReceiver}.`))) {
+                            return true;
+                        }
+                        if (priorReceiver === null &&
+                            hasBareIdentifierCallee(priorExpr) &&
+                            isAmbientlyReachableRoot(path.key, path.root, variableNames)) {
+                            return true;
+                        }
+                    }
+                }
+            }
             return false;
         }
         /**

package/lib/rules/prefer-map-over-conditional-dispatch.js

@@ -823,6 +823,68 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             }
             return values.some((value) => referencesThis(value) || referencesPrivateName(value));
         }
+        /**
+         * Whether stepping from `child` up to `parent` crosses a boundary that
+         * decides WHETHER — or how many times — the child is evaluated, or that
+         * owns bindings the child may read.
+         *
+         * The question is about the child's POSITION, not the parent's type alone:
+         * an `if` test, a `for` init and a `for…of` right-hand side are evaluated
+         * exactly once, before control reaches the construct they head, so text
+         * lifted out of them runs precisely when it used to. A while/do-while test
+         * is re-evaluated per iteration, so it is a boundary like the bodies are.
+         */
+        function crossingGuardsEvaluation(child, parent) {
+            switch (parent.type) {
+                case utils_1.AST_NODE_TYPES.IfStatement:
+                    return parent.test !== child;
+                case utils_1.AST_NODE_TYPES.WhileStatement:
+                case utils_1.AST_NODE_TYPES.DoWhileStatement:
+                    return true;
+                case utils_1.AST_NODE_TYPES.ForStatement:
+                    return parent.init !== child;
+                case utils_1.AST_NODE_TYPES.ForInStatement:
+                case utils_1.AST_NODE_TYPES.ForOfStatement:
+                    return parent.right !== child;
+                case utils_1.AST_NODE_TYPES.LogicalExpression:
+                    // `&&`/`||`/`??` evaluate the right operand only for some values of
+                    // the left; the left operand always runs.
+                    return parent.right === child;
+                case utils_1.AST_NODE_TYPES.ConditionalExpression:
+                    return parent.test !== child;
+                default:
+                    return false;
+            }
+        }
+        /**
+         * Whether the ternary form's hoist would carry the branch values across a
+         * guard that decides whether they are evaluated, or out of a scope that
+         * owns bindings they read.
+         *
+         * The hoist walk treats a braceless body as transparent — it stops only at
+         * a `BlockStatement`/`Program`/`SwitchCase` — so `if (box) return kind ===
+         * 'a' ? box.a.v : box.b.v;` lands the `Record` ABOVE the guard and
+         * dereferences both values with the narrowing left behind (#1990). Braces
+         * are what make the hoist safe: with them the walk stops inside the guarded
+         * block, where the values are still narrowed and every loop binding is
+         * still in scope, so the boundary test also cures the scope violation that
+         * hoisting out of `for (const r of rows)` produces (TS2304).
+         *
+         * Nothing else sees this: the branch values are ordinary member reads, so
+         * `EAGER_UNSAFE_NODES` passes them, and `isNarrowingExempt` inspects only
+         * narrowing by the discriminant's own root, never narrowing applied by a
+         * surrounding statement.
+         */
+        function hoistCrossesGuard(node) {
+            let child = node;
+            while (child.parent && !CONTAINER_TYPES.has(child.parent.type)) {
+                if (crossingGuardsEvaluation(child, child.parent)) {
+                    return true;
+                }
+                child = child.parent;
+            }
+            return false;
+        }
         // ---- Name derivation ----------------------------------------------------
         function toUpperSnake(name) {
             return name
@@ -1075,6 +1137,9 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             if (flags.hoistEscapesClass) {
                 return 'the Record would hoist outside the class body, where the branch values’ `this`/`#private` reads do not resolve; extract it manually inside the class';
             }
+            if (flags.hoistCrossesGuard) {
+                return 'the Record would hoist above the guard or loop that decides whether the branch values are evaluated, dropping their narrowing and any binding the guard scopes; add braces around the branch — or lift the guarded expression into its own statement — then convert';
+            }
             if (!flags.inStatementList) {
                 return 'the dispatch is the whole body of a braceless branch, where a declaration is not allowed; add braces around it, then convert';
             }
@@ -1090,6 +1155,9 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
             const { entries, contributingValues, dText, form, assignTargetText, fullCoverage, hasNullish, canPlaceFix, commentBlocked, } = analysis;
             const eagerSafe = contributingValues.every((expr) => !containsEagerUnsafe(expr));
             const hoistEscapesClass = form === 'expr' && hoistLeavesClassBody(node, contributingValues);
+            // Only the ternary hoists; every other form is replaced where it stands,
+            // so no guard can be crossed.
+            const crossesGuard = form === 'expr' && hoistCrossesGuard(node);
             // Every non-ternary form replaces the construct with a declaration plus a
             // statement, which needs a statement LIST to land in. As the sole body of
             // a braceless `if`/`else`/loop the construct sits where exactly one
@@ -1106,6 +1174,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 eagerSafe &&
                 canPlaceFix &&
                 !hoistEscapesClass &&
+                !crossesGuard &&
                 inStatementList &&
                 !commentBlocked) {
                 derivation = deriveLookupName(discriminantOf(node), fixScope);
@@ -1121,6 +1190,7 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                             eagerSafe,
                             canPlaceFix,
                             hoistEscapesClass,
+                            hoistCrossesGuard: crossesGuard,
                             inStatementList,
                             commentSafe: !commentBlocked,
                             derivation,

package/lib/utils/ASTHelpers.d.ts

@@ -49,6 +49,17 @@ export declare class ASTHelpers {
      * happens to share a member's name is not a reference to that member.
      */
     static classMethodDependenciesOf(node: TSESTree.Node | null, graph: Graph, className: string): string[];
+    /**
+     * Every class member a node reaches through `this.<member>` (or
+     * `<ClassName>.<member>`), fields included and unfiltered by any graph.
+     *
+     * Whatever a member's body reads, it reads as soon as that body runs, so a
+     * caller deciding whether an invocation is order-sensitive needs the field
+     * reads that `classMethodDependenciesOf` drops. A read nested in a callback
+     * counts: `arr.map((x) => this.field)` runs the callback before the
+     * enclosing body returns.
+     */
+    static classMemberNamesReferenced(node: TSESTree.Node | null, className: string): string[];
     /**
      * Collects the class members a property initializer reads while that
      * initializer runs.

package/lib/utils/ASTHelpers.js

@@ -308,15 +308,26 @@ class ASTHelpers {
      * happens to share a member's name is not a reference to that member.
      */
     static classMethodDependenciesOf(node, graph, className) {
-        const dependencies = [];
-        this.collectClassMemberReferences(node, className, true, dependencies);
-        return [
-            ...new Set(dependencies.filter((dep) => {
-                // Only include dependencies that exist exactly in the graph
-                // This prevents substring matches (e.g., 'nextMatches' vs 'nextMatchesWithResults')
-                return (graph?.[dep] !== undefined && graph?.[dep]?.type !== 'property');
-            })),
-        ];
+        return this.classMemberNamesReferenced(node, className).filter((dep) => {
+            // Only include dependencies that exist exactly in the graph
+            // This prevents substring matches (e.g., 'nextMatches' vs 'nextMatchesWithResults')
+            return graph?.[dep] !== undefined && graph?.[dep]?.type !== 'property';
+        });
+    }
+    /**
+     * Every class member a node reaches through `this.<member>` (or
+     * `<ClassName>.<member>`), fields included and unfiltered by any graph.
+     *
+     * Whatever a member's body reads, it reads as soon as that body runs, so a
+     * caller deciding whether an invocation is order-sensitive needs the field
+     * reads that `classMethodDependenciesOf` drops. A read nested in a callback
+     * counts: `arr.map((x) => this.field)` runs the callback before the
+     * enclosing body returns.
+     */
+    static classMemberNamesReferenced(node, className) {
+        const references = [];
+        this.collectClassMemberReferences(node, className, true, references);
+        return [...new Set(references)];
     }
     /**
      * Collects the class members a property initializer reads while that

package/lib/utils/hungarianNaming.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Mirrors the type-marker predicate the shipped `no-hungarian` rule applies to
+ * a declaration name, so a fixer can refuse to SYNTHESISE a name that rule
+ * rejects. `no-hungarian` is not fixable, so a generated identifier it flags
+ * converts machine-resolvable work into a manual rename inside a file that was
+ * clean before `--fix` ran (#1997).
+ *
+ * Scope is the shape a fixer emits: an alphanumeric camelCase/PascalCase
+ * identifier. `no-hungarian`'s SCREAMING_SNAKE_CASE branch and its
+ * compound-noun / descriptive-suffix / <entity>Number / <domain>Symbol
+ * carve-outs are deliberately absent. Every one of them can only turn a
+ * rejection into an acceptance, and each is keyed on a trailing word a
+ * generated name does not carry, so their absence is unreachable for such a
+ * name and, if ever reached, costs the caller its next candidate rather than
+ * reintroducing the defect. `no-array-length-in-deps.test.ts` pins agreement
+ * with the real rule over the corpus of names its fixer can emit, so a change
+ * to either predicate surfaces there.
+ */
+/**
+ * Whether `no-hungarian` reads `name` as encoding its own type.
+ */
+export declare function encodesTypeMarker(name: string): boolean;

package/lib/utils/hungarianNaming.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Mirrors the type-marker predicate the shipped `no-hungarian` rule applies to
+ * a declaration name, so a fixer can refuse to SYNTHESISE a name that rule
+ * rejects. `no-hungarian` is not fixable, so a generated identifier it flags
+ * converts machine-resolvable work into a manual rename inside a file that was
+ * clean before `--fix` ran (#1997).
+ *
+ * Scope is the shape a fixer emits: an alphanumeric camelCase/PascalCase
+ * identifier. `no-hungarian`'s SCREAMING_SNAKE_CASE branch and its
+ * compound-noun / descriptive-suffix / <entity>Number / <domain>Symbol
+ * carve-outs are deliberately absent. Every one of them can only turn a
+ * rejection into an acceptance, and each is keyed on a trailing word a
+ * generated name does not carry, so their absence is unreachable for such a
+ * name and, if ever reached, costs the caller its next candidate rather than
+ * reintroducing the defect. `no-array-length-in-deps.test.ts` pins agreement
+ * with the real rule over the corpus of names its fixer can emit, so a change
+ * to either predicate surfaces there.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodesTypeMarker = void 0;
+// Abbreviation type markers. No English word is spelled this way, so their
+// presence as a whole camelCase segment is unambiguously a type tag.
+const ABBREVIATION_MARKERS = ['str', 'num', 'int', 'bool', 'arr', 'obj'];
+const COMMON_TYPES = [
+    'String',
+    'Number',
+    'Boolean',
+    'Array',
+    'Object',
+    'RegExp',
+    'Promise',
+    'Symbol',
+    'BigInt',
+];
+const TYPE_MARKERS = [
+    ...ABBREVIATION_MARKERS,
+    'array',
+    ...COMMON_TYPES,
+    'Class',
+    'Interface',
+    'Enum',
+];
+const ABBREVIATION_MARKER_SET = new Set(ABBREVIATION_MARKERS);
+const FULL_TYPE_WORDS = new Set(COMMON_TYPES.map((word) => word.toLowerCase()));
+// Single-letter Hungarian type prefixes (b=boolean, i=integer/index), matched
+// only as a strict camelCase prefix. This is the arm that rejects `bHash`.
+const SINGLE_LETTER_PREFIXES = new Set(['b', 'i']);
+const CAMEL_SEGMENT_REGEX = /[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g;
+function splitCamelSegmentsRaw(name) {
+    return name.match(CAMEL_SEGMENT_REGEX) ?? [];
+}
+// A built-in type word carrying an internal capital (BigInt) splits into parts
+// whose tail collides with an abbreviation marker (Int/int), so the parts are
+// re-merged into one atomic segment before segment matching.
+const MULTI_CAPITAL_TYPE_WORD_PARTS = COMMON_TYPES.map(splitCamelSegmentsRaw).filter((parts) => parts.length > 1);
+function mergeMultiCapitalTypeWords(segments) {
+    const merged = [];
+    let index = 0;
+    while (index < segments.length) {
+        const match = MULTI_CAPITAL_TYPE_WORD_PARTS.find((parts) => parts.every((part, offset) => segments[index + offset]?.toLowerCase() === part.toLowerCase()));
+        if (match) {
+            merged.push(segments.slice(index, index + match.length).join(''));
+            index += match.length;
+        }
+        else {
+            merged.push(segments[index]);
+            index += 1;
+        }
+    }
+    return merged;
+}
+function splitCamelSegments(name) {
+    return mergeMultiCapitalTypeWords(splitCamelSegmentsRaw(name));
+}
+function isPascalCaseName(name) {
+    return /^[A-Z]/.test(name) && name !== name.toUpperCase();
+}
+// A PascalCase name whose type word qualifies a DIFFERENT head noun names a
+// concept or relation (StringToNumber, NumberAmountEditor), not the value's own
+// runtime type.
+function isSemanticTypeConcept(name) {
+    const segments = splitCamelSegments(name);
+    if (segments.length < 2) {
+        return false;
+    }
+    const hasTypeWord = segments.some((segment) => FULL_TYPE_WORDS.has(segment.toLowerCase()));
+    if (!hasTypeWord) {
+        return false;
+    }
+    return segments.some((segment) => !FULL_TYPE_WORDS.has(segment.toLowerCase()));
+}
+/**
+ * Whether `no-hungarian` reads `name` as encoding its own type.
+ */
+function encodesTypeMarker(name) {
+    if (isPascalCaseName(name) && isSemanticTypeConcept(name)) {
+        return false;
+    }
+    if (name.length > 1 &&
+        SINGLE_LETTER_PREFIXES.has(name[0]) &&
+        /[A-Z]/.test(name[1])) {
+        return true;
+    }
+    const normalizedName = name.toLowerCase();
+    return TYPE_MARKERS.some((marker) => {
+        const normalizedMarker = marker.toLowerCase();
+        if (normalizedName === normalizedMarker) {
+            return false;
+        }
+        // An abbreviation marker is a type tag only as a whole segment: "int"
+        // inside "Mint" or "point" is a word fragment, not a tag.
+        if (ABBREVIATION_MARKER_SET.has(normalizedMarker)) {
+            return splitCamelSegments(name).some((segment) => segment.toLowerCase() === normalizedMarker);
+        }
+        // A full type word tags the value's type only at a word boundary in
+        // leading or trailing position; a middle segment qualifies a domain concept.
+        if (normalizedName.startsWith(normalizedMarker) &&
+            normalizedName.length > normalizedMarker.length &&
+            /[A-Z0-9]/.test(name[normalizedMarker.length])) {
+            return true;
+        }
+        return (normalizedName.endsWith(normalizedMarker) &&
+            normalizedName.length > normalizedMarker.length &&
+            (/[A-Z0-9]/.test(name[name.length - normalizedMarker.length - 1]) ||
+                /[A-Z]/.test(name[name.length - normalizedMarker.length])));
+    });
+}
+exports.encodesTypeMarker = encodesTypeMarker;
+//# sourceMappingURL=hungarianNaming.js.map