oxlint-plugin-arch 0.2.1 → 0.2.2

package/package.json

@@ -1,25 +1,24 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./dist/index.js"
   },
   "files": [
     "CHANGELOG.md",
-    "src/index.ts",
-    "src/rules",
-    "src/utils"
+    "dist"
   ],
   "scripts": {
-    "check": "bun run lint && bun run test && bun run typecheck && bun run check:examples && bun run check:skill-assets",
+    "build": "bun build src/index.ts --outfile dist/index.js --target node --format esm --external @oxlint/plugins",
+    "check": "bun run lint && bun run test && bun run typecheck && bun run build && bun run check:examples && bun run check:skill-assets",
     "lint": "oxlint src examples scripts skills/install-oxlint-arch/scripts",
     "test": "vitest run src/tests",
     "typecheck": "tsc --noEmit",
     "sync:skill-assets": "bun scripts/sync-skill-assets.ts",
-    "check:examples": "oxlint examples/minimal.oxlint.config.ts -c examples/minimal.oxlint.config.ts --disable-nested-config && oxlint examples/full.oxlint.config.ts -c examples/full.oxlint.config.ts --disable-nested-config",
+    "check:examples": "oxlint examples/minimal.oxlint.config.ts -c examples/minimal.oxlint.config.ts --disable-nested-config && oxlint examples/full.oxlint.config.ts -c examples/full.oxlint.config.ts --disable-nested-config && oxlint examples/dist.oxlint.config.ts -c examples/dist.oxlint.config.ts --disable-nested-config",
     "check:skill-assets": "bun scripts/sync-skill-assets.ts --check",
     "prepublishOnly": "bun run check",
     "release": "bash scripts/release.sh",

package/src/index.ts

@@ -1,57 +0,0 @@
-import { eslintCompatPlugin } from '@oxlint/plugins'
-import { exportFilePrefix } from './rules/export-file-prefix.ts'
-import { exportNamePattern } from './rules/export-name-pattern.ts'
-import { filenameExportName } from './rules/filename-export-name.ts'
-import { filenameMatch } from './rules/filename-match.ts'
-import { folderPrefix } from './rules/folder-prefix.ts'
-import { noExtraExports } from './rules/no-extra-exports.ts'
-import { noExtraFactoryKeys } from './rules/no-extra-factory-keys.ts'
-import { noFileLevelHelpers } from './rules/no-file-level-helpers.ts'
-import { noImportedTypeAlias } from './rules/no-imported-type-alias.ts'
-import { noInlineSchemaElements } from './rules/no-inline-schema-elements.ts'
-import { noLocalSchemaConstruction } from './rules/no-local-schema-construction.ts'
-import { noRederiveSchema } from './rules/no-rederive-schema.ts'
-import { noRestrictedFiles } from './rules/no-restricted-files.ts'
-import { noRestrictedToken } from './rules/no-restricted-token.ts'
-import { noRuntimeInTypes } from './rules/no-runtime-in-types.ts'
-import { noSingleUseScalarSchema } from './rules/no-single-use-scalar-schema.ts'
-import { noTopLevelFunctions } from './rules/no-top-level-functions.ts'
-import { noTrivialFunctions } from './rules/no-trivial-functions.ts'
-import { noUnescapedLike } from './rules/no-unescaped-like.ts'
-import { onlyExportComponents } from './rules/only-export-components.ts'
-import { requireFileFactory } from './rules/require-file-factory.ts'
-import { requireObjectParams } from './rules/require-object-params.ts'
-import { requireOrpcOutput } from './rules/require-orpc-output.ts'
-import { requirePairedCall } from './rules/require-paired-call.ts'
-import { routeSurface } from './rules/route-surface.ts'
-
-export default eslintCompatPlugin({
-  meta: { name: 'arch' },
-  rules: {
-    'export-file-prefix': exportFilePrefix,
-    'export-name-pattern': exportNamePattern,
-    'filename-export-name': filenameExportName,
-    'filename-match': filenameMatch,
-    'folder-prefix': folderPrefix,
-    'no-extra-exports': noExtraExports,
-    'no-extra-factory-keys': noExtraFactoryKeys,
-    'no-file-level-helpers': noFileLevelHelpers,
-    'no-imported-type-alias': noImportedTypeAlias,
-    'no-inline-schema-elements': noInlineSchemaElements,
-    'no-local-schema-construction': noLocalSchemaConstruction,
-    'no-rederive-schema': noRederiveSchema,
-    'no-restricted-files': noRestrictedFiles,
-    'no-restricted-token': noRestrictedToken,
-    'no-runtime-in-types': noRuntimeInTypes,
-    'no-single-use-scalar-schema': noSingleUseScalarSchema,
-    'no-top-level-functions': noTopLevelFunctions,
-    'no-trivial-functions': noTrivialFunctions,
-    'no-unescaped-like': noUnescapedLike,
-    'only-export-components': onlyExportComponents,
-    'require-file-factory': requireFileFactory,
-    'require-object-params': requireObjectParams,
-    'require-orpc-output': requireOrpcOutput,
-    'require-paired-call': requirePairedCall,
-    'route-surface': routeSurface,
-  },
-})

package/src/rules/export-file-prefix.ts

@@ -1,70 +0,0 @@
-import { defineRule } from '@oxlint/plugins'
-import { declarationsCollectNamed, exportsCollect, namingFileBasename, optionsFirst } from '../utils/index.ts'
-
-interface ExportFilePrefixOptions {
-  stem?: 'before-first-dot' | 'full-basename'
-  normalize?: 'remove-separators' | 'none'
-  allDeclarations?: boolean
-  allowPattern?: string
-}
-
-/**
- * Checks that exported names start with a prefix taken from the filename, and can also check every function and type in the file.
- *
- * Example: In `foo-chart.tsx`, `fooChartPreview` and `interface FooChartPreviewProps` pass; `preview` fails when `allDeclarations` is on.
- */
-export const exportFilePrefix = defineRule({
-  meta: {
-    type: 'problem',
-    schema: [{
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        stem: { type: 'string', enum: ['before-first-dot', 'full-basename'] },
-        normalize: { type: 'string', enum: ['remove-separators', 'none'] },
-        allDeclarations: { type: 'boolean' },
-        allowPattern: { type: 'string' },
-      },
-    }],
-    messages: {
-      prefix: "'{{name}}' must start with file prefix '{{prefix}}'.",
-    },
-  },
-  createOnce(context) {
-    return {
-      Program(program) {
-        const options = optionsFirst<ExportFilePrefixOptions>(context, {
-          stem: 'before-first-dot',
-          normalize: 'remove-separators',
-        })
-        const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, '')
-        const stem = options.stem === 'full-basename' ? basename : (basename.split('.')[0] ?? '')
-        const prefix = options.normalize === 'none' ? stem : stem.replaceAll(/[-_]/g, '').toLowerCase()
-        const allowed = options.allowPattern ? new RegExp(options.allowPattern) : null
-        const names = options.allDeclarations
-          ? declarationsCollectNamed(program)
-          : exportsCollect(program).map((binding) => ({
-              name: binding.localName ?? binding.exportedName,
-              node: binding.node,
-            }))
-        const seen = new Set<string>()
-
-        for (const item of names) {
-          const key = `${item.name}:${item.node.start}:${item.node.end}`
-          const comparableName = options.normalize === 'none' ? item.name : item.name.replaceAll('_', '').toLowerCase()
-
-          if (seen.has(key) || allowed?.test(item.name) || comparableName.startsWith(prefix)) {
-            continue
-          }
-
-          seen.add(key)
-          context.report({
-            node: item.node,
-            messageId: 'prefix',
-            data: { name: item.name, prefix },
-          })
-        }
-      },
-    }
-  },
-})

