oxlint-plugin-arch 0.6.0 → 0.6.2

package/dist/utils/helpers/ast.d.ts

@@ -0,0 +1,12 @@
+import type { ESTree } from '@oxlint/plugins';
+export type AstRuntimeFunction = ESTree.Function | ESTree.ArrowFunctionExpression;
+export declare function astIsNode(value: unknown): value is ESTree.Node;
+export declare function astVisit(node: unknown, ancestors: ESTree.Node[], callback: (node: ESTree.Node, ancestors: ESTree.Node[]) => void): void;
+export declare function astContainsJsx(node: unknown): boolean;
+export declare function astNearestFunction(ancestors: readonly ESTree.Node[]): AstRuntimeFunction | undefined;
+export declare function astDirectReturnExpressions(node: AstRuntimeFunction): ESTree.Expression[];
+export declare function astStaticMemberName(node: ESTree.MemberExpression): string | undefined;
+export declare function astDottedName(node: ESTree.Node): string | undefined;
+export declare function astCallName(node: ESTree.CallExpression): string | undefined;
+export declare function astImportedCallAliases(program: ESTree.Program): Map<string, string>;
+export declare function astResolvedCallName(node: ESTree.CallExpression, aliases: ReadonlyMap<string, string>): string | undefined;

package/dist/utils/helpers/boundaries.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleBoundaryOptions } from '../../types/module-policy.types.ts';
+/** Resolve literal module paths with the configured aliases and owning app root. */
+export declare function boundaryResolveTarget(options: Pick<ModuleBoundaryOptions, 'web' | 'backend' | 'aliases'>, file: string, source: string): string;

package/dist/utils/helpers/comments.d.ts

@@ -0,0 +1,6 @@
+import type { ESTree } from '@oxlint/plugins';
+export declare function commentsNormalizedValue(comment: Pick<ESTree.Comment, 'type' | 'value'>): string;
+export declare function commentsIsDirective(value: string): boolean;
+export declare function commentsIsDisableNextLine(value: string): boolean;
+export declare function commentsIsWhy(value: string): boolean;
+export declare function commentsIsJsdoc(source: string, comment: Pick<ESTree.Comment, 'type' | 'range'>): boolean;

package/dist/utils/helpers/declarations.d.ts

@@ -0,0 +1,35 @@
+import type { AstRuntimeFunction } from './ast.ts';
+import type { ReactComponentsCandidate } from './react-components.ts';
+import type { ESTree } from '@oxlint/plugins';
+export type DeclarationsRuntime = ESTree.VariableDeclaration | ESTree.Function | ESTree.Class | ESTree.TSEnumDeclaration;
+export declare function declarationsTopLevelUnexportedFunctions(program: ESTree.Program): {
+    name: string;
+    node: ESTree.Function | ESTree.ArrowFunctionExpression;
+}[];
+export declare function declarationsFileLevelFunctionCandidates(program: ESTree.Program): ReactComponentsCandidate[];
+export declare function declarationsIsObjectParam(node: ESTree.ParamPattern): boolean;
+export declare function declarationsFunctionName(node: ESTree.Function | ESTree.VariableDeclarator): string;
+export declare function declarationsIsRuntime(node: ESTree.Node): node is DeclarationsRuntime;
+export declare function declarationsRuntimeName(node: DeclarationsRuntime): string;
+export declare function declarationsRuntimeKind(node: DeclarationsRuntime): 'class' | 'enum' | 'function' | 'variable';
+export declare function declarationsIsTrivialExpression(node: ESTree.Expression): boolean;
+export declare function declarationsIsTrivialFunction(node: AstRuntimeFunction): boolean;
+export declare const declarationsKinds: readonly ["function", "const", "let", "var", "class", "type", "interface", "enum"];
+export type DeclarationsKind = (typeof declarationsKinds)[number];
+export interface DeclarationsNamed {
+    name: string;
+    node: ESTree.Node;
+    kind?: DeclarationsKind;
+}
+export declare function declarationsNamedKind(node: ESTree.Node, ancestors: ESTree.Node[]): DeclarationsKind | undefined;
+export declare function declarationsCollectNamed(root: ESTree.Node, kinds?: readonly DeclarationsKind[]): DeclarationsNamed[];
+export declare function declarationsNamedFromNode(node: ESTree.Node): Required<DeclarationsNamed> | undefined;
+export declare function declarationsCollectFunctions(root: ESTree.Node): {
+    name: string;
+    node: AstRuntimeFunction;
+}[];
+export declare function declarationsPublicServiceMethods(program: ESTree.Program): {
+    name: string;
+    node: ESTree.Function;
+    binding: ESTree.VariableDeclarator;
+}[];

