@pobammer-ts/eslint-cease-nonsense-rules 1.2.4 → 1.3.0

package/dist/build-metadata.json

@@ -1,5 +1,5 @@
 {
-  "commit": "f5d749f024342afc52a8c71110e9cbaefe0eb78c",
-  "time": "2025-12-02T06:13:35.244Z",
-  "version": "1.2.4"
+  "commit": "0fcce01c203e7dc9198bc1d6ab21f087713ce4eb",
+  "time": "2025-12-02T11:56:43.810Z",
+  "version": "1.3.0"
 }

package/dist/index.d.ts

@@ -35,6 +35,7 @@ declare const recommended: {
     readonly rules: {
         readonly "cease-nonsense/ban-react-fc": "error";
         readonly "cease-nonsense/enforce-ianitor-check-type": "error";
+        readonly "cease-nonsense/no-async-constructor": "error";
         readonly "cease-nonsense/no-color3-constructor": "error";
         readonly "cease-nonsense/no-instance-methods-without-this": "error";
         readonly "cease-nonsense/no-print": "error";

package/dist/index.js

@@ -8420,6 +8420,214 @@ var enforceIanitorCheckType = createRule({
 });
 var enforce_ianitor_check_type_default = enforceIanitorCheckType;
 
+// src/rules/no-async-constructor.ts
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
+var PROMISE_CHAIN_METHODS = new Set(["then", "catch", "finally"]);
+function isNode(value) {
+  return typeof value === "object" && value !== null && "type" in value;
+}
+function hasDynamicProperties(_node) {
+  return true;
+}
+function getAsyncMethodNames(classBody) {
+  const asyncMethods = new Set;
+  for (const element of classBody.body) {
+    if (element.type !== AST_NODE_TYPES.MethodDefinition)
+      continue;
+    if (element.kind !== "method")
+      continue;
+    if (!element.value.async)
+      continue;
+    if (element.key.type === AST_NODE_TYPES.Identifier)
+      asyncMethods.add(element.key.name);
+  }
+  return asyncMethods;
+}
+function isPromiseChainCall(node) {
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression)
+    return false;
+  const { property } = node.callee;
+  if (property.type !== AST_NODE_TYPES.Identifier)
+    return false;
+  return PROMISE_CHAIN_METHODS.has(property.name);
+}
+function isAsyncIIFE(node) {
+  const { callee } = node;
+  if (callee.type === AST_NODE_TYPES.ArrowFunctionExpression && callee.async)
+    return true;
+  if (callee.type === AST_NODE_TYPES.FunctionExpression && callee.async)
+    return true;
+  return false;
+}
+function isThisAsyncMethodCall(node, asyncMethods) {
+  const { callee } = node;
+  if (callee.type !== AST_NODE_TYPES.MemberExpression)
+    return;
+  if (callee.object.type !== AST_NODE_TYPES.ThisExpression)
+    return;
+  if (callee.property.type !== AST_NODE_TYPES.Identifier)
+    return;
+  const methodName = callee.property.name;
+  return asyncMethods.has(methodName) ? methodName : undefined;
+}
+function isAssignedToThisProperty(node, parent) {
+  if (!parent)
+    return false;
+  if (parent.type !== AST_NODE_TYPES.AssignmentExpression)
+    return false;
+  if (parent.right !== node)
+    return false;
+  const { left } = parent;
+  return left.type === AST_NODE_TYPES.MemberExpression && left.object.type === AST_NODE_TYPES.ThisExpression;
+}
+function getLocalVariableAssignment(node, parent) {
+  if (!parent)
+    return;
+  if (parent.type !== AST_NODE_TYPES.VariableDeclarator)
+    return;
+  if (parent.init !== node)
+    return;
+  if (parent.id.type !== AST_NODE_TYPES.Identifier)
+    return;
+  return parent.id.name;
+}
+function isExpressionStatement(parent) {
+  return parent?.type === AST_NODE_TYPES.ExpressionStatement;
+}
+function checkAsyncMethodCall(current, parent, asyncMethods) {
+  const asyncMethodName = isThisAsyncMethodCall(current, asyncMethods);
+  if (asyncMethodName === undefined)
+    return;
+  if (isAssignedToThisProperty(current, parent))
+    return;
+  if (isExpressionStatement(parent)) {
+    return {
+      data: { methodName: asyncMethodName },
+      messageId: "unhandledAsyncCall",
+      node: current
+    };
+  }
+  const variableName = getLocalVariableAssignment(current, parent);
+  if (variableName !== undefined) {
+    return {
+      data: { variableName },
+      messageId: "orphanedPromise",
+      node: current
+    };
+  }
+  return;
+}
+function isNonIIFEFunction(node, parent) {
+  if (node.type !== AST_NODE_TYPES.ArrowFunctionExpression && node.type !== AST_NODE_TYPES.FunctionExpression) {
+    return false;
+  }
+  if (parent?.type === AST_NODE_TYPES.CallExpression && parent.callee === node) {
+    return false;
+  }
+  return true;
+}
+function findConstructorViolations(constructorBody, asyncMethods) {
+  const violations = new Array;
+  let size = 0;
+  const visited2 = new WeakSet;
+  const parentMap = new WeakMap;
+  function traverse(current) {
+    if (visited2.has(current))
+      return;
+    visited2.add(current);
+    const parent = parentMap.get(current);
+    if (isNonIIFEFunction(current, parent))
+      return;
+    if (current.type === AST_NODE_TYPES.AwaitExpression) {
+      violations[size++] = { messageId: "awaitInConstructor", node: current };
+    }
+    if (current.type === AST_NODE_TYPES.CallExpression) {
+      if (isPromiseChainCall(current)) {
+        violations[size++] = { messageId: "promiseChainInConstructor", node: current };
+      }
+      if (isAsyncIIFE(current))
+        violations[size++] = { messageId: "asyncIifeInConstructor", node: current };
+      const asyncViolation = checkAsyncMethodCall(current, parent, asyncMethods);
+      if (asyncViolation)
+        violations[size++] = asyncViolation;
+    }
+    if (!hasDynamicProperties(current))
+      return;
+    for (const key in current) {
+      const childValue = current[key];
+      if (childValue === undefined)
+        continue;
+      if (Array.isArray(childValue)) {
+        for (const item of childValue) {
+          if (!isNode(item))
+            continue;
+          parentMap.set(item, current);
+          traverse(item);
+        }
+        continue;
+      }
+      if (!isNode(childValue))
+        continue;
+      parentMap.set(childValue, current);
+      traverse(childValue);
+    }
+  }
+  traverse(constructorBody);
+  return violations;
+}
+function reportViolation(context, violation) {
+  if (violation.data) {
+    context.report({
+      data: violation.data,
+      messageId: violation.messageId,
+      node: violation.node
+    });
+    return;
+  }
+  context.report({
+    messageId: violation.messageId,
+    node: violation.node
+  });
+}
+var noAsyncConstructor = {
+  create(context) {
+    return {
+      "MethodDefinition[kind='constructor']"(node) {
+        const constructorValue = node.value;
+        if (constructorValue.type !== AST_NODE_TYPES.FunctionExpression)
+          return;
+        const { body } = constructorValue;
+        if (body.type !== AST_NODE_TYPES.BlockStatement)
+          return;
+        const classNode = node.parent;
+        if (classNode.type !== AST_NODE_TYPES.ClassBody)
+          return;
+        const asyncMethods = getAsyncMethodNames(classNode);
+        const violations = findConstructorViolations(body, asyncMethods);
+        for (const violation of violations)
+          reportViolation(context, violation);
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow asynchronous operations inside class constructors. Constructors return immediately, " + "so async work causes race conditions, unhandled rejections, and incomplete object states.",
+      recommended: true
+    },
+    messages: {
+      asyncIifeInConstructor: "Refactor this asynchronous operation outside of the constructor. " + "Async IIFEs create unhandled promises and incomplete object state.",
+      awaitInConstructor: "Refactor this asynchronous operation outside of the constructor. " + "Using 'await' in a constructor causes the class to be instantiated before the async operation completes.",
+      orphanedPromise: "Refactor this asynchronous operation outside of the constructor. " + "Promise assigned to '{{variableName}}' is never consumed - errors will be silently swallowed.",
+      promiseChainInConstructor: "Refactor this asynchronous operation outside of the constructor. " + "Promise chains (.then/.catch/.finally) in constructors lead to race conditions.",
+      unhandledAsyncCall: "Refactor this asynchronous operation outside of the constructor. " + "Calling async method '{{methodName}}' without handling its result creates uncontrolled async behavior."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+var no_async_constructor_default = noAsyncConstructor;
+
 // src/rules/no-color3-constructor.ts
 import { TSESTree as TSESTree4 } from "@typescript-eslint/types";
 var isNumericLiteralNode = Compile(build_default.Object({
@@ -8496,7 +8704,7 @@ var noColor3Constructor = {
 var no_color3_constructor_default = noColor3Constructor;
 
 // src/rules/no-instance-methods-without-this.ts
-import { AST_NODE_TYPES } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/types";
 var DEFAULT_OPTIONS = {
   checkPrivate: true,
   checkProtected: true,
@@ -8526,19 +8734,19 @@ function shouldCheckMethod(node, options3) {
     return false;
   return true;
 }
-function isNode(value) {
+function isNode2(value) {
   return typeof value === "object" && value !== null && "type" in value;
 }
-function hasDynamicProperties(_node) {
+function hasDynamicProperties2(_node) {
   return true;
 }
 function traverseForThis(currentNode, visited2) {
   if (visited2.has(currentNode))
     return false;
   visited2.add(currentNode);
-  if (currentNode.type === AST_NODE_TYPES.ThisExpression || currentNode.type === AST_NODE_TYPES.Super)
+  if (currentNode.type === AST_NODE_TYPES2.ThisExpression || currentNode.type === AST_NODE_TYPES2.Super)
     return true;
-  if (!hasDynamicProperties(currentNode))
+  if (!hasDynamicProperties2(currentNode))
     return false;
   for (const key in currentNode) {
     const childValue = currentNode[key];
@@ -8546,18 +8754,18 @@ function traverseForThis(currentNode, visited2) {
       continue;
     if (Array.isArray(childValue)) {
       for (const item of childValue)
-        if (isNode(item) && traverseForThis(item, visited2))
+        if (isNode2(item) && traverseForThis(item, visited2))
           return true;
       continue;
     }
-    if (isNode(childValue) && traverseForThis(childValue, visited2))
+    if (isNode2(childValue) && traverseForThis(childValue, visited2))
       return true;
   }
   return false;
 }
 function methodUsesThis(node) {
   const value = node.value;
-  if (value === undefined || value.type !== AST_NODE_TYPES.FunctionExpression)
+  if (value === undefined || value.type !== AST_NODE_TYPES2.FunctionExpression)
     return false;
   return traverseForThis(value, new WeakSet);
 }
@@ -8571,7 +8779,7 @@ var noInstanceMethodsWithoutThis = {
           return;
         if (methodUsesThis(node))
           return;
-        const methodName = node.key.type === AST_NODE_TYPES.Identifier ? node.key.name : "unknown";
+        const methodName = node.key.type === AST_NODE_TYPES2.Identifier ? node.key.name : "unknown";
         context.report({
           data: { methodName },
           messageId: "noInstanceMethodWithoutThis",
@@ -8769,13 +8977,13 @@ var noWarn = {
 var no_warn_default = noWarn;
 
 // src/rules/prefer-sequence-overloads.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/types";
 var sequenceDescriptors = [
   { keypointName: "ColorSequenceKeypoint", sequenceName: "ColorSequence" },
   { keypointName: "NumberSequenceKeypoint", sequenceName: "NumberSequence" }
 ];
 function isSequenceIdentifier(node) {
-  if (node.type !== AST_NODE_TYPES2.Identifier)
+  if (node.type !== AST_NODE_TYPES3.Identifier)
     return false;
   for (const { sequenceName } of sequenceDescriptors)
     if (sequenceName === node.name)
@@ -8789,16 +8997,16 @@ function findDescriptor(sequenceName) {
   return;
 }
 var isNumericLiteral = Compile(build_default.Object({
-  type: build_default.Literal(AST_NODE_TYPES2.Literal),
+  type: build_default.Literal(AST_NODE_TYPES3.Literal),
   value: build_default.Number()
 }));
 function isExpressionArgument(argument) {
-  return argument !== undefined && argument.type !== AST_NODE_TYPES2.SpreadElement;
+  return argument !== undefined && argument.type !== AST_NODE_TYPES3.SpreadElement;
 }
 function extractKeypoint(element, descriptor) {
-  if (element === undefined || element.type !== AST_NODE_TYPES2.NewExpression)
+  if (element === undefined || element.type !== AST_NODE_TYPES3.NewExpression)
     return;
-  if (element.callee.type !== AST_NODE_TYPES2.Identifier || element.callee.name !== descriptor.keypointName)
+  if (element.callee.type !== AST_NODE_TYPES3.Identifier || element.callee.name !== descriptor.keypointName)
     return;
   if (element.arguments.length !== 2)
     return;
@@ -8828,7 +9036,7 @@ var preferSequenceOverloads = {
         if (descriptor === undefined || node.arguments.length !== 1)
           return;
         const [argument] = node.arguments;
-        if (argument === undefined || argument.type !== AST_NODE_TYPES2.ArrayExpression || argument.elements.length !== 2)
+        if (argument === undefined || argument.type !== AST_NODE_TYPES3.ArrayExpression || argument.elements.length !== 2)
           return;
         const firstElement = argument.elements[0] ?? undefined;
         const secondElement = argument.elements[1] ?? undefined;
@@ -9368,7 +9576,7 @@ var requireNamedEffectFunctions = {
 var require_named_effect_functions_default = requireNamedEffectFunctions;
 
 // src/rules/require-paired-calls.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/types";
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/types";
 var isStringArray = Compile(build_default.Readonly(build_default.Array(build_default.String())));
 var isPairConfiguration = Compile(build_default.Readonly(build_default.Object({
   alternatives: build_default.Optional(isStringArray),
@@ -9386,20 +9594,20 @@ var isRuleOptions3 = Compile(build_default.Partial(build_default.Readonly(build_
   pairs: build_default.Readonly(build_default.Array(isPairConfiguration))
 }))));
 var LOOP_NODE_TYPES = new Set([
-  AST_NODE_TYPES3.DoWhileStatement,
-  AST_NODE_TYPES3.ForInStatement,
-  AST_NODE_TYPES3.ForOfStatement,
-  AST_NODE_TYPES3.ForStatement,
-  AST_NODE_TYPES3.WhileStatement
+  AST_NODE_TYPES4.DoWhileStatement,
+  AST_NODE_TYPES4.ForInStatement,
+  AST_NODE_TYPES4.ForOfStatement,
+  AST_NODE_TYPES4.ForStatement,
+  AST_NODE_TYPES4.WhileStatement
 ]);
 var DEFAULT_ROBLOX_YIELDING_FUNCTIONS = ["task.wait", "wait", "*.WaitForChild", "*.*Async"];
 function getCallName(node) {
   const { callee } = node;
-  if (callee.type === AST_NODE_TYPES3.Identifier)
+  if (callee.type === AST_NODE_TYPES4.Identifier)
     return callee.name;
-  if (callee.type === AST_NODE_TYPES3.MemberExpression) {
-    const object3 = callee.object.type === AST_NODE_TYPES3.Identifier ? callee.object.name : undefined;
-    const property = callee.property.type === AST_NODE_TYPES3.Identifier ? callee.property.name : undefined;
+  if (callee.type === AST_NODE_TYPES4.MemberExpression) {
+    const object3 = callee.object.type === AST_NODE_TYPES4.Identifier ? callee.object.name : undefined;
+    const property = callee.property.type === AST_NODE_TYPES4.Identifier ? callee.property.name : undefined;
     if (object3 !== undefined && property !== undefined)
       return `${object3}.${property}`;
   }
@@ -9435,12 +9643,12 @@ function isLoopLikeStatement(node) {
   return LOOP_NODE_TYPES.has(node.type);
 }
 function isSwitchStatement(node) {
-  return node?.type === AST_NODE_TYPES3.SwitchStatement;
+  return node?.type === AST_NODE_TYPES4.SwitchStatement;
 }
 function findLabeledStatementBody(label, startingNode) {
   let current = startingNode;
   while (current) {
-    if (current.type === AST_NODE_TYPES3.LabeledStatement && current.label.name === label.name)
+    if (current.type === AST_NODE_TYPES4.LabeledStatement && current.label.name === label.name)
       return current.body;
     current = current.parent ?? undefined;
   }
@@ -9693,7 +9901,7 @@ var rule = {
     function onIfConsequentExit(node) {
       const consequentNode = node;
       const parent = consequentNode.parent;
-      if (parent?.type === AST_NODE_TYPES3.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES4.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9708,7 +9916,7 @@ var rule = {
     function onIfAlternateExit(node) {
       const alternateNode = node;
       const parent = alternateNode.parent;
-      if (parent?.type === AST_NODE_TYPES3.IfStatement) {
+      if (parent?.type === AST_NODE_TYPES4.IfStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9757,7 +9965,7 @@ var rule = {
     function onTryBlockExit(node) {
       const blockNode = node;
       const { parent } = blockNode;
-      if (parent?.type === AST_NODE_TYPES3.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES4.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9776,7 +9984,7 @@ var rule = {
     function onCatchClauseExit(node) {
       const catchNode = node;
       const { parent } = catchNode;
-      if (parent?.type === AST_NODE_TYPES3.TryStatement) {
+      if (parent?.type === AST_NODE_TYPES4.TryStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9839,7 +10047,7 @@ var rule = {
     function onSwitchCaseExit(node) {
       const caseNode = node;
       const { parent } = caseNode;
-      if (parent?.type === AST_NODE_TYPES3.SwitchStatement) {
+      if (parent?.type === AST_NODE_TYPES4.SwitchStatement) {
         const branches = branchStacks.get(parent) ?? [];
         branches.push(cloneStack());
         branchStacks.set(parent, branches);
@@ -9870,7 +10078,7 @@ var rule = {
       for (const { opener, config, node: node2 } of openerStack) {
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES3.ReturnStatement ? "return" : "throw";
+        const statementType = statementNode.type === AST_NODE_TYPES4.ReturnStatement ? "return" : "throw";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -9887,7 +10095,7 @@ var rule = {
       const statementNode = node;
       if (openerStack.length === 0)
         return;
-      const targetLoop = statementNode.type === AST_NODE_TYPES3.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
+      const targetLoop = statementNode.type === AST_NODE_TYPES4.ContinueStatement ? resolveContinueTargetLoop(statementNode) : resolveBreakTargetLoop(statementNode);
       if (!targetLoop)
         return;
       for (const { node: openerNode, config, opener, loopAncestors } of openerStack) {
@@ -9895,7 +10103,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const statementType = statementNode.type === AST_NODE_TYPES3.BreakStatement ? "break" : "continue";
+        const statementType = statementNode.type === AST_NODE_TYPES4.BreakStatement ? "break" : "continue";
         const lineNumber = statementNode.loc?.start.line ?? 0;
         context.report({
           data: {
@@ -10033,7 +10241,7 @@ var rule = {
           continue;
         const validClosers = getValidClosers(config);
         const closer = validClosers.length === 1 ? validClosers[0] ?? "closer" : validClosers.join("' or '");
-        const asyncType = asyncNode.type === AST_NODE_TYPES3.AwaitExpression ? "await" : "yield";
+        const asyncType = asyncNode.type === AST_NODE_TYPES4.AwaitExpression ? "await" : "yield";
         context.report({
           data: { asyncType, closer, opener },
           messageId: "asyncViolation",
@@ -11580,6 +11788,7 @@ var rules = {
   "ban-instances": ban_instances_default,
   "ban-react-fc": ban_react_fc_default,
   "enforce-ianitor-check-type": enforce_ianitor_check_type_default,
+  "no-async-constructor": no_async_constructor_default,
   "no-color3-constructor": no_color3_constructor_default,
   "no-instance-methods-without-this": no_instance_methods_without_this_default,
   "no-print": no_print_default,
@@ -11602,6 +11811,7 @@ var recommended = {
   rules: {
     "cease-nonsense/ban-react-fc": "error",
     "cease-nonsense/enforce-ianitor-check-type": "error",
+    "cease-nonsense/no-async-constructor": "error",
     "cease-nonsense/no-color3-constructor": "error",
     "cease-nonsense/no-instance-methods-without-this": "error",
     "cease-nonsense/no-print": "error",
@@ -11636,4 +11846,4 @@ export {
   createBanInstancesOptions
 };
 
-//# debugId=42A0B9F9085ECD6764756E2164756E21
+//# debugId=734DB8BE5C92D79464756E2164756E21