@polariens/kitsune-lint 1.0.0-rc.3

package/eslint/configs/typescript.mjs

@@ -0,0 +1,184 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+import noNullInTypes from '../rules/no-null-in-types.mjs';
+import { IGNORE_PATTERNS, resolveFiles } from '../utils.mjs';
+
+/**
+ * @typedef {Object} TypescriptOptions
+ * @property {string[]} [files] - File patterns override
+ * @property {string[]} [ignores] - Patterns a ignorar
+ * @property {Record<string, unknown>} [rules] - Regras adicionais ou overrides
+ */
+
+/**
+ * Configuração TypeScript com regras recomendadas e naming conventions.
+ * @param {TypescriptOptions} [options={}]
+ * @returns {import('eslint').Linter.Config[]}
+ */
+export function typescript(options = {}) {
+  const { files, ignores, rules: extraRules = {} } = options;
+  const resolvedFiles = resolveFiles('all', files);
+
+  return [
+    {
+      ignores: ignores ?? ['**/*.config.{js,mjs,cjs,ts}', ...IGNORE_PATTERNS],
+    },
+    {
+      ...eslint.configs.recommended,
+      files: resolvedFiles,
+    },
+    ...tseslint.configs.recommended.map((config) => ({
+      ...config,
+      files: resolvedFiles,
+    })),
+    {
+      plugins: {
+        kitsune: {
+          rules: {
+            'no-null-in-types': noNullInTypes,
+          },
+        },
+      },
+    },
+    {
+      files: resolvedFiles,
+      name: '@kitsune/typescript/rules',
+      rules: {
+        // Prefer `===` or `!==` (never == or !=)
+        eqeqeq: ['error', 'always'],
+        '@typescript-eslint/no-empty-object-type': [
+          'error',
+          {
+            allowObjectTypes: 'never',
+            allowInterfaces: 'with-single-extends',
+          },
+        ],
+        '@typescript-eslint/naming-convention': [
+          'error',
+          { selector: 'default', format: ['camelCase'] },
+          { selector: 'variable', format: ['camelCase'] },
+          { selector: 'function', format: ['camelCase'] },
+          { selector: 'class', format: ['PascalCase'] },
+          {
+            selector: 'interface',
+            format: ['PascalCase'],
+            custom: { regex: '^(OAuth|[A-Z][a-z])', match: true },
+          },
+          {
+            selector: 'typeAlias',
+            format: ['PascalCase'],
+            custom: { regex: '^(OAuth|[A-Z][a-z])', match: true },
+          },
+          {
+            // camelCase for properties of interfaces/types
+            selector: 'typeProperty',
+            format: ['camelCase'],
+            leadingUnderscore: 'allow',
+            trailingUnderscore: 'allow',
+          },
+          {
+            // camelCase for class members
+            selector: 'classProperty',
+            format: ['camelCase'],
+            leadingUnderscore: 'allow',
+          },
+          {
+            // camelCase for methods of classes
+            selector: 'classMethod',
+            format: ['camelCase'],
+          },
+          {
+            // PascalCase for parameters of generic types of only one char
+            selector: 'typeParameter',
+            format: ['PascalCase'],
+            custom: { regex: '^[A-Z]$', match: true },
+          },
+          // PascalCase for enums names
+          { selector: 'enum', format: ['PascalCase'] },
+          {
+            // UPPER_CASE for enum members
+            selector: 'enumMember',
+            format: null,
+            custom: { regex: `^['"]?[A-Z]+([-_][A-Z]+)*['"]?$`, match: true },
+          },
+          // camelCase for object literal properties
+          { selector: 'objectLiteralProperty', format: null },
+          // camelCase or PascalCase for imports
+          { selector: 'import', format: ['camelCase', 'PascalCase'] },
+        ],
+        '@typescript-eslint/no-explicit-any': 'error',
+        '@typescript-eslint/consistent-type-imports': ['error', { prefer: 'type-imports' }],
+        '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
+        '@typescript-eslint/no-non-null-assertion': 'warn',
+        '@typescript-eslint/array-type': 'error',
+        'no-shadow': 'off',
+        '@typescript-eslint/no-shadow': 'warn',
+        // Block `console.log` only
+        'no-console': ['error', { allow: ['warn', 'error', 'info'] }],
+        // Disallows concatenation of string literals that can be combined into a single literal (e.g., 'foo' + 'bar' should be 'foobar').
+        'no-useless-concat': 'error',
+        'no-unused-vars': [
+          'error',
+          {
+            argsIgnorePattern: '^_',
+            varsIgnorePattern: '^_',
+          },
+        ],
+        '@typescript-eslint/no-unused-vars': [
+          'error',
+          {
+            argsIgnorePattern: '^_',
+            varsIgnorePattern: '^_',
+          },
+        ],
+        'no-restricted-imports': [
+          'error',
+          {
+            patterns: [
+              {
+                regex: '^\\.\\.\\/.*',
+                message: 'Use o alias @/ ao invés de imports relativos com ../',
+              },
+            ],
+          },
+        ],
+        'sort-imports': [
+          'error',
+          {
+            allowSeparatedGroups: true,
+            ignoreCase: false,
+            ignoreDeclarationSort: true,
+            ignoreMemberSort: false,
+            memberSyntaxSortOrder: ['none', 'all', 'multiple', 'single'],
+          },
+        ],
+        'no-var': 'error',
+        'prefer-const': 'error',
+        'prefer-rest-params': 'error',
+        'prefer-spread': 'error',
+        'no-restricted-syntax': [
+          'error',
+          { selector: 'ExportDefaultDeclaration', message: 'Prefer named exports' },
+          { selector: 'ImportDeclaration[specifiers.length = 0]', message: 'Empty imports are not allowed' },
+        ],
+        'no-duplicate-imports': 'error',
+        // No null in types/interfaces (allowed only with `Api` term)
+        'kitsune/no-null-in-types': [
+          'warn',
+          {
+            skipPattern: ['Api'],
+          },
+        ],
+        ...extraRules,
+      },
+    },
+    {
+      // Disable export/import default in router plugin and config files
+      files: ['src/router/*.ts', '**/*.config.{ts,js}', '.*/**/*.{ts,js}'],
+      rules: {
+        'no-restricted-syntax': 'off',
+      },
+    },
+  ];
+}

