@plugjs/eslint-plugin 0.1.23 → 0.2.0-beta.2

package/README.md

@@ -1,19 +1,55 @@
-PlugJS ESLint Shared Configuration
-==================================
+PlugJS ESLint (v9) Shared Configuration
+=======================================
 
-This package exports simple configurations for linting our project. It's the
+This package exports simple configurations for linting our projects. It's the
 easiest way to actually share some configs and plugins.
 
-Just add in your `.eslintrc.cjs` something similar to:
+Just add in your `eslint.config.mjs` something similar to:
 
 ```javascript
-module.exports = {
-  root: true,
-  extends: [
-    'plugin:@plugjs/typescript',
-  ],
-}
+import configurations from '@plugjs/eslint-plugin'
+
+export default [
+  ...configurations,
+  // any other configuration you might want to add for your project...
+]
 ```
 
+This includes a number of configurations:
+
+* `eslint-recommended`: recommended JavaScript config from ESLint.
+
+* `plugjs-base`: basic configuration of ESLint rules.
+* `plugjs-stylistic`: style shared between JavaScript and TypeScript.
+* `plugjs-unicorn`: extra niceties from the ESLint Unicorn plugin.
+* `plugjs-importx`: defines the style of our imports.
+
+* `plugjs-javascript`: basic extra rules for JavaScript sources.
+* `plugjs-javascript-cjs`: marks `*.cjs` files as `commonjs`.
+* `plugjs-javascript-mjs`: marks `*.mjs` files as `module`.
+
+* `typescript-eslint/recommended`: imports all the configurations from
+  TypeScript ESlint recommended, but restrict them to operate only on
+  `.ts`, `.cts`, and `.mts` files. This *should* include:
+  * `typescript-eslint/base`: basic parser configuration.
+  * `typescript-eslint/eslint-recommended`: disable ESLint rules conflicting
+    with TypeScript.
+  * `typescript-eslint/recommended`: recommended config for TypeScript
+* `plugjs-typescript`: our rules overriding `typescript-eslint/recommended`.
+
+Notes on building
+-----------------
+
+During this transitional period (ESLint from v8 to v9, and TypeScript ESLint
+from v7 to v8) a number of plugins, even if they are working, are specifying
+wrong/old dependencies in their packages.
+
+For those plugins, we bundle them up and ship them with this plugin, and
+hopefully we'll be able to un-bundle them as the various packages move in their
+transitions.
+
+Legal Stuff
+-----------
+
 * [Copyright Notice](NOTICE.md)
 * [License](LICENSE.md)

package/bundles/eslint-import-resolver-node.cjs

@@ -0,0 +1,64 @@
+"use strict";
+
+// node_modules/eslint-import-resolver-node/index.js
+var resolve = require("resolve/sync");
+var isCoreModule = require("is-core-module");
+var path = require("path");
+var log = require("debug")("eslint-plugin-import:resolver:node");
+exports.interfaceVersion = 2;
+exports.resolve = function(source, file, config) {
+  log("Resolving:", source, "from:", file);
+  let resolvedPath;
+  if (isCoreModule(source)) {
+    log("resolved to core");
+    return { found: true, path: null };
+  }
+  try {
+    const cachedFilter = function(pkg, dir) {
+      return packageFilter(pkg, dir, config);
+    };
+    resolvedPath = resolve(source, opts(file, config, cachedFilter));
+    log("Resolved to:", resolvedPath);
+    return { found: true, path: resolvedPath };
+  } catch (err) {
+    log("resolve threw error:", err);
+    return { found: false };
+  }
+};
+function opts(file, config, packageFilter2) {
+  return Object.assign({
+    // more closely matches Node (#333)
+    // plus 'mjs' for native modules! (#939)
+    extensions: [".mjs", ".js", ".json", ".node"]
+  }, config, {
+    // path.resolve will handle paths relative to CWD
+    basedir: path.dirname(path.resolve(file)),
+    packageFilter: packageFilter2
+  });
+}
+function identity(x) {
+  return x;
+}
+function packageFilter(pkg, dir, config) {
+  let found = false;
+  const file = path.join(dir, "dummy.js");
+  if (pkg.module) {
+    try {
+      resolve(String(pkg.module).replace(/^(?:\.\/)?/, "./"), opts(file, config, identity));
+      pkg.main = pkg.module;
+      found = true;
+    } catch (err) {
+      log("resolve threw error trying to find pkg.module:", err);
+    }
+  }
+  if (!found && pkg["jsnext:main"]) {
+    try {
+      resolve(String(pkg["jsnext:main"]).replace(/^(?:\.\/)?/, "./"), opts(file, config, identity));
+      pkg.main = pkg["jsnext:main"];
+      found = true;
+    } catch (err) {
+      log("resolve threw error trying to find pkg['jsnext:main']:", err);
+    }
+  }
+  return pkg;
+}

