@rotki/eslint-plugin 0.7.0 → 1.1.0

package/dist/index.cjs

@@ -1,707 +0,0 @@
-'use strict';
-
-const createDebug = require('debug');
-const node_path = require('node:path');
-const compat = require('eslint-compat-utils');
-const scule = require('scule');
-const utils = require('@typescript-eslint/utils');
-
-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 version = "0.7.0";
-const pkg = {
-	version: version};
-
-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 (!parserServices)
-    throw new Error("missing 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$5 = "no-deprecated-classes";
-const debug$3 = 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],
-  ["text--secondary", "text-rui-text-secondary"],
-  ["white--text", "text-white"],
-  ["primary--text", "text-rui-primary"],
-  [
-    /^([mp])([abelr-txy]?)-n(\d)$/,
-    ([type, position, size]) => `-${type}${position === "a" ? "" : position}-${size}`
-  ],
-  [
-    /^([mp])a-(\d)$/,
-    ([type, size]) => `${type}-${size}`
-  ]
-];
-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 undefined;
-}
-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$3(`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",
-      recommendation: "recommended"
-    },
-    fixable: "code",
-    messages: {
-      replacedWith: `'{{ className }}' has been replaced with '{{ replacement }}'`
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: RULE_NAME$5
-});
-
-const debug$2 = createDebug__default("@rotki/eslint-plugin:no-deprecated-components");
-const RULE_NAME$4 = "no-deprecated-components";
-const vuetify = {
-  VApp: true,
-  VAppBar: true,
-  VAppBarNavIcon: true,
-  VAutocomplete: true,
-  VAvatar: true,
-  VBottomSheet: true,
-  VColorPicker: true,
-  VCombobox: true,
-  VDataFooter: true,
-  VDataTable: true,
-  VDialog: true,
-  VDialogTransition: true,
-  VExpansionPanel: true,
-  VExpansionPanelContent: true,
-  VExpansionPanelHeader: true,
-  VExpansionPanels: true,
-  VMain: true,
-  VMenu: true,
-  VNavigationDrawer: true,
-  VPagination: true,
-  VSelect: true,
-  VSlider: true,
-  VSnackbar: true,
-  VSwitch: true,
-  VTextField: true
-};
-const replacements$1 = {
-  DataTable: true,
-  Fragment: false,
-  ...vuetify
-};
-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 (sourceCode?.parserServices && !("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$2(`${tag} has been deprecated`);
-          context.report({
-            data: {
-              name: tag
-            },
-            messageId: "deprecated",
-            node: element
-          });
-        } else {
-          debug$2(`${tag} has will be removed`);
-          context.report({
-            data: {
-              name: 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",
-      recommendation: "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$4
-});
-
-const debug$1 = createDebug__default("@rotki/eslint-plugin:no-deprecated-props");
-const RULE_NAME$3 = "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 undefined;
-    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$1(`${tag} has replacement properties`);
-        const propName = getPropName(node);
-        const propNameNode = node.directive ? node.key.argument : node.key;
-        if (!propName || !propNameNode) {
-          debug$1("could not get prop name and/or node");
-          return;
-        }
-        Object.entries(replacements[tag]).forEach(([prop, replacement]) => {
-          if (scule.kebabCase(prop) === propName) {
-            debug$1(`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: "Replaces deprecated props with their replacements",
-      recommendation: "recommended"
-    },
-    fixable: "code",
-    messages: {
-      replacedWith: `'{{ prop }}' has been replaced with '{{ replacement }}'`
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: RULE_NAME$3
-});
-
-const RULE_NAME$2 = "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.startsWith(legacyLibrary))
-          return;
-        const replacement = node.source.value.replace(legacyLibrary, newLibrary);
-        context.report({
-          fix(fixer) {
-            return fixer.replaceText(node.source, `'${replacement}'`);
-          },
-          messageId: "replacedWith",
-          node: node.source
-        });
-      }
-    };
-  },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: `Reports and replaces imports of ${legacyLibrary} with ${newLibrary}`,
-      recommendation: "recommended"
-    },
-    fixable: "code",
-    messages: {
-      replacedWith: `${legacyLibrary} has been replaced by ${newLibrary}`
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: RULE_NAME$2
-});
-
-const debug = createDebug__default("@rotki/eslint-plugin:consistent-ref-type-annotation");
-const RULE_NAME$1 = "consistent-ref-type-annotation";
-const FIXABLE_METHODS = ["ref", "computed"];
-function checkAssignmentDeclaration(context, node, declaration, options) {
-  const source = getSourceCode(context);
-  const { allowInference } = options;
-  let declarationTypeArguments;
-  const init = declaration.init;
-  if (!(init && init.type === utils.TSESTree.AST_NODE_TYPES.CallExpression))
-    return;
-  const callee = init.callee;
-  if (!(callee && callee.type === utils.TSESTree.AST_NODE_TYPES.Identifier))
-    return;
-  if (!Array.prototype.includes.call(FIXABLE_METHODS, callee.name))
-    return;
-  const name = callee.name;
-  debug(`found ${name}, checking type arguments`);
-  const initializationTypeArguments = init.typeArguments;
-  const typeAnnotation = declaration.id.typeAnnotation;
-  if (typeAnnotation) {
-    const typeNode = typeAnnotation.typeAnnotation;
-    if (typeNode && typeNode.type === utils.TSESTree.AST_NODE_TYPES.TSTypeReference)
-      declarationTypeArguments = typeNode.typeArguments;
-  }
-  if (initializationTypeArguments && !declarationTypeArguments)
-    return;
-  debug(`generating report for ${name}`);
-  if (!initializationTypeArguments && !declarationTypeArguments) {
-    if (allowInference) {
-      debug("type inference is allowed");
-    } else {
-      context.report({
-        data: {
-          name
-        },
-        messageId: "missingType",
-        node
-      });
-    }
-    return;
-  }
-  context.report({
-    data: {
-      name
-    },
-    fix(fixer) {
-      const fixes = [];
-      if (!initializationTypeArguments && callee)
-        fixes.push(fixer.insertTextAfter(callee, source.getText(declarationTypeArguments)));
-      if (typeAnnotation)
-        fixes.push(fixer.remove(typeAnnotation));
-      return fixes;
-    },
-    messageId: "inconsistent",
-    node
-  });
-}
-const consistentRefTypeAnnotation = createEslintRule({
-  create(context, optionsWithDefault) {
-    const options = optionsWithDefault[0] || {};
-    const allowInference = options.allowInference;
-    return {
-      VariableDeclaration: (node) => {
-        const declarations = node.declarations;
-        for (const declaration of declarations) {
-          if (declaration.type !== utils.TSESTree.AST_NODE_TYPES.VariableDeclarator)
-            continue;
-          checkAssignmentDeclaration(context, node, declaration, { allowInference });
-        }
-      }
-    };
-  },
-  defaultOptions: [{ allowInference: false }],
-  meta: {
-    docs: {
-      description: "Ensures consistent type annotation position for ref, computed assignments",
-      recommendation: "recommended"
-    },
-    fixable: "code",
-    messages: {
-      inconsistent: `Generic type annotation for the {{ name }} call was not on the right side`,
-      missingType: `variable assignment for {{ name }} is missing the type annotation`
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowInference: {
-            type: "boolean"
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  },
-  name: RULE_NAME$1
-});
-
-const RULE_NAME = "no-dot-ts-imports";
-const noDotTsImport = createEslintRule({
-  create(context) {
-    return {
-      ImportDeclaration(node) {
-        const importDeclaration = node.source.value;
-        if (!importDeclaration.endsWith(".ts"))
-          return;
-        const lastIndexOfExtension = importDeclaration.lastIndexOf(".ts");
-        const replacement = importDeclaration.substring(0, lastIndexOfExtension);
-        context.report({
-          data: {
-            import: importDeclaration
-          },
-          fix(fixer) {
-            return fixer.replaceText(node.source, `'${replacement}'`);
-          },
-          messageId: "invalidTSExtension",
-          node: node.source
-        });
-      }
-    };
-  },
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Checks and replaces .ts extension in import statements.",
-      recommendation: "recommended"
-    },
-    fixable: "code",
-    messages: {
-      invalidTSExtension: `'{{ import }}' has a .ts extension, please remove it'`
-    },
-    schema: [],
-    type: "problem"
-  },
-  name: RULE_NAME
-});
-
-const plugin = {
-  meta: {
-    name: "@rotki/eslint-plugin",
-    version: pkg.version
-  },
-  rules: {
-    "consistent-ref-type-annotation": consistentRefTypeAnnotation,
-    "no-deprecated-classes": noDeprecatedClasses,
-    "no-deprecated-components": noDeprecatedComponents,
-    "no-deprecated-props": noDeprecatedProps,
-    "no-dot-ts-imports": noDotTsImport,
-    "no-legacy-library-import": noLegacyLibraryImport
-  }
-};
-
-const configs = {
-  "recommended": createRecommended(plugin, "@rotki", false),
-  "recommended-flat": createRecommended(plugin, "@rotki", true)
-};
-
-const index = Object.assign(plugin, { configs });
-
-module.exports = index;