oxlint-plugin-arch 0.12.6 → 0.13.1

package/dist/preset/preset.utils.d.ts

@@ -2,6 +2,7 @@ import type * as PresetTypes from '../types/preset.types.ts';
 import type { OxlintOverride } from 'oxlint';
 export declare class PresetError extends Error {
 }
+export declare function presetEffectStyle(): PresetTypes.PresetEffectStyle;
 export declare function presetEffectPackages(): PresetTypes.PresetEffectPackages;
 export declare function presetScopes(roots: string[], suffix?: string): string[];
 export declare function presetServiceScopes(folders: Record<string, string>, sources: string[], suffix?: string): string[];
@@ -9,9 +10,14 @@ export declare function presetOverride(files: string[], rules: PresetTypes.Prese
 export declare function presetSeverity(rules: PresetTypes.PresetRules, level: PresetTypes.PresetLevel): PresetTypes.PresetRules;
 export declare function presetPackageName(root: string, directory: string): string | undefined;
 export declare function presetIntersect(glob: string, scope: string): string[];
+export declare function presetGlobEscape(path: string): string;
+export declare function presetFileOverlaps(root: string, build: (pattern: string, folder: PresetTypes.PresetFolder) => PresetTypes.PresetFileKey, keys: PresetTypes.PresetFileKey[]): PresetTypes.PresetFileKey[];
 export declare function presetAliases(root: string, aliases: Record<string, string> | undefined): Record<string, string>;
 export declare function presetRuntime(project: PresetTypes.PresetProject, settings: Required<PresetTypes.PresetFrameworkOptions>, framework: PresetTypes.PresetFramework, rule: string): OxlintOverride[];
 export declare function presetManifest(root: string, directory: string): PresetTypes.PresetManifest;
 export declare function presetIsDirectory(path: string): boolean;
 export declare function presetServicesFolder(root: string, source: string, configured?: string, fallback?: boolean): string;
 export declare function presetIsFile(path: string): boolean;
+export declare function presetSource(root: string, directory: string, configured?: string): string;
+export declare function presetFilled(conventions: PresetTypes.PresetFolders, exists: (path: string) => boolean): PresetTypes.PresetFolders;
+export declare function presetMerge(base: boolean | PresetTypes.PresetFolder | undefined, top: boolean | PresetTypes.PresetFolder): boolean | PresetTypes.PresetFolder;

package/dist/rules/code/code-delegate.d.ts

@@ -0,0 +1 @@
+export declare const codeDelegate: import("@oxlint/plugins").Rule;

package/dist/rules/layout/layout-type-arguments.d.ts

@@ -0,0 +1 @@
+export declare const layoutTypeArguments: import("@oxlint/plugins").Rule;

package/dist/rules/react/react-query-props.d.ts

@@ -0,0 +1 @@
+export declare const reactQueryProps: import("@oxlint/plugins").Rule;

package/dist/types/backend.types.d.ts

@@ -1,5 +1,4 @@
 export interface BackendOrpcOutputOptions {
-    composers: string[];
     handler?: string;
     output?: string;
 }
@@ -11,8 +10,8 @@ export interface BackendServiceFunctionsOptions {
     message?: string;
 }
 export interface BackendSqlLikeOptions {
-    methods: string[];
-    sanitizers: string[];
+    methods?: string[];
+    sanitizers?: string[];
     bindings?: boolean;
     operators?: string[];
 }

package/dist/types/boundaries.types.d.ts

@@ -6,13 +6,27 @@ export interface BoundariesOptions {
     roles?: string[];
     surfaces?: string[];
     services?: string[];
-    portable?: boolean;
+    portable?: boolean | string;
+    conventions?: BoundariesConventions;
     backendPackages: string[];
     appPackages: string[];
     aliases: Record<string, string>;
     entrypoints: string[];
     uiPackages?: string[];
 }
+export interface BoundariesConventions {
+    services?: string;
+    registry?: string;
+    types?: string;
+    lib?: string;
+    contracts?: string[];
+    implementations?: string[];
+    implementationFolders?: string[];
+    operations?: string[];
+    operationFolders?: string[];
+    domainFiles?: string[];
+    clients?: string[];
+}
 export interface BoundariesImport {
     options: BoundariesOptions;
     file: string;
@@ -25,7 +39,18 @@ export interface BoundariesImport {
     web?: string;
     backendImport: boolean;
 }
+export interface BoundariesRuntimeConventions {
+    server?: string[];
+    rsc?: string[];
+    actions?: string[];
+    client?: string[];
+    clientOnly?: string[];
+    hooks?: string[];
+    shared?: string[];
+    lib?: string;
+}
 export interface BoundariesNextOptions extends Partial<Pick<BoundariesOptions, 'web' | 'backend' | 'aliases' | 'backendPackages'>> {
+    conventions?: BoundariesRuntimeConventions;
     server?: string[];
     client?: string[];
     dynamic?: string[];

package/dist/types/code.types.d.ts

@@ -12,6 +12,11 @@ export interface CodeConstructorOptions {
     calls?: boolean;
     message?: string;
 }
+export interface CodeDelegateOptions {
+    methods?: string[];
+    reads?: string[];
+    max?: number;
+}
 export interface CodeLiteralInOptions {
     allow: string[];
 }
@@ -52,6 +57,7 @@ export interface CodeTrivialFunctionsOptions {
     services?: boolean;
     deny?: string[];
     guards?: boolean;
+    defaults?: boolean;
 }
 export interface CodeTrivialFunctionsGuardState {
     values: Set<string>;
@@ -63,6 +69,7 @@ export interface CodeTrivialFunctionsGuardState {
 export interface CodeInlineOptions {
     max?: number;
     nesting?: number;
+    callbacks?: boolean;
     allow?: OptionsPattern;
     keep?: OptionsPattern;
     services?: string[];

package/dist/types/comments.types.d.ts

@@ -4,6 +4,7 @@ export interface CommentsOptions {
     allow?: string[];
     jsdoc?: boolean;
     members?: 'off' | 'also' | 'only';
+    steps?: boolean;
 }
 export interface CommentsLines {
     starts: number[];

package/dist/types/dillon-anti-slop.types.d.ts

@@ -53,3 +53,9 @@ export interface DillonAntiSlopConstBinding {
     readonly declarator: ESTree.VariableDeclarator;
     readonly init: ESTree.Expression;
 }
+export interface DillonAntiSlopSymbolNamesOptions {
+    terms?: string[];
+}
+export interface DillonAntiSlopSafetyCommentOptions {
+    comment?: string;
+}

package/dist/types/effect.types.d.ts

@@ -22,6 +22,7 @@ export interface EffectLayerFileOptions {
     layer?: string;
     make?: string;
     prefix?: string;
+    suffix?: string;
     builders?: string[];
     layers?: OptionsPattern;
     services?: OptionsPattern;

package/dist/types/files.types.d.ts

@@ -1,4 +1,4 @@
-import type { NamingExportsStem } from './naming.types.ts';
+import type { NamingExportsStem, NamingStemMode } from './naming.types.ts';
 import type { OptionsPattern } from './options.types.ts';
 import type { ESTree } from '@oxlint/plugins';
 export interface FilesComponentsOnlyOptions {
@@ -24,7 +24,8 @@ export interface FilesDomainConstantsOptions {
     roles?: string[];
     file?: string;
 }
-export interface FilesExportsOptions extends Pick<NamingExportsStem, 'stem' | 'roles' | 'separators'> {
+export interface FilesExportsOptions extends Pick<NamingExportsStem, 'roles' | 'separators' | 'singularize'> {
+    stem?: NamingStemMode | 'folder';
     names?: string[];
     patterns?: string[];
     types?: boolean;

package/dist/types/layout.types.d.ts

@@ -9,6 +9,10 @@ export interface LayoutCallArgumentsOptions {
     min?: number;
     indent?: SourceIndent;
     split?: boolean;
+    pipe?: {
+        min: number;
+        methods?: string[];
+    };
     hug?: {
         max: number;
     };
@@ -55,6 +59,10 @@ export interface LayoutObjectOptions {
     min?: number;
     scope?: LayoutObjectScope;
     indent?: SourceIndent;
+    params?: boolean;
+    nested?: boolean;
+    siblings?: boolean;
+    inner?: number;
     join?: {
         max: number;
         keep?: string[];
@@ -66,6 +74,13 @@ export interface LayoutPaddingOptions {
     multiline?: boolean;
 }
 export type LayoutPaddingKind = 'variable' | 'block' | 'control' | 'return' | 'other';
+export interface LayoutPipeOptions {
+    methods?: string[];
+}
+export interface LayoutTypeArgumentsOptions {
+    min?: number;
+    indent?: SourceIndent;
+}
 export interface LayoutTernaryOptions {
     max?: number;
     indent?: SourceIndent;
@@ -79,6 +94,7 @@ export interface LayoutItemsOptions {
 }
 export interface LayoutCallDepthOptions {
     max?: number;
+    callbacks?: boolean;
 }
 export interface LayoutArrowBodyOptions {
     max?: number;

package/dist/types/naming.types.d.ts

@@ -49,4 +49,8 @@ export interface NamingFolderOptions {
     prefixes?: string[];
     after?: string;
 }
+export interface NamingTypesOptions {
+    pattern?: OptionsPattern;
+    message?: string;
+}
 export {};

package/dist/types/preset.types.d.ts

@@ -10,7 +10,7 @@ export interface PresetLayoutOptions {
     services?: PresetLayoutMode | false;
     hooks?: PresetLayoutMode | false;
     components?: PresetLayoutMode | false;
-    suffixes?: string[];
+    files?: string[];
     strict?: boolean;
     operations?: PresetOperations;
     service?: string[];
@@ -106,36 +106,30 @@ export interface PresetRegistryOptions {
 export interface PresetBackendOptions {
     exports?: string[];
     registry?: false | string | PresetRegistryOptions;
-    writes?: string[];
 }
 export interface PresetDenyOptions {
     imports?: Record<string, string | false>;
     calls?: Record<string, string | false>;
 }
-export interface PresetExternalsOptions {
-    packages?: string[];
-}
 export interface PresetOrpcOptions {
     public?: string[];
-    composers?: string[];
     client?: string;
 }
-export interface PresetFormsOptions {
-    resolver?: string;
-}
 export interface PresetEffectOptions {
+    code?: boolean;
     width?: number;
     exports?: OptionsPattern;
     skip?: OptionsPattern;
     entries?: string[];
 }
+export interface PresetEffectStyle {
+    rules: PresetRules;
+    jsPlugins: PresetJsPlugins;
+}
 export interface PresetEffectPackages {
     tsgo: typeof EffectTsgo;
     linteffect: typeof EffectLinteffect;
 }
-export interface PresetSqlOptions {
-    sanitizers?: string[];
-}
 export interface PresetGroups {
     layout?: PresetSwitch | PresetLayoutOptions;
     limits?: PresetSwitch | PresetLimitsOptions;
@@ -156,12 +150,12 @@ export interface PresetGroups {
     backend?: PresetSwitch | PresetBackendOptions;
     orpc?: PresetSwitch | PresetOrpcOptions;
     schemas?: PresetSwitch;
-    forms?: PresetSwitch | PresetFormsOptions;
-    sql?: PresetSwitch | PresetSqlOptions;
+    forms?: PresetSwitch;
+    sql?: PresetSwitch;
     effect?: PresetSwitch | PresetEffectOptions;
     console?: boolean;
     deny?: PresetSwitch | PresetDenyOptions;
-    externals?: PresetSwitch | PresetExternalsOptions;
+    externals?: PresetSwitch;
 }
 export type PresetGroupName = keyof PresetGroups;
 export interface PresetFolder extends PresetGroups {
@@ -171,18 +165,19 @@ export interface PresetFolder extends PresetGroups {
     rules?: PresetRules;
 }
 export type PresetFolders = Record<string, boolean | PresetFolder>;
+export type PresetEntry = [string, boolean | PresetFolder];
 export interface PresetConfig {
     root?: string;
     folders?: PresetFolders;
     detect?: boolean;
 }
-export type PresetRecipe = PresetGroups;
+export type PresetRecipe = PresetGroups & Partial<Record<symbol, string>>;
 export type PresetRules = NonNullable<OxlintConfig['rules']>;
 export type PresetJsPlugins = NonNullable<OxlintConfig['jsPlugins']>;
 export type PresetPlugins = NonNullable<OxlintConfig['plugins']>;
 export type PresetSettings = NonNullable<OxlintConfig['settings']>;
 export interface PresetResolvedGroups {
-    layout: PresetLayoutOptions & Required<Pick<PresetLayoutOptions, 'suffixes' | 'strict' | 'operations' | 'service'>>;
+    layout: PresetLayoutOptions & Required<Pick<PresetLayoutOptions, 'files' | 'strict' | 'operations' | 'service'>>;
     limits: Required<PresetLimitsOptions>;
     style: Required<PresetStyleOptions>;
     basics: Required<PresetBasicsOptions>;
@@ -200,21 +195,22 @@ export interface PresetResolvedGroups {
     };
     shadcn: Required<PresetShadcnOptions>;
     kit: PresetEmptyOptions;
-    backend: PresetBackendOptions & Required<Pick<PresetBackendOptions, 'writes'>>;
+    backend: PresetBackendOptions;
     orpc: PresetOrpcOptions;
     schemas: PresetEmptyOptions;
-    forms: Required<PresetFormsOptions>;
-    sql: Required<PresetSqlOptions>;
+    forms: PresetEmptyOptions;
+    sql: PresetEmptyOptions;
     effect: Pick<PresetEffectOptions, 'exports' | 'skip'> & {
+        code: boolean;
         width: number;
         entries: string[];
     };
     console: PresetEmptyOptions;
     deny: {
-        imports: Record<string, string>;
-        calls: Record<string, string>;
+        imports: Record<string, string | false>;
+        calls: Record<string, string | false>;
     };
-    externals: Required<PresetExternalsOptions>;
+    externals: PresetEmptyOptions;
 }
 export interface PresetEmptyOptions {
     empty?: never;
@@ -238,6 +234,11 @@ export interface PresetScope {
     folder: PresetFolder;
     effective: PresetEffective;
 }
+export interface PresetFileKey {
+    pattern: string;
+    folder: PresetFolder;
+    scopes: PresetScope[];
+}
 export interface PresetUnit {
     key: string;
     scope: PresetScope;
@@ -284,8 +285,9 @@ export interface PresetProject {
     root: string;
     serviceFolders: Record<string, string>;
     scopes: PresetScope[];
+    fileKeys: PresetFileKey[];
     units: PresetUnit[];
-    suffixes: string[];
+    fileKinds: string[];
     colocated: string[];
     orpc: Required<PresetOrpcOptions>;
     layouts: PresetLayoutScope[];

package/dist/types/react.types.d.ts

@@ -1,6 +1,10 @@
 import type { AstFunction } from './ast.types.ts';
 import type { DeclarationsCandidate } from './declarations.types.ts';
 import type { ESTree } from '@oxlint/plugins';
+export interface ReactQueryPropsOptions {
+    hooks?: string[];
+    functions?: string[];
+}
 export interface ReactPropsOptions {
     prefix?: boolean;
     suffix?: string;
@@ -13,3 +17,16 @@ export interface ReactPropsTarget {
     fn: AstFunction;
     typeArgument?: ESTree.TSType;
 }
+export interface ReactDynamicClassesOptions {
+    attributes?: string[];
+    message?: string;
+}
+export interface ReactEmptyEffectOptions {
+    hooks?: string[];
+    message?: string;
+}
+export interface ReactMemoOptions {
+    names?: string[];
+    sources?: string[];
+    message?: string;
+}

package/dist/types/types.types.d.ts

@@ -2,6 +2,7 @@ import type { OptionsPattern } from './options.types.ts';
 import type { ESTree } from '@oxlint/plugins';
 export interface TypesDeclarationsOptions {
     allow?: OptionsPattern;
+    modules?: boolean;
 }
 export type TypesDeclarationNode = ESTree.TSTypeAliasDeclaration | ESTree.TSInterfaceDeclaration;
 export interface TypesImportedBinding {
@@ -12,6 +13,9 @@ export interface TypesInlineOptions {
     parameters?: boolean;
     returns?: boolean;
     functions?: boolean;
+    variables?: boolean;
+    assertions?: boolean;
+    arguments?: boolean;
     min?: number;
 }
 export interface TypesServiceOptions {
@@ -26,3 +30,7 @@ export interface TypesDuplicateOptions {
     structs?: string[];
     min?: number;
 }
+export interface TypesLocalAliasOptions {
+    allow?: OptionsPattern;
+    message?: string;
+}

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

@@ -20,6 +20,5 @@ export declare function astSelectorRule(selector: string, message: string): impo
 export declare function astIsOneLine(node: ESTree.Node): boolean;
 export declare function astIsInlineFunction(node: ESTree.Node): node is AstFunction;
 export declare function astIsCall(node: ESTree.Node): node is AstCall;
-export declare function astIsPipe(node: AstCall): boolean;
 export declare function astSome(value: unknown, test: (node: ESTree.Node) => boolean, enter?: (node: ESTree.Node) => boolean): boolean;
-export declare function astCallDepth(value: unknown): number;
+export declare function astCallDepth(value: unknown, callbacks?: boolean): number;

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

@@ -1,5 +1,10 @@
-import type { BoundariesOptions } from '../types/boundaries.types.ts';
+import type { BoundariesOptions, BoundariesRuntimeConventions } from '../types/boundaries.types.ts';
 import type * as PluginsTypes from '@oxlint/plugins';
+export declare function boundariesConventionsFor(options: {
+    conventions?: BoundariesRuntimeConventions;
+}): Required<BoundariesRuntimeConventions>;
+export declare function boundariesHasSuffix(suffixes: readonly string[], path: string, optionalExtension?: boolean): boolean;
+export declare function boundariesIsClientOnly(conventions: Required<BoundariesRuntimeConventions>, target: string): boolean;
 export declare const boundariesServerGlobals: string[];
 export declare const boundariesBrowserGlobals: string[];
 export declare const boundariesRuntimeProperties: {
@@ -63,6 +68,65 @@ export declare const boundariesRuntimeProperties: {
             type: string;
         };
     };
+    conventions: {
+        type: string;
+        additionalProperties: boolean;
+        properties: {
+            server: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            rsc: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            actions: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            client: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            clientOnly: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            hooks: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            shared: {
+                type: string;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            lib: {
+                type: string;
+                minLength: number;
+            };
+        };
+    };
 };
 export declare const boundariesServerPackages: string[];
 export declare const boundariesRuntimeMessages: {
@@ -75,11 +139,15 @@ export declare function boundariesExportVisitors(check: (node: PluginsTypes.ESTr
 };
 export declare function boundariesLiteralSource(node: PluginsTypes.ESTree.ImportExpression): string | undefined;
 export declare function boundariesReport(context: PluginsTypes.Context, node: PluginsTypes.ESTree.Node, source: string, reason: string): void;
-export declare function boundariesImportExpression(context: PluginsTypes.Context, node: PluginsTypes.ESTree.ImportExpression, allowComputed: boolean, check: (source: string) => void): void;
-export declare function boundariesIsSharedFile(options: Pick<BoundariesOptions, 'web'>, file: string): boolean;
+export declare function boundariesRuntimeImportVisitors(context: PluginsTypes.Context, check: (node: PluginsTypes.ESTree.Node, source: string, typeOnly: boolean, reExport: boolean) => void, allowComputed: () => boolean): {
+    ExportNamedDeclaration(node: PluginsTypes.ESTree.ExportNamedDeclaration): void;
+    ExportAllDeclaration(node: PluginsTypes.ESTree.ExportAllDeclaration): void;
+    ImportExpression(node: PluginsTypes.ESTree.ImportExpression): void;
+};
+export declare function boundariesIsSharedFile(options: Pick<BoundariesOptions, 'web'>, conventions: Required<BoundariesRuntimeConventions>, file: string): boolean;
 export declare function boundariesDeclaredVariable(start: PluginsTypes.Scope | null, name: string): PluginsTypes.Variable | null;
 export declare function boundariesMatchesImport(prefixes: string[] | undefined, source: string): boolean;
 export declare function boundariesIsBackendImport(options: Pick<BoundariesOptions, 'backend' | 'backendPackages'>, target: string, source: string): boolean;
 export declare function boundariesIsServerPlatformImport(source: string, packages: readonly string[]): boolean;
 export declare function boundariesMemberName(node: PluginsTypes.ESTree.Node | null | undefined): string | null;
-export declare function boundariesResolveTarget(options: Pick<BoundariesOptions, 'web' | 'backend' | 'aliases'>, file: string, source: string): string;
+export declare function boundariesResolveTarget(options: Pick<BoundariesOptions, 'web' | 'backend' | 'aliases'>, file: string, source: string, services?: string): string;

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

@@ -9,3 +9,4 @@ export declare function optionsPatternsTest(patterns: RegExp[], value: string):
 export declare function optionsGlob(pattern: string): RegExp;
 export declare function optionsPatternLabel(pattern: OptionsPattern | undefined): string;
 export declare function optionsAssertMockingApis(patterns: string[]): void;
+export declare function optionsEscape(value: string): string;