package/eslint/configs/vitest.d.mts

@@ -0,0 +1,20 @@
+import type { Linter } from 'eslint';
+
+export type VitestFn = 'test' | 'it';
+
+export interface VitestOptions {
+  /** File patterns override */
+  files?: string[];
+  /** Regex para validação de títulos de testes @default Gherkin PT-BR */
+  titlePattern?: string;
+  /** Mensagem de erro para títulos inválidos */
+  titleMessage?: string;
+  /** Função de teste preferida @default 'test' */
+  fn?: VitestFn;
+  /** Máximo de describe aninhados @default 3 */
+  maxNestedDescribe?: number;
+  /** Regras adicionais ou overrides */
+  rules?: Partial<Linter.RulesRecord>;
+}
+
+export declare function vitest(options?: VitestOptions): Promise<Linter.Config[]>;

package/eslint/configs/vitest.mjs

@@ -0,0 +1,62 @@
+import { resolveFiles } from '../utils.mjs';
+
+/**
+ * @typedef {Object} VitestOptions
+ * @property {string[]} [files] - File patterns override
+ * @property {string} [titlePattern] - Regex para validação de títulos de testes
+ * @property {string} [titleMessage] - Mensagem de erro para títulos inválidos
+ * @property {'test' | 'it'} [fn='test'] - Função de teste preferida
+ * @property {number} [maxNestedDescribe=3] - Máximo de describe aninhados
+ * @property {Record<string, unknown>} [rules] - Regras adicionais ou overrides
+ */
+
+const GHERKIN_PT = '^Dado[^\\n]+(?:\\n\\s*(?:E|Mas)\\b[^\\n]+)*\\n\\s*Quando[^\\n]+(?:\\n\\s*(?:E|Mas)\\b[^\\n]+)*\\n\\s*Então[^\\n]+';
+const GHERKIN_PT_MESSAGE =
+  'O título do test() deve seguir o padrão Gherkin em português: "Dado ...\\nQuando ...\\nEntão ..."';
+
+/**
+ * Regras do plugin Vitest para padronização de testes.
+ * @param {VitestOptions} [options={}]
+ * @returns {Promise<import('eslint').Linter.Config[]>}
+ */
+export async function vitest(options = {}) {
+  const {
+    files,
+    titlePattern = GHERKIN_PT,
+    titleMessage = GHERKIN_PT_MESSAGE,
+    fn = 'test',
+    maxNestedDescribe = 3,
+    rules: extraRules = {},
+  } = options;
+
+  const vitestPlugin = await import('@vitest/eslint-plugin').then((m) => m.default ?? m);
+
+  return [
+    {
+      files: resolveFiles('tests', files),
+      name: '@kitsune/vitest/rules',
+      plugins: { vitest: vitestPlugin },
+      rules: {
+        ...vitestPlugin.configs.recommended.rules,
+        'vitest/consistent-test-filename': 'error',
+        'vitest/consistent-test-it': ['error', { fn }],
+        'vitest/valid-title': [
+          'error',
+          { mustMatch: { [fn]: [titlePattern, titleMessage] } },
+        ],
+        'vitest/require-top-level-describe': 'error',
+        'vitest/no-identical-title': 'error',
+        'vitest/no-focused-tests': 'error',
+        'vitest/no-disabled-tests': 'warn',
+        'vitest/no-duplicate-hooks': 'error',
+        'vitest/prefer-hooks-on-top': 'error',
+        'vitest/prefer-hooks-in-order': 'error',
+        'vitest/prefer-to-be': 'error',
+        'vitest/prefer-each': 'error',
+        'vitest/no-mocks-import': 'off',
+        'vitest/max-nested-describe': ['error', { max: maxNestedDescribe }],
+        ...extraRules,
+      },
+    },
+  ];
+}

