@pobammer-ts/eslint-cease-nonsense-rules 1.9.2 → 1.10.0

package/README.md

@@ -838,13 +838,19 @@ const doubled = items.map((x) => x * 2);
 
 Bans shorthand variable names in favor of descriptive full names.
 
+**Features**
+
+- Matches shorthands within compound identifiers (e.g., `plrData` → `playerData`)
+- Supports glob patterns (`*`, `?`) for flexible matching
+- Supports regex patterns (`/pattern/flags`) for advanced matching
+- Automatically ignores import specifiers (external packages control their naming)
+
 **Default mappings**
 
 - `plr` → `player` (or `localPlayer` for `Players.LocalPlayer`)
 - `args` → `parameters`
 - `dt` → `deltaTime`
 - `char` → `character`
-- `btn` → `button`
 
 **Configuration**
 
@@ -853,16 +859,52 @@ Bans shorthand variable names in favor of descriptive full names.
   "cease-nonsense/no-shorthand-names": ["error", {
     "shorthands": {
       "plr": "player",
-      "args": "parameters",
-      "dt": "deltaTime",
-      "char": "character",
-      "btn": "button"
+      "*Props": "*Properties"
     },
-    "allowPropertyAccess": ["char"]  // Allow as property
+    "allowPropertyAccess": ["char", "Props"],  // Allow as property/qualified name
+    "ignoreShorthands": ["PropsWithoutRef"]    // Ignore completely
   }]
 }
 ```
 
+**Options**
+
+- `shorthands`: Map of shorthand patterns to replacements (exact, glob `*`/`?`, or regex `/pattern/flags`)
+- `allowPropertyAccess`: Words allowed in property access (`obj.prop`) or type qualified names (`React.Props`)
+- `ignoreShorthands`: Words to ignore completely, regardless of context (supports same pattern syntax)
+
+**Pattern syntax**
+
+Glob patterns use `*` (any characters) and `?` (single character):
+
+```typescript
+{
+  "shorthands": {
+    "str*": "string*",         // strValue → stringValue
+    "*Props": "*Properties",   // DataProps → DataProperties
+    "*Btn*": "*Button*"        // myBtnClick → myButtonClick
+  }
+}
+```
+
+Regex patterns use `/pattern/flags` syntax:
+
+```typescript
+{
+  "shorthands": {
+    "/^str(.*)$/": "string$1",  // strName → stringName
+    "/^props$/i": "properties"  // Props or props → properties
+  }
+}
+```
+
+**Compound identifier matching**
+
+Identifiers are split at camelCase/PascalCase boundaries, and each word is checked independently:
+
+- `propsData` with `{ "props": "properties" }` → `propertiesData`
+- `UnitBoxBadgeInfoProps` with `{ "Props": "Properties" }` → `UnitBoxBadgeInfoProperties`
+
 **❌ Bad**
 
 ```typescript

package/dist/build-metadata.json

@@ -1,5 +1,5 @@
 {
-  "commit": "d84eba40b7747b35f7141d5e4f2ef9ce11db5e57",
-  "time": "2025-12-22T21:43:58.605Z",
-  "version": "1.9.2"
+  "commit": "8104213e0676ebea2ce52403f0e6559fb13d576e",
+  "time": "2025-12-23T03:11:07.286Z",
+  "version": "1.10.0"
 }

package/dist/index.js

