@rotki/eslint-plugin 0.0.3 → 0.2.0

package/README.md

@@ -13,4 +13,4 @@ See [here](https://rotki.github.io/eslint-plugin)
 
 ## License
 
-[AGPL-3.0](./LICENSE) License © 2023- [Rotki Solutions GmbH](https://github.com/rotki)
+[AGPL-3.0](./LICENSE) License © 2023- [Rotki Solutions GmbH](https://github.com/rotki)

package/dist/index.cjs

@@ -0,0 +1,625 @@
+'use strict';
+
+const createDebug = require('debug');
+const node_path = require('node:path');
+const compat = require('eslint-compat-utils');
+const scule = require('scule');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const createDebug__default = /*#__PURE__*/_interopDefaultCompat(createDebug);
+const compat__namespace = /*#__PURE__*/_interopNamespaceCompat(compat);
+
+const name = "@rotki/eslint-plugin";
+const version = "0.2.0";
+const packageManager = "pnpm@8.14.1";
+const type = "module";
+const license = "AGPL-3.0";
+const bugs = {
+	url: "https://github.com/rotki/eslint-plugin/issues"
+};
+const repository = {
+	type: "git",
+	url: "https://github.com/rotki/eslint-plugin.git"
+};
+const author = "Rotki Solutions GmbH <info@rotki.com>";
+const files = [
+	"dist"
+];
+const main = "./dist/index.mjs";
+const module$1 = "./dist/index.mjs";
+const types = "./dist/index.d.ts";
+const exports$1 = {
+	".": {
+		types: "./dist/index.d.ts",
+		require: "./dist/index.cjs",
+		"import": "./dist/index.mjs"
+	}
+};
+const sideEffects = false;
+const scripts = {
+	clean: "rimraf .nyc_output coverage dist docs/.vitepress/dist",
+	coverage: "nyc report --reporter lcov && opener coverage/lcov-report/index.html",
+	generate: "node --experimental-specifier-resolution=node --loader ts-node/esm scripts/update-rule-docs.ts",
+	lint: "eslint .",
+	"lint:fix": "eslint . --fix",
+	build: "unbuild",
+	dev: "unbuild --stub",
+	prepublishOnly: "pnpm run build",
+	test: "vitest",
+	"new": "node --experimental-specifier-resolution=node --loader ts-node/esm ./scripts/new-rule.ts",
+	docs: "vitepress dev docs",
+	"docs:build": "pnpm run generate && vitepress build docs",
+	prepare: "husky install",
+	typecheck: "tsc --noEmit",
+	release: "bumpp -r --no-push"
+};
+const peerDependencies = {
+	eslint: "^8.0.0 || ^9.0.0"
+};
+const dependencies = {
+	"@typescript-eslint/utils": "6.19.0",
+	debug: "4.3.4",
+	"eslint-compat-utils": "0.4.1",
+	"jsonc-eslint-parser": "2.4.0",
+	scule: "1.2.0",
+	"vue-eslint-parser": "9.4.1",
+	"yaml-eslint-parser": "1.2.2"
+};
+const devDependencies = {
+	"@commitlint/cli": "18.5.0",
+	"@commitlint/config-conventional": "18.5.0",
+	"@rotki/eslint-config": "2.3.0",
+	"@types/debug": "4.1.12",
+	"@types/eslint": "8.56.2",
+	"@types/node": "20",
+	"@typescript-eslint/eslint-plugin": "6.19.0",
+	"@typescript-eslint/parser": "6.19.0",
+	"@typescript-eslint/rule-tester": "6.19.0",
+	bumpp: "9.3.0",
+	debug: "4.3.4",
+	eslint: "8.56.0",
+	husky: "8.0.3",
+	"lint-staged": "15.2.0",
+	rimraf: "5.0.5",
+	"ts-node": "10.9.2",
+	typescript: "5.3.3",
+	unbuild: "2.0.0",
+	vitepress: "1.0.0-rc.40",
+	vitest: "1.2.1"
+};
+const engines = {
+	node: ">=18.0.0",
+	pnpm: ">=8 <9"
+};
+const pkg = {
+	name: name,
+	version: version,
+	packageManager: packageManager,
+	type: type,
+	license: license,
+	bugs: bugs,
+	repository: repository,
+	author: author,
+	files: files,
+	main: main,
+	module: module$1,
+	types: types,
+	exports: exports$1,
+	sideEffects: sideEffects,
+	scripts: scripts,
+	peerDependencies: peerDependencies,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	engines: engines,
+	"lint-staged": {
+	"*.{js,cjs,ts,vue,yml,json,md}": "eslint"
+}
+};
+
+function getFilename(context) {
+  return compat__namespace.getFilename(context);
+}
+function getSourceCode(context) {
+  return compat__namespace.getSourceCode(context);
+}
+
+const blobUrl = "https://rotki.github.io/eslint-plugin/rules/";
+function RuleCreator(urlCreator) {
+  return function createNamedRule({
+    meta,
+    name,
+    ...rule
+  }) {
+    return createRule({
+      meta: {
+        ...meta,
+        docs: {
+          ...meta.docs,
+          url: urlCreator(name)
+        }
+      },
+      ...rule
+    });
+  };
+}
+function createRule({
+  create,
+  defaultOptions,
+  meta
+}) {
+  return {
+    create: (context) => {
+      const optionsWithDefault = context.options.map((options, index) => ({
+        ...defaultOptions[index] || {},
+        ...options || {}
+      }));
+      return create(context, optionsWithDefault);
+    },
+    defaultOptions,
+    meta
+  };
+}
+const createEslintRule = RuleCreator(
+  (ruleName) => `${blobUrl}${ruleName}`
+);
+
+function defineTemplateBodyVisitor(context, templateBodyVisitor, scriptVisitor, options) {
+  const sourceCode = getSourceCode(context);
+  const parserServices = sourceCode.parserServices;
+  if (!("defineTemplateBodyVisitor" in parserServices) || parserServices.defineTemplateBodyVisitor == null) {
+    const filename = getFilename(context);
+    if (node_path.extname(filename) === ".vue") {
+      context.report({
+        loc: { column: 0, line: 1 },
+        message: "Use the latest vue-eslint-parser. See also https://github.com/vuejs/eslint-plugin-vue#what-is-the-use-the-latest-vue-eslint-parser-error"
+      });
+    }
+    return {};
+  }
+  return parserServices.defineTemplateBodyVisitor(
+    templateBodyVisitor,
+    scriptVisitor,
+    options
+  );
+}
+
+function getStringLiteralValue(node, stringOnly = false) {
+  if (node.type === "Literal") {
+    if (node.value == null) {
+      if (!stringOnly && node.bigint != null)
+        return node.bigint;
+      return null;
+    }
+    if (typeof node.value === "string")
+      return node.value;
+    if (!stringOnly)
+      return String(node.value);
+    return null;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1)
+    return node.quasis[0].value.cooked;
+  return null;
+}
+function getStaticPropertyName(node) {
+  if (node.type === "Property" || node.type === "MethodDefinition") {
+    if (!node.computed) {
+      const key2 = node.key;
+      if (key2.type === "Identifier")
+        return key2.name;
+    }
+    const key = node.key;
+    return getStringLiteralValue(key);
+  } else if (node.type === "MemberExpression") {
+    if (!node.computed) {
+      const property2 = node.property;
+      if (property2.type === "Identifier")
+        return property2.name;
+      return null;
+    }
+    const property = node.property;
+    return getStringLiteralValue(property);
+  }
+  return null;
+}
+
+function createRecommended(plugin, name, flat) {
+  const rules = Object.fromEntries(Object.entries(plugin.rules).filter(([_key, rule]) => rule.meta.recommended === "recommended" && !rule.meta.deprecated).map(([key]) => [`${name}/${key}`, 2]));
+  if (flat) {
+    return {
+      plugins: {
+        [name]: plugin
+      },
+      rules
+    };
+  } else {
+    return {
+      plugins: [name],
+      rules
+    };
+  }
+}
+
+const RULE_NAME$3 = "no-deprecated-classes";
+const debug$2 = createDebug__default("@rotki/eslint-plugin:no-deprecated-classes");
+const replacements$2 = [
+  ["d-block", "block"],
+  ["d-flex", "flex"],
+  ["flex-column", "flex-col"],
+  ["flex-grow-1", "grow"],
+  ["flex-grow-0", "grow-0"],
+  ["flex-shrink-1", "shrink"],
+  ["flex-shrink-0", "shrink-0"],
+  [
+    /^align-(start|end|center|baseline|stretch)$/,
+    ([align]) => `items-${align}`
+  ],
+  [/^justify-space-(between|around)$/, ([justify]) => `justify-${justify}`],
+  [
+    /^align-self-(start|end|center|baseline|auto|strech)$/,
+    ([align]) => `self-${align}`
+  ],
+  [
+    /^font-weight-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/,
+    ([weight]) => `font-${weight}`
+  ],
+  [/^text-(capitalize|uppercase|lowercase)$/, ([casing]) => casing]
+];
+function isString(replacement) {
+  return typeof replacement[0] === "string";
+}
+function isRegex(replacement) {
+  return replacement[0] instanceof RegExp;
+}
+function findReplacement(className) {
+  for (const replacement of replacements$2) {
+    if (isString(replacement) && replacement[0] === className)
+      return replacement[1];
+    if (isRegex(replacement)) {
+      const matches = (replacement[0].exec(className) || []).slice(1);
+      const replace = replacement[1];
+      if (matches.length > 0 && typeof replace === "function")
+        return replace(matches);
+    }
+  }
+  return void 0;
+}
+function getRange(node) {
+  if (node.type === "VAttribute" && node.value && node.value.range)
+    return node.value.range;
+  return node.range;
+}
+function reportReplacement(className, replacement, node, context, position = 1) {
+  debug$2(`found replacement ${replacement} for ${className}`);
+  const source = getSourceCode(context);
+  const initialRange = getRange(node);
+  const range = [
+    initialRange[0] + position,
+    initialRange[0] + position + className.length
+  ];
+  const loc = {
+    end: source.getLocFromIndex(range[1]),
+    start: source.getLocFromIndex(range[0])
+  };
+  context.report({
+    data: {
+      className,
+      replacement
+    },
+    fix(fixer) {
+      return fixer.replaceTextRange(range, replacement);
+    },
+    loc,
+    messageId: "replacedWith"
+  });
+}
+function* extractClassNames(node, textOnly = false) {
+  if (node.type === "Literal") {
+    const classNames = `${node.value}`;
+    yield* classNames.split(/\s+/).map((className) => ({ className, position: classNames.indexOf(className) + 1, reportNode: node }));
+    return;
+  }
+  if (node.type === "TemplateLiteral") {
+    for (const templateElement of node.quasis) {
+      const classNames = templateElement.value.cooked;
+      if (classNames === null)
+        continue;
+      yield* classNames.split(/\s+/).map((className) => ({ className, position: classNames.indexOf(className) + 1, reportNode: templateElement }));
+    }
+    for (const expr of node.expressions)
+      yield* extractClassNames(expr, true);
+    return;
+  }
+  if (node.type === "BinaryExpression") {
+    if (node.operator !== "+")
+      return;
+    yield* extractClassNames(node.left, true);
+    yield* extractClassNames(node.right, true);
+    return;
+  }
+  if (textOnly)
+    return;
+  if (node.type === "ObjectExpression") {
+    for (const prop of node.properties) {
+      if (prop.type !== "Property")
+        continue;
+      const classNames = getStaticPropertyName(prop);
+      if (!classNames)
+        continue;
+      yield* classNames.split(/\s+/).map((className) => ({ className, position: classNames.indexOf(className) + 1, reportNode: prop.key }));
+    }
+    return;
+  }
+  if (node.type === "ArrayExpression") {
+    for (const element of node.elements) {
+      if (element == null)
+        continue;
+      if (element.type === "SpreadElement")
+        continue;
+      yield* extractClassNames(element);
+    }
+  }
+  if (node.type === "ConditionalExpression") {
+    yield* extractClassNames(node.consequent);
+    yield* extractClassNames(node.alternate);
+  }
+}
+const noDeprecatedClasses = createEslintRule({
+  create(context) {
+    return defineTemplateBodyVisitor(context, {
+      'VAttribute[directive=false][key.name="class"]': function(node) {
+        if (!node.value || !node.value.value)
+          return;
+        for (const className of node.value.value.split(/\s+/).filter((s) => !!s)) {
+          const replacement = findReplacement(className);
+          const position = node.value.value.indexOf(className) + 1;
+          if (!replacement)
+            continue;
+          reportReplacement(className, replacement, node, context, position);
+        }
+      },
+      "VAttribute[directive=true][key.name.name='bind'][key.argument.name='class'] > VExpressionContainer.value": function(node) {
+        if (!node.expression)
+          return;
+        for (const { className, position, reportNode } of extractClassNames(node.expression)) {
+          const replacement = findReplacement(className);
+          if (!replacement)
+            continue;
+          reportReplacement(className, replacement, reportNode, context, position);
+        }
+      }
+    });
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "disallow the usage of vuetify css classes since they are replaced with tailwindcss",
+      recommended: "recommended"
+    },
+    fixable: "code",
+    messages: {
+      replacedWith: `'{{ className }}' has been replaced with '{{ replacement }}'`
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: RULE_NAME$3
+});
+
+const debug$1 = createDebug__default("@rotki/eslint-plugin:no-deprecated-components");
+const RULE_NAME$2 = "no-deprecated-components";
+const replacements$1 = {
+  DataTable: true,
+  Fragment: false
+};
+const skipInLegacy = [
+  "Fragment"
+];
+function hasReplacement$1(tag) {
+  return Object.prototype.hasOwnProperty.call(replacements$1, tag);
+}
+const noDeprecatedComponents = createEslintRule({
+  create(context, optionsWithDefault) {
+    const options = optionsWithDefault[0] || {};
+    const legacy = options.legacy;
+    return defineTemplateBodyVisitor(context, {
+      VElement(element) {
+        const tag = scule.pascalCase(element.rawName);
+        const sourceCode = getSourceCode(context);
+        if (!("getTemplateBodyTokenStore" in sourceCode.parserServices))
+          throw new Error("cannot find getTemplateBodyTokenStore in parserServices");
+        if (!hasReplacement$1(tag))
+          return;
+        const replacement = replacements$1[tag];
+        if (replacement || legacy && skipInLegacy.includes(tag)) {
+          debug$1(`${tag} has been deprecated`);
+          context.report({
+            data: {
+              name: scule.snakeCase(tag)
+            },
+            messageId: "deprecated",
+            node: element
+          });
+        } else {
+          debug$1(`${tag} has will be removed`);
+          context.report({
+            data: {
+              name: scule.snakeCase(tag)
+            },
+            fix(fixer) {
+              return [
+                fixer.remove(element.startTag),
+                ...element.endTag ? [fixer.remove(element.endTag)] : []
+              ];
+            },
+            messageId: "removed",
+            node: element
+          });
+        }
+      }
+    });
+  },
+  defaultOptions: [{ legacy: false }],
+  meta: {
+    docs: {
+      description: "Removes deprecated classes that do not exist anymore",
+      recommended: "recommended"
+    },
+    fixable: "code",
+    messages: {
+      deprecated: `'{{ name }}' has been deprecated`,
+      removed: `'{{ name }}' has been removed`,
+      replacedWith: `'{{ a }}' has been replaced with '{{ b }}'`
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          legacy: {
+            type: "boolean"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: RULE_NAME$2
+});
+
+const debug = createDebug__default("@rotki/eslint-plugin:no-deprecated-props");
+const RULE_NAME$1 = "no-deprecated-props";
+const replacements = {
+  RuiRadio: {
+    internalValue: "value"
+  }
+};
+function hasReplacement(tag) {
+  return Object.prototype.hasOwnProperty.call(replacements, tag);
+}
+function getPropName(node) {
+  if (node.directive) {
+    if (node.key.argument?.type !== "VIdentifier")
+      return void 0;
+    return scule.kebabCase(node.key.argument.rawName);
+  }
+  return scule.kebabCase(node.key.rawName);
+}
+const noDeprecatedProps = createEslintRule({
+  create(context) {
+    return defineTemplateBodyVisitor(context, {
+      VAttribute(node) {
+        if (node.directive && (node.value?.type === "VExpressionContainer" && (node.key.name.name !== "bind" || !node.key.argument)))
+          return;
+        const tag = scule.pascalCase(node.parent.parent.rawName);
+        if (!hasReplacement(tag))
+          return;
+        debug(`${tag} has replacement properties`);
+        const propName = getPropName(node);
+        const propNameNode = node.directive ? node.key.argument : node.key;
+        if (!propName || !propNameNode) {
+          debug("could not get prop name and/or node");
+          return;
+        }
+        Object.entries(replacements[tag]).forEach(([prop, replacement]) => {
+          if (scule.kebabCase(prop) === propName) {
+            debug(`preparing a replacement for ${tag}:${propName} -> ${replacement}`);
+            context.report({
+              data: {
+                prop,
+                replacement
+              },
+              fix(fixer) {
+                return fixer.replaceText(propNameNode, replacement);
+              },
+              messageId: "replacedWith",
+              node: propNameNode
+            });
+          }
+        });
+      }
+    });
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "..."
+    },
+    fixable: "code",
+    messages: {
+      replacedWith: `'{{ prop }}' has been replaced with '{{ replacement }}'`
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: RULE_NAME$1
+});
+
+const RULE_NAME = "no-legacy-library-import";
+const legacyLibrary = "@rotki/ui-library-compat";
+const newLibrary = "@rotki/ui-library";
+const noLegacyLibraryImport = createEslintRule({
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== legacyLibrary)
+          return;
+        context.report({
+          fix(fixer) {
+            return fixer.replaceText(node.source, `'${newLibrary}'`);
+          },
+          messageId: "replacedWith",
+          node: node.source
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: `Reports and replaces imports of ${legacyLibrary} with ${newLibrary}`
+    },
+    fixable: "code",
+    messages: {
+      replacedWith: `${legacyLibrary} has been replaced by ${newLibrary}`
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: RULE_NAME
+});
+
+const plugin = {
+  meta: {
+    name: "@rotki/eslint-plugin",
+    version: pkg.version
+  },
+  rules: {
+    "no-deprecated-classes": noDeprecatedClasses,
+    "no-deprecated-components": noDeprecatedComponents,
+    "no-deprecated-props": noDeprecatedProps,
+    "no-legacy-library-import": noLegacyLibraryImport
+  }
+};
+const plugin$1 = plugin;
+
+const configs = {
+  "recommended": createRecommended(plugin$1, "@rotki", false),
+  "recommended-flat": createRecommended(plugin$1, "@rotki", true)
+};
+
+const index = Object.assign(plugin$1, { configs });
+
+module.exports = index;