package/eslint/configs/vue.d.mts

@@ -0,0 +1,25 @@
+import type { Linter } from 'eslint';
+
+export type VueApiStyle = 'script-setup' | 'composition' | 'options';
+
+export type NameCasing = 'camelCase' | 'PascalCase' | 'kebab-case' | 'snake_case';
+
+
+export interface VueOptions {
+  /** File patterns override */
+  files?: string[];
+  /** Estilo de API Vue preferido @default 'script-setup' */
+  apiStyle?: VueApiStyle;
+  /** Nomeclatura para nomes de componentes @default 'PascalCase' */
+  componentsNameCasing?: NameCasing;
+  /** Padrões de componentes ignorados para validação de nomenclatura @default 'PascalCase' */
+  componentsNameCasingIgnores?: string[];
+  /** Nomeclatura para nomes de propriedades @default 'camelCase' */
+  propNameCasing?: NameCasing;
+  /** Nomeclatura para nomes de slots @default 'kebab-case' */
+  slotNameCasing?: NameCasing;
+  /** Regras adicionais ou overrides */
+  rules?: Partial<Linter.RulesRecord>;
+}
+
+export declare function vue(options?: VueOptions): Linter.Config[];

package/eslint/configs/vue.mjs

@@ -0,0 +1,71 @@
+import pluginVue from 'eslint-plugin-vue';
+import tseslint from 'typescript-eslint';
+import vueParser from 'vue-eslint-parser';
+
+import { resolveFiles } from '../utils.mjs';
+
+/**
+ * @typedef {Object} VueOptions
+ * @property {string[]} [files] - File patterns override
+ * @property {'script-setup' | 'composition' | 'options'} [apiStyle='script-setup']
+ * @property {Record<string, unknown>} [rules] - Regras adicionais ou overrides
+ */
+
+/**
+ * Regras para projetos Vue 3 com TypeScript.
+ * @param {VueOptions} [options={}]
+ * @returns {import('eslint').Linter.Config[]}
+ */
+export function vue(options = {}) {
+  const { 
+    files, 
+    apiStyle = 'script-setup', 
+    rules: extraRules = {}, 
+    componentsNameCasing = 'PascalCase', 
+    componentsNameCasingIgnores = [], 
+    propNameCasing = 'camelCase',
+    slotNameCasing = 'kebab-case', 
+  } = options;
+
+  return [
+    ...pluginVue.configs['flat/recommended'],
+    {
+      files: resolveFiles('vue', files),
+      name: '@kitsune/vue/rules',
+      languageOptions: {
+        parser: vueParser,
+        parserOptions: {
+          parser: tseslint.parser,
+        },
+      },
+      rules: {
+        'no-undef': 'off',
+        '@typescript-eslint/explicit-function-return-type': 'off',
+        'vue/block-lang': ['error', { script: { lang: 'ts' } }],
+        'vue/block-order': ['error', { order: ['script', 'template', 'style'] }],
+        'vue/block-tag-newline': 'error',
+        'vue/component-api-style': ['error', [apiStyle]],
+        'vue/define-props-declaration': ['error', 'type-based'],
+        'vue/define-emits-declaration': ['error', 'type-based'],
+        'vue/no-setup-props-reactivity-loss': 'error',
+        'vue/no-undef-properties': 'error',
+        'vue/no-unused-emit-declarations': 'error',
+        'vue/no-useless-v-bind': 'error',
+        'vue/padding-line-between-blocks': ['error', 'always'],
+        'vue/no-static-inline-styles': 'error',
+        'vue/require-typed-ref': 'error',
+        'vue/prop-name-casing': ['error', propNameCasing],
+        'vue/slot-name-casing': ['error', slotNameCasing],
+        'vue/component-name-in-template-casing': [
+          'error',
+          componentsNameCasing,
+          {
+            registeredComponentsOnly: false,
+            ignores: componentsNameCasingIgnores,
+          },
+        ],
+        ...extraRules,
+      },
+    },
+  ];
+}

