unguard 0.7.0 → 0.8.0

package/dist/chunk-NYM4SO7V.js

@@ -1,1213 +0,0 @@
-// src/utils/narrow.ts
-function prop(node, key) {
-  return node[key];
-}
-function child(node, key) {
-  const val = node[key];
-  if (val === void 0 || val === null) return null;
-  return val;
-}
-function children(node, key) {
-  const val = node[key];
-  if (!Array.isArray(val)) return [];
-  return val;
-}
-
-// src/rules/single-file/no-empty-catch.ts
-var noEmptyCatch = {
-  id: "no-empty-catch",
-  severity: "error",
-  message: "Empty catch blocks hide failures; handle, annotate, or rethrow explicitly",
-  visit(node, _parent, ctx) {
-    if (node.type !== "CatchClause") return;
-    const body = child(node, "body");
-    if (body && body.type === "BlockStatement" && children(body, "body").length === 0) {
-      const hasComment = ctx.comments.some((c) => c.start >= body.start && c.end <= body.end);
-      if (hasComment) return;
-      ctx.report(node);
-    }
-  }
-};
-
-// src/rules/single-file/no-non-null-assertion.ts
-var noNonNullAssertion = {
-  id: "no-non-null-assertion",
-  severity: "warning",
-  message: "Non-null assertion (!) overrides the type checker; narrow with a type guard or fix the type so it's not nullable",
-  visit(node, _parent, ctx) {
-    if (node.type !== "TSNonNullExpression") return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/single-file/no-double-negation-coercion.ts
-var noDoubleNegationCoercion = {
-  id: "no-double-negation-coercion",
-  severity: "info",
-  message: "!! coercion hides intent; use an explicit check (!== null, !== undefined, .length > 0) so the condition documents what it tests",
-  visit(node, _parent, ctx) {
-    if (node.type !== "UnaryExpression") return;
-    if (prop(node, "operator") !== "!") return;
-    const arg = child(node, "argument");
-    if (arg !== null && arg.type === "UnaryExpression" && prop(arg, "operator") === "!") {
-      ctx.report(node);
-    }
-  }
-};
-
-// src/rules/single-file/no-ts-ignore.ts
-var noTsIgnore = {
-  id: "no-ts-ignore",
-  severity: "error",
-  message: "@ts-ignore / @ts-expect-error suppresses type checking; fix the underlying type issue",
-  visit(_node, _parent, _ctx) {
-  },
-  visitComment(comment, ctx) {
-    if (comment.value.includes("@ts-ignore") || comment.value.includes("@ts-expect-error")) {
-      ctx.report(comment);
-    }
-  }
-};
-
-// src/rules/single-file/no-nullish-coalescing.ts
-var noNullishCoalescing = {
-  id: "no-nullish-coalescing",
-  severity: "info",
-  message: "Nullish coalescing (??) masks a possibly-nullable type; if the type guarantees non-null, remove the fallback; if not, fix the type upstream",
-  visit(node, _parent, ctx) {
-    if (node.type !== "LogicalExpression") return;
-    if (prop(node, "operator") !== "??") return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/single-file/no-optional-call.ts
-var noOptionalCall = {
-  id: "no-optional-call",
-  severity: "info",
-  message: "Optional call (?.) assumes the function could be undefined; if the type guarantees it exists, call directly; if not, fix the type upstream",
-  visit(node, _parent, ctx) {
-    if (node.type !== "CallExpression") return;
-    if (!prop(node, "optional")) return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/single-file/no-optional-property-access.ts
-var noOptionalPropertyAccess = {
-  id: "no-optional-property-access",
-  severity: "info",
-  message: "Optional chaining (?.) assumes the object could be nullish; if the type guarantees it, use a direct access; if not, fix the type upstream",
-  visit(node, _parent, ctx) {
-    if (node.type !== "MemberExpression") return;
-    if (prop(node, "optional") && !prop(node, "computed")) {
-      ctx.report(node);
-    }
-  }
-};
-
-// src/rules/single-file/no-optional-element-access.ts
-var noOptionalElementAccess = {
-  id: "no-optional-element-access",
-  severity: "info",
-  message: "Optional element access (?.[]) assumes the object could be nullish; if the type guarantees it, use a direct access; if not, fix the type upstream",
-  visit(node, _parent, ctx) {
-    if (node.type !== "MemberExpression") return;
-    if (prop(node, "optional") && prop(node, "computed")) {
-      ctx.report(node);
-    }
-  }
-};
-
-// src/utils/ast.ts
-function isNullish(node) {
-  if (node.type === "Literal" && prop(node, "value") === null) return true;
-  if (node.type === "Identifier" && prop(node, "name") === "undefined") return true;
-  return false;
-}
-function isLiteral(node) {
-  switch (node.type) {
-    case "Literal":
-    case "TemplateLiteral":
-    case "ArrayExpression":
-    case "ObjectExpression":
-      return true;
-    case "Identifier":
-      return prop(node, "name") === "undefined";
-    default:
-      return false;
-  }
-}
-
-// src/rules/single-file/no-logical-or-fallback.ts
-var noLogicalOrFallback = {
-  id: "no-logical-or-fallback",
-  severity: "warning",
-  message: "|| with a literal fallback assumes the left side could be falsy; if the type guarantees a value, remove the fallback; if not, fix the type upstream",
-  visit(node, _parent, ctx) {
-    if (node.type !== "LogicalExpression") return;
-    if (prop(node, "operator") !== "||") return;
-    const right = child(node, "right");
-    if (right && isLiteral(right)) {
-      ctx.report(node);
-    }
-  }
-};
-
-// src/rules/single-file/no-null-ternary-normalization.ts
-var noNullTernaryNormalization = {
-  id: "no-null-ternary-normalization",
-  severity: "warning",
-  message: "Ternary null-normalization (x == null ? fallback : x); if the type guarantees non-null, remove the ternary; if not, fix the type upstream",
-  visit(node, _parent, ctx) {
-    if (node.type !== "ConditionalExpression") return;
-    const test = child(node, "test");
-    if (test === null || test.type !== "BinaryExpression") return;
-    const op = prop(test, "operator");
-    if (op !== "===" && op !== "!==" && op !== "==" && op !== "!=") return;
-    const testLeft = child(test, "left");
-    const testRight = child(test, "right");
-    const hasNullishComparand = testLeft !== null && isNullish(testLeft) || testRight !== null && isNullish(testRight);
-    if (!hasNullishComparand) return;
-    const consequent = child(node, "consequent");
-    const alternate = child(node, "alternate");
-    if (consequent !== null && isNullish(consequent) || alternate !== null && isNullish(alternate)) {
-      ctx.report(node);
-    }
-  }
-};
-
-// src/rules/single-file/no-any-cast.ts
-var noAnyCast = {
-  id: "no-any-cast",
-  severity: "error",
-  message: "Casting to `any` erases type safety; use a specific type or generic instead",
-  visit(node, _parent, ctx) {
-    if (node.type !== "TSAsExpression") return;
-    const typeAnno = child(node, "typeAnnotation");
-    if (typeAnno !== null && typeAnno.type === "TSAnyKeyword") {
-      ctx.report(node);
-    }
-  }
-};
-
-// src/rules/single-file/no-explicit-any-annotation.ts
-var noExplicitAnyAnnotation = {
-  id: "no-explicit-any-annotation",
-  severity: "error",
-  message: "Explicit `any` annotation erases type safety; use a specific type, `unknown`, or a generic",
-  visit(node, parent, ctx) {
-    if (node.type !== "TSAnyKeyword") return;
-    if (parent !== null && parent.type === "TSAsExpression") return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/single-file/no-inline-type-in-params.ts
-var noInlineTypeInParams = {
-  id: "no-inline-type-in-params",
-  severity: "info",
-  message: "Inline type literal in annotation; extract to a named type for reuse and clarity",
-  visit(node, parent, ctx) {
-    if (node.type !== "TSTypeLiteral") return;
-    if (parent === null || parent.type !== "TSTypeAnnotation") return;
-    if (!isTopLevelFunctionParam(ctx.source, node.start)) return;
-    ctx.report(node);
-  }
-};
-function isTopLevelFunctionParam(source, offset) {
-  let depth = 0;
-  for (let i = offset - 1; i >= 0; i--) {
-    if (source[i] === "}") depth++;
-    if (source[i] === "{") {
-      if (depth === 0) {
-        const before = source.slice(Math.max(0, i - 150), i).trimEnd();
-        if (/(\)|\bfunction\b.*\))\s*$/.test(before)) {
-          depth--;
-          continue;
-        }
-        return false;
-      }
-      depth--;
-    }
-  }
-  return true;
-}
-
-// src/rules/single-file/no-type-assertion.ts
-var noTypeAssertion = {
-  id: "no-type-assertion",
-  severity: "error",
-  message: "Double type assertion (`as unknown as T`) circumvents the type system; fix the upstream type or use a type guard",
-  visit(node, _parent, ctx) {
-    if (node.type !== "TSAsExpression") return;
-    const inner = child(node, "expression");
-    if (inner === null || inner.type !== "TSAsExpression") return;
-    const innerType = child(inner, "typeAnnotation");
-    if (innerType === null || innerType.type !== "TSUnknownKeyword") return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/single-file/no-redundant-existence-guard.ts
-var noRedundantExistenceGuard = {
-  id: "no-redundant-existence-guard",
-  severity: "warning",
-  message: "Redundant existence guard (obj && obj.prop); if the type guarantees obj exists, remove the guard; if not, fix the type upstream",
-  visit(node, _parent, ctx) {
-    if (node.type !== "IfStatement") return;
-    const test = child(node, "test");
-    if (!test || test.type !== "LogicalExpression" || prop(test, "operator") !== "&&") return;
-    const left = child(test, "left");
-    const right = child(test, "right");
-    if (!left || left.type !== "Identifier") return;
-    if (!right || right.type !== "MemberExpression") return;
-    const obj = child(right, "object");
-    if (!obj || obj.type !== "Identifier") return;
-    if (prop(left, "name") !== prop(obj, "name")) return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/single-file/prefer-default-param-value.ts
-var preferDefaultParamValue = {
-  id: "prefer-default-param-value",
-  severity: "info",
-  message: "Use a default parameter value instead of reassigning from nullish coalescing inside the body",
-  visit(node, _parent, ctx) {
-    if (node.type !== "FunctionDeclaration" && node.type !== "ArrowFunctionExpression") return;
-    const params = children(node, "params");
-    const body = child(node, "body");
-    if (body === null || body.type !== "BlockStatement") return;
-    const stmts = children(body, "body");
-    if (stmts.length === 0) return;
-    const firstStmt = stmts[0];
-    if (firstStmt.type !== "ExpressionStatement") return;
-    const expr = child(firstStmt, "expression");
-    if (expr === null || expr.type !== "AssignmentExpression" || prop(expr, "operator") !== "=") return;
-    const right = child(expr, "right");
-    if (right === null || right.type !== "LogicalExpression" || prop(right, "operator") !== "??") return;
-    const assignee = child(expr, "left");
-    const coalescedLeft = child(right, "left");
-    if (assignee === null || assignee.type !== "Identifier") return;
-    if (coalescedLeft === null || coalescedLeft.type !== "Identifier") return;
-    if (prop(assignee, "name") !== prop(coalescedLeft, "name")) return;
-    const assigneeName = prop(assignee, "name");
-    const isParam = params.some((p) => {
-      if (p.type === "Identifier") return prop(p, "name") === assigneeName;
-      if (p.type === "AssignmentPattern") {
-        const left = child(p, "left");
-        return left !== null && left.type === "Identifier" && prop(left, "name") === assigneeName;
-      }
-      return false;
-    });
-    if (isParam) {
-      ctx.report(firstStmt);
-    }
-  }
-};
-
-// src/rules/single-file/prefer-required-param-with-guard.ts
-var preferRequiredParamWithGuard = {
-  id: "prefer-required-param-with-guard",
-  severity: "info",
-  message: "Optional param with immediate guard (if (!param) return/throw); make it required instead",
-  visit(node, _parent, ctx) {
-    if (node.type !== "FunctionDeclaration" && node.type !== "ArrowFunctionExpression") return;
-    const params = children(node, "params");
-    const body = child(node, "body");
-    if (body === null || body.type !== "BlockStatement") return;
-    const stmts = children(body, "body");
-    if (stmts.length === 0) return;
-    const firstStmt = stmts[0];
-    if (firstStmt.type !== "IfStatement") return;
-    const test = child(firstStmt, "test");
-    if (test === null) return;
-    let guardedName = null;
-    if (test.type === "UnaryExpression" && prop(test, "operator") === "!") {
-      const arg = child(test, "argument");
-      if (arg !== null && arg.type === "Identifier") guardedName = prop(arg, "name");
-    }
-    if (test.type === "BinaryExpression") {
-      const op = prop(test, "operator");
-      if (op === "===" || op === "==") {
-        const left = child(test, "left");
-        const right = child(test, "right");
-        if (left !== null && left.type === "Identifier" && right !== null && right.type === "Identifier" && prop(right, "name") === "undefined") {
-          guardedName = prop(left, "name");
-        }
-      }
-    }
-    if (guardedName === null) return;
-    const consequent = child(firstStmt, "consequent");
-    if (consequent === null) return;
-    const isGuard = consequent.type === "ReturnStatement" || consequent.type === "ThrowStatement" || consequent.type === "BlockStatement" && isGuardBlock(consequent);
-    if (!isGuard) return;
-    const isOptionalParam = params.some(
-      (p) => p.type === "Identifier" && prop(p, "name") === guardedName && prop(p, "optional") === true
-    );
-    if (isOptionalParam) {
-      ctx.report(firstStmt);
-    }
-  }
-};
-function isGuardBlock(block) {
-  const body = children(block, "body");
-  if (body.length !== 1) return false;
-  const stmt = body[0];
-  return stmt.type === "ReturnStatement" || stmt.type === "ThrowStatement";
-}
-
-// src/rules/cross-file/duplicate-type-declaration.ts
-var duplicateTypeDeclaration = {
-  id: "duplicate-type-declaration",
-  severity: "error",
-  message: "Identical type shape declared in multiple files; consolidate to a single definition",
-  analyze(project) {
-    const diagnostics = [];
-    for (const group of project.types.getDuplicateGroups()) {
-      const files = new Set(group.map((e) => e.file));
-      if (files.size < 2) continue;
-      const sorted = [...group].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-      for (const entry of sorted.slice(1)) {
-        const others = sorted.filter((e) => e !== entry).map((e) => `${e.name} (${e.file}:${e.line})`).join(", ");
-        diagnostics.push({
-          ruleId: this.id,
-          severity: this.severity,
-          message: `Type "${entry.name}" has identical shape to: ${others}`,
-          file: entry.file,
-          line: entry.line,
-          column: 1
-        });
-      }
-    }
-    return diagnostics;
-  }
-};
-
-// src/rules/cross-file/duplicate-function-declaration.ts
-var duplicateFunctionDeclaration = {
-  id: "duplicate-function-declaration",
-  severity: "error",
-  message: "Identical function body declared in multiple files; consolidate to a single definition",
-  analyze(project) {
-    const diagnostics = [];
-    for (const group of project.functions.getDuplicateGroups()) {
-      const files = new Set(group.map((e) => e.file));
-      if (files.size < 2) continue;
-      const first = group[0];
-      if (first !== void 0 && isSetter(first.node)) continue;
-      const sorted = [...group].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-      for (const entry of sorted.slice(1)) {
-        const others = sorted.filter((e) => e !== entry).map((e) => `${e.name} (${e.file}:${e.line})`).join(", ");
-        diagnostics.push({
-          ruleId: this.id,
-          severity: this.severity,
-          message: `Function "${entry.name}" has identical body to: ${others}`,
-          file: entry.file,
-          line: entry.line,
-          column: 1
-        });
-      }
-    }
-    return diagnostics;
-  }
-};
-function isSetter(node) {
-  let body = child(node, "body");
-  if (body === null) {
-    const init = child(node, "init");
-    if (init !== null) body = child(init, "body");
-  }
-  if (body === null || body.type !== "BlockStatement") return false;
-  const stmts = children(body, "body");
-  if (stmts.length !== 1) return false;
-  const stmt = stmts[0];
-  if (stmt === void 0 || stmt.type !== "ExpressionStatement") return false;
-  const expr = child(stmt, "expression");
-  return expr !== null && expr.type === "AssignmentExpression";
-}
-
-// src/rules/cross-file/optional-arg-always-used.ts
-var optionalArgAlwaysUsed = {
-  id: "optional-arg-always-used",
-  severity: "warning",
-  message: "Optional parameter is always provided at every call site; make it required",
-  analyze(project) {
-    const diagnostics = [];
-    for (const fn of project.functions.getAll()) {
-      for (let i = 0; i < fn.params.length; i++) {
-        const param = fn.params[i];
-        if (!param.optional && !param.hasDefault) continue;
-        const callSites = project.callSites.filter((c) => c.calleeName === fn.name);
-        if (callSites.length < 2) continue;
-        const allProvide = callSites.every((c) => c.argCount > i);
-        if (allProvide) {
-          diagnostics.push({
-            ruleId: this.id,
-            severity: this.severity,
-            message: `Optional parameter "${param.name}" is always provided at all ${callSites.length} call sites; make it required`,
-            file: fn.file,
-            line: fn.line,
-            column: 1
-          });
-        }
-      }
-    }
-    return diagnostics;
-  }
-};
-
-// src/rules/single-file/no-catch-return.ts
-var noCatchReturn = {
-  id: "no-catch-return",
-  severity: "warning",
-  message: "Catch block returns a fallback value, forcing callers to handle two data shapes; rethrow or let the error propagate",
-  visit(node, _parent, ctx) {
-    if (node.type !== "CatchClause") return;
-    const body = child(node, "body");
-    if (body === null) return;
-    if (hasReturn(body) && !hasThrow(body)) {
-      ctx.report(node);
-    }
-  }
-};
-function hasReturn(block) {
-  return walkForType(block, "ReturnStatement");
-}
-function hasThrow(block) {
-  return walkForType(block, "ThrowStatement");
-}
-function walkForType(root, targetType) {
-  if (root.type === targetType) return true;
-  const keys = Object.keys(root);
-  for (const key of keys) {
-    if (key === "start" || key === "end" || key === "type") continue;
-    const val = prop(root, key);
-    if (val === null || val === void 0 || typeof val !== "object") continue;
-    if (isFunction(val)) continue;
-    if (Array.isArray(val)) {
-      for (const item of val) {
-        if (item !== null && typeof item === "object" && "type" in item) {
-          if (isFunction(item)) continue;
-          if (walkForType(item, targetType)) return true;
-        }
-      }
-    } else if ("type" in val) {
-      if (walkForType(val, targetType)) return true;
-    }
-  }
-  return false;
-}
-function isFunction(node) {
-  return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
-}
-
-// src/rules/single-file/no-error-rewrap.ts
-var noErrorRewrap = {
-  id: "no-error-rewrap",
-  severity: "error",
-  message: "Re-wrapped error loses the original stack trace and type; use { cause: originalError } to preserve the error chain",
-  visit(node, _parent, ctx) {
-    if (node.type !== "CatchClause") return;
-    const param = child(node, "param");
-    if (param === null || param.type !== "Identifier") return;
-    const catchName = prop(param, "name");
-    const body = child(node, "body");
-    if (body === null) return;
-    findRewraps(body, catchName, ctx);
-  }
-};
-function findRewraps(root, catchName, ctx) {
-  if (root.type === "ThrowStatement") {
-    const arg = child(root, "argument");
-    if (arg !== null && arg.type === "NewExpression") {
-      const args = children(arg, "arguments");
-      if (args.length > 0 && referencesName(args, catchName) && !hasCauseArg(args)) {
-        ctx.report(root);
-      }
-    }
-    return;
-  }
-  if (root.type === "FunctionDeclaration" || root.type === "FunctionExpression" || root.type === "ArrowFunctionExpression") {
-    return;
-  }
-  const keys = Object.keys(root);
-  for (const key of keys) {
-    if (key === "start" || key === "end" || key === "type") continue;
-    const val = prop(root, key);
-    if (val === null || val === void 0 || typeof val !== "object") continue;
-    if (Array.isArray(val)) {
-      for (const item of val) {
-        if (item !== null && typeof item === "object" && "type" in item) {
-          findRewraps(item, catchName, ctx);
-        }
-      }
-    } else if ("type" in val) {
-      findRewraps(val, catchName, ctx);
-    }
-  }
-}
-function referencesName(nodes, name) {
-  for (const node of nodes) {
-    if (containsIdentifier(node, name)) return true;
-  }
-  return false;
-}
-function containsIdentifier(root, name) {
-  if (root.type === "Identifier" && prop(root, "name") === name) return true;
-  const keys = Object.keys(root);
-  for (const key of keys) {
-    if (key === "start" || key === "end" || key === "type") continue;
-    const val = prop(root, key);
-    if (val === null || val === void 0 || typeof val !== "object") continue;
-    if (Array.isArray(val)) {
-      for (const item of val) {
-        if (item !== null && typeof item === "object" && "type" in item) {
-          if (containsIdentifier(item, name)) return true;
-        }
-      }
-    } else if ("type" in val) {
-      if (containsIdentifier(val, name)) return true;
-    }
-  }
-  return false;
-}
-function hasCauseArg(args) {
-  for (const arg of args) {
-    if (arg.type === "ObjectExpression") {
-      const props = children(arg, "properties");
-      for (const p of props) {
-        const key = child(p, "key");
-        if (key !== null && key.type === "Identifier" && prop(key, "name") === "cause") {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-}
-
-// src/rules/cross-file/explicit-null-arg.ts
-var explicitNullArg = {
-  id: "explicit-null-arg",
-  severity: "warning",
-  message: "Explicit null/undefined passed to a project function; consider redesigning the interface to not accept nullish values",
-  analyze(project) {
-    const diagnostics = [];
-    const projectFnNames = /* @__PURE__ */ new Set();
-    for (const fn of project.functions.getAll()) {
-      projectFnNames.add(fn.name);
-    }
-    for (const site of project.callSites) {
-      if (!projectFnNames.has(site.calleeName)) continue;
-      const args = children(site.node, "arguments");
-      for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg === void 0) continue;
-        if (isNullish(arg)) {
-          const val = arg.type === "Literal" ? "null" : "undefined";
-          diagnostics.push({
-            ruleId: this.id,
-            severity: this.severity,
-            message: `Passing explicit ${val} to "${site.calleeName}" at argument ${i + 1}; consider redesigning the interface to not accept nullish values`,
-            file: site.file,
-            line: site.line,
-            column: 1
-          });
-          break;
-        }
-      }
-    }
-    return diagnostics;
-  }
-};
-
-// src/rules/cross-file/duplicate-function-name.ts
-import { dirname, resolve } from "path";
-var EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
-var duplicateFunctionName = {
-  id: "duplicate-function-name",
-  severity: "error",
-  message: "Same function name exported from multiple files; consolidate or rename to avoid ambiguity",
-  analyze(project) {
-    const diagnostics = [];
-    for (const group of project.functions.getNameCollisionGroups()) {
-      const hashes = new Set(group.map((e) => e.hash));
-      if (hashes.size === 1) continue;
-      const groupFiles = new Set(group.map((e) => e.file));
-      const funcName = group[0].name;
-      const hasImportLink = project.imports.some((imp) => {
-        if (!groupFiles.has(imp.file)) return false;
-        if (imp.importedName !== funcName && imp.localName !== funcName) return false;
-        if (!imp.source.startsWith(".")) return false;
-        const candidates = resolveCandidates(imp.file, imp.source);
-        return candidates.some((c) => groupFiles.has(c));
-      });
-      if (hasImportLink) continue;
-      const sorted = [...group].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-      for (const entry of sorted.slice(1)) {
-        const others = sorted.filter((e) => e !== entry).map((e) => `${e.file}:${e.line}`).join(", ");
-        diagnostics.push({
-          ruleId: this.id,
-          severity: this.severity,
-          message: `Exported function "${entry.name}" also defined in: ${others}`,
-          file: entry.file,
-          line: entry.line,
-          column: 1
-        });
-      }
-    }
-    return diagnostics;
-  }
-};
-function resolveCandidates(fromFile, specifier) {
-  const base = resolve(dirname(fromFile), specifier);
-  const candidates = [base];
-  for (const ext of EXTENSIONS) {
-    candidates.push(base + ext);
-    candidates.push(resolve(base, "index" + ext));
-  }
-  return candidates;
-}
-
-// src/rules/cross-file/duplicate-type-name.ts
-var duplicateTypeName = {
-  id: "duplicate-type-name",
-  severity: "error",
-  message: "Same type name exported from multiple files; consolidate or rename to avoid ambiguity",
-  analyze(project) {
-    const diagnostics = [];
-    for (const group of project.types.getNameCollisionGroups()) {
-      const hashes = new Set(group.map((e) => e.hash));
-      if (hashes.size === 1) continue;
-      const hasInferredType = group.some(
-        (e) => e.node.type !== "TSTypeLiteral" && e.node.type !== "TSInterfaceBody"
-      );
-      if (hasInferredType) continue;
-      const sorted = [...group].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-      for (const entry of sorted.slice(1)) {
-        const others = sorted.filter((e) => e !== entry).map((e) => `${e.file}:${e.line}`).join(", ");
-        diagnostics.push({
-          ruleId: this.id,
-          severity: this.severity,
-          message: `Exported type "${entry.name}" also defined in: ${others}`,
-          file: entry.file,
-          line: entry.line,
-          column: 1
-        });
-      }
-    }
-    return diagnostics;
-  }
-};
-
-// src/rules/single-file/no-dynamic-import.ts
-var noDynamicImport = {
-  id: "no-dynamic-import",
-  severity: "error",
-  message: "Dynamic import() breaks static analysis and hides dependencies; use a static import instead",
-  visit(node, _parent, ctx) {
-    if (node.type !== "ImportExpression") return;
-    ctx.report(node);
-  }
-};
-
-// src/rules/index.ts
-var allRules = [
-  noEmptyCatch,
-  noNonNullAssertion,
-  noDoubleNegationCoercion,
-  noTsIgnore,
-  noNullishCoalescing,
-  noOptionalCall,
-  noOptionalPropertyAccess,
-  noOptionalElementAccess,
-  noLogicalOrFallback,
-  noNullTernaryNormalization,
-  noAnyCast,
-  noExplicitAnyAnnotation,
-  noInlineTypeInParams,
-  noTypeAssertion,
-  noRedundantExistenceGuard,
-  preferDefaultParamValue,
-  preferRequiredParamWithGuard,
-  duplicateTypeDeclaration,
-  duplicateFunctionDeclaration,
-  optionalArgAlwaysUsed,
-  noCatchReturn,
-  noErrorRewrap,
-  explicitNullArg,
-  duplicateFunctionName,
-  duplicateTypeName,
-  noDynamicImport
-];
-
-// src/engine.ts
-import { parseSync as parseSync2 } from "oxc-parser";
-import { walk as walk2 } from "oxc-walker";
-import fg from "fast-glob";
-import { readFileSync as readFileSync2 } from "fs";
-
-// src/rules/types.ts
-function isSingleFileRule(r) {
-  return "visit" in r;
-}
-
-// src/collect/index.ts
-import { parseSync } from "oxc-parser";
-import { walk } from "oxc-walker";
-import { readFileSync } from "fs";
-
-// src/utils/hash.ts
-import { createHash } from "crypto";
-function hashTypeShape(node, source) {
-  const normalized = normalizeTypeNode(node, source);
-  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-}
-function normalizeTypeNode(node, source) {
-  if (node.type === "TSTypeLiteral") {
-    const members = children(node, "members");
-    const normalized = members.map((m) => normalizeTypeNode(m, source)).sort().join(";");
-    return `{${normalized}}`;
-  }
-  if (node.type === "TSInterfaceBody") {
-    const members = children(node, "body");
-    const normalized = members.map((m) => normalizeTypeNode(m, source)).sort().join(";");
-    return `{${normalized}}`;
-  }
-  if (node.type === "TSPropertySignature") {
-    const key = child(node, "key");
-    const rawName = key ? prop(key, "name") : void 0;
-    const keyName = rawName !== void 0 ? rawName : key ? source.slice(key.start, key.end) : "?";
-    const typeAnno = child(node, "typeAnnotation");
-    const innerType = typeAnno ? child(typeAnno, "typeAnnotation") : null;
-    const type = innerType ? normalizeTypeNode(innerType, source) : "any";
-    const optional = prop(node, "optional") ? "?" : "";
-    return `${keyName}${optional}:${type}`;
-  }
-  if (node.type === "TSTypeAnnotation") {
-    const inner = child(node, "typeAnnotation");
-    return inner ? normalizeTypeNode(inner, source) : "any";
-  }
-  return source.slice(node.start, node.end).replace(/\s+/g, " ").trim();
-}
-function hashFunctionBody(node, source) {
-  const bodyText = source.slice(node.start, node.end);
-  const normalized = bodyText.replace(/\s+/g, " ").trim();
-  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
-}
-
-// src/collect/type-registry.ts
-var TypeRegistry = class {
-  entries = [];
-  byHash = /* @__PURE__ */ new Map();
-  add(name, file, line, typeNode, source, exported) {
-    const hash = hashTypeShape(typeNode, source);
-    const entry = { name, file, line, hash, node: typeNode, exported };
-    this.entries.push(entry);
-    let list = this.byHash.get(hash);
-    if (list === void 0) {
-      list = [];
-      this.byHash.set(hash, list);
-    }
-    list.push(entry);
-  }
-  getDuplicateGroups() {
-    return [...this.byHash.values()].filter((group) => group.length > 1);
-  }
-  getAll() {
-    return this.entries;
-  }
-  getNameCollisionGroups() {
-    const byName = /* @__PURE__ */ new Map();
-    for (const entry of this.entries) {
-      if (!entry.exported) continue;
-      let list = byName.get(entry.name);
-      if (list === void 0) {
-        list = [];
-        byName.set(entry.name, list);
-      }
-      list.push(entry);
-    }
-    return [...byName.values()].filter((group) => {
-      if (group.length < 2) return false;
-      const files = new Set(group.map((e) => e.file));
-      return files.size > 1;
-    });
-  }
-};
-
-// src/collect/function-registry.ts
-var FunctionRegistry = class {
-  entries = [];
-  byHash = /* @__PURE__ */ new Map();
-  add(entry) {
-    this.entries.push(entry);
-    let list = this.byHash.get(entry.hash);
-    if (list === void 0) {
-      list = [];
-      this.byHash.set(entry.hash, list);
-    }
-    list.push(entry);
-  }
-  getDuplicateGroups() {
-    return [...this.byHash.values()].filter((group) => group.length > 1);
-  }
-  getAll() {
-    return this.entries;
-  }
-  getByName(name) {
-    return this.entries.filter((e) => e.name === name);
-  }
-  getNameCollisionGroups() {
-    const byName = /* @__PURE__ */ new Map();
-    for (const entry of this.entries) {
-      if (!entry.exported) continue;
-      let list = byName.get(entry.name);
-      if (list === void 0) {
-        list = [];
-        byName.set(entry.name, list);
-      }
-      list.push(entry);
-    }
-    return [...byName.values()].filter((group) => {
-      if (group.length < 2) return false;
-      const files = new Set(group.map((e) => e.file));
-      return files.size > 1;
-    });
-  }
-};
-
-// src/collect/index.ts
-function collectProject(files) {
-  const types = new TypeRegistry();
-  const functions = new FunctionRegistry();
-  const callSites = [];
-  const imports = [];
-  const fileMap = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const source = readFileSync(file, "utf8");
-    const result = parseSync(file, source);
-    fileMap.set(file, { source, program: result.program, comments: result.comments });
-    walk(result.program, {
-      enter(node, parent) {
-        collectTypes(node, parent, file, source, types);
-        collectFunctions(node, parent, file, source, functions);
-        collectCallSites(node, file, source, callSites);
-        collectImports(node, file, imports);
-      }
-    });
-  }
-  return { types, functions, callSites, imports, files: fileMap };
-}
-function lineAt(source, offset) {
-  let line = 1;
-  for (let i = 0; i < offset; i++) {
-    if (source[i] === "\n") line++;
-  }
-  return line;
-}
-function collectTypes(node, parent, file, source, registry) {
-  if (node.type === "TSTypeAliasDeclaration") {
-    const id = child(node, "id");
-    const typeAnno = child(node, "typeAnnotation");
-    if (id && typeAnno) {
-      registry.add(prop(id, "name"), file, lineAt(source, node.start), typeAnno, source, isExported(parent));
-    }
-  }
-  if (node.type === "TSInterfaceDeclaration") {
-    const id = child(node, "id");
-    const body = child(node, "body");
-    if (id && body) {
-      registry.add(prop(id, "name"), file, lineAt(source, node.start), body, source, isExported(parent));
-    }
-  }
-}
-function isExported(parent) {
-  if (parent === null) return false;
-  return parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration";
-}
-function collectFunctions(node, parent, file, source, registry) {
-  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression") {
-    const id = child(node, "id");
-    const body = child(node, "body");
-    if (!id || !body) return;
-    const name = prop(id, "name");
-    const params = extractParams(children(node, "params"), source);
-    const hash = hashFunctionBody(body, source);
-    const exported = isExported(parent);
-    registry.add({ name, file, line: lineAt(source, node.start), hash, params, node, exported });
-  }
-  if (node.type === "VariableDeclarator") {
-    const init = child(node, "init");
-    const id = child(node, "id");
-    if (init !== null && init.type === "ArrowFunctionExpression" && id !== null && id.type === "Identifier") {
-      const body = child(init, "body");
-      if (!body) return;
-      const name = prop(id, "name");
-      const params = extractParams(children(init, "params"), source);
-      const hash = hashFunctionBody(body, source);
-      const lineStart = source.lastIndexOf("\n", node.start) + 1;
-      const linePrefix = source.slice(lineStart, node.start);
-      const exported = linePrefix.includes("export");
-      registry.add({ name, file, line: lineAt(source, node.start), hash, params, node, exported });
-    }
-  }
-}
-function paramName(node, source) {
-  const name = prop(node, "name");
-  if (name !== void 0) return name;
-  return source.slice(node.start, node.end);
-}
-function typeText(node, source) {
-  if (node === null) return null;
-  return source.slice(node.start, node.end);
-}
-function extractParams(params, source) {
-  return params.map((p) => {
-    if (p.type === "AssignmentPattern") {
-      const left = child(p, "left");
-      if (left === null) {
-        return { name: "?", optional: false, hasDefault: true, typeText: null };
-      }
-      return {
-        name: paramName(left, source),
-        optional: prop(left, "optional") === true,
-        hasDefault: true,
-        typeText: typeText(child(left, "typeAnnotation"), source)
-      };
-    }
-    const typeAnno = child(p, "typeAnnotation");
-    return {
-      name: paramName(p, source),
-      optional: prop(p, "optional") === true,
-      hasDefault: false,
-      typeText: typeText(typeAnno, source)
-    };
-  });
-}
-function collectImports(node, file, imports) {
-  if (node.type !== "ImportDeclaration") return;
-  const sourceNode = child(node, "source");
-  if (sourceNode === null) return;
-  const moduleSource = prop(sourceNode, "value");
-  if (moduleSource === void 0) return;
-  const specifiers = children(node, "specifiers");
-  for (const spec of specifiers) {
-    if (spec.type === "ImportSpecifier") {
-      const imported = child(spec, "imported");
-      const local = child(spec, "local");
-      if (imported !== null && local !== null) {
-        imports.push({
-          file,
-          localName: prop(local, "name"),
-          importedName: prop(imported, "name"),
-          source: moduleSource
-        });
-      }
-    } else if (spec.type === "ImportDefaultSpecifier") {
-      const local = child(spec, "local");
-      if (local !== null) {
-        imports.push({
-          file,
-          localName: prop(local, "name"),
-          importedName: "default",
-          source: moduleSource
-        });
-      }
-    }
-  }
-}
-function collectCallSites(node, file, source, sites) {
-  if (node.type !== "CallExpression") return;
-  const callee = child(node, "callee");
-  let calleeName = null;
-  if (callee !== null && callee.type === "Identifier") {
-    calleeName = prop(callee, "name");
-  } else if (callee !== null && callee.type === "MemberExpression" && prop(callee, "computed") !== true) {
-    const property = child(callee, "property");
-    if (property) calleeName = prop(property, "name");
-  }
-  if (calleeName) {
-    sites.push({
-      calleeName,
-      file,
-      line: lineAt(source, node.start),
-      argCount: children(node, "arguments").length,
-      node
-    });
-  }
-}
-
-// src/engine.ts
-async function scan(options) {
-  const patterns = options.paths.length > 0 ? options.paths : ["."];
-  const globs = patterns.map((p) => {
-    if (p === ".") return `./**/*.{ts,cts,mts,tsx}`;
-    if (p.endsWith("/")) return `${p}**/*.{ts,cts,mts,tsx}`;
-    if (!p.includes("*") && !p.endsWith(".ts") && !p.endsWith(".tsx") && !p.endsWith(".cts") && !p.endsWith(".mts")) {
-      return `${p}/**/*.{ts,cts,mts,tsx}`;
-    }
-    return p;
-  });
-  const files = await fg(globs, {
-    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**", "**/*.d.ts", "**/*.d.cts", "**/*.d.mts"],
-    absolute: true
-  });
-  const activeRules = allRules.filter((r) => {
-    if (options.rules && !options.rules.includes(r.id)) return false;
-    return true;
-  });
-  const singleFileRules = activeRules.filter(isSingleFileRule);
-  const crossFileRules = activeRules.filter((r) => !isSingleFileRule(r));
-  const diagnostics = [];
-  for (const file of files) {
-    const source = readFileSync2(file, "utf8");
-    const result = parseSync2(file, source);
-    const fileDiags = runSingleFileRules(singleFileRules, result.program, result.comments, source, file);
-    annotate(fileDiags, result.comments, source);
-    diagnostics.push(...fileDiags);
-  }
-  if (crossFileRules.length > 0 && files.length > 0) {
-    const projectIndex = collectProject(files);
-    for (const rule of crossFileRules) {
-      const crossDiags = rule.analyze(projectIndex);
-      for (const d of crossDiags) {
-        const fileData = projectIndex.files.get(d.file);
-        if (fileData !== void 0) annotate([d], fileData.comments, fileData.source);
-      }
-      diagnostics.push(...crossDiags);
-    }
-  }
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const d of diagnostics) {
-    const key = `${d.file}:${d.line}:${d.ruleId}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    deduped.push(d);
-  }
-  if (options.strict) {
-    for (const d of deduped) {
-      d.severity = "error";
-    }
-  }
-  return { diagnostics: deduped, fileCount: files.length };
-}
-function runSingleFileRules(rules, program, comments, source, filename) {
-  const diagnostics = [];
-  const makeCtx = (rule) => ({
-    filename,
-    source,
-    comments,
-    report(span, message) {
-      const pos = lineCol(source, span.start);
-      diagnostics.push({
-        ruleId: rule.id,
-        severity: rule.severity,
-        message: message === void 0 ? rule.message : message,
-        file: filename,
-        ...pos
-      });
-    }
-  });
-  const contexts = rules.map((r) => ({ rule: r, ctx: makeCtx(r) }));
-  walk2(program, {
-    enter(node, parent) {
-      for (const { rule, ctx } of contexts) {
-        rule.visit(node, parent, ctx);
-      }
-    }
-  });
-  for (const { rule, ctx } of contexts) {
-    if (rule.visitComment) {
-      for (const comment of comments) {
-        rule.visitComment(comment, ctx);
-      }
-    }
-  }
-  return diagnostics;
-}
-function annotate(diagnostics, comments, source) {
-  if (comments.length === 0 || diagnostics.length === 0) return;
-  const byEndLine = /* @__PURE__ */ new Map();
-  for (const c of comments) {
-    const endLine = lineAt2(source, c.end);
-    let list = byEndLine.get(endLine);
-    if (list === void 0) {
-      list = [];
-      byEndLine.set(endLine, list);
-    }
-    list.push(c);
-  }
-  for (const d of diagnostics) {
-    const inline = findInlineComment(d.line, byEndLine);
-    if (inline !== null) {
-      d.annotation = inline;
-      continue;
-    }
-    const above = collectAnnotation(d.line - 1, byEndLine, source);
-    if (above !== null) d.annotation = above;
-  }
-}
-function findInlineComment(diagLine, byEndLine) {
-  const commentsOnLine = byEndLine.get(diagLine);
-  if (commentsOnLine === void 0 || commentsOnLine.length === 0) return null;
-  const comment = commentsOnLine.at(-1);
-  if (comment === void 0) return null;
-  if (comment.type !== "Line") return null;
-  const text = comment.value.trim();
-  if (text.startsWith("@expect")) return null;
-  return text;
-}
-function collectAnnotation(commentEndLine, byEndLine, source) {
-  const commentsOnLine = byEndLine.get(commentEndLine);
-  if (commentsOnLine === void 0 || commentsOnLine.length === 0) return null;
-  const comment = commentsOnLine.at(-1);
-  if (comment === void 0) return null;
-  if (comment.type === "Block") {
-    return cleanBlockComment(comment.value);
-  }
-  const lines = [comment.value.trim()];
-  let prevLine = commentEndLine - 1;
-  for (; ; ) {
-    const prev = byEndLine.get(prevLine);
-    if (prev === void 0 || prev.length === 0) break;
-    const prevComment = prev.at(-1);
-    if (prevComment === void 0 || prevComment.type !== "Line") break;
-    if (lineAt2(source, prevComment.start) !== prevLine) break;
-    lines.unshift(prevComment.value.trim());
-    prevLine--;
-  }
-  return lines.join("\n");
-}
-function cleanBlockComment(value) {
-  return value.split("\n").map((line) => line.replace(/^\s*\*\s?/, "").trim()).filter((line) => line.length > 0).join("\n");
-}
-function lineAt2(source, offset) {
-  let line = 1;
-  for (let i = 0; i < offset && i < source.length; i++) {
-    if (source[i] === "\n") line++;
-  }
-  return line;
-}
-function lineCol(source, offset) {
-  let line = 1;
-  let col = 1;
-  for (let i = 0; i < offset && i < source.length; i++) {
-    if (source[i] === "\n") {
-      line++;
-      col = 1;
-    } else {
-      col++;
-    }
-  }
-  return { line, column: col };
-}
-
-export {
-  allRules,
-  scan
-};
-//# sourceMappingURL=chunk-NYM4SO7V.js.map