eslint-plugin-esm 0.0.0 → 0.1.0

package/src/index.ts

@@ -0,0 +1,23 @@
+import { nearestRelativePath } from "./rules/nearest-relative-path.js";
+import { noDirectoryImports } from "./rules/no-directory-imports.js";
+import { noDynamicImports } from "./rules/no-dynamic-imports.js";
+import { noGitIgnoredImports } from "./rules/no-git-ignored-imports.js";
+import { noPhantomDepImports } from "./rules/no-phantom-dep-imports.js";
+import { noRelativeParentImports } from "./rules/no-relative-parent-imports.js";
+import { noRenameExports } from "./rules/no-rename-exports.js";
+import { noRenameImports } from "./rules/no-rename-imports.js";
+import { noSideEffectImports } from "./rules/no-side-effect-imports.js";
+import { noTsFileImports } from "./rules/no-ts-file-imports.js";
+
+export const rules = {
+  [nearestRelativePath.name]: nearestRelativePath.rule,
+  [noDirectoryImports.name]: noDirectoryImports.rule,
+  [noDynamicImports.name]: noDynamicImports.rule,
+  [noGitIgnoredImports.name]: noGitIgnoredImports.rule,
+  [noPhantomDepImports.name]: noPhantomDepImports.rule,
+  [noRelativeParentImports.name]: noRelativeParentImports.rule,
+  [noRenameExports.name]: noRenameExports.rule,
+  [noRenameImports.name]: noRenameImports.rule,
+  [noSideEffectImports.name]: noSideEffectImports.rule,
+  [noTsFileImports.name]: noTsFileImports.rule,
+};

package/src/rules/nearest-relative-path.spec.ts

@@ -0,0 +1,43 @@
+import { test } from "../test.spec.js";
+import { nearestRelativePath } from "./nearest-relative-path.js";
+
+const valid = [
+  'import xxx from "../a"',
+  'import "../a"',
+  'import("../a")',
+  'require("../a")',
+  'import xxx from "./a"',
+  'import xxx from "a"',
+  'import xxx from ".a"',
+  'export * from "a"',
+  'export * from "./a"',
+  'export {a} from "a"',
+  'export {a} from "./a"',
+].map((code) => ({ code, filename: "/a/b/c/d/e.js" }));
+
+const invalid = [
+  'import xxx from ".././../a"',
+  'import ".././../a"',
+  'import(".././../a")',
+  'export * from ".././../a"',
+  'export {a} from ".././../a"',
+
+  'import xxx from "./../a"',
+  'import "./../a"',
+  'import("./../a")',
+  'export * from "./../a"',
+  'export {a} from "./../a"',
+
+  'import "././foo"',
+  'import "./../.././foo"',
+  'import("./../.././foo")',
+  'export * from "./../.././foo"',
+  'export {a} from "./../.././foo"',
+
+  'import "./../foo"',
+  'import("./../foo")',
+  'export * from "./../foo"',
+  'export {a} from "./../foo"',
+].map((code) => ({ code, filename: "/a/b/c/d/e.js" }));
+
+test({ valid, invalid, ...nearestRelativePath });

package/src/rules/nearest-relative-path.ts

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { create, createRule, getRuleName, getSourceType } from "../common.js";
+
+export const nearestRelativePath = createRule({
+  name: getRuleName(import.meta.url),
+  message: "The relative source path should be a nearest relative path.",
+  create: (context) => create(context, check),
+});
+
+function check(filename: string, source: string) {
+  if (getSourceType(source) !== "local" || source.startsWith("/")) {
+    return false;
+  }
+  const currentPath = path.dirname(filename);
+  const absoluteSource = path.resolve(currentPath, source);
+  // compatible with windows
+  let resultPath = path
+    .relative(currentPath, absoluteSource)
+    .replaceAll("\\", "/");
+  if (!resultPath.startsWith("./") && !resultPath.startsWith("../")) {
+    resultPath = `./${resultPath}`;
+  }
+  return resultPath !== source;
+}

package/src/rules/no-directory-imports.spec.ts