package/eslint/index.d.mts

@@ -0,0 +1,51 @@
+import type { Linter } from 'eslint';
+
+import type { BaseOptions } from './configs/base.mjs';
+import type { CleanCodeOptions } from './configs/clean-code.mjs';
+import type { PiniaOptions } from './configs/pinia.mjs';
+import type { SecurityOptions } from './configs/security.mjs';
+import type { TestsOptions } from './configs/tests.mjs';
+import type { TypescriptOptions } from './configs/typescript.mjs';
+import type { VitestOptions } from './configs/vitest.mjs';
+import type { VueOptions } from './configs/vue.mjs';
+
+export type { BaseOptions } from './configs/base.mjs';
+export type { CleanCodeOptions } from './configs/clean-code.mjs';
+export type { PiniaOptions } from './configs/pinia.mjs';
+export type { SecurityOptions } from './configs/security.mjs';
+export type { TestsOptions } from './configs/tests.mjs';
+export type { TypescriptOptions } from './configs/typescript.mjs';
+export type { VitestFn, VitestOptions } from './configs/vitest.mjs';
+export type { VueApiStyle, VueOptions } from './configs/vue.mjs';
+
+export { base } from './configs/base.mjs';
+export { cleanCode } from './configs/clean-code.mjs';
+export { pinia } from './configs/pinia.mjs';
+export { security } from './configs/security.mjs';
+export { tests } from './configs/tests.mjs';
+export { typescript } from './configs/typescript.mjs';
+export { vitest } from './configs/vitest.mjs';
+export { vue } from './configs/vue.mjs';
+
+export interface CreateKitsuneConfigOptions {
+  /** Configuração base (globals do ambiente) @default true */
+  base?: BaseOptions | boolean;
+  /** Regras TypeScript + naming conventions @default true */
+  typescript?: TypescriptOptions | boolean;
+  /** Regras de segurança (eval, XSS, injection) @default true */
+  security?: SecurityOptions | boolean;
+  /** Regras de clean code (SRP, legibilidade, imutabilidade) @default true */
+  cleanCode?: CleanCodeOptions | boolean;
+  /** Regras Vue 3 (script setup, block order) @default false */
+  vue?: VueOptions | boolean;
+  /** Regras Pinia (naming, organização de stores) @default false */
+  pinia?: PiniaOptions | boolean;
+  /** Relaxamentos para arquivos de teste @default false */
+  tests?: TestsOptions | boolean;
+  /** Regras Vitest (plugin vitest) @default false */
+  vitest?: VitestOptions | boolean;
+  /** Configs adicionais a incluir no final (ex: eslint-config-prettier) */
+  extend?: Linter.Config[];
+}
+
+export declare function createKitsuneConfig(options?: CreateKitsuneConfigOptions): Promise<Linter.Config[]>;

package/eslint/index.mjs

