eslint-plugin-esm 0.0.0 → 0.1.1

package/src/rules/no-ts-file-imports.ts

@@ -0,0 +1,23 @@
+import { create, createRule, getRuleName } from "../common.js";
+
+export const noTsFileImports = createRule({
+  name: getRuleName(import.meta.url),
+  message: "Disallow importing from a declaration style file or a ts file",
+  create: (context) => create(context, check),
+});
+
+function check(filename: string, source: string) {
+  // disabled this rule in declaration files
+  if (
+    [".d.ts", ".d.cts", ".d.mts", ".d.tsx"].some((ext) =>
+      filename.endsWith(ext),
+    )
+  ) {
+    return false;
+  }
+  const file = source.split("/").at(-1);
+  if (!file || file.includes(".d.")) {
+    return true;
+  }
+  return [".ts", ".cts", ".mts", ".tsx"].some((ext) => file.endsWith(ext));
+}

package/src/test.spec.ts

@@ -0,0 +1,110 @@
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+import { RuleTester, type Rule } from "eslint";
+import { outdent } from "outdent";
+
+export type TestCase = string | { code: string; filename?: string };
+
+const tester = new RuleTester({
+  parser: createRequire(import.meta.url).resolve("@typescript-eslint/parser"),
+  parserOptions: { ecmaVersion: "latest", sourceType: "module" },
+});
+
+export async function test({
+  name,
+  rule,
+  valid,
+  invalid,
+  errors = 1,
+}: {
+  name: string;
+  rule: Rule.RuleModule;
+  valid: TestCase[];
+  invalid: TestCase[];
+  errors?: number;
+}) {
+  await describe(name, async () => {
+    await Promise.all(
+      valid.map(async (testCase) => {
+        await it(JSON.stringify(testCase), () => {
+          tester.run(name, rule, {
+            valid: [testCase],
+            invalid: [],
+          });
+        });
+      }),
+    );
+
+    await Promise.all(
+      invalid.map(async (testCase) => {
+        await it(JSON.stringify(testCase), () => {
+          const code = typeof testCase === "string" ? testCase : testCase.code;
+          const filename =
+            typeof testCase === "string" ? undefined : testCase.filename;
+          tester.run(name, rule, {
+            valid: [],
+            invalid: [{ code, errors, filename }],
+          });
+        });
+      }),
+    );
+
+    await genDoc({ name, rule, valid, invalid });
+  });
+}
+
+async function genDoc({
+  name,
+  rule,
+  valid,
+  invalid,
+}: {
+  name: string;
+  rule: Rule.RuleModule;
+  valid: TestCase[];
+  invalid: TestCase[];
+}) {
+  const handle = (testCases: TestCase[]) =>
+    testCases
+      .map((testCase) =>
+        typeof testCase === "string" ? { code: testCase } : testCase,
+      )
+      .map((testCase) =>
+        testCase.filename
+          ? `${testCase.code} // filename: ${testCase.filename}`
+          : testCase.code,
+      )
+      .join("\n");
+  const mdContent = outdent`
+    <!-- prettier-ignore-start -->
+    # ${name}
+
+    ${rule.meta?.docs?.description}
+
+    ## Rule Details
+
+    ### Fail
+
+    \`\`\`ts
+    ${handle(invalid)}
+    \`\`\`
+
+    ### Pass
+
+    \`\`\`ts
+    ${handle(valid)}
+    \`\`\`
+    <!-- prettier-ignore-end -->
+
+  `.replaceAll(process.cwd(), "/foo");
+
+  const currentDir = path.dirname(fileURLToPath(import.meta.url));
+  await fs.writeFile(
+    path.join(currentDir, "..", "doc", "rules", `${name}.md`),
+    mdContent,
+  );
+}

package/src/utils.ts

@@ -0,0 +1,15 @@
+/**
+ * Like [lodash.memoize](https://lodash.com/docs/4.17.15#memoize)
+ */
+export function memoize<Arg, Res>(fn: (arg: Arg) => Res): (arg: Arg) => Res {
+  const cache = new Map<Arg, Res>(); // memory leak
+  return (arg: Arg) => {
+    if (cache.has(arg)) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      return cache.get(arg)!;
+    }
+    const result = fn(arg);
+    cache.set(arg, result);
+    return result;
+  };
+}