eslint-plugin-esm 0.8.1 → 0.8.2

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

@@ -1,58 +0,0 @@
-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.ts";
-import { memoize } from "../utils.ts";
-
-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
-        // Adding `stdio: 'pipe'` to depress unexpected error messages in console.
-        // For example, `git check-ignore /absolute/path/to/file` (even wrapped with try-catch) will print something unnecessary.
-        .execSync(`git check-ignore ${filePath}`, {
-          encoding: "utf8",
-          stdio: "pipe",
-        })
-        .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.test.ts

@@ -1,35 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noPhantomDepImports } from "./no-phantom-dep-imports.ts";
-
-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 'estree'" },
-  { code: "import type {Foo} from 'eslint'" },
-  {
-    code: "import foo from '@fenge/dev-utils'",
-    options: [{ allowDevDependencies: true }],
-  },
-];
-
-const invalid = [
-  {
-    code: "import type foo from 'foo'",
-    options: [{ allowDevDependencies: true }],
-  },
-  {
-    code: "import type foo from 'foo'",
-    options: [{ allowDevDependencies: false }],
-  },
-  { code: "import {type Foo} from 'foo'" },
-  { code: "import foo from 'foo'" },
-
-  { code: "import {type Foo} from 'eslint'" },
-  { code: "import {Foo} from 'eslint'" },
-  { code: "import eslint from 'eslint'" },
-];
-
-test({ valid, invalid, ...noPhantomDepImports });

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

@@ -1,124 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import process from "node:process";
-import { create, createRule, getRuleName, getSourceType } from "../common.ts";
-
-function isObject(value: unknown) {
-  return value !== null && typeof value === "object";
-}
-
-function isFile(filePath: string) {
-  try {
-    return fs.statSync(filePath).isFile();
-  } catch {
-    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.",
-  schema: [
-    {
-      type: "object",
-      properties: {
-        allowDevDependencies: { type: "boolean" },
-      },
-      additionalProperties: false,
-    },
-  ],
-  create: (context) =>
-    create(context, (filename, source, node) => {
-      const option = context.options[0];
-      // default false
-      const allowDevDependencies: boolean =
-        (typeof option === "object" &&
-          option &&
-          "allowDevDependencies" in option &&
-          typeof option.allowDevDependencies === "boolean" &&
-          option.allowDevDependencies) ??
-        false;
-
-      // ignore `import {foo} from './'`
-      // check `import {foo} from 'node:foo'` and `import {foo} from 'foo'`
-      if (getSourceType(source) === "local") {
-        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 peerDep =
-        "peerDependencies" in pkgJson.content &&
-        isObject(pkgJson.content.peerDependencies)
-          ? pkgJson.content.peerDependencies
-          : {};
-      const devDep =
-        "devDependencies" in pkgJson.content &&
-        isObject(pkgJson.content.devDependencies)
-          ? pkgJson.content.devDependencies
-          : {};
-
-      // TODO: Optimize the error message which is reported on `import foo from 'node:foo'`
-      // 1. check `import foo from 'node:foo'`
-      if (source.startsWith("node:")) {
-        return !("@types/node" in devDep || "@types/node" in dep);
-      }
-
-      // 2. check `import foo from 'foo'`
-      const moduleName = source
-        .split("/")
-        .slice(0, source.startsWith("@") ? 2 : 1)
-        .join("/");
-
-      const isInDep = moduleName in dep || moduleName in peerDep;
-      const isInDev = moduleName in devDep;
-      if ("importKind" in node && node.importKind === "type") {
-        const typeDepName = moduleName.startsWith("@")
-          ? `@types/${moduleName.slice(1).replace("/", "__")}`
-          : `@types/${moduleName}`;
-        return !(
-          isInDep ||
-          isInDev ||
-          typeDepName in dep ||
-          typeDepName in devDep
-        );
-      } else {
-        return allowDevDependencies ? !(isInDep || isInDev) : !isInDep;
-      }
-    }),
-});

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

@@ -1,28 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noRelativeParentImports } from "./no-relative-parent-imports.ts";
-
-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