@@ -0,0 +1,31 @@
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { test } from "../test.spec.js";
+import { noDirectoryImports } from "./no-directory-imports.js";
+
+const valid = [
+  "import foo from 'foo'",
+  "import foo from './foo'",
+  `import foo from '${process.cwd()}/index.js'`,
+  `import foo from '${process.cwd()}/index.ts'`,
+  `import foo from '${process.cwd()}/package.json'`,
+].map((code) => ({
+  code,
+  filename: fileURLToPath(import.meta.url),
+}));
+
+const invalid = [
+  "import foo from '.'",
+  "import foo from './'",
+  "import foo from '..'",
+  "import foo from '../'",
+  "import foo from '../rules'",
+  "import foo from '../rules/'",
+  "import foo from '../../src'",
+  `import foo from '${process.cwd()}'`,
+].map((code) => ({
+  code,
+  filename: fileURLToPath(import.meta.url),
+}));
+
+test({ valid, invalid, ...noDirectoryImports });

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

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import path from "node:path";
+import { create, createRule, getRuleName, getSourceType } from "../common.js";
+import { memoize } from "../utils.js";
+
+export const noDirectoryImports = createRule({
+  name: getRuleName(import.meta.url),
+  message: "Disallow importing from a directory.",
+  create: (context) => create(context, check),
+});
+
+function check(filename: string, source: string) {
+  if (getSourceType(source) !== "local") {
+    return false;
+  }
+  if (source.endsWith(".") || source.endsWith("./")) {
+    return true;
+  }
+  const absolutePath = path.resolve(path.dirname(filename), source);
+  if (!absolutePath.startsWith("/")) {
+    throw new Error(
+      `ESLint plugin internal error. Absolute path incorrect: ${absolutePath}.`,
+    );
+  }
+  return isDir(absolutePath);
+}
+
+const isDir = memoize((filePath: string) => {
+  try {
+    return fs.statSync(filePath).isDirectory();
+  } catch (e) {
+    return false;
+  }
+});

package/src/rules/no-dynamic-imports.spec.ts

@@ -0,0 +1,27 @@
+import { test } from "../test.spec.js";
+import { noDynamicImports } from "./no-dynamic-imports.js";
+
+const valid = [
+  "import('foo')",
+  'import("foo")',
+  'import("./foo")',
+  'await import("foo")',
+  'const foo = await import("foo")',
+];
+
+const invalid = [
+  // 'import()',
+  // 'await import()',
+  "import(false)",
+  "import(123)",
+  "await import(123)",
+  "import(`foo`)",
+  "import(foo)",
+  "import({})",
+  "import([])",
+  "const foo = await import(foo)",
+  // "import(foo, {})", // only ts support it, not ecmascript
+  // 'import("foo", {})', // only ts support it, not ecmascript
+];
+
+test({ valid, invalid, ...noDynamicImports });

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

@@ -0,0 +1,15 @@
+import type { Node } from "estree";
+import { createRule, DEFAULT_MESSAGE_ID, getRuleName } from "../common.js";
+
+export const noDynamicImports = createRule({
+  name: getRuleName(import.meta.url),
+  message: "`import()` should be called with string literal.",
+  create: (context) => ({
+    "ImportExpression > :not(Literal)": (node: Node) => {
+      context.report({ node, messageId: DEFAULT_MESSAGE_ID });
+    },
+    "ImportExpression > Literal[raw=/^[^'\"].*[^'\"]$/]": (node: Node) => {
+      context.report({ node, messageId: DEFAULT_MESSAGE_ID });
+    },
+  }),
+});

package/src/rules/no-git-ignored-imports.spec.ts

@@ -0,0 +1,40 @@
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { test } from "../test.spec.js";
+import { noGitIgnoredImports } from "./no-git-ignored-imports.js";
+
+const valid = [
+  "import foo from 'foo'",
+  "import 'foo'",
+  "require('foo')",
+  "import('foo')",
+  "export * from 'foo'",
+  "export {name} from 'foo'",
+
+  "import foo from '.foo'",
+  "import foo from '../../../../for-test'",
+].map((code) => ({
+  code,
+  filename: fileURLToPath(import.meta.url),
+}));
+
+const invalid = [
+  "import foo from './dist/foo'",
+  "import './dist/foo'",
+  "import('./dist/foo')",
+  "export * from './dist/foo'",
+  "export {name} from './dist/foo'",
+
+  "import foo from '../dist/index.js'",
+  "import foo from '../../node_modules/foo/bar.js'",
+
+  "import foo from '/foo/tmp'",
+  `import foo from '${process.cwd()}/tmp'`,
+  "import foo from '../../test/for-test'",
+  "import foo from '../../../../../for-test'",
+].map((code) => ({
+  code,
+  filename: fileURLToPath(import.meta.url),
+}));
+
+test({ valid, invalid, ...noGitIgnoredImports });

package/src/rules/no-git-ignored-imports.ts

