@heyramzi/lint 0.0.0-stage → 1.32.2

package/rules/no-relative-imports.js

@@ -0,0 +1,213 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+
+// SvelteKit generates `./$types` beside each route; it has no alias.
+const EXEMPT = new Set(["./$types", "./$types.js"]);
+const TEST_CALLS = new Set(["mock", "doMock", "unmock", "importActual", "requireActual"]);
+// Vite and friends load these before any alias exists, so only package.json `imports` is safe there.
+const CONFIG_FILE = /\.config\.[cm]?[jt]s$/;
+
+const cache = new Map();
+const memo = (key, fn) => {
+  if (!cache.has(key)) cache.set(key, fn());
+  return cache.get(key);
+};
+
+/** JSONC to JSON: drops comments and trailing commas, leaves strings alone. */
+function parseJsonc(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === '"') {
+      let j = i + 1;
+      while (j < text.length && text[j] !== '"') j += text[j] === "\\" ? 2 : 1;
+      out += text.slice(i, j + 1);
+      i = j;
+    } else if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+    } else if (c === "/" && text[i + 1] === "*") {
+      i = text.indexOf("*/", i + 2) + 1;
+    } else out += c;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+
+function readJson(file) {
+  return memo(`json:${file}`, () => {
+    if (!existsSync(file)) return null;
+    try {
+      return parseJsonc(readFileSync(file, "utf8"));
+    } catch {
+      return null;
+    }
+  });
+}
+
+function findUp(dir, name) {
+  for (let d = dir; ; d = dirname(d)) {
+    if (existsSync(join(d, name))) return join(d, name);
+    if (dirname(d) === d) return null;
+  }
+}
+
+function resolveExtends(from, spec) {
+  if (spec.startsWith("."))
+    return resolve(dirname(from), spec.endsWith(".json") ? spec : `${spec}.json`);
+  const req = createRequire(from);
+  for (const s of [spec, `${spec}.json`, `${spec}/tsconfig.json`]) {
+    try {
+      return req.resolve(s);
+    } catch {
+      // try the next form
+    }
+  }
+  return null;
+}
+
+/** Merged tsconfig: paths with the directory they resolve from, plus the include globs. */
+function loadTsconfig(file) {
+  return memo(`ts:${file}`, () => {
+    const json = readJson(file);
+    if (!json) return null;
+    const dir = dirname(file);
+    let merged = { paths: null, base: null, baseUrl: null, include: null, root: dir };
+    const parents = [json.extends ?? []].flat();
+    for (const p of parents) {
+      const parent = resolveExtends(file, p);
+      const loaded = parent && loadTsconfig(parent);
+      if (loaded) Object.assign(merged, loaded, { root: dir });
+    }
+    const opts = json.compilerOptions ?? {};
+    if (opts.baseUrl) merged.baseUrl = resolve(dir, opts.baseUrl);
+    if (opts.paths) Object.assign(merged, { paths: opts.paths, base: dir });
+    if (json.include || json.files) {
+      merged.include = [...(json.include ?? []), ...(json.files ?? [])].map((g) => resolve(dir, g));
+    }
+    return merged;
+  });
+}
+
+const globToRegExp = (glob) =>
+  new RegExp(
+    `^${glob
+      .split(sep)
+      .join("/")
+      .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+      .replace(/\*\*\//g, "\uE000")
+      .replace(/\*\*/g, "\uE001")
+      .replace(/\*/g, "[^/]*")
+      .replace(/\uE000/g, "(?:.*/)?")
+      .replace(/\uE001/g, ".*")}(?:/.*)?$`,
+  );
+
+const included = (ts, file) =>
+  !ts.include
+    ? file.startsWith(ts.root + sep)
+    : ts.include.some((g) => globToRegExp(g).test(file.split(sep).join("/")));
+
+/** `X/*` → `Y/*` pairs only: an alias that maps a directory, as [prefix, absolute dir]. */
+function wildcardPairs(map, base) {
+  const pairs = [];
+  for (const [key, value] of Object.entries(map ?? {})) {
+    let target = [value].flat()[0];
+    if (target && typeof target === "object") target = target.import ?? target.default;
+    if (typeof target !== "string" || !key.endsWith("/*") || !target.endsWith("/*")) continue;
+    pairs.push([key.slice(0, -1), resolve(base, target.slice(0, -2))]);
+  }
+  return pairs;
+}
+
+/** Aliases usable from `file`: package.json `imports` first, since Node, tsx, Vite and esbuild all honour them. */
+function aliasesFor(file) {
+  const dir = dirname(file);
+  const pkgFile = findUp(dir, "package.json");
+  const pkg = pkgFile && readJson(pkgFile);
+  const aliases = wildcardPairs(pkg?.imports, pkgFile ? dirname(pkgFile) : dir);
+  const tsFile = findUp(dir, "tsconfig.json");
+  const ts = tsFile && loadTsconfig(tsFile);
+  const runsUnbundled = /\.[cm]js$/.test(file) || CONFIG_FILE.test(basename(file));
+  if (ts?.paths && !runsUnbundled && included(ts, file)) {
+    aliases.push(...wildcardPairs(ts.paths, ts.baseUrl ?? ts.base));
+  }
+  return aliases;
+}
+
+const firstArg = (node) => node.arguments?.[0];
+
+/** The aliased specifier, or null. The deepest alias directory wins; on a tie tsconfig `paths` beat package.json `imports`. */
+export function toAlias(file, source) {
+  const target = resolve(dirname(file), source);
+  let best = null;
+  for (const [prefix, dir] of aliasesFor(file)) {
+    if (!target.startsWith(dir + sep)) continue;
+    if (!best || dir.length >= best[1].length) best = [prefix, dir];
+  }
+  if (!best) return null;
+  const rest = relative(best[1], target).split(sep).join("/");
+  return best[0] + rest + (source.endsWith("/") ? "/" : "");
+}
+
+export default {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description:
+        "Disallow relative module specifiers. Use a path alias from tsconfig `paths` or package.json `imports`.",
+    },
+    messages: {
+      noRelativeImport: "Use a path alias instead of relative import '{{ source }}'.",
+      noAlias:
+        "Relative import '{{ source }}' has no alias covering its target. Add one to tsconfig `paths` or package.json `imports`.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const file = context.physicalFilename ?? context.filename;
+    const check = (literal) => {
+      if (!literal || typeof literal.value !== "string") return;
+      const source = literal.value;
+      if (
+        !source.startsWith("./") &&
+        !source.startsWith("../") &&
+        source !== "." &&
+        source !== ".."
+      )
+        return;
+      if (EXEMPT.has(source)) return;
+      const alias = toAlias(file, source);
+      if (!alias) {
+        context.report({ node: literal, messageId: "noAlias", data: { source } });
+        return;
+      }
+      const quote = context.sourceCode.getText(literal)[0];
+      context.report({
+        node: literal,
+        messageId: "noRelativeImport",
+        data: { source },
+        fix: (fixer) => fixer.replaceText(literal, quote + alias + quote),
+      });
+    };
+    return {
+      ImportDeclaration: (node) => check(node.source),
+      ExportNamedDeclaration: (node) => check(node.source),
+      ExportAllDeclaration: (node) => check(node.source),
+      ImportExpression: (node) => check(node.source),
+      TSImportType: (node) => check(node.source),
+      TSExternalModuleReference: (node) => check(node.expression),
+      CallExpression(node) {
+        const { callee } = node;
+        if (callee.type === "Identifier" && callee.name === "require") check(firstArg(node));
+        if (
+          callee.type === "MemberExpression" &&
+          callee.object.type === "Identifier" &&
+          ["vi", "jest"].includes(callee.object.name) &&
+          TEST_CALLS.has(callee.property.name)
+        )
+          check(firstArg(node));
+      },
+    };
+  },
+};

