eslint-config-vylda-typescript 5.0.0

package/rules/stylisticTs.mjs

@@ -0,0 +1,495 @@
+// @ts-check
+import { constants, plus, stylistic } from 'eslint-config-vylda-vanilla';
+
+const { OBJECT_CURLY_MIN_PROPS } = constants;
+
+/**
+ *
+ * @returns  {import('eslint').Linter.RuleEntry | undefined}
+ */
+const createComaRule = () => {
+  const [baseStylistic] = stylistic;
+  const { rules: baseStylisticsRules } = baseStylistic;
+
+  if (!baseStylisticsRules) {
+    return undefined;
+  }
+
+  const rule = baseStylisticsRules['@stylistic/comma-dangle'];
+
+  if (!rule) {
+    return undefined;
+  }
+
+  if (typeof rule === 'string' || !Array.isArray(rule)) {
+    return rule;
+  }
+
+  const [
+    severity,
+    options,
+  ] = rule;
+
+  if (typeof options === 'string') {
+    return rule;
+  }
+
+  /** @type {import('eslint').Linter.RuleEntry} */
+  const enhancedRule = [
+    severity,
+    {
+      ...options,
+      enums: options.arrays,
+      generics: options.arrays,
+      tuples: options.arrays,
+    },
+  ];
+
+  return enhancedRule;
+};
+
+/**
+ *
+ * @returns  {import('eslint').Linter.RuleEntry | undefined}
+ */
+const createCurlyNewLineRule = () => {
+  const [baseStylistic] = plus;
+  const { rules: baseStylisticsRules } = baseStylistic;
+
+  if (!baseStylisticsRules) {
+    return undefined;
+  }
+
+  const rule = baseStylisticsRules['@stylistic/curly-newline'];
+
+  if (!rule) {
+    return undefined;
+  }
+
+  if (typeof rule === 'string' || !Array.isArray(rule)) {
+    return rule;
+  }
+
+  const [
+    severity,
+    options,
+  ] = rule;
+
+  if (typeof options === 'string') {
+    return rule;
+  }
+
+  /** @type {import('eslint').Linter.RuleEntry} */
+  const enhancedRule = [
+    severity,
+    {
+      ...options,
+      TSModuleBlock: 'always',
+    },
+  ];
+
+  return enhancedRule;
+};
+
+/**
+ *
+ * @returns  {import('eslint').Linter.RuleEntry | undefined}
+ */
+const createIndentRule = () => {
+  const [baseStylistic] = stylistic;
+  const { rules: baseStylisticsRules } = baseStylistic;
+
+  if (!baseStylisticsRules) {
+    return undefined;
+  }
+
+  const rule = baseStylisticsRules['@stylistic/indent'];
+
+  if (!rule) {
+    return undefined;
+  }
+
+  if (typeof rule === 'object') {
+    const [severity, indent, options] = rule;
+
+    return [
+      severity,
+      indent,
+      {
+        ...options,
+        FunctionDeclaration: {
+          body: 1,
+          parameters: 1,
+          returnType: 1,
+        },
+        FunctionExpression: {
+          body: 1,
+          parameters: 1,
+          returnType: 1,
+        },
+      },
+    ];
+  }
+
+  return rule;
+};
+
+/**
+ *
+ * @returns  {import('eslint').Linter.RuleEntry | undefined}
+ */
+const createLinesAroundCommentRule = () => {
+  const [baseStylistic] = stylistic;
+  const { rules: baseStylisticsRules } = baseStylistic;
+
+  if (!baseStylisticsRules) {
+    return undefined;
+  }
+
+  const rule = baseStylisticsRules['@stylistic/lines-around-comment'];
+
+  if (!rule) {
+    return undefined;
+  }
+
+  if (typeof rule === 'string' || !Array.isArray(rule)) {
+    return rule;
+  }
+
+  const [
+    severity,
+    options,
+  ] = rule;
+
+  if (typeof options === 'string') {
+    return rule;
+  }
+
+  /** @type {import('eslint').Linter.RuleEntry} */
+  const enhancedRule = [
+    severity,
+    {
+      ...options,
+      allowEnumEnd: false,
+      allowEnumStart: false,
+      allowInterfaceEnd: false,
+      allowInterfaceStart: false,
+      allowModuleEnd: false,
+      allowModuleStart: false,
+      allowTypeEnd: true,
+      allowTypeStart: true,
+    },
+  ];
+
+  return enhancedRule;
+};
+
+/**
+ *
+ * @returns  {import('eslint').Linter.RuleEntry | undefined}
+ */
+const createLinesBetweenClassMembersRule = () => {
+  const [baseStylistic] = stylistic;
+  const { rules: baseStylisticsRules } = baseStylistic;
+
+  if (!baseStylisticsRules) {
+    return undefined;
+  }
+
+  const rule = baseStylisticsRules['@stylistic/lines-between-class-members'];
+
+  if (!rule) {
+    return undefined;
+  }
+
+  if (typeof rule === 'string' || !Array.isArray(rule)) {
+    return rule;
+  }
+
+  const [
+    severity,
+    options,
+  ] = rule;
+
+  if (typeof options === 'string') {
+    return rule;
+  }
+
+  /** @type {import('eslint').Linter.RuleEntry} */
+  const enhancedRule = [
+    severity,
+    {
+      ...options,
+      exceptAfterOverload: true,
+    },
+  ];
+
+  return enhancedRule;
+};
+
+/**
+ *
+ * @returns  {import('eslint').Linter.RuleEntry | undefined}
+ */
+const createObjectCurlyNewLineRule = () => {
+  const [baseStylistic] = plus;
+  const { rules: baseStylisticsRules } = baseStylistic;
+
+  if (!baseStylisticsRules) {
+    return undefined;
+  }
+
+  const rule = baseStylisticsRules['@stylistic/object-curly-newline'];
+
+  if (!rule) {
+    return undefined;
+  }
+
+  if (typeof rule === 'string' || !Array.isArray(rule)) {
+    return rule;
+  }
+
+  const [
+    severity,
+    options,
+  ] = rule;
+
+  if (typeof options === 'string') {
+    return rule;
+  }
+
+  /** @type {import('eslint').Linter.RuleEntry} */
+  const enhancedRule = [
+    severity,
+    {
+      ...options,
+      TSEnumBody: {
+        consistent: true,
+        minProperties: OBJECT_CURLY_MIN_PROPS,
+        multiline: true,
+      },
+      TSInterfaceBody: {
+        consistent: true,
+        minProperties: OBJECT_CURLY_MIN_PROPS,
+        multiline: true,
+      },
+      TSTypeLiteral: {
+        consistent: true,
+        minProperties: OBJECT_CURLY_MIN_PROPS,
+        multiline: true,
+      },
+    },
+  ];
+
+  return enhancedRule;
+};
+
+/**
+ *
+ * @returns  {import('eslint').Linter.RuleEntry | undefined}
+ */
+const createPaddingLineBetweenStatementsRule = () => {
+  const [baseStylistic] = stylistic;
+  const { rules: baseStylisticsRules } = baseStylistic;
+
+  if (!baseStylisticsRules) {
+    return undefined;
+  }
+
+  const rule = baseStylisticsRules['@stylistic/padding-line-between-statements'];
+
+  if (!rule) {
+    return undefined;
+  }
+
+  if (typeof rule === 'string' || !Array.isArray(rule)) {
+    return rule;
+  }
+
+  const [
+    severity,
+    ...options
+  ] = rule;
+
+  if (typeof options === 'string') {
+    return rule;
+  }
+
+  /** @type {import('eslint').Linter.RuleEntry} */
+  const enhancedRule = [
+    severity,
+    ...options,
+    {
+      blankLine: 'always',
+      next: ['enum', 'interface', 'type'],
+      prev: '*',
+    },
+    {
+      blankLine: 'always',
+      next: ['enum'],
+      prev: ['enum'],
+    },
+    {
+      blankLine: 'never',
+      next: ['interface'],
+      prev: ['interface'],
+    },
+    {
+      blankLine: 'always',
+      next: ['type'],
+      prev: ['type'],
+    },
+  ];
+
+  return enhancedRule;
+};
+
+/**
+ *
+ * @returns  {import('eslint').Linter.RuleEntry | undefined}
+ */
+const createSpaceInfixOpsRule = () => {
+  const [baseStylistic] = stylistic;
+  const { rules: baseStylisticsRules } = baseStylistic;
+
+  if (!baseStylisticsRules) {
+    return undefined;
+  }
+
+  const rule = baseStylisticsRules['@stylistic/space-infix-ops'];
+
+  if (!rule) {
+    return undefined;
+  }
+
+  if (typeof rule === 'string' || typeof rule === 'number') {
+    return [
+      rule,
+      {
+        ignoreTypes: false,
+        int32Hint: false,
+      },
+    ];
+  }
+
+  return [
+    'error',
+    {
+      ignoreTypes: false,
+      int32Hint: false,
+    },
+  ];
+};
+
+const comaDangleRule = createComaRule();
+const curlyNewlineRule = createCurlyNewLineRule();
+const indentRule = createIndentRule();
+const linesAroundCommentRule = createLinesAroundCommentRule();
+const linesBetweenClassMembersRule = createLinesBetweenClassMembersRule();
+const objectCurlyNewlineRule = createObjectCurlyNewLineRule();
+const paddingLineBetweenStatementsRule = createPaddingLineBetweenStatementsRule();
+const spaceInfixOpsRule = createSpaceInfixOpsRule();
+
+/** @type {import('eslint').Linter.RulesRecord} */
+const rules = {
+  // Require or disallow an empty line between class members.
+  // https://eslint.style/rules/ts/member-delimiter-style
+  '@stylistic/member-delimiter-style': [
+    'error',
+    {
+      multiline: {
+        delimiter: 'semi',
+        requireLast: true,
+      },
+      singleline: {
+        delimiter: 'semi',
+        requireLast: false,
+      },
+    },
+  ],
+
+  // Eenforce specific spacing patterns around type annotations and function types in type literals.
+  // https://eslint.style/rules/ts/type-annotation-spacing
+  '@stylistic/type-annotation-spacing': [
+    'error',
+    {
+      after: true,
+      before: false,
+      overrides: {
+        arrow: {
+          after: true,
+          before: true,
+        },
+        colon: {
+          after: true,
+          before: false,
+        },
+      },
+    },
+  ],
+};
+
+if (comaDangleRule) {
+  // The TypeScript version also adds 3 new options, all of which should be
+  // https://eslint.style/rules/ts/comma-dangle
+  rules['@stylistic/comma-dangle'] = comaDangleRule;
+}
+
+if (curlyNewlineRule) {
+  // A number of style guides require or disallow line breaks inside of block statements and block-like code.
+  // https://eslint.style/rules/plus/curly-newline
+  rules['@stylistic/curly-newline'] = curlyNewlineRule;
+}
+
+if (indentRule) {
+  // this option sets a specific tab width for your code
+  // https://eslint.style/rules/js/indent
+  rules['@stylistic/indent'] = indentRule;
+}
+
+if (linesAroundCommentRule) {
+  // Extends the base lines-around-comment rule. It adds support for TypeScript syntax.
+  // https://eslint.style/rules/ts/lines-around-comment
+  rules['@stylistic/lines-around-comment'] = linesAroundCommentRule;
+}
+
+if (linesBetweenClassMembersRule) {
+  // Require or disallow an empty line between class members.
+  // https://eslint.style/rules/ts/lines-between-class-members
+  rules['@stylistic/lines-between-class-members'] = linesBetweenClassMembersRule;
+}
+
+if (objectCurlyNewlineRule) {
+  // enforce line breaks between braces
+  // https://eslint.style/rules/js/object-curly-newline
+  rules['@stylistic/object-curly-newline'] = objectCurlyNewlineRule;
+}
+
+if (paddingLineBetweenStatementsRule) {
+  // requires or disallows blank lines between the given 2 kinds of statements. Properly blank lines help developers to understand the code.
+  // https://eslint.style/rules/padding-line-between-statements
+  rules['@stylistic/padding-line-between-statements'] = paddingLineBetweenStatementsRule;
+}
+
+if (paddingLineBetweenStatementsRule) {
+  // requires or disallows blank lines between the given 2 kinds of statements. Properly blank lines help developers to understand the code.
+  // https://eslint.style/rules/padding-line-between-statements
+  rules['@stylistic/padding-line-between-statements'] = paddingLineBetweenStatementsRule;
+}
+
+if (spaceInfixOpsRule) {
+  // This rule is aimed at ensuring there are spaces around infix operators.
+  // https://eslint.style/rules/ts/space-infix-ops
+  rules['@stylistic/space-infix-ops'] = spaceInfixOpsRule;
+}
+
+/** @type {import('eslint').Linter.Config[]} */
+const config = [
+  {
+    name: '@stylistic/ts',
+
+    rules,
+  },
+];
+
+export default config;

