@lvce-editor/eslint-plugin-nvmrc 11.0.1

package/dist/index.js

@@ -0,0 +1,200 @@
+const createProgram = () => {
+  return {
+    type: 'Program',
+    body: [],
+    sourceType: 'script',
+    range: [0, 0],
+    loc: {
+      start: {
+        line: 1,
+        column: 0
+      },
+      end: {
+        line: 1,
+        column: 0
+      }
+    },
+    comments: [],
+    tokens: []
+  };
+};
+const parseForESLint = () => {
+  return {
+    ast: createProgram(),
+    services: {
+      isNvmrc: true
+    },
+    scopeManager: null,
+    visitorKeys: {
+      Program: ['body']
+    }
+  };
+};
+const meta$1 = {
+  name: 'nvmrc-parser',
+  version: '0.0.1'
+};
+
+const parser = {
+  __proto__: null,
+  meta: meta$1,
+  parseForESLint
+};
+
+const defaultMinimumVersion = '20.0.0';
+const defaultMaximumVersion = '24.15.0';
+const defaultBadVersions = ['24.16.0'];
+const versionPattern = String.raw`^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$`;
+const versionRegex = new RegExp(versionPattern);
+const parseVersion = value => {
+  const match = versionRegex.exec(value.trim());
+  if (!match) {
+    return undefined;
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    text: `${Number(match[1])}.${Number(match[2])}.${Number(match[3])}`
+  };
+};
+const compareVersion = (a, b) => {
+  if (a.major !== b.major) {
+    return a.major - b.major;
+  }
+  if (a.minor !== b.minor) {
+    return a.minor - b.minor;
+  }
+  return a.patch - b.patch;
+};
+const getRuleOptions = context => {
+  const [options = {}] = context.options;
+  return {
+    minimumVersion: options.minimumVersion ?? defaultMinimumVersion,
+    maximumVersion: options.maximumVersion ?? defaultMaximumVersion,
+    badVersions: options.badVersions ?? defaultBadVersions
+  };
+};
+const meta = {
+  type: 'problem',
+  docs: {
+    description: 'Disallow invalid or unsupported .nvmrc versions'
+  },
+  schema: [{
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      minimumVersion: {
+        type: 'string',
+        pattern: versionPattern
+      },
+      maximumVersion: {
+        type: 'string',
+        pattern: versionPattern
+      },
+      badVersions: {
+        type: 'array',
+        items: {
+          type: 'string',
+          pattern: versionPattern
+        },
+        uniqueItems: true
+      }
+    }
+  }],
+  messages: {
+    invalidVersion: 'Invalid .nvmrc version: {{value}}',
+    versionTooOld: '.nvmrc version {{value}} is older than {{minimumVersion}}',
+    versionTooNew: '.nvmrc version {{value}} is newer than {{maximumVersion}}',
+    badVersion: '.nvmrc version {{value}} is not allowed'
+  }
+};
+const create = context => {
+  const parserServices = context.sourceCode.parserServices;
+  if (!parserServices?.isNvmrc) {
+    return {};
+  }
+  return {
+    Program(node) {
+      const value = context.sourceCode.text.trim();
+      const version = parseVersion(value);
+      if (!version) {
+        context.report({
+          node,
+          messageId: 'invalidVersion',
+          data: {
+            value
+          }
+        });
+        return;
+      }
+      const options = getRuleOptions(context);
+      const minimumVersion = parseVersion(options.minimumVersion) ?? parseVersion(defaultMinimumVersion);
+      const maximumVersion = parseVersion(options.maximumVersion) ?? parseVersion(defaultMaximumVersion);
+      const badVersions = new Set(options.badVersions.map(badVersion => parseVersion(badVersion)?.text ?? badVersion));
+      if (badVersions.has(version.text)) {
+        context.report({
+          node,
+          messageId: 'badVersion',
+          data: {
+            value: version.text
+          }
+        });
+        return;
+      }
+      if (compareVersion(version, minimumVersion) < 0) {
+        context.report({
+          node,
+          messageId: 'versionTooOld',
+          data: {
+            value: version.text,
+            minimumVersion: minimumVersion.text
+          }
+        });
+        return;
+      }
+      if (compareVersion(version, maximumVersion) > 0) {
+        context.report({
+          node,
+          messageId: 'versionTooNew',
+          data: {
+            value: version.text,
+            maximumVersion: maximumVersion.text
+          }
+        });
+        return;
+      }
+    }
+  };
+};
+
+const validVersion = {
+  __proto__: null,
+  create,
+  meta
+};
+
+const plugin = {
+  meta: {
+    name: 'nvmrc',
+    version: '0.0.1'
+  },
+  rules: {
+    'valid-version': validVersion
+  },
+  configs: {}
+};
+const recommended = [{
+  files: ['**/.nvmrc'],
+  plugins: {
+    nvmrc: plugin
+  },
+  languageOptions: {
+    parser
+  },
+  rules: {
+    'nvmrc/valid-version': 'error'
+  }
+}];
+
+export { recommended as default };

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@lvce-editor/eslint-plugin-nvmrc",
+  "version": "11.0.1",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lvce-editor/eslint-config.git"
+  },
+  "type": "module",
+  "keywords": [],
+  "license": "MIT",
+  "description": "Lint .nvmrc files."
+}