@@ -1,13 +0,0 @@
-import { create, createRule, getRuleName } from "../common.ts";
-
-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.toString()},}`).test(source);
-}

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

@@ -1,22 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noRenameExports } from "./no-rename-exports.ts";
-
-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

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

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

@@ -1,22 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noRenameImports } from "./no-rename-imports.ts";
-
-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

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

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

@@ -1,24 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noSideEffectImports } from "./no-side-effect-imports.ts";
-
-const valid = [
-  "import 'reflect-metadata'",
-  "import {} from 'reflect-metadata'",
-  "import {foo} from 'foo'",
-];
-
-const invalid = [
-  "import 'foo'",
-  "import './foo'",
-  "import {} from 'foo'",
-  "import {} from './foo'",
-  "import './reflect-metadata'",
-  "import './foo.module.css'",
-  "import 'foo.module.css'",
-
-  "import 'foo.css'",
-  "import './foo.css'",
-  "import 'module.css'",
-];
-
-test({ valid, invalid, ...noSideEffectImports });

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

@@ -1,39 +0,0 @@
-import type { ImportDeclaration } from "estree";
-import { createRule, DEFAULT_MESSAGE_ID, getRuleName } from "../common.ts";
-
-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) => {
-    const ignoreExps = ignores.map((ignore) => new RegExp(ignore));
-    return {
-      "ImportDeclaration[specifiers.length=0]": (node: ImportDeclaration) => {
-        if (
-          ignoreExps.some(
-            (exp) =>
-              typeof node.source.value === "string" &&
-              exp.test(node.source.value),
-          )
-        ) {
-          return;
-        }
-        context.report({ node, messageId: DEFAULT_MESSAGE_ID });
-      },
-    };
-  },
-});

package/src/rules/no-useless-path-segments.test.ts

@@ -1,52 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { noUselessPathSegments } from "./no-useless-path-segments.ts";
-
-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"',
-
-  'import foo from "."',
-  "import foo from '..'",
-  "import foo from '../..'",
-].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"',
-
-  'import foo from "./"',
-  "import foo from '../'",
-  "import foo from '../../'",
-  "import foo from './..'",
-].map((code) => ({ code, filename: "/a/b/c/d/e.js" }));
-
-test({ valid, invalid, ...noUselessPathSegments });

package/src/rules/no-useless-path-segments.ts

@@ -1,31 +0,0 @@
-import path from "node:path";
-import { create, createRule, getRuleName, getSourceType } from "../common.ts";
-
-export const noUselessPathSegments = 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("/") ||
-    source === "."
-  ) {
-    return false;
-  }
-  if (source.endsWith("/")) {
-    return true;
-  }
-  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/required-exports.test.ts

@@ -1,24 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { requiredExports } from "./required-exports.ts";
-
-const valid = [
-  "export {}",
-  "const foo = 'foo'; export {foo}",
-  "export const foo = {}",
-  "export default {}",
-  "export {foo} from 'foo'",
-  "export {} from 'foo'",
-  "export * as foo from 'foo'",
-  "export {}; let foo = ''",
-];
-
-const invalid = [
-  "// This rule will also report on empty files",
-  "",
-  "console.log()",
-  "import foo from 'foo'",
-  "exports.foo = {}",
-  "module.exports = {}",
-];
-
-test({ valid, invalid, ...requiredExports });

package/src/rules/required-exports.ts

@@ -1,22 +0,0 @@
-import { createRule, DEFAULT_MESSAGE_ID, getRuleName } from "../common.ts";
-
-export const requiredExports = createRule({
-  name: getRuleName(import.meta.url),
-  message: "It's required at least one `export` statement in a file.",
-  create: (context) => {
-    let existExport = false;
-    const hasExport = () => {
-      existExport = true;
-    };
-    return {
-      ExportAllDeclaration: () => hasExport(),
-      ExportDefaultDeclaration: () => hasExport(),
-      ExportNamedDeclaration: () => hasExport(),
-      "Program:exit": (node) => {
-        if (!existExport) {
-          context.report({ node, messageId: DEFAULT_MESSAGE_ID });
-        }
-      },
-    };
-  },
-});

package/src/rules/top-side-effect-imports.test.ts

@@ -1,24 +0,0 @@
-import { test } from "@fenge/dev-utils";
-import { topSideEffectImports } from "./top-side-effect-imports.ts";
-
-const valid = [
-  "import 'reflect-metadata'; import {foo} from 'foo'",
-  "import 'foo.css'; import {bar} from 'bar'",
-  "import 'reflect-metadata'; import 'foo.css'",
-  "import 'foo.css'; import 'bar'",
-  "import 'reflect-metadata'; import {foo} from 'foo'; import {bar} from 'bar'",
-  "import 'foo.css'; import {foo} from 'foo'; import {bar} from 'bar'",
-  "import 'reflect-metadata'", // Single side-effect import
-  "import {foo} from 'foo'", // Single non-side-effect import
-];
-
-const invalid = [
-  "import {foo} from 'foo'; import 'reflect-metadata'",
-  "import {bar} from 'bar'; import 'foo.css'",
-  "import {foo} from 'foo'; import {} from 'bar'",
-  "import {foo} from 'foo'; import 'bar'; import * as foo from 'reflect-metadata'", // Three import statements
-  "import {foo} from 'foo'; import {} from 'reflect-metadata'; import * as bar from 'bar'", // Three import statements
-  "import 'bar'; import r from 'reflect-metadata'; import {} from 'foo'", // Three import statements
-];
-
-test({ valid, invalid, ...topSideEffectImports });

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

@@ -1,22 +0,0 @@
-import type { ImportDeclaration } from "estree";
-import { createRule, DEFAULT_MESSAGE_ID, getRuleName } from "../common.ts";
-
-export const topSideEffectImports = createRule({
-  name: getRuleName(import.meta.url),
-  message: "Side effect imports must be placed before other import statements.",
-  create: (context) => {
-    let hasNonSideEffectImport = false;
-
-    return {
-      ImportDeclaration: (node: ImportDeclaration) => {
-        if (node.specifiers.length > 0) {
-          hasNonSideEffectImport = true;
-          return;
-        }
-        if (hasNonSideEffectImport) {
-          context.report({ node, messageId: DEFAULT_MESSAGE_ID });
-        }
-      },
-    };
-  },
-});

package/src/utils.ts

@@ -1,18 +0,0 @@
-/**
- * Like [lodash.memoize](https://lodash.com/docs/4.17.15#memoize)
- * Type `Res` must be non-nullable, otherwise it will cause bug.
- */
-export function memoize<Arg, Res extends NonNullable<unknown>>(
-  fn: (arg: Arg) => Res,
-): (arg: Arg) => Res {
-  const cache = new Map<Arg, Res>(); // memory leak
-  return (arg: Arg) => {
-    const cachedResult = cache.get(arg);
-    if (cachedResult !== undefined) {
-      return cachedResult;
-    }
-    const result = fn(arg);
-    cache.set(arg, result);
-    return result;
-  };
-}

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig",
-  "include": ["src"],
-  "exclude": ["**/*.test.ts"]
-}