package/src/rules/export-name-pattern.ts

@@ -1,71 +0,0 @@
-import { defineRule } from '@oxlint/plugins'
-import { declarationsCollectNamed, exportsCollect, optionsFirst } from '../utils/index.ts'
-
-interface ExportNamePatternOptions {
-  pattern: string
-  flags?: string
-  ignoreTypeExports?: boolean
-  allDeclarations?: boolean
-  allowPattern?: string
-}
-
-/**
- * Checks exported names, or every function and type, against a regular expression supplied in the rule options.
- *
- * Example: With `^user[A-Z]`, `userGet` passes while `getUser` fails.
- */
-export const exportNamePattern = defineRule({
-  meta: {
-    type: 'problem',
-    schema: [{
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        pattern: { type: 'string' },
-        flags: { type: 'string' },
-        ignoreTypeExports: { type: 'boolean' },
-        allDeclarations: { type: 'boolean' },
-        allowPattern: { type: 'string' },
-      },
-      required: ['pattern'],
-    }],
-    messages: {
-      pattern: "'{{name}}' must match {{pattern}}.",
-    },
-  },
-  createOnce(context) {
-    return {
-      Program(program) {
-        const {
-          pattern,
-          flags,
-          ignoreTypeExports = false,
-          allDeclarations = false,
-          allowPattern,
-        } = optionsFirst<ExportNamePatternOptions>(context)
-        const allowed = allowPattern ? new RegExp(allowPattern) : null
-        const names = allDeclarations
-          ? declarationsCollectNamed(program)
-          : exportsCollect(program).flatMap((binding) => ignoreTypeExports && binding.typeOnly
-            ? []
-            : [{ name: binding.localName ?? binding.exportedName, node: binding.node }])
-        const seen = new Set<string>()
-
-        for (const item of names) {
-          const key = `${item.name}:${item.node.start}:${item.node.end}`
-
-          if (seen.has(key) || allowed?.test(item.name) || new RegExp(pattern, flags).test(item.name)) {
-            continue
-          }
-
-          seen.add(key)
-          context.report({
-            node: item.node,
-            messageId: 'pattern',
-            data: { name: item.name, pattern },
-          })
-        }
-      },
-    }
-  },
-})