@@ -0,0 +1,53 @@
+import childProcess from "node:child_process";
+import path from "node:path";
+import process from "node:process";
+import { isNativeError } from "node:util/types";
+import { create, createRule, getRuleName, getSourceType } from "../common.js";
+import { memoize } from "../utils.js";
+
+export const noGitIgnoredImports = createRule({
+  name: getRuleName(import.meta.url),
+  message: "Disallow to import module from a git-ignored path.",
+  create: (context) => create(context, checkIgnored),
+});
+
+function checkIgnored(filename: string, source: string) {
+  // from node_modules
+  if (getSourceType(source) !== "local") {
+    return false;
+  }
+  // out side of project root
+  if (source.startsWith("/") && !source.startsWith(process.cwd())) {
+    return true;
+  }
+  // This file of absolutePath may be a symbolic link
+  const absolutePath = path.resolve(path.dirname(filename), source);
+  if (!absolutePath.startsWith("/")) {
+    throw new Error(
+      `ESLint plugin internal error. Absolute path incorrect: ${absolutePath}.`,
+    );
+  }
+  return isIgnored(absolutePath);
+}
+
+const isIgnored = memoize((filePath: string) => {
+  try {
+    return (
+      childProcess
+        .execSync(`git check-ignore ${filePath}`, { encoding: "utf8" })
+        .trim() === filePath
+    );
+  } catch (e) {
+    if (
+      isNativeError(e) &&
+      "stdout" in e &&
+      e.stdout === "" &&
+      "stderr" in e &&
+      e.stderr === ""
+    ) {
+      return false;
+    }
+    // We cannot throw an error here. So we have to return true to report the filePath is bad.
+    return true;
+  }
+});

package/src/rules/no-phantom-dep-imports.spec.ts

@@ -0,0 +1,28 @@
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { test } from "../test.spec.js";
+import { noPhantomDepImports } from "./no-phantom-dep-imports.js";
+
+const valid = [
+  { code: "import foo from '/foo'" },
+  { code: "import foo from './foo'" },
+  { code: "import foo from '../foo'" },
+  { code: "import foo from 'node:foo'" },
+  { code: "import type {Foo} from 'foo'" },
+  {
+    code: "import eslint from 'eslint'",
+    filename: fileURLToPath(import.meta.url),
+  },
+];
+
+const invalid = [
+  { code: "import {type Foo} from 'foo'" },
+  { code: "import foo from 'foo'", filename: fileURLToPath(import.meta.url) },
+  {
+    code: "import eslint from 'eslint'",
+    filename: path.join(process.cwd(), "foo.js"),
+  },
+];
+
+test({ valid, invalid, ...noPhantomDepImports });

package/src/rules/no-phantom-dep-imports.ts

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import {
+  create,
+  createRule,
+  getRuleName,
+  getSourceType,
+  type ImportationNode,
+} from "../common.js";
+
+function isObject(value: unknown) {
+  return value !== null && typeof value === "object";
+}
+
+function isFile(filePath: string) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch (e) {
+    return false;
+  }
+}
+
+const cache = new Map<string, { path: string; content: object } | undefined>(); // key is dir, value is package.json
+function getPkgJson(
+  dir: string,
+): { path: string; content: object } | undefined {
+  if (cache.has(dir)) {
+    return cache.get(dir);
+  }
+  const pkgJsonPath = path.join(dir, "package.json");
+  if (isFile(pkgJsonPath)) {
+    const content: unknown = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+    const result = isObject(content)
+      ? { path: pkgJsonPath, content }
+      : undefined;
+    cache.set(dir, result);
+    return result;
+  }
+
+  // if it is a directory
+  if (dir === process.cwd() || dir === "/") {
+    // stop here
+    cache.set(dir, undefined);
+    return undefined;
+  }
+
+  return getPkgJson(path.join(dir, ".."));
+}
+
+export const noPhantomDepImports = createRule({
+  name: getRuleName(import.meta.url),
+  message:
+    "Disallow importing from a module which the nearest `package.json` doesn't include it.",
+  create: (context) => create(context, check),
+});
+
+function check(filename: string, source: string, node: ImportationNode) {
+  // ignore `import type {foo} from 'foo'`
+  if ("importKind" in node && node.importKind === "type") {
+    return false;
+  }
+  // ignore `import {foo} from './'`
+  if (getSourceType(source) !== "module") {
+    return false;
+  }
+  const pkgJson = getPkgJson(path.dirname(filename));
+  // cannot find package.json file
+  if (!pkgJson) {
+    return true;
+  }
+  const dep =
+    "dependencies" in pkgJson.content && isObject(pkgJson.content.dependencies)
+      ? pkgJson.content.dependencies
+      : {};
+  const devDep =
+    "devDependencies" in pkgJson.content &&
+    isObject(pkgJson.content.devDependencies)
+      ? pkgJson.content.devDependencies
+      : {};
+
+  const moduleName = source
+    .split("/")
+    .slice(0, source.startsWith("@") ? 2 : 1)
+    .join("/");
+  if (["test", "spec"].includes(filename.split(".").at(-2) ?? "")) {
+    return !(moduleName in dep || moduleName in devDep);
+  }
+  return !(moduleName in dep);
+}

