@rotki/eslint-plugin 0.0.3 → 0.1.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,409 @@
+'use strict';
+
+const node_path = require('node:path');
+const compat = require('eslint-compat-utils');
+const createDebug = require('debug');
+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 compat__namespace = /*#__PURE__*/_interopNamespaceCompat(compat);
+const createDebug__default = /*#__PURE__*/_interopDefaultCompat(createDebug);
+
+const name = "@rotki/eslint-plugin";
+const version = "0.1.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",
+	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
+  );
+}
+
+const RULE_NAME$1 = "no-deprecated-classes";
+const replacements$1 = [
+  ["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;
+}
+const noDeprecatedClasses = createEslintRule({
+  create(context) {
+    return defineTemplateBodyVisitor(context, {
+      'VAttribute[key.name="class"]': function(node) {
+        if (!node.value || !node.value.value)
+          return;
+        const classes = node.value.value.split(/\s+/).filter((s) => !!s);
+        const source = getSourceCode(context);
+        const replaced = [];
+        classes.forEach((className) => {
+          for (const replacement of replacements$1) {
+            if (isString(replacement) && replacement[0] === className)
+              replaced.push([className, 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 replaced.push([className, replace(matches)]);
+            }
+          }
+        });
+        replaced.forEach((replacement) => {
+          if (!node.value)
+            return;
+          const idx = node.value.value.indexOf(replacement[0]) + 1;
+          const range = [
+            node.value.range[0] + idx,
+            node.value.range[0] + idx + replacement[0].length
+          ];
+          const loc = {
+            end: source.getLocFromIndex(range[1]),
+            start: source.getLocFromIndex(range[0])
+          };
+          context.report({
+            data: {
+              a: replacement[0],
+              b: replacement[1]
+            },
+            fix(fixer) {
+              return fixer.replaceTextRange(range, replacement[1]);
+            },
+            loc,
+            messageId: "replacedWith"
+          });
+        });
+      }
+    });
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "disallow the usage of vuetify css classes since they are replaced with tailwindcss",
+      recommended: "recommended"
+    },
+    fixable: "code",
+    messages: {
+      replacedWith: `'{{ a }}' has been replaced with '{{ b }}'`
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: RULE_NAME$1
+});
+
+const debug = createDebug__default("@rotki/eslint-plugin:no-deprecated-components");
+const RULE_NAME = "no-deprecated-components";
+const replacements = {
+  DataTable: true,
+  Fragment: false
+};
+const skipInLegacy = [
+  "Fragment"
+];
+function hasReplacement(tag) {
+  return Object.prototype.hasOwnProperty.call(replacements, 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(tag))
+          return;
+        const replacement = replacements[tag];
+        if (replacement || legacy && skipInLegacy.includes(tag)) {
+          debug(`${tag} has been deprecated`);
+          context.report({
+            data: {
+              name: scule.snakeCase(tag)
+            },
+            messageId: "deprecated",
+            node: element
+          });
+        } else {
+          debug(`${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
+});
+
+const plugin = {
+  meta: {
+    name: "@rotki/eslint-plugin",
+    version: pkg.version
+  },
+  rules: {
+    "no-deprecated-classes": noDeprecatedClasses,
+    "no-deprecated-components": noDeprecatedComponents
+  }
+};
+const plugin$1 = plugin;
+
+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 configs = {
+  "recommended": createRecommended(plugin$1, "@rotki", false),
+  "recommended-flat": createRecommended(plugin$1, "@rotki", true)
+};
+
+const index = Object.assign(plugin$1, { configs });
+
+module.exports = index;

package/dist/index.d.cts

@@ -0,0 +1,88 @@
+import { Rule, Linter } from 'eslint';
+
+interface PluginRuleModule<TOptions extends readonly unknown[] = []> extends Rule.RuleModule {
+    defaultOptions: TOptions;
+}
+
+type Options = [{
+    legacy: boolean;
+}];
+
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'no-deprecated-classes': PluginRuleModule<[]>;
+        'no-deprecated-components': PluginRuleModule<Options>;
+    };
+};
+
+declare const _default: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'no-deprecated-classes': PluginRuleModule<[]>;
+        'no-deprecated-components': PluginRuleModule<Options>;
+    };
+} & {
+    configs: {
+        recommended: {
+            plugins: {
+                [x: string]: {
+                    meta: {
+                        name: string;
+                        version: string;
+                    };
+                    rules: {
+                        'no-deprecated-classes': PluginRuleModule<[]>;
+                        'no-deprecated-components': PluginRuleModule<Options>;
+                    };
+                };
+            };
+            rules: {
+                [k: string]: number;
+            };
+        } | {
+            plugins: string[];
+            rules: {
+                [k: string]: number;
+            };
+        };
+        'recommended-flat': {
+            plugins: {
+                [x: string]: {
+                    meta: {
+                        name: string;
+                        version: string;
+                    };
+                    rules: {
+                        'no-deprecated-classes': PluginRuleModule<[]>;
+                        'no-deprecated-components': PluginRuleModule<Options>;
+                    };
+                };
+            };
+            rules: {
+                [k: string]: number;
+            };
+        } | {
+            plugins: string[];
+            rules: {
+                [k: string]: number;
+            };
+        };
+    };
+};
+
+type RuleDefinitions = typeof plugin['rules'];
+type RuleOptions = {
+    [K in keyof RuleDefinitions]: RuleDefinitions[K]['defaultOptions'];
+};
+type Rules = {
+    [K in keyof RuleOptions]: Linter.RuleEntry<RuleOptions[K]>;
+};
+
+export { type RuleOptions, type Rules, _default as default };

package/dist/index.d.mts

@@ -0,0 +1,88 @@
+import { Rule, Linter } from 'eslint';
+
+interface PluginRuleModule<TOptions extends readonly unknown[] = []> extends Rule.RuleModule {
+    defaultOptions: TOptions;
+}
+
+type Options = [{
+    legacy: boolean;
+}];
+
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'no-deprecated-classes': PluginRuleModule<[]>;
+        'no-deprecated-components': PluginRuleModule<Options>;
+    };
+};
+
+declare const _default: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'no-deprecated-classes': PluginRuleModule<[]>;
+        'no-deprecated-components': PluginRuleModule<Options>;
+    };
+} & {
+    configs: {
+        recommended: {
+            plugins: {
+                [x: string]: {
+                    meta: {
+                        name: string;
+                        version: string;
+                    };
+                    rules: {
+                        'no-deprecated-classes': PluginRuleModule<[]>;
+                        'no-deprecated-components': PluginRuleModule<Options>;
+                    };
+                };
+            };
+            rules: {
+                [k: string]: number;
+            };
+        } | {
+            plugins: string[];
+            rules: {
+                [k: string]: number;
+            };
+        };
+        'recommended-flat': {
+            plugins: {
+                [x: string]: {
+                    meta: {
+                        name: string;
+                        version: string;
+                    };
+                    rules: {
+                        'no-deprecated-classes': PluginRuleModule<[]>;
+                        'no-deprecated-components': PluginRuleModule<Options>;
+                    };
+                };
+            };
+            rules: {
+                [k: string]: number;
+            };
+        } | {
+            plugins: string[];
+            rules: {
+                [k: string]: number;
+            };
+        };
+    };
+};
+
+type RuleDefinitions = typeof plugin['rules'];
+type RuleOptions = {
+    [K in keyof RuleDefinitions]: RuleDefinitions[K]['defaultOptions'];
+};
+type Rules = {
+    [K in keyof RuleOptions]: Linter.RuleEntry<RuleOptions[K]>;
+};
+
+export { type RuleOptions, type Rules, _default as default };

package/dist/index.d.ts

@@ -1,29 +1,88 @@
+import { Rule, Linter } from 'eslint';
+
+interface PluginRuleModule<TOptions extends readonly unknown[] = []> extends Rule.RuleModule {
+    defaultOptions: TOptions;
+}
+
+type Options = [{
+    legacy: boolean;
+}];
+
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'no-deprecated-classes': PluginRuleModule<[]>;
+        'no-deprecated-components': PluginRuleModule<Options>;
+    };
+};
+
 declare const _default: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'no-deprecated-classes': PluginRuleModule<[]>;
+        'no-deprecated-components': PluginRuleModule<Options>;
+    };
+} & {
     configs: {
-        base: {
-            parser: string;
+        recommended: {
+            plugins: {
+                [x: string]: {
+                    meta: {
+                        name: string;
+                        version: string;
+                    };
+                    rules: {
+                        'no-deprecated-classes': PluginRuleModule<[]>;
+                        'no-deprecated-components': PluginRuleModule<Options>;
+                    };
+                };
+            };
+            rules: {
+                [k: string]: number;
+            };
+        } | {
             plugins: string[];
+            rules: {
+                [k: string]: number;
+            };
         };
-        recommended: {
-            extends: string[];
-            parserOptions: {
-                ecmaVersion: number;
-                sourceType: string;
-                ecmaFeatures: {
-                    jsx: boolean;
+        'recommended-flat': {
+            plugins: {
+                [x: string]: {
+                    meta: {
+                        name: string;
+                        version: string;
+                    };
+                    rules: {
+                        'no-deprecated-classes': PluginRuleModule<[]>;
+                        'no-deprecated-components': PluginRuleModule<Options>;
+                    };
                 };
             };
-            env: {
-                browser: boolean;
-                es6: boolean;
+            rules: {
+                [k: string]: number;
             };
+        } | {
+            plugins: string[];
             rules: {
-                '@rotki/no-deprecated-classes': "warn";
+                [k: string]: number;
             };
         };
     };
-    rules: {
-        'no-deprecated-classes': import("./types").RuleModule;
-    };
 };
-export = _default;
+
+type RuleDefinitions = typeof plugin['rules'];
+type RuleOptions = {
+    [K in keyof RuleDefinitions]: RuleDefinitions[K]['defaultOptions'];
+};
+type Rules = {
+    [K in keyof RuleOptions]: Linter.RuleEntry<RuleOptions[K]>;
+};
+
+export { type RuleOptions, type Rules, _default as default };