package/src/rules/filename-export-name.ts

@@ -1,86 +0,0 @@
-import { defineRule } from '@oxlint/plugins'
-import {
-  declarationsCollectFunctions,
-  exportsCollectFunctions,
-  factoriesExpandTemplate,
-  namingFileBasename,
-  namingMatchTemplate,
-  optionsFirst,
-} from '../utils/index.ts'
-
-interface FilenameExportNameOptions {
-  file: string
-  export: string
-  mode?: 'all' | 'some'
-  placeholderPattern?: string
-  allDeclarations?: boolean
-}
-
-/**
- * Builds an expected function name from filename placeholders, then checks exported or all functions against it.
- *
- * Example: `user-action.create.ts` can require `makeUserActionCreate`; `mode: some` allows additional exports.
- */
-export const filenameExportName = defineRule({
-  meta: {
-    type: 'problem',
-    schema: [{
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        file: { type: 'string' },
-        export: { type: 'string' },
-        mode: { type: 'string', enum: ['all', 'some'] },
-        placeholderPattern: { type: 'string' },
-        allDeclarations: { type: 'boolean' },
-      },
-      required: ['file', 'export'],
-    }],
-    messages: {
-      mismatch: "Function '{{actual}}' must match '{{expected}}'.",
-    },
-  },
-  createOnce(context) {
-    return {
-      Program(program) {
-        const {
-          file,
-          export: exportTemplate,
-          mode = 'all',
-          placeholderPattern,
-          allDeclarations = false,
-        } = optionsFirst<FilenameExportNameOptions>(context)
-        const groups = namingMatchTemplate(namingFileBasename(context.filename), file, placeholderPattern)
-
-        if (!groups) {
-          return
-        }
-
-        const expected = factoriesExpandTemplate(exportTemplate, groups)
-        const functions = allDeclarations ? declarationsCollectFunctions(program) : exportsCollectFunctions(program)
-
-        if (mode === 'some') {
-          if (!functions.some((item) => item.name === expected)) {
-            const first = functions.at(0)
-            context.report({
-              node: first?.node ?? program,
-              messageId: 'mismatch',
-              data: { actual: first?.name ?? '<none>', expected },
-            })
-          }
-          return
-        }
-
-        for (const item of functions) {
-          if (item.name !== expected) {
-            context.report({
-              node: item.node,
-              messageId: 'mismatch',
-              data: { actual: item.name, expected },
-            })
-          }
-        }
-      },
-    }
-  },
-})

package/src/rules/filename-match.ts

@@ -1,47 +0,0 @@
-import { defineRule } from '@oxlint/plugins'
-import { namingFileBasename, optionsFirst } from '../utils/index.ts'
-
-interface FilenameMatchOptions {
-  pattern: string
-  message: string
-  flags?: string
-}
-
-/**
- * Checks the current filename against a configurable regular expression and reports the configured message.
- *
- * Example: A pattern ending in `.spec.ts` accepts `login.spec.ts` and rejects `login.test.ts`.
- */
-export const filenameMatch = defineRule({
-  meta: {
-    type: 'problem',
-    schema: [{
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        pattern: { type: 'string' },
-        message: { type: 'string' },
-        flags: { type: 'string' },
-      },
-      required: ['pattern', 'message'],
-    }],
-    messages: {
-      mismatch: '{{message}}',
-    },
-  },
-  createOnce(context) {
-    return {
-      Program(program) {
-        const { pattern, message, flags } = optionsFirst<FilenameMatchOptions>(context)
-
-        if (!new RegExp(pattern, flags).test(namingFileBasename(context.filename))) {
-          context.report({
-            node: program,
-            messageId: 'mismatch',
-            data: { message },
-          })
-        }
-      },
-    }
-  },
-})