@@ -0,0 +1,85 @@
+export { base } from './configs/base.mjs';
+export { cleanCode } from './configs/clean-code.mjs';
+export { pinia } from './configs/pinia.mjs';
+export { security } from './configs/security.mjs';
+export { tests } from './configs/tests.mjs';
+export { typescript } from './configs/typescript.mjs';
+export { vitest } from './configs/vitest.mjs';
+export { vue } from './configs/vue.mjs';
+
+/**
+ * @typedef {Object} CreateKitsuneConfigOptions
+ * @property {import('./configs/base.mjs').BaseOptions | boolean} [base=true]
+ * @property {import('./configs/typescript.mjs').TypescriptOptions | boolean} [typescript=true]
+ * @property {import('./configs/security.mjs').SecurityOptions | boolean} [security=true]
+ * @property {import('./configs/clean-code.mjs').CleanCodeOptions | boolean} [cleanCode=true]
+ * @property {import('./configs/vue.mjs').VueOptions | boolean} [vue=false]
+ * @property {import('./configs/pinia.mjs').PiniaOptions | boolean} [pinia=false]
+ * @property {import('./configs/tests.mjs').TestsOptions | boolean} [tests=false]
+ * @property {import('./configs/vitest.mjs').VitestOptions | boolean} [vitest=false]
+ * @property {import('eslint').Linter.Config[]} [extend] - Configs adicionais a incluir no final
+ */
+
+/**
+ * Factory que compõe uma configuração ESLint completa a partir de módulos selecionados.
+ *
+ * @example
+ * import { createKitsuneConfig } from '@merieli/kitsune-lint/eslint';
+ * export default await createKitsuneConfig();
+ *
+ * @example
+ * import { createKitsuneConfig } from '@merieli/kitsune-lint/eslint';
+ * export default await createKitsuneConfig({ vue: true, pinia: true, tests: true, vitest: true });
+ *
+ * @example
+ * import { createKitsuneConfig } from '@merieli/kitsune-lint/eslint';
+ * export default await createKitsuneConfig({
+ *   base: { environment: 'node' },
+ *   cleanCode: { maxDepth: 3, maxParams: 3, complexity: 10 },
+ *   vue: { apiStyle: 'composition' },
+ *   pinia: true,
+ *   tests: true,
+ *   vitest: true,
+ * });
+ *
+ * @param {CreateKitsuneConfigOptions} [options={}]
+ * @returns {Promise<import('eslint').Linter.Config[]>}
+ */
+export async function createKitsuneConfig(options = {}) {
+  const {
+    base: baseOpt = true,
+    typescript: tsOpt = true,
+    security: secOpt = true,
+    cleanCode: cleanOpt = true,
+    vue: vueOpt = false,
+    pinia: piniaOpt = false,
+    tests: testsOpt = false,
+    vitest: vitestOpt = false,
+    extend = [],
+  } = options;
+
+  const configs = [];
+
+  const moduleMap = [
+    { opt: baseOpt, name: 'base', file: 'base' },
+    { opt: tsOpt, name: 'typescript', file: 'typescript' },
+    { opt: secOpt, name: 'security', file: 'security' },
+    { opt: cleanOpt, name: 'cleanCode', file: 'clean-code' },
+    { opt: vueOpt, name: 'vue', file: 'vue' },
+    { opt: piniaOpt, name: 'pinia', file: 'pinia' },
+    { opt: testsOpt, name: 'tests', file: 'tests' },
+    { opt: vitestOpt, name: 'vitest', file: 'vitest' },
+  ];
+
+  for (const { opt, name, file } of moduleMap) {
+    if (opt) {
+      const mod = await import(`./configs/${file}.mjs`);
+      const configArr = await mod[name](opt === true ? {} : opt);
+      configs.push(...configArr);
+    }
+  }
+
+  configs.push(...extend);
+
+  return configs;
+}

package/eslint/rules/no-null-in-types.mjs

