@darksheep/eslint 4.1.3

package/src/utilities/filesystem.js

@@ -0,0 +1,73 @@
+import * as Path from 'node:path';
+import { stat } from 'node:fs/promises';
+
+/**
+ * @param {string} path The absolute path to the file to check
+ * @returns {Promise<boolean>}
+ */
+export async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Does {filePath} exist in {projectPath}
+ * @param {string} [filePath] The path of the file to check
+ * @param {string} [projectPath] The path to the project root
+ * @returns {boolean}
+ */
+export function descendsFrom(filePath, projectPath) {
+    if (
+        typeof filePath !== 'string' ||
+        typeof projectPath !== 'string'
+    ) {
+        return false;
+    }
+
+    return Path.relative(projectPath, filePath).startsWith('..') === false;
+}
+
+/**
+ * Create a list of parent directories from {filepath} to {stopDirectory}
+ * @param {string} filepath The file to start from
+ * @param {string} [stopDirectory] The directory to stop at
+ * @returns {string[]}
+ */
+export function listParents(filepath, stopDirectory = '/') {
+    // The file is not from within the stopDirectory
+    if (descendsFrom(filepath, stopDirectory) === false) {
+        return [];
+    }
+
+    const output = [];
+    const end = Path.resolve(stopDirectory);
+    do {
+        filepath = Path.dirname(filepath);
+        output.push(filepath);
+    } while (end !== filepath);
+
+    return output;
+}
+
+/**
+ * Find the closest {filename} starting from {rootFilePath}
+ * @param {string} rootFilePath The file to start the search from
+ * @param {string} filename The filename to find
+ * @param {string} [stopDirectory] The directory to stop searching at
+ * @returns {Promise<string|null>} Returns absolute path to the closest {filename} if found
+ */
+export async function findUp(rootFilePath, filename, stopDirectory = Path.resolve('/')) {
+    for (const directory of listParents(rootFilePath, stopDirectory)) {
+        const target = Path.join(directory, filename);
+
+        if (await exists(target)) {
+            return target;
+        }
+    }
+
+    return null;
+}

package/src/utilities/make-compat.js

@@ -0,0 +1,17 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { FlatCompat } from '@eslint/eslintrc';
+
+/**
+ * @param {import('node:url').URL} root root url
+ * @returns {import('@eslint/eslintrc').FlatCompat}
+ */
+export function makeCompat(root) {
+    return new FlatCompat({
+        // The root of the importing project
+        baseDirectory: fileURLToPath(root),
+        // The root of our project
+        resolvePluginsRelativeTo: resolve(fileURLToPath(import.meta.url), '..', '..', '..'),
+    });
+}

package/src/utilities/package.js

@@ -0,0 +1,49 @@
+import { createRequire } from 'node:module';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { findUp } from './filesystem.js';
+
+const errorCodesToSkip = new Set([
+    'ENOENT',
+    'MODULE_NOT_FOUND',
+]);
+
+const cache = new Map();
+
+/**
+ * Get the path of the eslint package json
+ * @param {import('node:url').URL} root root url
+ * @param {string} [packageName] The name of the npm package
+ * @returns {Promise<import('type-fest').PackageJson | null>}
+ */
+export async function getPackageJson(root, packageName) {
+    const rootPath = fileURLToPath(root);
+    if (cache.has(`${root}::${packageName}`)) {
+        return cache.get(`${root}::${packageName}`);
+    }
+    try {
+        const require = createRequire(root);
+        const path = typeof packageName === 'string'
+            ? require.resolve(packageName)
+            : rootPath;
+        const jsonPath = await findUp(path, 'package.json');
+
+        if (jsonPath == null) {
+            return null;
+        }
+
+        const result = JSON.parse(await readFile(jsonPath, 'utf8'));
+        cache.set(`${root}::${packageName}`, result);
+        return result;
+    } catch (error) {
+        const shouldSkip = errorCodesToSkip.has(
+            /** @type {Error & {code: string}} */ (error).code,
+        );
+
+        if (shouldSkip === false) {
+            throw error;
+        }
+
+        return null;
+    }
+}