package/dist/utils/helpers/exports.d.ts

@@ -0,0 +1,18 @@
+import type { AstRuntimeFunction } from './ast.ts';
+import type { ESTree } from '@oxlint/plugins';
+export interface ExportsBinding {
+    exportedName: string;
+    localName?: string;
+    node: ESTree.Node;
+    declaration?: ESTree.Declaration;
+    initializer?: ESTree.Expression | null;
+    typeOnly: boolean;
+    default: boolean;
+    reExport: boolean;
+}
+export interface ExportsFunction {
+    name: string;
+    node: AstRuntimeFunction;
+}
+export declare function exportsCollect(program: ESTree.Program): ExportsBinding[];
+export declare function exportsCollectFunctions(program: ESTree.Program): ExportsFunction[];

package/dist/utils/helpers/factories.d.ts

@@ -0,0 +1,9 @@
+import type { ESTree } from '@oxlint/plugins';
+export interface FactoriesFunction {
+    name: string;
+    node: ESTree.Function | ESTree.ArrowFunctionExpression;
+}
+export declare function factoriesExpandTemplate(template: string, groups: Record<string, string>, camelCase?: boolean): string;
+export declare function factoriesCollectTopLevel(program: ESTree.Program, pattern: RegExp): FactoriesFunction[];
+export declare function factoriesDirectlyReturnedObjects(factory: FactoriesFunction): ESTree.ObjectExpression[];
+export declare function factoriesObjectPropertyName(property: ESTree.ObjectPropertyKind): string | undefined;

package/dist/utils/helpers/guards.d.ts

@@ -0,0 +1,11 @@
+import type { AstRuntimeFunction } from './ast.ts';
+import type { ESTree } from '@oxlint/plugins';
+interface GuardsState {
+    values: Set<string>;
+    predicates: Set<string>;
+    primitive: boolean;
+    returned: boolean;
+    globalArray: (node: ESTree.Node) => boolean;
+}
+export declare function guardsIsGenericHelper(node: AstRuntimeFunction, globalArray: GuardsState['globalArray']): boolean;
+export {};

package/dist/utils/helpers/index.d.ts

@@ -0,0 +1,16 @@
+export * from './ast.ts';
+export * from './comments.ts';
+export * from './declarations.ts';
+export * from './exports.ts';
+export * from './factories.ts';
+export * from './guards.ts';
+export * from './layout.ts';
+export * from './naming.ts';
+export * from './options.ts';
+export * from './orpc.ts';
+export * from './react-components.ts';
+export * from './routes.ts';
+export * from './sanitizers.ts';
+export * from './schemas.ts';
+export * from './trivial.ts';
+export * from './boundaries.ts';

package/dist/utils/helpers/layout.d.ts

@@ -0,0 +1,15 @@
+export type LayoutIndent = number | 'tab';
+export declare const layoutIndentSchema: {
+    anyOf: ({
+        type: string;
+        minimum: number;
+        enum?: undefined;
+    } | {
+        type: string;
+        enum: string[];
+        minimum?: undefined;
+    })[];
+};
+export declare function layoutLineIndent(text: string, offset: number): string;
+export declare function layoutIndentUnit(indent?: LayoutIndent): string;
+export declare function layoutNewline(text: string): string;

package/dist/utils/helpers/naming.d.ts