package/rules/no-relative-type-imports.js

@@ -0,0 +1,40 @@
+export default {
+  meta: {
+    type: "suggestion",
+    deprecated: true,
+    replacedBy: ["no-relative-imports"],
+    docs: {
+      description: "Disallow relative imports for type-only imports. Use @/ path alias instead.",
+    },
+    messages: {
+      noRelativeTypeImport:
+        "Use @/ path alias for type imports instead of relative import '{{ source }}'.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === "type" || hasTypeImport(node)) {
+          const source = node.source.value;
+          if (source === "./$types") {
+            return;
+          }
+          if (source.startsWith(".")) {
+            context.report({
+              node: node.source,
+              messageId: "noRelativeTypeImport",
+              data: { source },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+function hasTypeImport(node) {
+  return node.specifiers.some(
+    (specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type",
+  );
+}

package/rules/no-rune-outside-svelte-file.js

@@ -0,0 +1,56 @@
+/**
+ * Ban a rune (`$state`, `$derived`, `$effect`, `$props`...) in a file Svelte doesn't compile.
+ */
+
+/*
+ * Runes work in `.svelte`, `.svelte.ts` and `.svelte.js` only. In a plain `.ts` file `$derived` throws `rune_outside_svelte` at runtime. Rename the file to `.svelte.ts`.
+ */
+
+const RUNES = new Set([
+  "$state",
+  "$derived",
+  "$effect",
+  "$props",
+  "$bindable",
+  "$inspect",
+  "$host",
+]);
+
+const COMPILED = /\.svelte(\.[^./\\]+)?\.[jt]s$|\.svelte$/;
+
+function runeOf(callee) {
+  if (callee.type === "Identifier") return callee.name;
+  if (callee.type === "MemberExpression" && callee.object.type === "Identifier") {
+    return callee.object.name;
+  }
+  return null;
+}
+
+export default {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow runes outside .svelte, .svelte.ts and .svelte.js files." },
+    messages: {
+      runeOutside:
+        "`{{ rune }}` only works in a `.svelte`, `.svelte.ts` or `.svelte.js` file; here it throws `rune_outside_svelte`. Rename this file to `{{ suggested }}`.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const filename = context.filename;
+    if (COMPILED.test(filename) || filename.endsWith(".d.ts")) return {};
+    if (!/\.[cm]?[jt]sx?$/.test(filename)) return {};
+    return {
+      CallExpression(node) {
+        const rune = runeOf(node.callee);
+        if (!rune || !RUNES.has(rune)) return;
+        const base = filename.split(/[\\/]/).pop();
+        context.report({
+          node,
+          messageId: "runeOutside",
+          data: { rune, suggested: base.replace(/\.[cm]?([jt]s)x?$/, ".svelte.$1") },
+        });
+      },
+    };
+  },
+};

package/rules/no-rune-shadowing-binding.js

@@ -0,0 +1,85 @@
+/**
+ * Ban a top-level binding named like a rune (`state`, `derived`, `effect`...) in a file that calls that rune.
+ */
+
+/*
+ * `let { state } = $props()` makes `$state(...)` read as a store subscription and the call throws `store_invalid_shape`. Svelte only warns, `store_rune_conflict`, so a push never stopped it.
+ */
+
+const RUNES = new Set(["state", "derived", "effect", "inspect", "host", "bindable"]);
+
+function boundNames(pattern, out) {
+  if (!pattern) return;
+  switch (pattern.type) {
+    case "Identifier":
+      out.push(pattern);
+      break;
+    case "ObjectPattern":
+      for (const prop of pattern.properties) {
+        boundNames(prop.type === "RestElement" ? prop.argument : prop.value, out);
+      }
+      break;
+    case "ArrayPattern":
+      for (const element of pattern.elements) boundNames(element, out);
+      break;
+    case "AssignmentPattern":
+      boundNames(pattern.left, out);
+      break;
+    case "RestElement":
+      boundNames(pattern.argument, out);
+      break;
+    default:
+  }
+}
+
+function declaredNames(statement, out) {
+  const declaration =
+    statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+  if (!declaration) return;
+  if (declaration.type === "VariableDeclaration") {
+    for (const declarator of declaration.declarations) boundNames(declarator.id, out);
+  } else if (
+    declaration.type === "FunctionDeclaration" ||
+    declaration.type === "ClassDeclaration"
+  ) {
+    if (declaration.id) out.push(declaration.id);
+  } else if (statement.type === "ImportDeclaration") {
+    for (const specifier of statement.specifiers) out.push(specifier.local);
+  }
+}
+
+export default {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow top-level bindings that shadow a rune's name." },
+    messages: {
+      shadowsRune:
+        "`{{ name }}` collides with the `${{ name }}` rune: the compiler reads `${{ name }}(...)` as a store subscription and it throws `store_invalid_shape` at runtime. Rename it (`{{ name }}Value`, `current{{ cap }}`).",
+    },
+    schema: [],
+  },
+  create(context) {
+    if (
+      !context.filename.endsWith(".svelte") &&
+      !/\.svelte(\.[^./\\]+)?\.[jt]s$/.test(context.filename)
+    ) {
+      return {};
+    }
+    return {
+      Program(program) {
+        const source = context.sourceCode.text;
+        const names = [];
+        for (const statement of program.body) declaredNames(statement, names);
+        for (const id of names) {
+          if (!RUNES.has(id.name)) continue;
+          if (!new RegExp(`\\$${id.name}\\s*[(<]`).test(source)) continue;
+          context.report({
+            node: id,
+            messageId: "shadowsRune",
+            data: { name: id.name, cap: id.name[0].toUpperCase() + id.name.slice(1) },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-skipped-or-focused-tests.js

@@ -0,0 +1,74 @@
+/**
+ * Ban a test left skipped or focused: `.only`, `xit`, `it.skip("name", fn)`.
+ */
+
+/*
+ * A skipped test hides a failure and a focused one drops the rest of the suite. Playwright's conditional `test.skip(isCI, "reason")` passes: it has a condition, not a title.
+ */
+
+const SUITE = new Set(["describe", "it", "test", "suite", "bench"]);
+const X_NAMES = new Set(["xdescribe", "xit", "xtest"]);
+const F_NAMES = new Set(["fdescribe", "fit", "ftest"]);
+const FUNCTIONS = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+
+const isTitle = (node) =>
+  node?.type === "TemplateLiteral" || (node?.type === "Literal" && typeof node.value === "string");
+
+/** `it("name", fn)`: a title, then a body. Keeps a helper that happens to be called `fit` clear. */
+function looksLikeTest(args) {
+  return isTitle(args[0]) && args.slice(1).some((arg) => FUNCTIONS.has(arg.type));
+}
+
+/** Walks `test.describe.skip` down to the identifier `test`. */
+function baseName(node) {
+  let current = node;
+  while (current?.type === "MemberExpression") current = current.object;
+  return current?.type === "Identifier" ? current.name : null;
+}
+
+function modifierOf(callee) {
+  if (callee.type !== "MemberExpression" || callee.computed) return null;
+  const name = callee.property.name;
+  if (name !== "skip" && name !== "only") return null;
+  return SUITE.has(baseName(callee.object)) ? name : null;
+}
+
+export default {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow skipped and focused tests." },
+    messages: {
+      only: "`.only` runs this test alone and silently drops the rest of the suite. Remove it.",
+      skip: "A skipped test hides a failure. Fix it or delete it; never `.skip` or `x`-prefix it to get a green build. A conditional `test.skip(condition, 'reason')` is fine.",
+      focused: "`{{ name }}` focuses this test and drops the rest of the suite. Use `{{ plain }}`.",
+      disabled: "`{{ name }}` disables the test. Fix it or delete it, then use `{{ plain }}`.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type === "Identifier") {
+          if (!looksLikeTest(node.arguments)) return;
+          const plain = callee.name.slice(1);
+          if (F_NAMES.has(callee.name)) {
+            context.report({ node, messageId: "focused", data: { name: callee.name, plain } });
+          } else if (X_NAMES.has(callee.name)) {
+            context.report({ node, messageId: "disabled", data: { name: callee.name, plain } });
+          }
+          return;
+        }
+        const modifier = modifierOf(callee);
+        if (modifier === "only") {
+          context.report({ node, messageId: "only" });
+        } else if (modifier === "skip") {
+          const [first, second] = node.arguments;
+          if (!first || isTitle(first) || FUNCTIONS.has(second?.type)) {
+            context.report({ node, messageId: "skip" });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-snake-case-props.js

@@ -0,0 +1,45 @@
+const SNAKE_CASE_RE = /^[a-z]+(_[a-z0-9]+)+$/;
+
+function toCamelCase(name) {
+  return name.replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Use camelCase properties; quote fixed wire-format and database keys.",
+    },
+    messages: {
+      snakeCaseProp:
+        "Property '{{ name }}' uses snake_case. Rename to '{{ suggested }}' internally, or quote a fixed external key.",
+    },
+    schema: [],
+  },
+  create(context) {
+    function checkPropertyName(node, nameNode) {
+      // Quoted keys name fixed protocol fields; destructuring reads an existing field.
+      if (node.computed || node.parent?.type === "ObjectPattern" || nameNode.type !== "Identifier")
+        return;
+      const name = nameNode.name;
+      if (SNAKE_CASE_RE.test(name)) {
+        context.report({
+          node: nameNode,
+          messageId: "snakeCaseProp",
+          data: { name, suggested: toCamelCase(name) },
+        });
+      }
+    }
+
+    return {
+      // Object literal properties: { company_name: "foo" }
+      Property(node) {
+        if (node.key) checkPropertyName(node, node.key);
+      },
+      // TypeScript interface/type properties: company_name: string
+      TSPropertySignature(node) {
+        if (node.key) checkPropertyName(node, node.key);
+      },
+    };
+  },
+};

package/rules/no-svelte4-syntax.js

@@ -0,0 +1,33 @@
+/**
+ * Ban Svelte 4 script syntax: `export let` and `$:`. Write Svelte 5.
+ */
+
+/*
+ * Markup (`on:click`, `<slot>`, `<svelte:component>`) can't reach oxlint, so `heyramzi-svelte-markup` reads it. Props are `$props()`, derived values `$derived`.
+ */
+
+export default {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow `export let` and `$:` in .svelte files." },
+    messages: {
+      exportLet: "`export let` is Svelte 4. Declare props with `let { name } = $props()`.",
+      reactiveLabel:
+        "`$:` is Svelte 4. Use `$derived` for a value that follows other state, `$effect` for a side effect.",
+    },
+    schema: [],
+  },
+  create(context) {
+    if (!context.filename.endsWith(".svelte")) return {};
+    return {
+      ExportNamedDeclaration(node) {
+        if (node.declaration?.type === "VariableDeclaration" && node.declaration.kind === "let") {
+          context.report({ node, messageId: "exportLet" });
+        }
+      },
+      LabeledStatement(node) {
+        if (node.label.name === "$") context.report({ node, messageId: "reactiveLabel" });
+      },
+    };
+  },
+};

package/rules/no-vitest-import-in-vite-plus.js

@@ -0,0 +1,64 @@
+/**
+ * In a Vite+ package that has no `vitest` of its own, import test helpers from `vite-plus/test`.
+ */
+
+/*
+ * Under `vp test` the `vitest` re-export fails with "Cannot read properties of undefined (reading 'config')". A package that depends on vitest directly runs standalone and isn't touched.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+const cache = new Map();
+
+function declares(pkg, name) {
+  return ["dependencies", "devDependencies", "peerDependencies"].some(
+    (field) => pkg[field] && name in pkg[field],
+  );
+}
+
+/** Walks up to the repo root: the nearest package.json that names vitest or vite-plus decides. */
+function usesVitePlusRunner(dir) {
+  if (cache.has(dir)) return cache.get(dir);
+  let verdict = null;
+  const manifest = path.join(dir, "package.json");
+  if (existsSync(manifest)) {
+    try {
+      const pkg = JSON.parse(readFileSync(manifest, "utf8"));
+      if (declares(pkg, "vitest")) verdict = false;
+      else if (declares(pkg, "vite-plus")) verdict = true;
+    } catch {
+      verdict = null;
+    }
+  }
+  if (verdict === null) {
+    const parent = path.dirname(dir);
+    verdict =
+      existsSync(path.join(dir, ".git")) || parent === dir ? false : usesVitePlusRunner(parent);
+  }
+  cache.set(dir, verdict);
+  return verdict;
+}
+
+export default {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow importing from vitest in a Vite+ package." },
+    messages: {
+      vitestImport:
+        'Import from "vite-plus/test", not "vitest". Under `vp test` the vitest re-export fails with "Cannot read properties of undefined (reading \'config\')".',
+    },
+    schema: [],
+  },
+  create(context) {
+    if (!usesVitePlusRunner(path.dirname(context.filename))) return {};
+    return {
+      ImportDeclaration(node) {
+        if (node.importKind === "type" || node.source.value !== "vitest") return;
+        context.report({ node, messageId: "vitestImport" });
+      },
+      ImportExpression(node) {
+        if (node.source?.value === "vitest") context.report({ node, messageId: "vitestImport" });
+      },
+    };
+  },
+};

package/rules/props-interface.js

@@ -0,0 +1,44 @@
+/**
+ * Ban `type Props = {...}` in a .svelte file. Write `interface Props {...}`.
+ */
+
+/*
+ * A union or a conditional type can't be an interface, so those stay allowed. The fix rewrites an object-literal alias, the common case.
+ */
+
+const NOT_AN_INTERFACE = new Set(["TSUnionType", "TSConditionalType", "TSMappedType"]);
+
+export default {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: { description: "Require `interface Props` over `type Props` in Svelte components." },
+    messages: {
+      typeProps:
+        "Declare component props as `interface Props { ... }`, not `type Props`. Extend another type with `interface Props extends Other { ... }`.",
+    },
+    schema: [],
+  },
+  create(context) {
+    if (!context.filename.endsWith(".svelte")) return {};
+    return {
+      TSTypeAliasDeclaration(node) {
+        if (node.id.name !== "Props") return;
+        if (NOT_AN_INTERFACE.has(node.typeAnnotation.type)) return;
+        const fixable =
+          node.typeAnnotation.type === "TSTypeLiteral" && !node.typeParameters && !node.declare;
+        context.report({
+          node,
+          messageId: "typeProps",
+          fix: fixable
+            ? (fixer) =>
+                fixer.replaceTextRange(
+                  [node.range[0], node.typeAnnotation.range[0]],
+                  "interface Props ",
+                )
+            : undefined,
+        });
+      },
+    };
+  },
+};