package/src/rules/folder-prefix.ts

@@ -1,73 +0,0 @@
-import { defineRule } from '@oxlint/plugins'
-import {
-  namingDirSegments,
-  namingFileBasename,
-  namingFolderPrefixes,
-  namingPosixPath,
-  namingSegmentsAfter,
-  optionsFirst,
-} from '../utils/index.ts'
-
-interface FolderPrefixOptions {
-  singularize?: 'none' | 'trailing-s'
-  separators?: string[]
-  after?: string
-}
-
-/**
- * Checks that a filename equals or starts with its parent folder name, or with the folders after a configured root.
- *
- * Example: Inside `users/`, `user-card.tsx` passes. With `after: 'components'`, `components/admin/insights/admin-insights-foo.tsx` passes.
- */
-export const folderPrefix = defineRule({
-  meta: {
-    type: 'problem',
-    schema: [{
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        singularize: { type: 'string', enum: ['none', 'trailing-s'] },
-        separators: { type: 'array', items: { type: 'string' } },
-        after: { type: 'string' },
-      },
-    }],
-    messages: {
-      prefix: "File '{{file}}' must start with folder name '{{folder}}' or an allowed singular form.",
-    },
-  },
-  createOnce(context) {
-    return {
-      Program(program) {
-        const {
-          singularize = 'trailing-s',
-          separators = ['-'],
-          after,
-        } = optionsFirst<FolderPrefixOptions>(context, {})
-        const filename = namingPosixPath(context.filename)
-        const folders = after
-          ? namingSegmentsAfter(filename, after)
-          : [namingDirSegments(filename).at(-1) ?? '']
-
-        if (!folders) {
-          return
-        }
-
-        const resolved = folders.length > 0 ? folders : [namingDirSegments(filename).at(-1) ?? '']
-        const separator = separators[0] ?? '-'
-        const prefixes = namingFolderPrefixes(resolved, separator, singularize)
-        const file = namingFileBasename(filename)
-        const stem = file.replace(/\.(tsx?|jsx?)$/, '')
-        const valid = prefixes.some((prefix) => stem === prefix
-          || separators.some((item) => stem.startsWith(`${prefix}${item}`)))
-
-        if (!valid) {
-          context.report({
-            node: program,
-            messageId: 'prefix',
-            data: { file, folder: prefixes[0] ?? '' },
-          })
-        }
-      },
-    }
-  },
-})

package/src/rules/no-extra-exports.ts

@@ -1,60 +0,0 @@
-import { defineRule } from '@oxlint/plugins'
-import { exportsCollect, namingCamelCase, namingFileBasename, namingPascalCase, optionsFirst } from '../utils/index.ts'
-
-interface NoExtraExportsOptions {
-  names: string[]
-  domainStem?: 'before-first-dot' | 'full-basename'
-  allowTypeExports?: boolean
-}
-
-/**
- * Allows only the configured export-name templates, with placeholders derived from the filename.
- *
- * Example: `billing.service.ts` may allow `makeBillingService`; an exported `helper` then fails.
- */
-export const noExtraExports = defineRule({
-  meta: {
-    type: 'problem',
-    schema: [{
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        names: { type: 'array', items: { type: 'string' } },
-        domainStem: { type: 'string', enum: ['before-first-dot', 'full-basename'] },
-        allowTypeExports: { type: 'boolean' },
-      },
-      required: ['names'],
-    }],
-    messages: {
-      extraExport: "Export '{{name}}' is not allowed; expected one of: {{allowed}}.",
-    },
-  },
-  createOnce(context) {
-    return {
-      Program(program) {
-        const options = optionsFirst<NoExtraExportsOptions>(context)
-        const basename = namingFileBasename(context.filename).replace(/\.(tsx?|jsx?)$/, '')
-        const domain = options.domainStem === 'full-basename' ? basename : (basename.split('.')[0] ?? '')
-        const allowed = options.names.map((template) => template
-          .replaceAll('{Domain}', namingPascalCase(domain))
-          .replaceAll('{domain}', namingCamelCase(domain)))
-
-        for (const binding of exportsCollect(program)) {
-          if (options.allowTypeExports && binding.typeOnly) {
-            continue
-          }
-
-          const name = binding.localName ?? binding.exportedName
-
-          if (!allowed.includes(name)) {
-            context.report({
-              node: binding.node,
-              messageId: 'extraExport',
-              data: { name, allowed: allowed.join(', ') },
-            })
-          }
-        }
-      },
-    }
-  },
-})