@@ -0,0 +1,117 @@
+/**
+ * Custom ESLint rule: disallow `null` in interfaces/types unless
+ * the interface/type name contains a specific string defined via
+ * configuration. Default is "Api".
+ *
+ * @file
+ */
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow `null` in interfaces/types unless the name contains a configured string.',
+      category: 'Possible Errors',
+      recommended: false,
+    },
+    messages: {
+      noNull:
+        'Type "{{name}}" uses `null`; only interfaces/types whose name contains "{{skipPattern}}" may contain `null`.',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          skipPattern: {
+            oneOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }],
+            description:
+              'String or array of strings that, if present in the type name, skips the null check.',
+            default: 'Api',
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options?.[0] ?? {};
+    let skipPatterns = options.skipPattern ?? 'Api';
+    if (!Array.isArray(skipPatterns)) {
+      skipPatterns = [skipPatterns];
+    }
+
+    /**
+     * Detects if a type node contains a `null` literal.
+     *
+     * @param {TSESTree.TSType} node
+     * @returns {boolean}
+     */
+    function containsNull(node) {
+      if (!node) return false;
+
+      switch (node.type) {
+        case AST_NODE_TYPES.TSNullKeyword:
+          return true;
+        case AST_NODE_TYPES.TSUnionType:
+          return node.types.some(containsNull);
+        case AST_NODE_TYPES.TSTypeAnnotation:
+          return containsNull(node.typeAnnotation);
+        case AST_NODE_TYPES.TSTypeLiteral:
+          // Check members only for object literal types
+          return node.members.some(
+            (m) =>
+              m.type === AST_NODE_TYPES.TSPropertySignature &&
+              containsNull(m.typeAnnotation?.typeAnnotation),
+          );
+        default:
+          return false;
+      }
+    }
+
+    /**
+     * Handles property signatures inside interfaces or type literals.
+     *
+     * @param {TSESTree.TSPropertySignature} prop
+     * @param {string} typeName
+     */
+    function checkProperty(prop, typeName) {
+      const typeNode = prop.typeAnnotation?.typeAnnotation;
+      if (typeNode && containsNull(typeNode)) {
+        context.report({
+          node: prop,
+          messageId: 'noNull',
+          data: { name: typeName, skipPattern: skipPatterns.join(', ') },
+        });
+      }
+    }
+
+    return {
+      TSInterfaceDeclaration(node) {
+        const name = node.id?.name;
+        if (!name || skipPatterns.some((pattern) => name.includes(pattern))) return; // skip based on config
+
+        node.body.body.forEach((member) => {
+          if (member.type === AST_NODE_TYPES.TSPropertySignature) {
+            checkProperty(member, name);
+          }
+        });
+      },
+
+      TSTypeAliasDeclaration(node) {
+        const name = node.id?.name;
+        if (!name || skipPatterns.some((pattern) => name.includes(pattern))) return; // skip based on config
+
+        if (node.typeAnnotation.type === 'TSTypeLiteral') {
+          node.typeAnnotation.members.forEach((member) => {
+            if (member.type === AST_NODE_TYPES.TSPropertySignature) {
+              checkProperty(member, name);
+            }
+          });
+        }
+      },
+    };
+  },
+};

package/eslint/utils.d.mts

@@ -0,0 +1,7 @@
+export type FilePatternKey = 'all' | 'tests' | 'vue' | 'pinia' | 'configs';
+
+export declare const FILE_PATTERNS: Record<FilePatternKey, string[]>;
+
+export declare const IGNORE_PATTERNS: string[];
+
+export declare function resolveFiles(key: FilePatternKey, custom?: string[]): string[];

package/eslint/utils.mjs

@@ -0,0 +1,20 @@
+export const FILE_PATTERNS = {
+  all: ['**/*.{vue,js,mjs,cjs,ts}'],
+  tests: ['tests/**/*.{js,mjs,cjs,ts}'],
+  vue: ['**/*.vue'],
+  pinia: ['src/state/**/*.{ts}'],
+  configs: ['**/*.config.{js,mjs,cjs,ts}'],
+};
+
+export const IGNORE_PATTERNS = ['coverage', 'dist', 'node_modules'];
+
+/**
+ * Mescla file patterns customizados com os padrões.
+ * @param {string} key - Chave do FILE_PATTERNS a usar como base
+ * @param {string[] | undefined} custom - Patterns adicionais do consumidor
+ * @returns {string[]}
+ */
+export function resolveFiles(key, custom) {
+  if (custom) return custom;
+  return FILE_PATTERNS[key] ?? FILE_PATTERNS.all;
+}