@@ -0,0 +1,13 @@
+export declare function namingPosixPath(filePath: string): string;
+export declare function namingFileBasename(filePath: string): string;
+export declare function namingDirSegments(filePath: string): string[];
+export declare function namingSegmentsAfter(filePath: string, after: string): string[] | undefined;
+export declare function namingFolderPrefixes(folders: string[], separator: string, singularize: 'none' | 'trailing-s'): string[];
+export declare function namingPascalCase(value: string): string;
+export declare function namingCamelCase(value: string): string;
+export declare function namingMatchTemplate(basename: string, template: string, placeholderPattern?: string): Record<string, string> | null;
+export declare const namingStemModes: readonly ["before-first-dot", "full-basename"];
+export type NamingStemMode = (typeof namingStemModes)[number];
+export declare function namingNormalized(value: string, normalize: 'remove-separators' | 'none'): string;
+export declare function namingFileStem(basename: string, mode?: NamingStemMode, trailingRoles?: readonly string[], roleSeparators?: readonly string[]): string;
+export declare function namingFilePrefixes(stem: string, normalize?: 'remove-separators' | 'none', singularize?: 'none' | 'trailing-s'): string[];

package/dist/utils/helpers/options.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@oxlint/plugins';
+export declare function optionsFirst<T>(context: Context, fallback?: T): T;
+export type OptionsPattern = string | string[];
+export declare const optionsPatternSchema: {
+    anyOf: ({
+        type: string;
+        items?: undefined;
+        minItems?: undefined;
+    } | {
+        type: string;
+        items: {
+            type: string;
+        };
+        minItems: number;
+    })[];
+};
+/** Compiles a regex option that accepts one pattern or a list where any pattern may match. */
+export declare function optionsPatterns(pattern: OptionsPattern | undefined, flags?: string): RegExp[];
+/** Like `optionsPatterns`, for options where an empty string has always meant "not set". */
+export declare function optionsOptionalPatterns(pattern: OptionsPattern | undefined, flags?: string): RegExp[];
+export declare function optionsPatternLabel(pattern: OptionsPattern | undefined): string;
+export declare function optionsPatternsTest(patterns: RegExp[], value: string): boolean;

package/dist/utils/helpers/orpc.d.ts

@@ -0,0 +1,3 @@
+import type { ESTree } from '@oxlint/plugins';
+export declare function orpcFindChainCall(expression: ESTree.Expression, method: string): ESTree.CallExpression | undefined;
+export declare function orpcIsNamedOrComposedArgument(argument: ESTree.Argument | undefined, composers: Set<string>): boolean;

package/dist/utils/helpers/react-components.d.ts

@@ -0,0 +1,13 @@
+import type { AstRuntimeFunction } from './ast.ts';
+import type { ESTree } from '@oxlint/plugins';
+export interface ReactComponentsCandidate {
+    name: string;
+    node: ESTree.Node;
+    declaration?: ESTree.Declaration;
+    initializer?: ESTree.Expression | null;
+    typeOnly?: boolean;
+}
+export declare function reactComponentsExportCandidates(program: ESTree.Program): ReactComponentsCandidate[];
+export declare function reactComponentsFunctionReturnsOutput(program: ESTree.Program, node: AstRuntimeFunction): boolean;
+export declare function reactComponentsIsLike(program: ESTree.Program, candidate: ReactComponentsCandidate): boolean;
+export declare function reactComponentsPascalFromBasename(basename: string): string;

package/dist/utils/helpers/routes.d.ts

@@ -0,0 +1,5 @@
+import type { Context, ESTree } from '@oxlint/plugins';
+export declare function routesInspectFunction(context: Context, item: {
+    name: string;
+    node: ESTree.Function | ESTree.ArrowFunctionExpression;
+}, bannedHooks: Set<string>, banIntrinsicJsx: boolean): void;

package/dist/utils/helpers/sanitizers.d.ts

@@ -0,0 +1,3 @@
+import type { ESTree } from '@oxlint/plugins';
+export declare function sanitizersCallsConfigured(node: unknown, names: Set<string>): boolean;
+export declare function sanitizersConfiguredBindings(program: ESTree.Program, names: Set<string>): Set<string>;

package/dist/utils/helpers/schemas.d.ts