package/src/rules/no-extra-factory-keys.ts

@@ -1,58 +0,0 @@
-import { defineRule } from '@oxlint/plugins'
-import {
-  factoriesCollectTopLevel,
-  factoriesDirectlyReturnedObjects,
-  factoriesObjectPropertyName,
-  optionsFirst,
-} from '../utils/index.ts'
-
-interface NoExtraFactoryKeysOptions {
-  keys: string[]
-  factoryPattern?: string
-}
-
-/**
- * Checks direct object returns from selected top-level factories and rejects keys outside the configured allow-list.
- *
- * Example: With `keys: [run]`, `return { run }` passes while `return { run, preview }` fails.
- */
-export const noExtraFactoryKeys = defineRule({
-  meta: {
-    type: 'problem',
-    schema: [{
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        keys: { type: 'array', items: { type: 'string' } },
-        factoryPattern: { type: 'string' },
-      },
-      required: ['keys'],
-    }],
-    messages: {
-      extraKey: "Factory '{{factory}}' must not return key '{{key}}'; allowed keys: {{allowed}}.",
-    },
-  },
-  createOnce(context) {
-    return {
-      Program(program) {
-        const { keys, factoryPattern = '^make[A-Z]' } = optionsFirst<NoExtraFactoryKeysOptions>(context)
-
-        for (const factory of factoriesCollectTopLevel(program, new RegExp(factoryPattern))) {
-          for (const object of factoriesDirectlyReturnedObjects(factory)) {
-            for (const property of object.properties) {
-              const key = factoriesObjectPropertyName(property)
-
-              if (!key || !keys.includes(key)) {
-                context.report({
-                  node: property,
-                  messageId: 'extraKey',
-                  data: { factory: factory.name, key: key ?? '<computed or spread>', allowed: keys.join(', ') },
-                })
-              }
-            }
-          }
-        }
-      },
-    }
-  },
-})

package/src/rules/no-file-level-helpers.ts

@@ -1,58 +0,0 @@
-import { defineRule } from '@oxlint/plugins'
-import { declarationsFileLevelFunctionCandidates, optionsFirst, reactComponentsIsLike } from '../utils/index.ts'
-
-interface NoFileLevelHelpersOptions {
-  allowPattern?: string
-  detectComponents?: boolean
-  hookPattern?: string
-}
-
-/**
- * Rejects top-level functions unless they are recognized components, hooks, or names allowed by configuration.
- *
- * Example: `useDialog` can pass as a hook, while a file-level `buildPayload` helper fails.
- */
-export const noFileLevelHelpers = defineRule({
-  meta: {
-    type: 'problem',
-    schema: [{
-      type: 'object',
-      additionalProperties: false,
-      properties: {
-        allowPattern: { type: 'string' },
-        detectComponents: { type: 'boolean' },
-        hookPattern: { type: 'string' },
-      },
-    }],
-    messages: {
-      helper: 'File-level helper {{name}} must move inside its owning component or hook.',
-    },
-  },
-  createOnce(context) {
-    return {
-      Program(program) {
-        const {
-          allowPattern,
-          detectComponents = true,
-          hookPattern = '^use[A-Z]',
-        } = optionsFirst<NoFileLevelHelpersOptions>(context, {})
-        const allowed = allowPattern ? new RegExp(allowPattern) : null
-        const hooks = new RegExp(hookPattern)
-
-        for (const candidate of declarationsFileLevelFunctionCandidates(program)) {
-          if ((detectComponents && reactComponentsIsLike(program, candidate))
-            || hooks.test(candidate.name)
-            || allowed?.test(candidate.name)) {
-            continue
-          }
-
-          context.report({
-            node: candidate.node,
-            messageId: 'helper',
-            data: { name: candidate.name },
-          })
-        }
-      },
-    }
-  },
-})