package/rules/typescriptConfig.mjs

@@ -0,0 +1,16 @@
+// @ts-check
+import defaultTs from './defaultTs.mjs';
+import off from './off.mjs';
+import plus from './plus.mjs';
+import strictTs from './strictTs.mjs';
+import stylisticTs from './stylisticTs.mjs';
+
+const config = [
+  ...off,
+  ...defaultTs,
+  ...plus,
+  ...strictTs,
+  ...stylisticTs,
+];
+
+export default config;

package/rules/vanillaConfig.mjs

@@ -0,0 +1,26 @@
+// @ts-check
+import {
+  bestPractices, customs, errors, es6, node, perfectionist, strict, stylistic,
+} from 'eslint-config-vylda-vanilla';
+import getImportConfig from './imports.mjs';
+import variables from './variablesTs.mjs';
+
+/**
+ * Returns basic confing (Vanilla rules) for typescript ESLint
+ * @param {string} baseDir
+ * @returns {Object[]}
+ */
+const getVanillaConfig = (baseDir) => [
+  ...getImportConfig(baseDir),
+  ...es6,
+  ...strict,
+  ...stylistic,
+  ...bestPractices,
+  ...errors,
+  ...node,
+  ...perfectionist,
+  ...variables,
+  ...customs,
+];
+
+export default getVanillaConfig;