@@ -0,0 +1,10 @@
+import type { ESTree } from '@oxlint/plugins';
+export declare function schemasIsPackage(source: string, packages: ReadonlySet<string>): boolean;
+export declare function schemasIsCall(node: ESTree.CallExpression, namespaces: Set<string>): boolean;
+export declare function schemasRuntimeImportLocals(node: ESTree.ImportDeclaration): string[];
+export declare function schemasIsRuntimeImport(node: ESTree.ImportDeclaration, packages: ReadonlySet<string>): boolean;
+export declare function schemasIsRuntimeReexport(node: ESTree.ExportNamedDeclaration | ESTree.ExportAllDeclaration, packages: ReadonlySet<string>): boolean;
+export declare function schemasIsConstruction(node: ESTree.CallExpression, constructors: ReadonlySet<string>): boolean;
+export declare function schemasElements(node: ESTree.CallExpression): ESTree.Argument[];
+export declare function schemasIsAllowedElement(node: ESTree.Argument, allowScalars: boolean, namespaces: Set<string>, structuralMethods: Set<string>): boolean;
+export declare function schemasTypeOperator(node: ESTree.TSTypeReference, namespaces: Set<string>, operators: Set<string>): string | undefined;

package/dist/utils/helpers/syntax.d.ts

@@ -0,0 +1 @@
+export declare function syntaxRule(selector: string, message: string): import("@oxlint/plugins").Rule;

package/dist/utils/helpers/test-tables.d.ts

@@ -0,0 +1,8 @@
+import type { ESTree, SourceCode } from '@oxlint/plugins';
+import type { AstRuntimeFunction } from './ast.ts';
+import type { TestRegistration, TestTableRow } from '../../types/test-analysis.types.ts';
+export declare function testTablesRegistration(call: ESTree.CallExpression, names: string[], functions: Map<ESTree.Node, AstRuntimeFunction>): TestRegistration | undefined;
+export declare function testTablesResolve(expression: ESTree.Expression, values: Map<ESTree.Node, ESTree.Expression>): ESTree.Expression;
+export declare function testTablesRows(registration: TestRegistration, sourceCode: SourceCode, values: Map<ESTree.Node, ESTree.Expression>, functions: Map<ESTree.Node, AstRuntimeFunction>): TestTableRow[] | undefined;
+export declare function testTablesCallName(node: ESTree.Node): string | undefined;
+export declare function testTablesAssertionPattern(name: string): RegExp;

package/dist/utils/helpers/trivial.d.ts

@@ -0,0 +1,6 @@
+import type { AstRuntimeFunction } from './ast.ts';
+import type { ESTree } from '@oxlint/plugins';
+export declare function trivialExpression(node: AstRuntimeFunction): ESTree.Expression | null;
+export declare function trivialUnwrap(expression: ESTree.Expression): ESTree.Expression;
+export declare function trivialCallRoot(expression: ESTree.Expression): string | undefined;
+export declare function trivialIsForwarder(node: AstRuntimeFunction, expression: ESTree.Expression): boolean;

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './helpers/index.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,6 +13,14 @@
     "./presets/tanstack-start-react-modules-preset": {
       "types": "./dist/presets/tanstack-start-react-modules-preset.d.ts",
       "default": "./dist/presets/tanstack-start-react-modules-preset.js"
+    },
+    "./rules/dillon-anti-slop": {
+      "types": "./dist/rules/dillon-anti-slop/index.d.ts",
+      "default": "./dist/rules/dillon-anti-slop/index.js"
+    },
+    "./rules/module-policy": {
+      "types": "./dist/rules/module-policy/index.d.ts",
+      "default": "./dist/rules/module-policy/index.js"
     }
   },
   "files": [
@@ -30,7 +38,6 @@
     "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 && oxlint examples/monorepo.oxlint.config.ts -c examples/monorepo.oxlint.config.ts --disable-nested-config && oxlint --print-config -c examples/preset.oxlint.config.ts > /dev/null",
     "prepublishOnly": "bun run check",
     "release": "bash scripts/release.sh",
-    "release:dry-run": "bash scripts/release.sh --dry-run",
     "release:patch": "bash scripts/release.sh patch --yes",
     "release:minor": "bash scripts/release.sh minor --yes",
     "release:major": "bash scripts/release.sh major --yes"