package/src/rules/no-relative-parent-imports.spec.ts

@@ -0,0 +1,28 @@
+import { test } from "../test.spec.js";
+import { noRelativeParentImports } from "./no-relative-parent-imports.js";
+
+const valid = [
+  "import foo from 'foo'",
+  "import 'foo'",
+  "require('foo')",
+  "import('foo')",
+  "export * from 'foo'",
+  "export {name} from 'foo'",
+
+  "import foo from '.foo'",
+  "import foo from './foo'",
+  "import foo from '../foo'",
+  "import foo from '../../foo'",
+];
+
+const invalid = [
+  "import foo from '../../../foo'",
+  "import '../../../foo'",
+  "import('../../../foo')",
+  "export * from '../../../foo'",
+  "export {name} from '../../../foo'",
+
+  "import foo from '../../../../foo'",
+];
+
+test({ valid, invalid, ...noRelativeParentImports });

package/src/rules/no-relative-parent-imports.ts

@@ -0,0 +1,13 @@
+import { create, createRule, getRuleName } from "../common.js";
+
+const depth = 3;
+
+export const noRelativeParentImports = createRule({
+  name: getRuleName(import.meta.url),
+  message: "Disallow importing module from a relative parent path too deeply.",
+  create: (context) => create(context, checkDepth),
+});
+
+function checkDepth(_filename: string, source: string) {
+  return new RegExp(`^(\\.\\./){${depth},}`).test(source);
+}

package/src/rules/no-rename-exports.spec.ts

@@ -0,0 +1,22 @@
+import { test } from "../test.spec.js";
+import { noRenameExports } from "./no-rename-exports.js";
+
+const valid = [
+  "let foo=1; export {foo}",
+  "export let foo",
+  "export const foo = bar",
+  "export default foo",
+  "export default {}",
+  "export {}",
+];
+const invalid = [
+  "let foo=1; export {foo as bar}",
+  "let foo=1; export {foo as default}",
+  "export {foo as bar} from './foo'",
+  "export {default as foo} from './foo'",
+  // ts
+  "export {type Foo as Bar}",
+  "export type {Foo as Bar}",
+];
+
+test({ valid, invalid, ...noRenameExports });

package/src/rules/no-rename-exports.ts

@@ -0,0 +1,13 @@
+import { createRule, DEFAULT_MESSAGE_ID, getRuleName } from "../common.js";
+
+export const noRenameExports = createRule({
+  name: getRuleName(import.meta.url),
+  message: "Disallow renaming the named-exports.",
+  create: (context) => ({
+    ExportSpecifier: (node) => {
+      if (node.exported.name !== node.local.name) {
+        context.report({ node, messageId: DEFAULT_MESSAGE_ID });
+      }
+    },
+  }),
+});

package/src/rules/no-rename-imports.spec.ts

@@ -0,0 +1,22 @@
+import { test } from "../test.spec.js";
+import { noRenameImports } from "./no-rename-imports.js";
+
+const valid = [
+  "import Foo from 'foo'",
+  "import {foo, bar} from 'foo'",
+  // ts
+  "import {type foo} from 'foo'",
+  "import type {foo} from 'foo'",
+  "import type Foo from 'foo'",
+];
+const invalid = [
+  "import {foo as bar} from 'foo'",
+  "import {default as foo} from 'foo'",
+  // ts
+  "import type {foo as bar} from 'foo'",
+  "import {type foo as bar} from 'foo'",
+  "import type {default as foo} from 'foo'",
+  "import {type default as foo} from 'foo'",
+];
+
+test({ valid, invalid, ...noRenameImports });

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