package/rules/variablesTs.mjs

@@ -0,0 +1,129 @@
+import { variables } from 'eslint-config-vylda-vanilla';
+
+/**
+ * @typedef {import('eslint').Linter.RuleSeverity} RuleSeverity
+ *  @typedef {import('eslint').Linter.RulesRecord} GenericRule
+ * @typedef {import('eslint').Linter.Config} Config
+ */
+
+/**
+ *
+ * @param {string} ruleName Rule name
+ * @param {import('eslint').Linter.RulesRecord} rules All rules
+ * @param {Object} [defaultRuleOptions={ }] Rule options for vanilla rule options
+ * @returns {import('eslint').Linter.RulesRecord}
+ */
+const updateGenericRule = (ruleName, rules, defaultRuleOptions = {}) => {
+  const rule = rules[ruleName];
+
+  if (!rule) {
+    return rules;
+  }
+
+  if (typeof rule === 'string' || !Array.isArray(rule)) {
+    /** @type {import('eslint').Linter.RuleEntry} */
+    const newValue = [
+      rule,
+      defaultRuleOptions,
+    ];
+
+    return {
+      ...rules,
+      [ruleName]: newValue,
+    };
+  }
+
+  const [severity, options] = rule;
+
+  if (!options) {
+    /** @type {import('eslint').Linter.RuleEntry} */
+    const newValue = [
+      severity,
+      defaultRuleOptions,
+    ];
+
+    return {
+      ...rules,
+      [ruleName]: newValue,
+    };
+  }
+
+  /** @type {import('eslint').Linter.RuleEntry} */
+  const newValue = [
+    severity,
+    {
+      ...defaultRuleOptions,
+      ...options,
+    },
+  ];
+
+  return {
+    ...rules,
+    [ruleName]: newValue,
+  };
+};
+
+/**
+ *
+ * @param {any} rules
+ * @returns {GenericRule}
+ */
+const updateNoShadowRule = (rules) => {
+  const defaultRuleOptions = {
+    builtinGlobals: true,
+    hoist: 'functions-and-types',
+    ignoreFunctionTypeParameterNameValueShadow: false,
+    ignoreOnInitialization: false,
+    ignoreTypeValueShadow: false,
+  };
+
+  return updateGenericRule('no-shadow', rules, defaultRuleOptions);
+};
+
+/**
+ *
+ * @param {any} rules
+ * @returns {GenericRule}
+ */
+const updateNoUseBeforeDefineRule = (rules) => {
+  const defaultRuleOptions = {
+    classes: true,
+    enums: true,
+    functions: true,
+    ignoreTypeReferences: false,
+    typedefs: true,
+    variables: true,
+  };
+
+  return updateGenericRule('no-use-before-define', rules, defaultRuleOptions);
+};
+
+/**
+ * Update vanilla variables rules
+ * @param {Array<import('eslint').Linter.Config>} variablesConfigs
+ * @returns {Array<import('eslint').Linter.Config>}
+ */
+const updateVariables = (variablesConfigs) => {
+  const updatedVariables = variablesConfigs.map((configItem) => {
+    const { name: configName, rules } = configItem;
+
+    if (!rules) {
+      return configItem;
+    }
+
+    const updatedRulesNoShadow = updateNoShadowRule(rules);
+    const updatesRulesNoUseBeforeDefine = updateNoUseBeforeDefineRule(updatedRulesNoShadow);
+
+    return {
+      ...configItem,
+      name: `typescript/variables extends ${configName ?? 'old config'}`,
+      rules: updatesRulesNoUseBeforeDefine,
+    };
+  });
+
+  return updatedVariables;
+};
+
+const config = updateVariables(variables);
+
+export default config;

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "allowJs": true,
+  "checkJs": true,
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "module": "nodenext",
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "es5"
+  },
+  "exclude": [
+    "node_modules"
+  ],
+  "files": [
+    "index.js",
+    "eslint.config.mjs",
+  ],
+  "include": ["*.js", "*.cjs", "*.mjs", "*.ts"],
+  "noEmit": true
+}