eslint-plugin-unslop 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1119 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// package.json
+var package_default = {
+  name: "eslint-plugin-unslop",
+  version: "0.1.0",
+  description: "ESLint plugin with rules for reducing AI-generated code smells",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    }
+  },
+  files: [
+    "dist"
+  ],
+  sideEffects: false,
+  engines: {
+    node: ">=18"
+  },
+  scripts: {
+    build: "tsup",
+    format: "prettier . --write",
+    "format:check": "prettier . --check",
+    knip: "knip",
+    lint: "npm run build && eslint .",
+    test: "vitest run",
+    "test:watch": "vitest",
+    typecheck: "tsc --noEmit",
+    prepublishOnly: "npm run build"
+  },
+  keywords: [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "ai",
+    "code-quality",
+    "unslop"
+  ],
+  license: "MIT",
+  peerDependencies: {
+    eslint: ">=9.0.0",
+    typescript: ">=5.0.0"
+  },
+  peerDependenciesMeta: {
+    typescript: {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@eslint/js": "^9.39.4",
+    "@types/estree": "^1.0.8",
+    "@types/node": "^22.18.0",
+    "@typescript-eslint/parser": "^8.57.2",
+    eslint: "^9.39.1",
+    globals: "^17.4.0",
+    knip: "^6.1.0",
+    prettier: "^3.8.1",
+    tsup: "^8.5.0",
+    typescript: "^5.9.3",
+    "typescript-eslint": "^8.57.2",
+    vitest: "^3.2.4"
+  }
+};
+
+// src/utils/string-literal-listener.ts
+function createStringLiteralListener(includeEscapedUnicode, visitLiteral) {
+  function inspect(node) {
+    const text = getStringValue(node, includeEscapedUnicode);
+    if (text == void 0) {
+      return;
+    }
+    visitLiteral(node, text);
+  }
+  return {
+    Literal: inspect,
+    TemplateLiteral: inspect
+  };
+}
+function getStringValue(node, includeEscapedUnicode) {
+  if (node.type === "TemplateLiteral") {
+    return node.quasis.map(
+      (q) => includeEscapedUnicode ? q.value.raw ?? q.value.cooked ?? "" : q.value.cooked ?? ""
+    ).join("");
+  }
+  if (typeof node.value !== "string") {
+    return void 0;
+  }
+  return includeEscapedUnicode ? node.raw ?? node.value : node.value;
+}
+
+// src/rules/no-special-unicode.ts
+var no_special_unicode_default = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow special unicode punctuation and whitespace in strings",
+      recommended: true
+    },
+    schema: [],
+    messages: {
+      bannedCharacter: "String contains {{name}} (U+{{code}}). Use the ASCII equivalent."
+    }
+  },
+  create(context) {
+    return createStringLiteralListener(false, (node, text) => {
+      if (!BANNED_CHARS_RE.test(text)) {
+        return;
+      }
+      for (const [char, name] of BANNED_CHARS) {
+        if (!text.includes(char)) {
+          continue;
+        }
+        const code = char.codePointAt(0) ?? 0;
+        context.report({
+          node,
+          messageId: "bannedCharacter",
+          data: {
+            name,
+            code: code.toString(16).toUpperCase().padStart(4, "0")
+          }
+        });
+      }
+    });
+  }
+};
+var BANNED_CHARS = /* @__PURE__ */ new Map([
+  ["\u201C", "left double quotation mark"],
+  ["\u201D", "right double quotation mark"],
+  ["\u2018", "left single quotation mark"],
+  ["\u2019", "right single quotation mark"],
+  ["\xA0", "non-breaking space"],
+  ["\u202F", "narrow no-break space"],
+  ["\u2007", "figure space"],
+  ["\u2008", "punctuation space"],
+  ["\u2009", "thin space"],
+  ["\u200A", "hair space"],
+  ["\u200B", "zero-width space"],
+  ["\u2002", "en space"],
+  ["\u2003", "em space"],
+  ["\u205F", "medium mathematical space"],
+  ["\u3000", "ideographic space"],
+  ["\uFEFF", "zero-width no-break space"],
+  ["\u2013", "en dash"],
+  ["\u2014", "em dash"],
+  ["\u2026", "horizontal ellipsis"]
+]);
+var BANNED_CHARS_RE = new RegExp([...BANNED_CHARS.keys()].join("|"));
+
+// src/rules/no-unicode-escape.ts
+var no_unicode_escape_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer literal unicode characters over \\uXXXX escape sequences",
+      recommended: true
+    },
+    schema: [],
+    messages: {
+      preferLiteral: "Use the actual character instead of a \\uXXXX escape sequence."
+    }
+  },
+  create(context) {
+    return createStringLiteralListener(true, (node, text) => {
+      if (UNICODE_ESCAPE_RE.test(text)) {
+        context.report({ node, messageId: "preferLiteral" });
+      }
+    });
+  }
+};
+var UNICODE_ESCAPE_RE = /\\u[0-9a-fA-F]{4}/;
+
+// src/rules/no-deep-imports.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
+
+// src/utils/path-helpers.ts
+var import_node_path = __toESM(require("path"), 1);
+function toPosix(filePath) {
+  return filePath.split(import_node_path.default.sep).join("/");
+}
+function isInsidePath(filePath, parentPath) {
+  const relativePath = import_node_path.default.relative(parentPath, filePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !import_node_path.default.isAbsolute(relativePath);
+}
+
+// src/utils/rule-options.ts
+function readSourceRootOption(options) {
+  const option = options[0];
+  if (!isRecord(option) || !("sourceRoot" in option)) {
+    return void 0;
+  }
+  return typeof option.sourceRoot === "string" ? option.sourceRoot : void 0;
+}
+function readDirsOption(options, rootMode = "file") {
+  const option = options[0];
+  if (!isRecord(option) || !("dirs" in option)) {
+    return [];
+  }
+  const rootModeResolved = readRootMode(option, rootMode);
+  const { dirs } = option;
+  if (!Array.isArray(dirs)) {
+    return [];
+  }
+  return dirs.flatMap((entry) => {
+    const parsed = parseDirEntry(entry, rootModeResolved);
+    return parsed ? [parsed] : [];
+  });
+}
+function readRootMode(option, fallback) {
+  if (!("mode" in option)) {
+    return fallback;
+  }
+  return option.mode === "dir" ? "dir" : "file";
+}
+function parseDirEntry(entry, defaultMode) {
+  if (!isRecord(entry) || !("path" in entry)) {
+    return void 0;
+  }
+  if (typeof entry.path !== "string") {
+    return void 0;
+  }
+  const modeValue = "mode" in entry ? entry.mode : void 0;
+  const mode = modeValue === "dir" ? "dir" : defaultMode;
+  return { path: entry.path, mode };
+}
+function isRecord(value) {
+  return value != void 0 && typeof value === "object";
+}
+
+// src/utils/source-root.ts
+var import_node_fs = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+function resolveSourceContext(filename, sourceRootOverride) {
+  if (filename === "<input>") {
+    return void 0;
+  }
+  const absoluteFilename = import_node_path2.default.isAbsolute(filename) ? filename : import_node_path2.default.resolve(filename);
+  if (sourceRootOverride) {
+    const projectRoot = findNearestPackageRoot(import_node_path2.default.dirname(absoluteFilename)) ?? process.cwd();
+    return buildContext(
+      absoluteFilename,
+      projectRoot,
+      import_node_path2.default.isAbsolute(sourceRootOverride) ? sourceRootOverride : import_node_path2.default.join(projectRoot, sourceRootOverride)
+    );
+  }
+  const packageRoot = findNearestPackageRoot(import_node_path2.default.dirname(absoluteFilename));
+  if (packageRoot) {
+    return buildContext(
+      absoluteFilename,
+      packageRoot,
+      (0, import_node_fs.existsSync)(import_node_path2.default.join(packageRoot, "src")) ? import_node_path2.default.join(packageRoot, "src") : packageRoot
+    );
+  }
+  return resolveLegacySourceRoot(absoluteFilename);
+}
+function findNearestPackageRoot(startDirectory) {
+  let directory = startDirectory;
+  while (true) {
+    if ((0, import_node_fs.existsSync)(import_node_path2.default.join(directory, "package.json"))) {
+      return directory;
+    }
+    const parent = import_node_path2.default.dirname(directory);
+    if (parent === directory) {
+      return void 0;
+    }
+    directory = parent;
+  }
+}
+function resolveLegacySourceRoot(filename) {
+  const normalized = toPosix(filename);
+  const sourceIndex = normalized.lastIndexOf("/src/");
+  if (sourceIndex === -1) {
+    return void 0;
+  }
+  const projectRoot = normalized.slice(0, sourceIndex);
+  const sourceRoot = import_node_path2.default.join(projectRoot, "src");
+  return buildContext(filename, projectRoot, sourceRoot);
+}
+function buildContext(filename, projectRoot, sourceRoot) {
+  if (!isInsidePath(filename, sourceRoot)) {
+    return void 0;
+  }
+  return {
+    projectRoot,
+    sourceRoot,
+    sourceRelativePath: toPosix(import_node_path2.default.relative(sourceRoot, filename))
+  };
+}
+
+// src/rules/no-deep-imports.ts
+var NO_DEEP_IMPORTS_SCHEMA = [
+  {
+    type: "object",
+    properties: {
+      sourceRoot: { type: "string" }
+    },
+    additionalProperties: false
+  }
+];
+var no_deep_imports_default = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid deep imports inside the same top-level folder",
+      recommended: true
+    },
+    messages: {
+      tooDeep: "{{sourceRelativePath}}: {{targetRelativePath}} is too deep (max 1 level below importer)."
+    },
+    schema: NO_DEEP_IMPORTS_SCHEMA
+  },
+  create(context) {
+    const filename = context.filename;
+    const sourceRootOption = readSourceRootOption(context.options);
+    const sourceContext = resolveSourceContext(filename, sourceRootOption);
+    if (!sourceContext) {
+      return {};
+    }
+    const { sourceRelativePath, sourceRoot } = sourceContext;
+    return {
+      ImportDeclaration(node) {
+        const specifier = typeof node.source.value === "string" ? node.source.value : "";
+        const violation = findViolation(specifier, filename, sourceRoot, sourceRelativePath);
+        if (violation) {
+          context.report({
+            node,
+            messageId: "tooDeep",
+            data: violation
+          });
+        }
+      }
+    };
+  }
+};
+function findViolation(specifier, filename, sourceRoot, sourceRelativePath) {
+  const targetSourceRelative = resolveImportSourceRelative(specifier, filename, sourceRoot);
+  if (!targetSourceRelative) {
+    return void 0;
+  }
+  const targetRelativePath = resolveTarget(targetSourceRelative, sourceRoot);
+  if (!targetRelativePath) {
+    return void 0;
+  }
+  const folderScope = folderScopeFromPath(sourceRelativePath);
+  if (!isInScope(targetRelativePath, folderScope)) {
+    return void 0;
+  }
+  const importerDepth = depthWithinScope(sourceRelativePath, folderScope);
+  const targetDepth = depthWithinScope(targetRelativePath, folderScope);
+  if (targetDepth <= importerDepth + 1) {
+    return void 0;
+  }
+  return {
+    sourceRelativePath,
+    targetRelativePath: stripTsExtension(targetRelativePath)
+  };
+}
+function resolveImportSourceRelative(specifier, filename, sourceRoot) {
+  const normalizedSpecifier = specifier.replace(/\.js$/, "");
+  if (normalizedSpecifier.startsWith("@/")) {
+    return normalizedSpecifier.slice(2);
+  }
+  if (!normalizedSpecifier.startsWith(".")) {
+    return void 0;
+  }
+  const absoluteTarget = import_node_path3.default.resolve(import_node_path3.default.dirname(filename), normalizedSpecifier);
+  const targetSourceRelative = import_node_path3.default.relative(sourceRoot, absoluteTarget);
+  if (targetSourceRelative.startsWith("..")) {
+    return void 0;
+  }
+  return toPosix(targetSourceRelative);
+}
+function resolveTarget(targetSourceRelative, sourceRoot) {
+  const cacheKey = `${sourceRoot}\0${targetSourceRelative}`;
+  if (resolveCache.has(cacheKey)) {
+    return resolveCache.get(cacheKey);
+  }
+  const candidates = [
+    targetSourceRelative + ".ts",
+    targetSourceRelative + ".tsx",
+    targetSourceRelative + "/index.ts",
+    targetSourceRelative + "/index.tsx"
+  ];
+  const candidate = candidates.find((entry) => (0, import_node_fs2.existsSync)(import_node_path3.default.join(sourceRoot, entry)));
+  const targetRelativePath = candidate ? toPosix(candidate) : void 0;
+  resolveCache.set(cacheKey, targetRelativePath);
+  return targetRelativePath;
+}
+function folderScopeFromPath(sourceRelativePath) {
+  const [firstPart = ""] = sourceRelativePath.split("/");
+  return stripTsExtension(firstPart);
+}
+function isInScope(targetRelativePath, scope) {
+  const targetNoExtension = stripTsExtension(targetRelativePath);
+  return targetNoExtension === scope || targetNoExtension.startsWith(`${scope}/`);
+}
+function depthWithinScope(relativePath, scope) {
+  const withoutExtension = stripTsExtension(relativePath);
+  if (withoutExtension === scope) {
+    return 0;
+  }
+  const suffix = withoutExtension.slice(scope.length + 1);
+  return suffix.split("/").length - 1;
+}
+var resolveCache = /* @__PURE__ */ new Map();
+function stripTsExtension(filePath) {
+  return filePath.replace(/\.tsx?$/, "");
+}
+
+// src/rules/no-false-sharing/analysis.ts
+var import_node_fs3 = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_typescript = __toESM(require("typescript"), 1);
+function runConsumerCheck(program, projectRoot, sourceRoot, directories) {
+  const checker = program.getTypeChecker();
+  const sourceFiles = program.getSourceFiles().filter((sf) => isInsidePath(sf.fileName, sourceRoot));
+  const modules = indexModules(directories, projectRoot, sourceRoot);
+  const barrels = indexBarrels(directories, projectRoot, sourceFiles, checker);
+  const ctx = { modules, barrels, checker };
+  countConsumers(sourceFiles, sourceRoot, ctx);
+  return collectErrors(modules);
+}
+function indexModules(directories, projectRoot, sourceRoot) {
+  const modules = /* @__PURE__ */ new Map();
+  for (const dir of directories) {
+    const absDir = import_node_path4.default.join(projectRoot, dir.path);
+    for (const file of listModuleFiles(absDir)) {
+      modules.set(file, {
+        relativePath: toPosix(import_node_path4.default.relative(sourceRoot, file)),
+        mode: dir.mode,
+        consumers: /* @__PURE__ */ new Set()
+      });
+    }
+  }
+  return modules;
+}
+function listModuleFiles(directory) {
+  if (!(0, import_node_fs3.existsSync)(directory)) {
+    return [];
+  }
+  return (0, import_node_fs3.readdirSync)(directory, { withFileTypes: true }).filter(
+    (e) => e.isFile() && (e.name.endsWith(".ts") || e.name.endsWith(".tsx")) && e.name !== "index.ts" && !isTestFile(e.name)
+  ).map((e) => import_node_path4.default.join(directory, e.name));
+}
+function indexBarrels(directories, projectRoot, sourceFiles, checker) {
+  const barrels = /* @__PURE__ */ new Map();
+  const sfByPath = new Map(sourceFiles.map((sf) => [sf.fileName, sf]));
+  for (const dir of directories) {
+    const barrelPath = import_node_path4.default.join(projectRoot, dir.path, "index.ts");
+    const barrelSf = sfByPath.get(barrelPath);
+    if (barrelSf) {
+      barrels.set(barrelPath, buildBarrelMap(barrelSf, checker));
+    }
+  }
+  return barrels;
+}
+function buildBarrelMap(barrelFile, checker) {
+  const map = /* @__PURE__ */ new Map();
+  for (const stmt of barrelFile.statements) {
+    if (!isNamedReExport(stmt)) continue;
+    const targetPath = resolveModulePath(stmt.moduleSpecifier, checker);
+    if (!targetPath) continue;
+    for (const el of stmt.exportClause.elements) {
+      if (!el.isTypeOnly) {
+        map.set(el.name.text, targetPath);
+      }
+    }
+  }
+  return map;
+}
+function isNamedReExport(stmt) {
+  return import_typescript.default.isExportDeclaration(stmt) && !stmt.isTypeOnly && !!stmt.moduleSpecifier && !!stmt.exportClause && import_typescript.default.isNamedExports(stmt.exportClause);
+}
+function countConsumers(sourceFiles, sourceRoot, ctx) {
+  for (const sf of sourceFiles) {
+    if (ctx.modules.has(sf.fileName) || isTestFile(sf.fileName)) continue;
+    const consumerPath = toPosix(import_node_path4.default.relative(sourceRoot, sf.fileName));
+    for (const stmt of sf.statements) {
+      if (import_typescript.default.isImportDeclaration(stmt)) {
+        recordImport(stmt, consumerPath, ctx);
+      }
+    }
+  }
+}
+function isTestFile(filePath) {
+  return TEST_FILE_RE.test(filePath);
+}
+var TEST_FILE_RE = /\.(test|integration-test|test-suite)\.ts$/;
+function recordImport(stmt, consumerPath, ctx) {
+  const targetPath = resolveModulePath(stmt.moduleSpecifier, ctx.checker);
+  if (!targetPath) return;
+  const direct = ctx.modules.get(targetPath);
+  if (direct) {
+    direct.consumers.add(deriveEntity(consumerPath, direct.mode));
+    return;
+  }
+  const barrelMap = ctx.barrels.get(targetPath);
+  if (barrelMap) {
+    resolveBarrelImports(stmt, barrelMap, consumerPath, ctx.modules);
+  }
+}
+function resolveBarrelImports(stmt, barrelMap, consumerPath, modules) {
+  const bindings = stmt.importClause?.namedBindings;
+  if (!bindings) return;
+  const paths = import_typescript.default.isNamespaceImport(bindings) ? [...barrelMap.values()] : resolveNamedImports(bindings, barrelMap);
+  for (const resolved of paths) {
+    const entry = modules.get(resolved);
+    entry?.consumers.add(deriveEntity(consumerPath, entry.mode));
+  }
+}
+function resolveNamedImports(bindings, barrelMap) {
+  const result = [];
+  for (const el of bindings.elements) {
+    const name = el.propertyName?.text ?? el.name.text;
+    const resolved = barrelMap.get(name);
+    if (resolved) {
+      result.push(resolved);
+    }
+  }
+  return result;
+}
+function resolveModulePath(specifier, checker) {
+  const symbol = checker.getSymbolAtLocation(specifier);
+  return symbol?.declarations?.[0]?.getSourceFile().fileName;
+}
+function collectErrors(modules) {
+  const errors = /* @__PURE__ */ new Map();
+  for (const [, entry] of modules) {
+    if (entry.consumers.size >= 2) continue;
+    const consumers = [...entry.consumers];
+    const description = consumers.length === 0 ? "not imported by any entity" : `only used by: ${consumers.join(", ")}`;
+    errors.set(entry.relativePath, [`${description} -> Must be used by 2+ entities`]);
+  }
+  return errors;
+}
+function deriveEntity(consumerPath, mode) {
+  if (mode === "file") {
+    return consumerPath;
+  }
+  return consumerPath.split("/").slice(0, -1).slice(0, MAX_DIR_DEPTH).join("/");
+}
+var MAX_DIR_DEPTH = 3;
+
+// src/rules/no-false-sharing.ts
+var SCHEMA = [
+  {
+    type: "object",
+    properties: {
+      dirs: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+            mode: { type: "string", enum: ["file", "dir"] }
+          },
+          required: ["path"],
+          additionalProperties: false
+        }
+      },
+      mode: { type: "string", enum: ["file", "dir"] },
+      sourceRoot: { type: "string" }
+    },
+    required: ["dirs"],
+    additionalProperties: false
+  }
+];
+var no_false_sharing_default = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require selected modules to be shared across at least two consumer entities",
+      recommended: false
+    },
+    schema: SCHEMA
+  },
+  create(context) {
+    const dirs = readDirsOption(context.options);
+    if (dirs.length === 0) {
+      return {};
+    }
+    const filename = context.filename;
+    const sourceRootOption = readSourceRootOption(context.options);
+    const sourceContext = resolveSourceContext(filename, sourceRootOption);
+    if (!sourceContext) {
+      return {};
+    }
+    const { sourceRelativePath, sourceRoot, projectRoot } = sourceContext;
+    return {
+      Program(node) {
+        const program = extractTsProgram(context);
+        if (!program) {
+          return;
+        }
+        const errors = runConsumerCheck(program, projectRoot, sourceRoot, dirs);
+        const fileErrors = errors.get(sourceRelativePath);
+        if (!fileErrors) {
+          return;
+        }
+        for (const message of fileErrors) {
+          context.report({ node, message });
+        }
+      }
+    };
+  }
+};
+function extractTsProgram(context) {
+  const services = context.sourceCode.parserServices;
+  if (!isRecord2(services) || !("program" in services)) {
+    return void 0;
+  }
+  const program = services.program;
+  if (!isTsProgram(program)) {
+    return void 0;
+  }
+  return program;
+}
+function isTsProgram(value) {
+  return isRecord2(value) && "getTypeChecker" in value;
+}
+function isRecord2(value) {
+  return value != void 0 && typeof value === "object";
+}
+
+// src/rules/read-friendly-order/class-order.ts
+function reportClassOrdering(program, context) {
+  for (const classNode of collectClassDeclarations(program)) {
+    const members = collectClassMembers(classNode);
+    reportConstructorOrder(members, classNode, context);
+    reportPublicFieldOrder(members, context);
+    reportClassDependencyOrder(members, context);
+  }
+}
+function collectClassDeclarations(program) {
+  const classes = [];
+  for (const statement of getTopLevelStatements(program)) {
+    const classNode = extractClassNode(statement);
+    if (classNode) classes.push(classNode);
+  }
+  return classes;
+}
+function extractClassNode(statement) {
+  if (statement.type === "ClassDeclaration") return statement;
+  if (statement.type === "ExportNamedDeclaration" && statement.declaration?.type === "ClassDeclaration") {
+    return statement.declaration;
+  }
+  if (statement.type === "ExportDefaultDeclaration" && statement.declaration.type === "ClassDeclaration") {
+    return statement.declaration;
+  }
+  return void 0;
+}
+function reportConstructorOrder(members, classNode, context) {
+  const ctor = members.find((m) => m.kind === "constructor");
+  if (!ctor || ctor.index === 0) return;
+  context.report({
+    node: ctor.node,
+    messageId: "constructorFirst",
+    data: { className: classNode.id?.name ?? "anonymous class" }
+  });
+}
+function reportPublicFieldOrder(members, context) {
+  const ctorIndex = members.find((m) => m.kind === "constructor")?.index ?? -1;
+  const startIndex = ctorIndex >= 0 ? ctorIndex + 1 : 0;
+  let seenOther = false;
+  for (const member of members) {
+    if (member.index < startIndex) continue;
+    if (member.kind === "public-field") {
+      if (seenOther) {
+        context.report({
+          node: member.node,
+          messageId: "publicFieldOrder",
+          data: { memberName: member.name }
+        });
+      }
+      continue;
+    }
+    seenOther = true;
+  }
+}
+function reportClassDependencyOrder(members, context) {
+  const others = members.filter((m) => m.kind === "other");
+  for (const member of others) {
+    const consumer = findFirstClassConsumer(others, member, context);
+    if (!consumer) continue;
+    context.report({
+      node: member.node,
+      messageId: "moveMemberBelow",
+      data: { memberName: member.name, consumerName: consumer.name }
+    });
+  }
+}
+function collectClassMembers(classNode) {
+  const members = [];
+  for (const [index, raw] of classNode.body.body.entries()) {
+    const named = toNamedMember(raw);
+    if (!named) continue;
+    members.push({ name: named.name, node: named.node, index, kind: classifyMember(named.node) });
+  }
+  return members;
+}
+function toNamedMember(raw) {
+  if (!hasMemberKey(raw)) return void 0;
+  const name = readMemberName(raw.key);
+  return name ? { name, node: raw } : void 0;
+}
+function hasMemberKey(value) {
+  return "key" in value && isNode(value.key);
+}
+function readMemberName(key) {
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "Literal" && typeof key.value === "string") return key.value;
+  if (key.type === "PrivateIdentifier") return `#${key.name}`;
+  return void 0;
+}
+function classifyMember(member) {
+  if (member.type === "MethodDefinition" && member.kind === "constructor") return "constructor";
+  if (isPublicField(member)) return "public-field";
+  return "other";
+}
+function isPublicField(member) {
+  if (member.type !== "PropertyDefinition" || member.static) return false;
+  if (member.key.type === "PrivateIdentifier") return false;
+  if (!("accessibility" in member)) return true;
+  return member.accessibility === void 0 || member.accessibility === "public";
+}
+function findFirstClassConsumer(members, member, context) {
+  const pattern = new RegExp(`\\bthis(?:\\?\\.|\\.)${escapeRegex(member.name)}\\b`);
+  for (const candidate of members) {
+    if (candidate.index <= member.index) continue;
+    if (pattern.test(context.sourceCode.getText(candidate.node))) return candidate;
+  }
+  return void 0;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isNode(value) {
+  return !!value && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+
+// src/rules/read-friendly-order/test-order.ts
+function reportTestOrdering(program, context) {
+  const entries = collectTestPhaseEntries(program);
+  if (!entries.some((entry) => entry.kind === "test")) {
+    return;
+  }
+  reportSetupOrder(entries, context);
+  reportTeardownOrder(entries, context);
+}
+function collectTestPhaseEntries(program) {
+  const entries = [];
+  for (const [index, statement] of getTopLevelStatements(program).entries()) {
+    const entry = toTestPhaseEntry(statement, index);
+    if (entry) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+function toTestPhaseEntry(statement, index) {
+  if (statement.type !== "ExpressionStatement" || statement.expression.type !== "CallExpression") {
+    return void 0;
+  }
+  const rootName = getCallRootName(statement.expression);
+  if (!rootName) {
+    return void 0;
+  }
+  const kind = classifyHookName(rootName);
+  if (!kind) {
+    return void 0;
+  }
+  return { index, kind, hookName: rootName, node: statement };
+}
+function classifyHookName(name) {
+  if (SETUP_HOOKS.has(name)) return "setup";
+  if (TEARDOWN_HOOKS.has(name)) return "teardown";
+  if (TEST_CALLS.has(name)) return "test";
+  return void 0;
+}
+var SETUP_HOOKS = /* @__PURE__ */ new Set(["beforeAll", "beforeEach", "before"]);
+var TEARDOWN_HOOKS = /* @__PURE__ */ new Set(["afterAll", "afterEach", "after"]);
+var TEST_CALLS = /* @__PURE__ */ new Set(["test", "it"]);
+function getCallRootName(call) {
+  const callee = call.callee;
+  if (callee.type === "Identifier") return callee.name;
+  if (callee.type === "MemberExpression") return readObjectRoot(callee.object);
+  if (callee.type === "CallExpression") return getCallRootName(callee);
+  return void 0;
+}
+function readObjectRoot(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "MemberExpression") return readObjectRoot(node.object);
+  if (node.type === "CallExpression") return getCallRootName(node);
+  return void 0;
+}
+function reportSetupOrder(entries, context) {
+  const firstTeardown = findFirstIndex(entries, "teardown");
+  const firstTest = findFirstIndex(entries, "test");
+  for (const entry of entries) {
+    if (entry.kind !== "setup") continue;
+    if (firstTeardown >= 0 && entry.index > firstTeardown) {
+      context.report({
+        node: entry.node,
+        messageId: "setupBeforeTeardown",
+        data: { hookName: entry.hookName }
+      });
+      continue;
+    }
+    if (firstTest >= 0 && entry.index > firstTest) {
+      context.report({
+        node: entry.node,
+        messageId: "setupBeforeTests",
+        data: { hookName: entry.hookName }
+      });
+    }
+  }
+}
+function reportTeardownOrder(entries, context) {
+  const firstTest = findFirstIndex(entries, "test");
+  if (firstTest < 0) return;
+  for (const entry of entries) {
+    if (entry.kind !== "teardown" || entry.index <= firstTest) continue;
+    context.report({
+      node: entry.node,
+      messageId: "teardownBeforeTests",
+      data: { hookName: entry.hookName }
+    });
+  }
+}
+function findFirstIndex(entries, kind) {
+  const match = entries.find((entry) => entry.kind === kind);
+  return match ? match.index : -1;
+}
+
+// src/rules/read-friendly-order.ts
+var READ_FRIENDLY_ORDER_MESSAGES = {
+  moveHelperBelow: 'Place helper "{{helperName}}" below the top-level symbol "{{symbolName}}" that depends on it.',
+  moveConstantBelow: 'Place constant "{{constantName}}" below the top-level symbol "{{symbolName}}" that uses it.',
+  constructorFirst: 'Place constructor first in class "{{className}}".',
+  publicFieldOrder: 'Place public field "{{memberName}}" right after constructor and before other class members.',
+  moveMemberBelow: 'Place class member "{{memberName}}" below member "{{consumerName}}" that depends on it.',
+  setupBeforeTeardown: 'Place setup hook "{{hookName}}" before teardown hooks in this test file.',
+  setupBeforeTests: 'Place setup hook "{{hookName}}" before test cases in this test file.',
+  teardownBeforeTests: 'Place teardown hook "{{hookName}}" before test cases in this test file.'
+};
+var read_friendly_order_default = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce top-level symbols before helper declarations they depend on",
+      recommended: false
+    },
+    schema: [],
+    messages: READ_FRIENDLY_ORDER_MESSAGES
+  },
+  create(context) {
+    return {
+      Program(program) {
+        reportTopLevelOrdering(program, context);
+        reportClassOrdering(program, context);
+        reportTestOrdering(program, context);
+      }
+    };
+  }
+};
+function reportTopLevelOrdering(program, context) {
+  const body = getTopLevelStatements(program);
+  const helpers = collectHelpers(body);
+  const refs = collectReferences(context.sourceCode.scopeManager.globalScope);
+  const cyclicNames = findCyclicHelperNames(body, helpers, refs);
+  for (const helper of helpers) {
+    if (cyclicNames.has(helper.name)) continue;
+    if (hasEagerReference(body, helper, refs)) continue;
+    const consumer = findFirstConsumer(body, helper, refs);
+    if (!consumer) continue;
+    context.report({
+      node: helper.node,
+      messageId: helper.kind === "constant" ? "moveConstantBelow" : "moveHelperBelow",
+      data: {
+        helperName: helper.name,
+        constantName: helper.name,
+        symbolName: getSymbolName(consumer)
+      }
+    });
+  }
+}
+function getTopLevelStatements(program) {
+  return program.body.filter((s) => s.type !== "ImportDeclaration");
+}
+function collectHelpers(body) {
+  const helpers = [];
+  for (const [index, statement] of body.entries()) {
+    helpers.push(...collectHelperEntries(statement, index));
+  }
+  return helpers;
+}
+function collectHelperEntries(statement, index) {
+  const typeName = getTypeDeclarationName(statement);
+  if (typeName) return [{ name: typeName, node: statement, index, kind: "helper" }];
+  if (statement.type === "FunctionDeclaration" && statement.id) {
+    return [{ name: statement.id.name, node: statement, index, kind: "helper" }];
+  }
+  if (statement.type === "ExportNamedDeclaration") {
+    return collectExportedHelpers(statement, index);
+  }
+  if (statement.type === "VariableDeclaration") {
+    return collectVariableHelpers(statement, index);
+  }
+  return [];
+}
+function getTypeDeclarationName(statement) {
+  const t = statement.type;
+  if (t !== "TSTypeAliasDeclaration" && t !== "TSInterfaceDeclaration") return void 0;
+  return hasIdentifierId(statement) ? statement.id.name : void 0;
+}
+function hasIdentifierId(value) {
+  if (!("id" in value)) return false;
+  const { id } = value;
+  return !!id && typeof id === "object" && "type" in id && "name" in id && id.type === "Identifier";
+}
+function collectExportedHelpers(statement, index) {
+  const decl = statement.declaration;
+  if (!decl) return [];
+  if (decl.type === "FunctionDeclaration" && decl.id) {
+    return [{ name: decl.id.name, node: statement, index, kind: "helper" }];
+  }
+  if (decl.type === "VariableDeclaration") return collectVariableHelpers(decl, index);
+  return [];
+}
+function collectVariableHelpers(decl, index) {
+  const helpers = [];
+  for (const item of decl.declarations) {
+    if (item.id.type !== "Identifier") continue;
+    const isFn = isFunctionInit(item.init ?? null);
+    if (!isFn && decl.kind !== "const") continue;
+    helpers.push({
+      name: item.id.name,
+      node: item,
+      index,
+      kind: isFn ? "helper" : "constant"
+    });
+  }
+  return helpers;
+}
+function isFunctionInit(node) {
+  return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+function findFirstConsumer(body, helper, refs) {
+  for (let i = helper.index + 1; i < body.length; i += 1) {
+    const stmt = body[i];
+    if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) continue;
+    if (statementUsesName(stmt, helper.name, refs)) return stmt;
+  }
+  return void 0;
+}
+function findCyclicHelperNames(body, helpers, refs) {
+  const deps = /* @__PURE__ */ new Map();
+  for (const helper of helpers) {
+    const helperDeps = /* @__PURE__ */ new Set();
+    for (const other of helpers) {
+      if (other.name !== helper.name && statementUsesName(body[helper.index], other.name, refs)) {
+        helperDeps.add(other.name);
+      }
+    }
+    deps.set(helper.name, helperDeps);
+  }
+  const cyclic = /* @__PURE__ */ new Set();
+  for (const helper of helpers) {
+    if (canReachSelf(helper.name, deps)) cyclic.add(helper.name);
+  }
+  return cyclic;
+}
+function statementUsesName(statement, name, refs) {
+  const range = statement.range;
+  if (!range) return false;
+  for (const ref of refs) {
+    if (ref.identifier.name !== name) continue;
+    const idRange = ref.identifier.range;
+    if (!idRange) continue;
+    if (idRange[0] >= range[0] && idRange[1] <= range[1]) return true;
+  }
+  return false;
+}
+function canReachSelf(start, deps) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...deps.get(start) ?? []];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === start) return true;
+    if (visited.has(current)) continue;
+    visited.add(current);
+    for (const dep of deps.get(current) ?? []) queue.push(dep);
+  }
+  return false;
+}
+function collectReferences(scope) {
+  if (!scope) return [];
+  const refs = [...scope.references];
+  for (const child of scope.childScopes) {
+    refs.push(...collectReferences(child));
+  }
+  return refs;
+}
+function hasEagerReference(body, helper, refs) {
+  for (let i = helper.index + 1; i < body.length; i += 1) {
+    const stmt = body[i];
+    if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) continue;
+    if (statementHasEagerUse(stmt, helper.name, refs)) return true;
+  }
+  return false;
+}
+function statementHasEagerUse(statement, name, refs) {
+  const range = statement.range;
+  if (!range) return false;
+  for (const ref of refs) {
+    if (ref.identifier.name !== name || isTypeReference(ref)) continue;
+    if (isEagerRefInRange(ref, range)) return true;
+  }
+  return false;
+}
+function isEagerRefInRange(ref, range) {
+  const idRange = ref.identifier.range;
+  if (!idRange) return false;
+  const inside = idRange[0] >= range[0] && idRange[1] <= range[1];
+  return inside && (ref.from.type === "module" || ref.from.type === "global");
+}
+function isTypeReference(ref) {
+  return "isTypeReference" in ref && ref.isTypeReference === true;
+}
+function getSymbolName(statement) {
+  if (statement.type === "ExportDefaultDeclaration") return "default export";
+  if (statement.type === "ExportNamedDeclaration") return getNamedExportName(statement);
+  if (statement.type === "FunctionDeclaration" && statement.id) return statement.id.name;
+  if (statement.type === "VariableDeclaration")
+    return getVarName(statement) ?? "top-level statement";
+  return "top-level statement";
+}
+function getNamedExportName(statement) {
+  const decl = statement.declaration;
+  if (!decl) return "named export";
+  if (decl.type === "FunctionDeclaration" && decl.id) return decl.id.name;
+  if (decl.type === "VariableDeclaration") return getVarName(decl) ?? "named export";
+  return "named export";
+}
+function getVarName(decl) {
+  const [first] = decl.declarations;
+  return first?.id.type === "Identifier" ? first.id.name : void 0;
+}
+
+// src/rules/index.ts
+var rules_default = {
+  "no-special-unicode": no_special_unicode_default,
+  "no-unicode-escape": no_unicode_escape_default,
+  "no-deep-imports": no_deep_imports_default,
+  "no-false-sharing": no_false_sharing_default,
+  "read-friendly-order": read_friendly_order_default
+};
+
+// src/index.ts
+var plugin = {
+  meta: {
+    name: package_default.name,
+    version: package_default.version
+  },
+  rules: rules_default,
+  configs: {}
+};
+var recommended = {
+  name: "unslop/recommended",
+  plugins: { unslop: plugin },
+  rules: {
+    "unslop/no-special-unicode": "error",
+    "unslop/no-unicode-escape": "error",
+    "unslop/no-deep-imports": "error"
+  }
+};
+plugin.configs["recommended"] = recommended;
+var index_default = plugin;
+//# sourceMappingURL=index.cjs.map