@@ -18728,6 +18728,7 @@ var no_print_default = noPrint;
 import { TSESTree as TSESTree6 } from "@typescript-eslint/types";
 var isRuleOptions = Compile(build_default.Object({
   allowPropertyAccess: build_default.Optional(build_default.Array(build_default.String())),
+  ignoreShorthands: build_default.Optional(build_default.Array(build_default.String())),
   shorthands: build_default.Optional(build_default.Record(build_default.String(), build_default.String()))
 }));
 function isRecord2(value) {
@@ -18735,6 +18736,7 @@ function isRecord2(value) {
 }
 var DEFAULT_OPTIONS2 = {
   allowPropertyAccess: ["char"],
+  ignoreShorthands: [],
   shorthands: {
     args: "parameters",
     char: "character",
@@ -18744,32 +18746,78 @@ var DEFAULT_OPTIONS2 = {
 };
 var REGEX_PATTERN_MATCHER = regex2("^/(?<first>.+)/(?<second>[gimsuy]*)$");
 var WORD_BOUNDARY_REGEX = /(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-zA-Z])(?=\d)|(?<=\d)(?=[a-zA-Z])/;
+var FUNT_PATTERN = regex2("[.+^${}()|[\\]\\\\]", "g");
+var SPLIT_CACHE = new Map;
+var MAX_SPLIT_CACHE_SIZE = 1024;
 function splitIdentifierIntoWords(identifier3) {
-  return identifier3.split(WORD_BOUNDARY_REGEX);
+  const cached = SPLIT_CACHE.get(identifier3);
+  if (cached !== undefined)
+    return cached;
+  const words = identifier3.split(WORD_BOUNDARY_REGEX);
+  if (SPLIT_CACHE.size >= MAX_SPLIT_CACHE_SIZE) {
+    const firstKey = SPLIT_CACHE.keys().next().value;
+    if (firstKey !== undefined)
+      SPLIT_CACHE.delete(firstKey);
+  }
+  SPLIT_CACHE.set(identifier3, words);
+  return words;
+}
+function countCaptureGroups(replacement) {
+  const matches = replacement.match(/\$(\d+)/g);
+  if (matches === null)
+    return 0;
+  let maxGroup = 0;
+  for (const dollarRef of matches) {
+    const groupNum = Number.parseInt(dollarRef.slice(1), 10);
+    if (groupNum > maxGroup)
+      maxGroup = groupNum;
+  }
+  return maxGroup;
+}
+var REPLACEMENT_PATTERN_CACHE = new Map;
+function getReplacementPattern(index2) {
+  let pattern4 = REPLACEMENT_PATTERN_CACHE.get(index2);
+  if (pattern4 === undefined) {
+    pattern4 = new RegExp(`\\$${index2}`, "g");
+    REPLACEMENT_PATTERN_CACHE.set(index2, pattern4);
+  }
+  return pattern4;
+}
+function buildReplacementPatterns(replacement) {
+  const count = countCaptureGroups(replacement);
+  if (count === 0)
+    return [];
+  const patterns2 = new Array(count);
+  for (let index2 = 1;index2 <= count; index2 += 1) {
+    patterns2[index2 - 1] = getReplacementPattern(index2);
+  }
+  return patterns2;
 }
 function createMatcher(key, replacement) {
   if (key.startsWith("/")) {
-    const match = REGEX_PATTERN_MATCHER.exec(key);
-    if (match) {
+    const match = key.match(REGEX_PATTERN_MATCHER);
+    if (match?.groups) {
       return {
         matcher: {
           original: key,
           pattern: new RegExp(`^${match.groups.first}$`, match.groups.second),
-          replacement
+          replacement,
+          replacementPatterns: buildReplacementPatterns(replacement)
         },
         type: "pattern"
       };
     }
   }
   if (key.includes("*") || key.includes("?")) {
-    const regexPattern = key.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`).replaceAll("*", "(.*)").replaceAll("?", "(.)");
+    const regexPattern = key.replaceAll(FUNT_PATTERN, String.raw`\$&`).replaceAll("*", "(.*)").replaceAll("?", "(.)");
     let captureIndex = 0;
     const regexReplacement = replacement.replaceAll("*", () => `$${++captureIndex}`);
     return {
       matcher: {
         original: key,
         pattern: new RegExp(`^${regexPattern}$`),
-        replacement: regexReplacement
+        replacement: regexReplacement,
+        replacementPatterns: buildReplacementPatterns(regexReplacement)
       },
       type: "pattern"
     };
@@ -18784,6 +18832,7 @@ function matchWord(word, matchers, exactMatchers) {
   const exactReplacement = exactMatchers.get(word);
   if (exactReplacement !== undefined) {
     return {
+      matchedWord: word,
       replacement: exactReplacement,
       shorthand: word
     };
@@ -18792,10 +18841,13 @@ function matchWord(word, matchers, exactMatchers) {
     const match = word.match(matcher.pattern);
     if (match) {
       let replaced = matcher.replacement;
-      for (let index2 = 1;index2 < match.length; index2 += 1) {
-        replaced = replaced.replaceAll(new RegExp(`\\$${index2}`, "g"), match[index2] ?? "");
+      let captureIndex = 1;
+      for (const replacementPattern of matcher.replacementPatterns) {
+        replaced = replaced.replaceAll(replacementPattern, match[captureIndex] ?? "");
+        captureIndex += 1;
       }
       return {
+        matchedWord: word,
         replacement: replaced,
         shorthand: matcher.original
       };
@@ -18803,22 +18855,13 @@ function matchWord(word, matchers, exactMatchers) {
   }
   return;
 }
-function buildReplacementIdentifier(identifier3, options3) {
-  const words = splitIdentifierIntoWords(identifier3);
-  const matches = new Array;
-  let hasMatch = false;
-  const newWords = words.map((word) => {
-    const match = matchWord(word, options3.matchers, options3.exactMatchers);
-    if (match) {
-      hasMatch = true;
-      matches.push(match);
-      return match.replacement;
-    }
-    return word;
-  });
-  if (!hasMatch)
-    return;
-  return { matches, replaced: newWords.join("") };
+function isWordIgnored(word, ignoreMatchers, ignoreExact) {
+  if (ignoreExact.has(word))
+    return true;
+  for (const matcher of ignoreMatchers)
+    if (matcher.pattern.test(word))
+      return true;
+  return false;
 }
 function normalizeOptions2(rawOptions) {
   const mergedShorthands = { ...DEFAULT_OPTIONS2.shorthands };
@@ -18836,29 +18879,112 @@ function normalizeOptions2(rawOptions) {
       matchers.push(result.matcher);
   }
   const allowPropertyAccessSource = rawOptions?.allowPropertyAccess ?? DEFAULT_OPTIONS2.allowPropertyAccess;
+  const ignoreMatchers = new Array;
+  const ignoreExact = new Set;
+  for (const pattern4 of rawOptions?.ignoreShorthands ?? []) {
+    const result = createMatcher(pattern4, "");
+    if (result.type === "exact")
+      ignoreExact.add(result.original);
+    else
+      ignoreMatchers.push(result.matcher);
+  }
   return {
     allowPropertyAccess: new Set(allowPropertyAccessSource),
     exactMatchers,
+    ignoreExact,
+    ignoreMatchers,
     matchers,
     selector: "Identifier"
   };
 }
+var IMPORT_PARENT_TYPES = new Set(["ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier"]);
 var noShorthandNames = {
   create(context) {
     const validatedOptions = isRuleOptions.Check(context.options[0]) ? context.options[0] : undefined;
     const normalized = normalizeOptions2(validatedOptions);
-    const { allowPropertyAccess, selector } = normalized;
+    const { allowPropertyAccess, ignoreMatchers, ignoreExact, selector, matchers, exactMatchers } = normalized;
+    const identifierResultCache = new Map;
+    const ignoredWordCache = new Map;
+    function cachedIsWordIgnored(word) {
+      const cached = ignoredWordCache.get(word);
+      if (cached !== undefined)
+        return cached;
+      const result = isWordIgnored(word, ignoreMatchers, ignoreExact);
+      ignoredWordCache.set(word, result);
+      return result;
+    }
+    function getIdentifierResult(identifier3) {
+      if (identifierResultCache.has(identifier3))
+        return identifierResultCache.get(identifier3);
+      const words = splitIdentifierIntoWords(identifier3);
+      const matches = new Array;
+      let hasMatch = false;
+      for (const word of words) {
+        const match = matchWord(word, matchers, exactMatchers);
+        if (match) {
+          hasMatch = true;
+          matches.push(match);
+        }
+      }
+      if (!hasMatch) {
+        identifierResultCache.set(identifier3, undefined);
+        return;
+      }
+      let replaced = "";
+      let matchIndex = 0;
+      for (const word of words) {
+        const currentMatch = matches[matchIndex];
+        if (currentMatch !== undefined && currentMatch.matchedWord === word) {
+          replaced += currentMatch.replacement;
+          matchIndex += 1;
+        } else {
+          replaced += word;
+        }
+      }
+      const result = { matches, replaced };
+      identifierResultCache.set(identifier3, result);
+      return result;
+    }
     return {
       [selector](node) {
+        const { parent } = node;
+        if (parent !== undefined && isRecord2(parent)) {
+          const parentType = parent.type;
+          if (IMPORT_PARENT_TYPES.has(parentType))
+            return;
+        }
         const identifierName = node.name;
-        const result = buildReplacementIdentifier(identifierName, normalized);
+        const result = getIdentifierResult(identifierName);
         if (result === undefined)
           return;
         const { replaced, matches } = result;
-        const { parent } = node;
-        const [match] = matches;
-        if (matches.length === 1 && match !== undefined && allowPropertyAccess.has(match.shorthand) && parent !== undefined && isRecord2(parent) && parent.type === TSESTree6.AST_NODE_TYPES.MemberExpression && parent.property === node) {
+        if (cachedIsWordIgnored(identifierName))
+          return;
+        let allIgnored = true;
+        for (const match of matches) {
+          if (!cachedIsWordIgnored(match.matchedWord)) {
+            allIgnored = false;
+            break;
+          }
+        }
+        if (allIgnored)
           return;
+        if (parent !== undefined && isRecord2(parent)) {
+          const parentType = parent.type;
+          const isPropertyAccess = parentType === "MemberExpression" && parent.property === node || parentType === "TSQualifiedName" && parent.right === node;
+          if (isPropertyAccess) {
+            if (allowPropertyAccess.has(identifierName))
+              return;
+            let allWordsAllowed = true;
+            for (const match of matches) {
+              if (!allowPropertyAccess.has(match.matchedWord)) {
+                allWordsAllowed = false;
+                break;
+              }
+            }
+            if (allWordsAllowed)
+              return;
+          }
         }
         if (identifierName === "plr" && parent?.type === TSESTree6.AST_NODE_TYPES.VariableDeclarator && parent.id === node) {
           const { init } = parent;
@@ -18893,7 +19019,12 @@ var noShorthandNames = {
         additionalProperties: false,
         properties: {
           allowPropertyAccess: {
-            description: "Shorthand names that are allowed as property access",
+            description: "Shorthand names allowed as property access or qualified names",
+            items: { type: "string" },
+            type: "array"
+          },
+          ignoreShorthands: {
+            description: "Shorthand patterns to ignore completely (supports exact, glob, regex)",
             items: { type: "string" },
             type: "array"
           },
@@ -20620,6 +20751,17 @@ function resolveContinueTargetLoop(statement) {
 function cloneEntry(value) {
   return { ...value, loopAncestors: [...value.loopAncestors] };
 }
+var messages = {
+  asyncViolation: "Cannot use {{asyncType}} between '{{opener}}' and '{{closer}}' (requireSync: true)",
+  conditionalOpener: "Conditional opener '{{opener}}' at {{location}} may not have matching closer on all paths",
+  maxNestingExceeded: "Maximum nesting depth of {{max}} exceeded for paired calls",
+  multipleOpeners: "Multiple consecutive calls to '{{opener}}' without matching closers (allowMultipleOpeners: false)",
+  robloxYieldViolation: "Yielding function '{{yieldingFunction}}' auto-closes all profiles - subsequent '{{closer}}' will error",
+  unexpectedCloser: "Unexpected call to '{{closer}}' - expected one of: {{expected}}",
+  unpairedCloser: "Unexpected call to '{{closer}}' - no matching opener on stack",
+  unpairedOpener: "Unpaired call to '{{opener}}' - missing '{{closer}}' on {{paths}}",
+  wrongOrder: "Closer '{{closer}}' called out of order - expected to close '{{expected}}' but '{{actual}}' is still open"
+};
 var rule = {
   create(context) {
     const [rawOptions] = context.options;
@@ -20656,12 +20798,14 @@ var rule = {
       if (closerToOpenersCache.has(closer))
         return closerToOpenersCache.get(closer) ?? [];
       const names = new Array;
+      let size = 0;
       for (const pair of options3.pairs) {
         if (!getValidClosers(pair).includes(closer))
           continue;
-        for (const openerName of getAllOpeners(pair))
+        for (const openerName of getAllOpeners(pair)) {
           if (!names.includes(openerName))
-            names.push(openerName);
+            names[size++] = openerName;
+        }
       }
       closerToOpenersCache.set(closer, names);
       return names;
@@ -20670,6 +20814,7 @@ var rule = {
       if (openerToClosersCache.has(opener))
         return openerToClosersCache.get(opener) ?? [];
       const closers = new Array;
+      let size = 0;
       for (const pair of options3.pairs) {
         const allOpeners = getAllOpeners(pair);
         if (!allOpeners.includes(opener))
@@ -20677,7 +20822,7 @@ var rule = {
         const validClosers = getValidClosers(pair);
         for (const closer of validClosers)
           if (!closers.includes(closer))
-            closers.push(closer);
+            closers[size++] = closer;
       }
       openerToClosersCache.set(opener, closers);
       return closers;
@@ -20713,13 +20858,8 @@ var rule = {
     function saveSnapshot(node) {
       stackSnapshots.set(node, cloneStack());
     }
-    function findPairConfig(functionName, isOpener) {
-      return options3.pairs.find((pair) => {
-        if (isOpener)
-          return getAllOpeners(pair).includes(functionName);
-        const validClosers = getValidClosers(pair);
-        return validClosers.includes(functionName);
-      });
+    function findPairConfiguration(functionName, isOpener) {
+      return options3.pairs.find((pair) => (isOpener ? getAllOpeners(pair) : getValidClosers(pair)).includes(functionName));
     }
     function isRobloxYieldingFunction(functionName, configuration) {
       if (configuration.platform !== "roblox")
@@ -21058,12 +21198,12 @@ var rule = {
       const callName = getCallName(callNode);
       if (callName === undefined || callName === "")
         return;
-      const openerConfig = findPairConfig(callName, true);
+      const openerConfig = findPairConfiguration(callName, true);
       if (openerConfig) {
         handleOpener(callNode, callName, openerConfig);
         return;
       }
-      if (findPairConfig(callName, false)) {
+      if (findPairConfiguration(callName, false)) {
         handleCloser(callNode, callName);
         return;
       }
@@ -21115,31 +21255,31 @@ var rule = {
             messageId: "unpairedCloser",
             node
           });
+          return;
+        }
+        const topEntry = openerStack.at(-1);
+        if (topEntry) {
+          const expectedClosers = getExpectedClosersForOpener(topEntry.opener);
+          const closerDescription = formatOpenerList(expectedClosers);
+          context.report({
+            data: {
+              closer,
+              expected: closerDescription
+            },
+            messageId: "unexpectedCloser",
+            node
+          });
         } else {
-          const topEntry = openerStack.at(-1);
-          if (topEntry) {
-            const expectedClosers = getExpectedClosersForOpener(topEntry.opener);
-            const closerDescription = formatOpenerList(expectedClosers);
-            context.report({
-              data: {
-                closer,
-                expected: closerDescription
-              },
-              messageId: "unexpectedCloser",
-              node
-            });
-          } else {
-            const openerCandidates = getConfiguredOpenersForCloser(closer);
-            const openerDescription = formatOpenerList(openerCandidates);
-            context.report({
-              data: {
-                closer,
-                opener: openerDescription
-              },
-              messageId: "unpairedCloser",
-              node
-            });
-          }
+          const openerCandidates = getConfiguredOpenersForCloser(closer);
+          const openerDescription = formatOpenerList(openerCandidates);
+          context.report({
+            data: {
+              closer,
+              opener: openerDescription
+            },
+            messageId: "unpairedCloser",
+            node
+          });
         }
         return;
       }
@@ -21200,10 +21340,9 @@ var rule = {
       ForInStatement: onLoopEnter,
       "ForInStatement:exit": onLoopExit,
       ForOfStatement: (node) => {
-        const forOfNode = node;
-        if (forOfNode.await)
-          onAsyncYield(forOfNode);
-        onLoopEnter(forOfNode);
+        if (node.await)
+          onAsyncYield(node);
+        onLoopEnter(node);
       },
       "ForOfStatement:exit": onLoopExit,
       ForStatement: onLoopEnter,
@@ -21232,6 +21371,7 @@ var rule = {
       YieldExpression: onAsyncYield
     };
   },
+  defaultOptions: [],
   meta: {
     docs: {
       description: "Enforces balanced opener/closer function calls across all execution paths",
@@ -21239,17 +21379,7 @@ var rule = {
       url: "https://github.com/howmanysmall/eslint-idiot-lint/tree/main/docs/rules/require-paired-calls.md"
     },
     fixable: "code",
-    messages: {
-      asyncViolation: "Cannot use {{asyncType}} between '{{opener}}' and '{{closer}}' (requireSync: true)",
-      conditionalOpener: "Conditional opener '{{opener}}' at {{location}} may not have matching closer on all paths",
-      maxNestingExceeded: "Maximum nesting depth of {{max}} exceeded for paired calls",
-      multipleOpeners: "Multiple consecutive calls to '{{opener}}' without matching closers (allowMultipleOpeners: false)",
-      robloxYieldViolation: "Yielding function '{{yieldingFunction}}' auto-closes all profiles - subsequent '{{closer}}' will error",
-      unexpectedCloser: "Unexpected call to '{{closer}}' - expected one of: {{expected}}",
-      unpairedCloser: "Unexpected call to '{{closer}}' - no matching opener on stack",
-      unpairedOpener: "Unpaired call to '{{opener}}' - missing '{{closer}}' on {{paths}}",
-      wrongOrder: "Closer '{{closer}}' called out of order - expected to close '{{expected}}' but '{{actual}}' is still open"
-    },
+    messages,
     schema: [
       {
         additionalProperties: false,
@@ -21999,8 +22129,9 @@ function isStableValue(variable, identifierName, stableHooks) {
       return true;
     if (type3 === "Variable" && node.type === TSESTree10.AST_NODE_TYPES.VariableDeclarator) {
       const { parent } = node;
-      if (!parent || parent.type !== TSESTree10.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const")
+      if (!parent || parent.type !== TSESTree10.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const") {
         continue;
+      }
       const init = node.init;
       if (init && isStableHookValue(init, node, identifierName, stableHooks))
         return true;
@@ -22575,8 +22706,9 @@ function isHookCall(node) {
   const { callee } = node;
   if (callee.type === TSESTree11.AST_NODE_TYPES.Identifier)
     return isReactHook(callee.name);
-  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier)
+  if (callee.type === TSESTree11.AST_NODE_TYPES.MemberExpression && callee.property.type === TSESTree11.AST_NODE_TYPES.Identifier) {
     return isReactHook(callee.property.name);
+  }
   return false;
 }
 var FUNCTION_BOUNDARIES2 = new Set([
@@ -22610,9 +22742,7 @@ function isRecursiveCall(node, functionName) {
   if (!functionName)
     return false;
   const { callee } = node;
-  if (callee.type === "Identifier")
-    return callee.name === functionName;
-  return false;
+  return callee.type === "Identifier" && callee.name === functionName;
 }
 var useHookAtTopLevel = {
   create(context) {
@@ -22913,7 +23043,7 @@ function createNoInstanceMethodsOptions(options3 = {}) {
   };
 }
 function createNoShorthandOptions(options3 = {}) {
-  return { allowPropertyAccess: [], shorthands: {}, ...options3 };
+  return { allowPropertyAccess: [], ignoreShorthands: [], shorthands: {}, ...options3 };
 }
 function createEffectFunctionOptions(options3 = {}) {
   return { environment: "standard", hooks: [], ...options3 };
@@ -23055,4 +23185,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=C1BEC810E1B754DD64756E2164756E21
+//# debugId=CB943D9A894DADAF64756E2164756E21