@open-xchange/linter-presets 0.0.6 → 0.1.0

package/{lib → dist}/eslint/rules/no-invalid-modules.js

@@ -18,23 +18,15 @@
  * Any use of the work other than as authorized under this license or copyright law is prohibited.
  *
  */
-
 import { createRequire } from "node:module";
 import { posix, dirname, extname } from "node:path";
-
 import { packageUpSync } from "package-up";
-
+import { AST_NODE_TYPES as NodeType, ESLintUtils } from "@typescript-eslint/utils";
 import { Schema, makeArray, toPosixPath, isFile, matchModuleName, getModuleName } from "../shared/rule-utils.js";
-
 // constants ==================================================================
-
 const FILE_EXTENSIONS = ["js", "ts", "d.ts"];
-
 // exports ====================================================================
-
-/** @type {import("eslint").Rule.RuleModule} */
-export default {
-
+export default ESLintUtils.RuleCreator.withoutDocs({
     meta: {
         type: "problem",
         schema: [
@@ -56,47 +48,37 @@ export default {
         },
         fixable: "code",
     },
-
-    create(context) {
-
-        // resolve and decompose rule settings
-        const {
-            alias = {},
-            external: externalModules = [],
-            packages = {},
-        } = context.options[0] || {};
-
+    defaultOptions: [{
+            alias: {},
+            external: [],
+            packages: {},
+        }],
+    create(context, [options]) {
         // convert "alias" option to map
-        const aliasMap = new Map(Object.entries(alias));
-
-        // convert "packages" options (strings to arrays)
+        const aliasMap = new Map(Object.entries(options.alias));
         const packagesMap = new Map();
-        for (const [key, settings] of Object.entries(packages)) {
+        for (const [key, settings] of Object.entries(options.packages)) {
             packagesMap.set(key, {
                 ...settings,
                 src: makeArray(settings.src),
                 extends: makeArray(settings.extends),
             });
         }
-
         // collect all globs for package members
         const packagesGlobs = Array.from(packagesMap.values(), settings => settings.src).flat();
-
         // resolve file name
         const packagePath = packageUpSync();
-        const rootDir = toPosixPath(dirname(packagePath));
+        const rootDir = packagePath && toPosixPath(dirname(packagePath));
         const fileName = toPosixPath(context.filename);
-        if (!fileName.startsWith(rootDir + "/")) {
+        if (!rootDir || !fileName.startsWith(rootDir + "/")) {
             throw new Error("invalid root directory");
         }
-
         // path of current module (slice rootDir with "/" from start, and extension with "." from end)
         const fileExt = extname(fileName);
         const selfModulePath = fileName.slice(rootDir.length + 1, -fileExt.length);
         if (!selfModulePath) {
             throw new Error("invalid own module path");
         }
-
         // replace alias path with alias key
         let selfModuleName = selfModulePath;
         for (const [aliasKey, aliasPath] of aliasMap) {
@@ -105,88 +87,83 @@ export default {
                 break;
             }
         }
-
         // returns an existing alias key used by the passed module name
-        const resolveAlias = moduleName => {
+        const resolveAlias = (moduleName) => {
             const [key, ...rest] = moduleName.split("/");
             const aliasPath = (key && rest[0]) ? aliasMap.get(key) : undefined;
             const aliasKey = aliasPath ? key : "";
             const modulePath = aliasPath ? posix.join(aliasPath, ...rest) : moduleName;
-            return { aliasKey, modulePath };
+            return [aliasKey, modulePath];
         };
-
         // returns whether a source file exists for the specified module
-        const fileExists = resolvedName => {
+        const fileExists = (resolvedName) => {
             // check modules with explicit extension
             const resolvedPath = posix.join(rootDir, resolvedName);
-            if (extname(resolvedName)) { return isFile(resolvedPath); }
+            if (extname(resolvedName)) {
+                return isFile(resolvedPath);
+            }
             // search for a file with a known extension
             return FILE_EXTENSIONS.some(ext => isFile(resolvedPath + "." + ext));
         };
-
         // returns whether the passed module name is an installed NPM package
         const requireModule = createRequire(packagePath);
-        const packageExists = moduleName => {
+        const packageExists = (moduleName) => {
             try {
                 requireModule.resolve(moduleName);
                 return true;
-            } catch {
+            }
+            catch {
                 return false;
             }
         };
-
         return {
             "ImportDeclaration, TSExternalModuleReference, ImportExpression, ExportAllDeclaration, ExportNamedDeclaration"(node) {
-
                 // import/export statement must contain string literal
                 const { sourceNode, moduleName } = getModuleName(node);
-                if (!sourceNode || !moduleName) { return; }
-
+                if (!sourceNode || !moduleName) {
+                    return;
+                }
                 // skip glob patterns in TypeScript type imports
-                if ((node.type === "ImportDeclaration") && (node.importKind === "type") && moduleName.includes("*")) {
+                if ((node.type === NodeType.ImportDeclaration) && (node.importKind === "type") && moduleName.includes("*")) {
                     return;
                 }
-
                 // extract alias key, replace with alias path
-                const { aliasKey, modulePath } = resolveAlias(moduleName);
-
+                const [aliasKey, modulePath] = resolveAlias(moduleName);
                 // whether the import is a known external module
-                const isExternal = !aliasKey && matchModuleName(moduleName, externalModules);
-
+                const isExternal = !aliasKey && matchModuleName(moduleName, options.external);
                 // whether the import is an installed NPM package
                 const isPackage = !isExternal && !aliasKey && packageExists(moduleName);
-
                 // check existence of source file
                 if (!isExternal && !isPackage && !fileExists(modulePath)) {
                     context.report({ messageId: "SOURCE_FILE_NOT_FOUND", node: sourceNode, data: { moduleName } });
                     return;
                 }
-
                 // check dependencies if the imported module is covered in the configuration
-                if (!matchModuleName(moduleName, packagesGlobs)) { return; }
-
+                if (!matchModuleName(moduleName, packagesGlobs)) {
+                    return;
+                }
                 // check package dependencies
                 // whether an invalid static import has been found
                 let invalidStatic = false;
-
                 // recursively checks the imported module for dependency violations
                 const checkDependencies = (settings, root) => {
-
                     // only allow static imports from specified package, if it is not optional
                     if (matchModuleName(moduleName, settings.src)) {
-                        if (!root && (node.type !== "ImportExpression") && settings.optional) { invalidStatic = true; }
+                        if (!root && (node.type !== NodeType.ImportExpression) && settings.optional) {
+                            invalidStatic = true;
+                        }
                         return true;
                     }
-
                     // do not traverse into dependencies of optional modules
                     if (!settings.extends.length || (!root && settings.optional)) {
                         return false;
                     }
-
                     // allow imports from any of the dependent packages
-                    return settings.extends.some(key => checkDependencies(packagesMap.get(key), false));
+                    return settings.extends.some(key => {
+                        const package2 = packagesMap.get(key);
+                        return !!package2 && checkDependencies(package2, false);
+                    });
                 };
-
                 // check dependencies of all configured packages (not for anonymous modules)
                 let invalidDeps = false;
                 for (const settings of packagesMap.values()) {
@@ -195,14 +172,14 @@ export default {
                         break;
                     }
                 }
-
                 // report package hierarchy errors
                 if (invalidStatic) {
                     context.report({ messageId: "UNEXPECTED_OPTIONAL_STATIC", node: sourceNode });
-                } else if (invalidDeps) {
+                }
+                else if (invalidDeps) {
                     context.report({ messageId: "INVALID_PACKAGE_HIERARCHY", node: sourceNode });
                 }
             },
         };
     },
-};
+});

package/dist/eslint/shared/env-utils.d.ts

@@ -0,0 +1,150 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+/**
+ * Configuration options for language and project setup.
+ */
+export interface LanguageOptions {
+    /**
+     * The ECMAScript version to be used in the project (version or year).
+     * Default value is `2022`.
+     */
+    ecmaVersion?: TSESLint.ParserOptions["ecmaVersion"];
+    /**
+     * Specifies how to treat `.js`, `.jsx`, `.ts`, and `.tsx` files.
+     *
+     * - "module": The files will be considered being ES modules.
+     * - "commonjs": The files will be considered being CommonJS modules.
+     *
+     * Default value is "module".
+     */
+    sourceType?: "module" | "commonjs";
+}
+/**
+ * Configuration options for code style.
+ */
+export interface StylisticOptions {
+    /**
+     * Default indentation size (number of space characters). Will be applied
+     * to JavaScript, TypeScript, JSON, and YAML files, as well as JSX markup.
+     * Default value is `2`.
+     */
+    indent?: number;
+    /**
+     * Specifies whether to require semicolons following all statements. By
+     * default, semicolons must be omitted if possible according to ASI rules.
+     */
+    semi?: boolean;
+    /**
+     * The type of the string delimiter character. Default value is "single".
+     */
+    quotes?: "single" | "double" | "off";
+    /**
+     * Specifies how to treat dangling commas in multiline lists.
+     *
+     * - "always": Dangling commas will be required in all multi-line array
+     *   literals, object literals, function parameters, template parameters,
+     *   imports, and exports.
+     * - "never": Dangling commas will be forbidden.
+     * - "off": Dangling commas will not be checked.
+     *
+     * Default value is "always".
+     */
+    dangle?: "always" | "never" | "off";
+}
+/**
+ * Shared options for an environment preset with included and excluded files.
+ */
+export interface EnvFilesOptions {
+    /**
+     * Glob patterns for source files to be included into the environment.
+     */
+    files: string[];
+    /**
+     * Glob patterns for source files matching `files` to be ignored.
+     */
+    ignores?: string[];
+}
+/**
+ * Shared options for an environment preset: include and exclude files, and add
+ * more linter rules.
+ */
+export interface EnvBaseOptions extends EnvFilesOptions {
+    /**
+     * Additional linter rules to be added to the configuration.
+     */
+    rules?: TSESLint.FlatConfig.Rules;
+}
+/**
+ * Configuration for a single banned global or import.
+ */
+export interface EnvRestrictedName {
+    name: string;
+    message: string;
+}
+/**
+ * Configuration for a single banned object property.
+ */
+export interface EnvRestrictedProperty {
+    object: string;
+    property: string;
+    message: string;
+}
+/**
+ * Configuration for a single banned syntax construct.
+ */
+export interface EnvRestrictedSyntax {
+    selector: string;
+    message: string;
+}
+/**
+ * Collection of banned globals, imports, properties, and syntax constructs.
+ */
+export interface EnvRestrictedItems {
+    /** The global symbols to be banned. */
+    globals?: EnvRestrictedName[];
+    /** The module imports to be banned. */
+    imports?: EnvRestrictedName[];
+    /** The global object properties to be banned. */
+    properties?: EnvRestrictedProperty[];
+    /** The syntax constructs to be banned. */
+    syntax?: EnvRestrictedSyntax[];
+}
+/**
+ * Collection of banned globals, imports, properties, and syntax constructs,
+ * for a specific subset of the files included in an environment.
+ */
+export interface EnvRestrictedOverride extends EnvFilesOptions, EnvRestrictedItems {
+}
+/**
+ * Configuration options for restricted imports and globals.
+ */
+export interface EnvRestrictedOptions extends EnvRestrictedItems {
+    overrides?: EnvRestrictedOverride[];
+}
+export interface EnvRestrictedRulesResult {
+    rules: TSESLint.FlatConfig.Rules;
+    overrides: TSESLint.FlatConfig.ConfigArray;
+}
+/**
+ * Shared options for the core rule `no-unused-vars`, and the plugin rule
+ * `@typescript-eslint/no-unused-vars`.
+ */
+export declare const NO_UNUSED_VARS_OPTIONS: {
+    varsIgnorePattern: string;
+    argsIgnorePattern: string;
+    destructuredArrayIgnorePattern: string;
+    caughtErrors: string;
+    ignoreRestSiblings: boolean;
+};
+/**
+ * Generates various "no-restricted-?" rules from the passed configuration.
+ *
+ * @param fixed
+ *  The fixed restricted items provided by the environment preset.
+ *
+ * @param options
+ *  The custom configuration passed to an environment preset.
+ *
+ * @returns
+ *  The generated linter rules to forbid the restricted items.
+ */
+export declare function generateRestrictedRules(fixed: EnvRestrictedItems, options?: EnvRestrictedOptions): EnvRestrictedRulesResult;

package/{lib → dist}/eslint/shared/env-utils.js

@@ -1,6 +1,4 @@
-
 // constants ==================================================================
-
 /**
  * Global symbols to be banned in all source code files.
  */
@@ -8,7 +6,6 @@ const RESTRICTED_GLOBALS = [
     { name: "isFinite", message: "Use 'Number.isFinite' instead." },
     { name: "isNaN", message: "Use 'Number.isNaN' instead." },
 ];
-
 /**
  * Syntax constructs to be banned in all source code files.
  */
@@ -17,7 +14,6 @@ const RESTRICTED_SYNTAX = [
     { selector: ":matches(PropertyDefinition, MethodDefinition[kind!='constructor'])[accessibility='private'][decorators.length=0]", message: "Use #private syntax instead." },
     { selector: "MethodDefinition[kind='constructor'] TSParameterProperty[accessibility]", message: "Use explicit class properties." },
 ];
-
 /**
  * Shared options for the core rule `no-unused-vars`, and the plugin rule
  * `@typescript-eslint/no-unused-vars`.
@@ -29,39 +25,36 @@ export const NO_UNUSED_VARS_OPTIONS = {
     caughtErrors: "all",
     ignoreRestSiblings: true,
 };
-
 // functions ==================================================================
-
 /**
- * Concatenates the elements of multiple arrays. Skips all nullish parameters.
+ * Concatenates the elements of multiple arrays. Skips `undefined` parameters.
  *
- * @template T
- *
- * @param {Array<T[] | undefined | null>} arrays
+ * @param arrays
  *  The arrays to be concatenated.
  *
- * @returns {T[]}
+ * @returns
  *  The concatenated arrays.
  */
 function concatArrays(...arrays) {
     return arrays.flatMap(array => array || []);
 }
-
 /**
  * Creates a rules record for all restricted items.
  *
- * @param {(key: string) => object[]} generator
+ * @param generator
  *  The generator callback function that returns the restricted items to be
  *  inserted into the linter rules.
  *
- * @returns {import("eslint").Linter.RulesRecord}
+ * @returns
  *  The rules record containing entries for all existing restricted items.
  */
 function createRulesRecord(generator) {
     const rules = {};
     for (const key of ["globals", "imports", "properties", "syntax"]) {
         const items = generator(key);
-        if (items?.length) { rules[`no-restricted-${key}`] = ["error", ...items]; }
+        if (items?.length) {
+            rules[`no-restricted-${key}`] = ["error", ...items];
+        }
     }
     // same restrictions for CommonJS `require` as for `import` statements
     if ("no-restricted-imports" in rules) {
@@ -69,21 +62,20 @@ function createRulesRecord(generator) {
     }
     return rules;
 }
-
+// ----------------------------------------------------------------------------
 /**
  * Generates various "no-restricted-?" rules from the passed configuration.
  *
- * @param {import("./env-utils").EnvRestrictedItems} fixed
+ * @param fixed
  *  The fixed restricted items provided by the environment preset.
  *
- * @param {import("./env-utils").EnvRestrictedOptions} [options]
+ * @param options
  *  The custom configuration passed to an environment preset.
  *
- * @returns {import("./env-utils").EnvRestrictedRulesResult}
+ * @returns
  *  The generated linter rules to forbid the restricted items.
  */
 export function generateRestrictedRules(fixed, options) {
-
     // restricted items for all files in the environment
     const items = {
         globals: concatArrays(RESTRICTED_GLOBALS, fixed.globals, options?.globals),
@@ -91,10 +83,8 @@ export function generateRestrictedRules(fixed, options) {
         properties: concatArrays(fixed.properties, options?.properties),
         syntax: concatArrays(RESTRICTED_SYNTAX, fixed.syntax, options?.syntax),
     };
-
     // base rules for all files in the environment
     const rules = createRulesRecord(key => items[key]);
-
     // generate the override entries (join with base items)
     const overrides = [];
     for (const override of options?.overrides ?? []) {
@@ -104,6 +94,5 @@ export function generateRestrictedRules(fixed, options) {
             rules: createRulesRecord(key => concatArrays(items[key], override[key])),
         });
     }
-
     return { rules, overrides };
 }

package/dist/eslint/shared/rule-utils.d.ts

@@ -0,0 +1,76 @@
+import pm from "picomatch";
+import type { JSONSchema, TSESTree } from "@typescript-eslint/utils";
+export type ImportExportNode = TSESTree.ImportDeclaration | TSESTree.ImportExpression | TSESTree.ExportAllDeclaration | TSESTree.ExportNamedDeclaration | TSESTree.TSExternalModuleReference;
+export interface ModuleNameResult {
+    sourceNode: TSESTree.StringLiteral | undefined;
+    moduleName: string;
+}
+/**
+ * Helper functions to build a JSON schema for custom ESLint rules.
+ */
+export declare const Schema: {
+    boolean(): JSONSchema.JSONSchema4BooleanSchema;
+    string(): JSONSchema.JSONSchema4StringSchema;
+    stringNE(): JSONSchema.JSONSchema4StringSchema;
+    array(items: JSONSchema.JSONSchema4): JSONSchema.JSONSchema4ArraySchema;
+    maybeArray(items: JSONSchema.JSONSchema4): JSONSchema.JSONSchema4OneOfSchema;
+    dictionary(properties: JSONSchema.JSONSchema4): JSONSchema.JSONSchema4ObjectSchema;
+    options(properties: Record<string, JSONSchema.JSONSchema4>, required?: boolean | string[]): JSONSchema.JSONSchema4ObjectSchema;
+};
+/**
+ * Returns a passed array unmodified, converts the value `undefined` to an
+ * empty array, and converts all other values to an array with one element.
+ *
+ * @param value
+ *  Any value to be converted to an array.
+ *
+ * @returns
+ *  An array containing the value, unless the value is already an array.
+ */
+export declare function makeArray<T>(value: T | T[] | undefined): T[];
+/**
+ * Converts a Windows file path to a Posix file path.
+ *
+ * @param path
+ *  The file path to be normalized to Posix format.
+ *
+ * @returns
+ *  The normalized Posix file path.
+ */
+export declare function toPosixPath(path: string): string;
+/**
+ * Returns whether the passed path refers to an existing file.
+ *
+ * @param path
+ *  The path to be checked.
+ *
+ * @returns
+ *  Whether the passed path refers to an existing file (returns `false` for
+ *  existing directories).
+ */
+export declare function isFile(path: string): boolean;
+/**
+ * Returns whether a module name matches the specified glob patterns.
+ *
+ * @param moduleName
+ *  The module name to be checked.
+ *
+ * @param patterns
+ *  The glob patterns to be matched against the module name.
+ *
+ * @returns
+ *  Whether the module name matches at least one glob pattern.
+ */
+export declare const matchModuleName: typeof pm.isMatch;
+/**
+ * Extracts the source node and module name of an import/export statement node,
+ * or a dynamic import expression node.
+ *
+ * @param node
+ *  The import/export statement node, or dynamic import expression node.
+ *
+ * @returns
+ *  The string literal node containing the module name, and the resulting
+ *  extracted module name.
+ */
+export declare function getModuleName(node: ImportExportNode): ModuleNameResult;