@@ -0,0 +1,13 @@
+import { createRule, DEFAULT_MESSAGE_ID, getRuleName } from "../common.js";
+
+export const noRenameImports = createRule({
+  name: getRuleName(import.meta.url),
+  message: "Disallow renaming the named-imports.",
+  create: (context) => ({
+    ImportSpecifier: (node) => {
+      if (node.imported.name !== node.local.name) {
+        context.report({ node, messageId: DEFAULT_MESSAGE_ID });
+      }
+    },
+  }),
+});

package/src/rules/no-side-effect-imports.spec.ts

@@ -0,0 +1,25 @@
+import { test } from "../test.spec.js";
+import { noSideEffectImports } from "./no-side-effect-imports.js";
+
+const valid = [
+  "import 'reflect-metadata'",
+  "import {} from 'reflect-metadata'",
+  "import 'foo.css'",
+  "import './foo.css'",
+  "import 'module.css'",
+  "import {foo} from 'foo'",
+]
+  .map((code) => ({ code, filename: "foo.ts" }))
+  .concat({ code: "import 'foo'", filename: "foo.d.ts" });
+
+const invalid = [
+  "import 'foo'",
+  "import './foo'",
+  "import {} from 'foo'",
+  "import {} from './foo'",
+  "import './reflect-metadata'",
+  "import './foo.module.css'",
+  "import 'foo.module.css'",
+].map((code) => ({ code, filename: "foo.ts" }));
+
+test({ valid, invalid, ...noSideEffectImports });

package/src/rules/no-side-effect-imports.ts

@@ -0,0 +1,44 @@
+import type { ImportDeclaration } from "estree";
+import { createRule, DEFAULT_MESSAGE_ID, getRuleName } from "../common.js";
+
+const ignores = [
+  "^reflect-metadata$",
+  // https://github.com/vitejs/vite/blob/main/packages/vite/client.d.ts
+  "(?<!\\.module)\\.css$",
+  "(?<!\\.module)\\.scss$",
+  "(?<!\\.module)\\.sass$",
+  "(?<!\\.module)\\.less$",
+  "(?<!\\.module)\\.styl$",
+  "(?<!\\.module)\\.stylus$",
+  "(?<!\\.module)\\.pcss$",
+  "(?<!\\.module)\\.sss$",
+];
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import
+export const noSideEffectImports = createRule({
+  name: getRuleName(import.meta.url),
+  message:
+    "Side effect import is often used for polyfills and css. It's unsafe to use it.",
+  create: (context) => {
+    if (
+      [".d.ts", ".d.cts", ".d.mts", ".d.tsx"].some((ext) =>
+        context.filename.endsWith(ext),
+      )
+    ) {
+      return {};
+    }
+    const ignoreExps = ignores.map((ignore) => new RegExp(ignore));
+    return {
+      "ImportDeclaration[specifiers.length=0]": (node: ImportDeclaration) => {
+        if (
+          ignoreExps.some((exp) =>
+            exp.test(node.source.value?.toString() ?? ""),
+          )
+        ) {
+          return;
+        }
+        context.report({ node, messageId: DEFAULT_MESSAGE_ID });
+      },
+    };
+  },
+});

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

@@ -0,0 +1,39 @@
+import { test } from "../test.spec.js";
+import { noTsFileImports } from "./no-ts-file-imports.js";
+
+const codes = [
+  "import foo from './foo.ts'",
+  "import foo from './foo.cts'",
+  "import foo from './foo.mts'",
+  "import foo from './foo.tsx'",
+
+  "import foo from 'foo.d.bar'",
+  "import foo from './foo.d.bar'",
+  "import foo from './foo/foo.d.bar'",
+
+  "import foo from './foo.d.ts'",
+  "import foo from './foo.d.cts'",
+  "import foo from './foo.d.mts'",
+  "import foo from './foo.d.tsx'",
+
+  "import foo from './foo.d.js'",
+  "import foo from './foo.d.cjs'",
+  "import foo from './foo.d.mjs'",
+  "import foo from './foo.d.jsx'",
+
+  "import foo from '/foo.ts'",
+  "import foo from '/foo.d.js'",
+];
+
+const invalid = codes.flatMap((code) => [
+  { code, filename: "bar.js" },
+  { code, filename: "bar" },
+  { code, filename: "bar.ts" },
+  { code, filename: "bar.tsx" },
+]);
+const valid = codes.flatMap((code) => [
+  { code, filename: "bar.d.ts" },
+  { code, filename: "bar.d.tsx" },
+]);
+
+test({ valid, invalid, ...noTsFileImports });

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));
+}