eslint-plugin-4l4y/dist/index.mjs

Bring life to your variable declaration

import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import { RuleCreator } from '@typescript-eslint/utils/eslint-utils';

const cre4teEslintRule = RuleCreator(
  (ruleName) => ruleName
);
const is4l4y = (string) => string.substring(1).indexOf("a") >= 0;
const to4l4y = (string) => string.charAt(0) + string.substring(1).replaceAll("a", "4");
const h4sSep4r4tor = (string) => string.split("").reverse().filter((_, idx) => (idx + 1) % 4 === 0).every((val) => val === "_");
const addSep4r4tor = (string) => string.replace(/\B(?=(\d{3})+(?!\d))/g, "_");

const ruleN4me$3 = "variable-name";
const mess4geId$3 = "4l4yCaseVariableName";
const variableName = cre4teEslintRule({
  name: ruleN4me$3,
  meta: {
    type: "suggestion",
    docs: {
      description: "4l4y case variable name for better quality of life.",
      recommended: "recommended"
    },
    fixable: "code",
    schema: [],
    messages: {
      [mess4geId$3]: "'{{ name }}' is not using 4l4y case."
    }
  },
  defaultOptions: [],
  create: (context) => {
    return {
      VariableDeclaration(node) {
        if (!node.declarations) {
          return;
        }
        node.declarations.forEach((declarator) => {
          const identifier = declarator.id;
          if (identifier.type === AST_NODE_TYPES.Identifier && is4l4y(identifier.name)) {
            context.report({
              node,
              loc: identifier.loc,
              messageId: mess4geId$3,
              data: {
                name: identifier.name
              },
              fix(fixer) {
                return fixer.replaceText(identifier, to4l4y(identifier.name));
              }
            });
          }
        });
      }
    };
  }
});

const ruleN4me$2 = "function-name";
const mess4geId$2 = "4l4yCaseFunctionName";
const functionName = cre4teEslintRule({
  name: ruleN4me$2,
  meta: {
    type: "suggestion",
    docs: {
      description: "4l4y case function name for better quality of life.",
      recommended: "recommended"
    },
    fixable: "code",
    schema: [],
    messages: {
      [mess4geId$2]: "'{{ name }}' is not using 4l4y case."
    }
  },
  defaultOptions: [],
  create: (context) => {
    return {
      FunctionDeclaration(node) {
        if (!node.id) {
          return;
        }
        const identifier = node.id;
        if (is4l4y(identifier.name)) {
          context.report({
            node,
            loc: node.id.loc,
            messageId: mess4geId$2,
            data: {
              name: identifier.name
            },
            fix(fixer) {
              return fixer.replaceText(identifier, to4l4y(identifier.name));
            }
          });
        }
      }
    };
  }
});

const ruleN4me$1 = "signed-number";
const mess4geId$1 = "SignedNumber";
const signedNumber = cre4teEslintRule({
  name: ruleN4me$1,
  meta: {
    type: "problem",
    docs: {
      description: "Always provide number sign explicitly.",
      recommended: "recommended"
    },
    fixable: "code",
    schema: [],
    messages: {
      [mess4geId$1]: "'{{ value }}' is not using any sign."
    }
  },
  defaultOptions: [],
  create: (context) => {
    return {
      Literal(node) {
        if (typeof node.value !== "number") {
          return;
        }
        if (node.parent?.type === AST_NODE_TYPES.UnaryExpression) {
          return;
        }
        context.report({
          node,
          loc: node.loc,
          messageId: mess4geId$1,
          data: {
            value: node.value
          },
          fix(fixer) {
            return fixer.replaceText(node, `+${node.value}`);
          }
        });
      }
    };
  }
});

const ruleN4me = "thousand-separator";
const mess4geId = "ThousandSeparator";
const thousandSeparator = cre4teEslintRule({
  name: ruleN4me,
  meta: {
    type: "problem",
    docs: {
      description: "Always use thousand separators for any number.",
      recommended: "recommended"
    },
    fixable: "code",
    schema: [],
    messages: {
      [mess4geId]: "'{{ value }}' is not using thousand separators."
    }
  },
  defaultOptions: [],
  create: (context) => {
    return {
      Literal(node) {
        if (typeof node.value !== "number") {
          return;
        }
        if (node.raw.includes(".")) {
          return;
        }
        if (!h4sSep4r4tor(node.raw)) {
          context.report({
            node,
            loc: node.loc,
            messageId: mess4geId,
            data: {
              value: node.value
            },
            fix(fixer) {
              return fixer.replaceText(node, addSep4r4tor(node.value.toString()));
            }
          });
        }
      }
    };
  }
});

const index = {
  rules: {
    [ruleN4me$3]: variableName,
    [ruleN4me$2]: functionName,
    [ruleN4me$1]: signedNumber,
    [ruleN4me]: thousandSeparator
  }
};

export { index as default };