package/bundles/eslint-import-resolver-typescript.cjs

@@ -0,0 +1,277 @@
+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);
+
+// node_modules/eslint-import-resolver-typescript/lib/index.js
+var lib_exports = {};
+__export(lib_exports, {
+  defaultConditionNames: () => defaultConditionNames,
+  defaultExtensionAlias: () => defaultExtensionAlias,
+  defaultExtensions: () => defaultExtensions,
+  defaultMainFields: () => defaultMainFields,
+  interfaceVersion: () => interfaceVersion,
+  resolve: () => resolve
+});
+module.exports = __toCommonJS(lib_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_debug = __toESM(require("debug"), 1);
+var import_enhanced_resolve = __toESM(require("enhanced-resolve"), 1);
+var import_hash = require("eslint-module-utils/hash.js");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_get_tsconfig = require("get-tsconfig");
+var import_is_core_module = __toESM(require("is-core-module"), 1);
+var import_is_glob = __toESM(require("is-glob"), 1);
+var { globSync } = import_fast_glob.default;
+var IMPORTER_NAME = "eslint-import-resolver-typescript";
+var log = (0, import_debug.default)(IMPORTER_NAME);
+var defaultConditionNames = [
+  "types",
+  "import",
+  "esm2020",
+  "es2020",
+  "es2015",
+  "require",
+  "node",
+  "node-addons",
+  "browser",
+  "default"
+];
+var defaultExtensions = [
+  ".ts",
+  ".tsx",
+  ".d.ts",
+  ".js",
+  ".jsx",
+  ".json",
+  ".node"
+];
+var defaultExtensionAlias = {
+  ".js": [
+    ".ts",
+    ".tsx",
+    ".d.ts",
+    ".js"
+  ],
+  ".jsx": [".tsx", ".d.ts", ".jsx"],
+  ".cjs": [".cts", ".d.cts", ".cjs"],
+  ".mjs": [".mts", ".d.mts", ".mjs"]
+};
+var defaultMainFields = [
+  "types",
+  "typings",
+  "fesm2020",
+  "fesm2015",
+  "esm2020",
+  "es2020",
+  "module",
+  "jsnext:main",
+  "main"
+];
+var interfaceVersion = 2;
+var fileSystem = import_node_fs.default;
+var JS_EXT_PATTERN = /\.(?:[cm]js|jsx?)$/;
+var RELATIVE_PATH_PATTERN = /^\.{1,2}(?:\/.*)?$/;
+var previousOptionsHash;
+var optionsHash;
+var cachedOptions;
+var prevCwd;
+var mappersCachedOptions;
+var mappers;
+var resolverCachedOptions;
+var resolver;
+var digestHashObject = (value) => (0, import_hash.hashObject)(value ?? {}).digest("hex");
+function resolve(source, file, options) {
+  if (!cachedOptions || previousOptionsHash !== (optionsHash = digestHashObject(options))) {
+    previousOptionsHash = optionsHash;
+    cachedOptions = {
+      ...options,
+      conditionNames: options?.conditionNames ?? defaultConditionNames,
+      extensions: options?.extensions ?? defaultExtensions,
+      extensionAlias: options?.extensionAlias ?? defaultExtensionAlias,
+      mainFields: options?.mainFields ?? defaultMainFields,
+      fileSystem: new import_enhanced_resolve.default.CachedInputFileSystem(fileSystem, 5 * 1e3),
+      useSyncFileSystemCalls: true
+    };
+  }
+  if (!resolver || resolverCachedOptions !== cachedOptions) {
+    resolver = import_enhanced_resolve.default.ResolverFactory.createResolver(cachedOptions);
+    resolverCachedOptions = cachedOptions;
+  }
+  log("looking for:", source);
+  source = removeQuerystring(source);
+  if ((0, import_is_core_module.default)(source)) {
+    log("matched core:", source);
+    return {
+      found: true,
+      path: null
+    };
+  }
+  initMappers(cachedOptions);
+  const mappedPath = getMappedPath(source, file, cachedOptions.extensions, true);
+  if (mappedPath) {
+    log("matched ts path:", mappedPath);
+  }
+  let foundNodePath;
+  try {
+    foundNodePath = resolver.resolveSync({}, import_node_path.default.dirname(import_node_path.default.resolve(file)), mappedPath ?? source) || null;
+  } catch {
+    foundNodePath = null;
+  }
+  if ((JS_EXT_PATTERN.test(foundNodePath) || cachedOptions.alwaysTryTypes && !foundNodePath) && !/^@types[/\\]/.test(source) && !import_node_path.default.isAbsolute(source) && !source.startsWith(".")) {
+    const definitelyTyped = resolve("@types" + import_node_path.default.sep + mangleScopedPackage(source), file, options);
+    if (definitelyTyped.found) {
+      return definitelyTyped;
+    }
+  }
+  if (foundNodePath) {
+    log("matched node path:", foundNodePath);
+    return {
+      found: true,
+      path: foundNodePath
+    };
+  }
+  log("didn't find ", source);
+  return {
+    found: false
+  };
+}
+function removeQuerystring(id) {
+  const querystringIndex = id.lastIndexOf("?");
+  if (querystringIndex >= 0) {
+    return id.slice(0, querystringIndex);
+  }
+  return id;
+}
+var isFile = (path2) => {
+  try {
+    return !!(path2 && import_node_fs.default.statSync(path2, { throwIfNoEntry: false })?.isFile());
+  } catch {
+    return false;
+  }
+};
+var isModule = (modulePath) => {
+  return !!modulePath && isFile(import_node_path.default.resolve(modulePath, "package.json"));
+};
+function getMappedPath(source, file, extensions = defaultExtensions, retry) {
+  const originalExtensions = extensions;
+  extensions = ["", ...extensions];
+  let paths = [];
+  if (RELATIVE_PATH_PATTERN.test(source)) {
+    const resolved = import_node_path.default.resolve(import_node_path.default.dirname(file), source);
+    if (isFile(resolved)) {
+      paths = [resolved];
+    }
+  } else {
+    paths = mappers.map((mapper) => mapper?.(source).map((item) => [
+      ...extensions.map((ext) => `${item}${ext}`),
+      ...originalExtensions.map((ext) => `${item}/index${ext}`)
+    ])).flat(2).filter((mappedPath) => {
+      if (mappedPath === void 0) {
+        return false;
+      }
+      try {
+        const stat = import_node_fs.default.statSync(mappedPath, { throwIfNoEntry: false });
+        if (stat === void 0)
+          return false;
+        if (stat.isFile())
+          return true;
+        if (stat.isDirectory()) {
+          return isModule(mappedPath);
+        }
+      } catch {
+        return false;
+      }
+      return false;
+    });
+  }
+  if (retry && paths.length === 0) {
+    const isJs = JS_EXT_PATTERN.test(source);
+    if (isJs) {
+      const jsExt = import_node_path.default.extname(source);
+      const tsExt = jsExt.replace("js", "ts");
+      const basename = source.replace(JS_EXT_PATTERN, "");
+      const resolved = getMappedPath(basename + tsExt, file) || getMappedPath(basename + ".d" + (tsExt === ".tsx" ? ".ts" : tsExt), file);
+      if (resolved) {
+        return resolved;
+      }
+    }
+    for (const ext of extensions) {
+      const resolved = (isJs ? null : getMappedPath(source + ext, file)) || getMappedPath(source + `/index${ext}`, file);
+      if (resolved) {
+        return resolved;
+      }
+    }
+  }
+  if (paths.length > 1) {
+    log("found multiple matching ts paths:", paths);
+  }
+  return paths[0];
+}
+function initMappers(options) {
+  if (mappers && mappersCachedOptions === options && prevCwd === process.cwd()) {
+    return;
+  }
+  prevCwd = process.cwd();
+  const configPaths = typeof options.project === "string" ? [options.project] : Array.isArray(options.project) ? options.project : [process.cwd()];
+  const ignore = ["!**/node_modules/**"];
+  const projectPaths = [
+    .../* @__PURE__ */ new Set([
+      ...configPaths.filter((path2) => !(0, import_is_glob.default)(path2)),
+      ...globSync([...configPaths.filter((path2) => (0, import_is_glob.default)(path2)), ...ignore])
+    ])
+  ];
+  mappers = projectPaths.map((projectPath) => {
+    let tsconfigResult;
+    if (isFile(projectPath)) {
+      const { dir, base } = import_node_path.default.parse(projectPath);
+      tsconfigResult = (0, import_get_tsconfig.getTsconfig)(dir, base);
+    } else {
+      tsconfigResult = (0, import_get_tsconfig.getTsconfig)(projectPath);
+    }
+    return tsconfigResult && (0, import_get_tsconfig.createPathsMatcher)(tsconfigResult);
+  });
+  mappersCachedOptions = options;
+}
+function mangleScopedPackage(moduleName) {
+  if (moduleName.startsWith("@")) {
+    const replaceSlash = moduleName.replace(import_node_path.default.sep, "__");
+    if (replaceSlash !== moduleName) {
+      return replaceSlash.slice(1);
+    }
+  }
+  return moduleName;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultConditionNames,
+  defaultExtensionAlias,
+  defaultExtensions,
+  defaultMainFields,
+  interfaceVersion,
+  resolve
+});