oxlint-plugin-arch 0.12.3 → 0.12.4

package/dist/preset/groups/effect.d.ts

@@ -0,0 +1,2 @@
+import type { PresetBuilder } from '../../types/preset.types.ts';
+export declare const effectGroup: PresetBuilder<'effect'>;

package/dist/preset/preset-recipes.d.ts

@@ -40,6 +40,10 @@ export declare const presetRecipes: {
     library: {
         schemas: true;
     };
+    effect: {
+        schemas: true;
+        effect: true;
+    };
     ui: {
         react: boolean;
         kit: boolean;

package/dist/preset/preset.d.ts

@@ -45,6 +45,10 @@ export declare const recipes: {
     library: {
         schemas: true;
     };
+    effect: {
+        schemas: true;
+        effect: true;
+    };
     ui: {
         react: boolean;
         kit: boolean;

package/dist/preset/preset.js

@@ -18,6 +18,7 @@ var presetRecipes = {
   react: { react: true, tailwind: true, schemas: true },
   desktop: { console: true },
   library: { schemas: true },
+  effect: { schemas: true, effect: true },
   ui: presetUi,
   kit: presetUi,
   cli: { console: true }
@@ -399,6 +400,7 @@ var presetGroupOrder = [
   "schemas",
   "sql",
   "orpc",
+  "effect",
   "react",
   "forms",
   "tanstack",
@@ -460,6 +462,7 @@ var presetGroupOptions = {
   schemas: { level: "error" },
   forms: { level: "error", resolver: "standardSchemaResolver" },
   sql: { level: "error", sanitizers: ["escapeLikeWildcards"] },
+  effect: { level: "error", width: 160, exports: undefined, skip: undefined },
   console: { level: "error" },
   deny: { level: "error", imports: {}, calls: {} },
   externals: { level: "error", packages: presetExternals }
@@ -806,7 +809,8 @@ function presetBackendConventions(root, key, value, denied) {
     ]));
     conventions[posix2.join(servicesKey, domain)] = presetDeny(Object.fromEntries(imports));
   }
-  for (const tests of ["tests", "test"]) {
+  const testFolders = ["tests", "test"];
+  for (const tests of testFolders) {
     if (exists(posix2.join(tests, "kits"))) {
       conventions[tests] = presetDeny(Object.fromEntries(presetKitImports.map((pattern) => [pattern, "Import the kit file you need."])));
       conventions[posix2.join(tests, "kits")] = { naming: { files: presetKitFiles } };
@@ -818,7 +822,7 @@ function presetBackendConventions(root, key, value, denied) {
     for (const child of presetDirectories(root, posix2.join(key, folder)).map((path) => posix2.relative(key, path))) {
       if (posix2.basename(child) === "migrations") {
         conventions[child] = { layout: false, naming: { files: presetMigrationFiles, unique: presetMigrationNumber } };
-      } else if (child.split("/").length < 8) {
+      } else if (child.split("/").length < 8 && !testFolders.includes(posix2.basename(child))) {
         queue.push(child);
       }
     }
@@ -1070,6 +1074,34 @@ var denyGroup = (project, settings) => {
   return overrides;
 };
 
+// src/preset/groups/effect.ts
+var effectGroup = (project, settings) => {
+  const files = [`**/${presetExtensions}`];
+  const max = settings.width;
+  return [
+    presetOverride(files, {
+      "arch/code-trivial-functions": "off",
+      "arch/code-branch-once": "error",
+      "arch/code-function-nesting": ["error", { max: 4 }],
+      "arch/code-inline": ["error", { max, nesting: 2, keep: ["^[A-Z]", "^layer"], allow: "^(?:decode|encode)[A-Z]", services: ["of"] }],
+      "arch/code-yield-argument": "error",
+      "arch/layout-arrow-body": ["error", { max }],
+      "arch/layout-call-arguments": ["error", { split: false, hug: { max }, join: { max, nesting: 2, keep: ["Layer.mergeAll"] } }],
+      "arch/layout-call-depth": ["error", { max: 2 }],
+      "arch/layout-items": "error",
+      "arch/layout-pipe": "error",
+      "arch/layout-ternary": ["error", { fit: false, branch: { max: 3 } }]
+    }),
+    presetOverride(files, {
+      "arch/code-justified-call": [
+        "error",
+        { calls: ["Effect.promise"], message: "Effect.promise turns a rejection into a defect; otherwise use Effect.tryPromise with a tagged error." }
+      ],
+      "arch/code-traced": ["error", { exports: settings.exports, skip: settings.skip, message: "An exported function or service method gets a span: use Effect.fn('<name>')." }]
+    }, project.testFiles)
+  ];
+};
+
 // src/preset/groups/expo.ts
 var expoGroup = (project, settings) => {
   const { expoWeb, testFiles } = project;
@@ -2184,6 +2216,7 @@ var presetBuilders = {
   schemas: schemasGroup,
   sql: sqlGroup,
   orpc: orpcGroup,
+  effect: effectGroup,
   react: reactGroup,
   forms: formsGroup,
   tanstack: tanstackGroup,

package/dist/rules/code/code-branch-once.d.ts

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

package/dist/rules/code/code-function-nesting.d.ts

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

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

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

package/dist/rules/code/code-justified-call.d.ts

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

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

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

package/dist/rules/code/code-yield-argument.d.ts

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

package/dist/rules/layout/layout-arrow-body.d.ts

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

package/dist/rules/layout/layout-call-depth.d.ts

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

package/dist/rules/layout/layout-items.d.ts

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

package/dist/rules/layout/layout-pipe.d.ts

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

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

@@ -1,2 +1,3 @@
 import type { ESTree } from '@oxlint/plugins';
 export type AstFunction = ESTree.Function | ESTree.ArrowFunctionExpression;
+export type AstCall = ESTree.CallExpression | ESTree.NewExpression;

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

@@ -57,3 +57,25 @@ export interface CodeTrivialFunctionsGuardState {
     returned: boolean;
     globalArray: (node: ESTree.Node) => boolean;
 }
+export interface CodeInlineOptions {
+    max?: number;
+    nesting?: number;
+    allow?: OptionsPattern;
+    keep?: OptionsPattern;
+    services?: string[];
+}
+export interface CodeFunctionNestingOptions {
+    max?: number;
+}
+export interface CodeJustifiedCallOptions {
+    calls: string[];
+    comment?: string;
+    message?: string;
+}
+export interface CodeTracedOptions {
+    untraced?: string[];
+    exports?: OptionsPattern;
+    services?: string[];
+    skip?: OptionsPattern;
+    message?: string;
+}

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

@@ -8,6 +8,15 @@ export interface LayoutEdit {
 export interface LayoutCallArgumentsOptions {
     min?: number;
     indent?: number;
+    split?: boolean;
+    hug?: {
+        max: number;
+    };
+    join?: {
+        max: number;
+        nesting?: number;
+        keep?: string[];
+    };
 }
 export interface LayoutCallArrayOptions {
     callees?: string[];
@@ -52,4 +61,17 @@ export type LayoutPaddingKind = 'variable' | 'block' | 'control' | 'return' | 'o
 export interface LayoutTernaryOptions {
     max?: number;
     indent?: number;
+    fit?: boolean;
+    branch?: {
+        max: number;
+    };
+}
+export interface LayoutItemsOptions {
+    indent?: SourceIndent;
+}
+export interface LayoutCallDepthOptions {
+    max?: number;
+}
+export interface LayoutArrowBodyOptions {
+    max?: number;
 }

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

@@ -1,3 +1,4 @@
+import type { OptionsPattern } from './options.types.ts';
 import type { OxlintConfig, OxlintOverride } from 'oxlint';
 export type PresetLevel = 'error' | 'warn';
 export type PresetSwitch = boolean | 'warn';
@@ -120,6 +121,11 @@ export interface PresetOrpcOptions {
 export interface PresetFormsOptions {
     resolver?: string;
 }
+export interface PresetEffectOptions {
+    width?: number;
+    exports?: OptionsPattern;
+    skip?: OptionsPattern;
+}
 export interface PresetSqlOptions {
     sanitizers?: string[];
 }
@@ -145,6 +151,7 @@ export interface PresetGroups {
     schemas?: PresetSwitch;
     forms?: PresetSwitch | PresetFormsOptions;
     sql?: PresetSwitch | PresetSqlOptions;
+    effect?: PresetSwitch | PresetEffectOptions;
     console?: boolean;
     deny?: PresetSwitch | PresetDenyOptions;
     externals?: PresetSwitch | PresetExternalsOptions;
@@ -190,6 +197,9 @@ export interface PresetResolvedGroups {
     schemas: PresetEmptyOptions;
     forms: Required<PresetFormsOptions>;
     sql: Required<PresetSqlOptions>;
+    effect: Pick<PresetEffectOptions, 'exports' | 'skip'> & {
+        width: number;
+    };
     console: PresetEmptyOptions;
     deny: {
         imports: Record<string, string>;

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

@@ -1,4 +1,4 @@
-import type { AstFunction } from '../types/ast.types.ts';
+import type { AstCall, AstFunction } from '../types/ast.types.ts';
 import type { ESTree } from '@oxlint/plugins';
 export declare function astVisit(node: unknown, ancestors: ESTree.Node[], callback: (node: ESTree.Node, ancestors: ESTree.Node[]) => void): void;
 export declare function astMatchesCallee(name: string | undefined, callees: readonly string[], modifiers: ReadonlySet<string>): boolean;
@@ -17,3 +17,9 @@ export declare function astMemberName(node: ESTree.MemberExpression): string | u
 export declare function astDottedName(node: ESTree.Node): string | undefined;
 export declare function astCallName(node: ESTree.CallExpression): string | undefined;
 export declare function astSelectorRule(selector: string, message: string): import("@oxlint/plugins").Rule;
+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;

package/dist/utils/source.utils.d.ts

@@ -1,5 +1,5 @@
 import type { SourceIndent } from '../types/source.types.ts';
-import type { ESTree } from '@oxlint/plugins';
+import type * as PluginsTypes from '@oxlint/plugins';
 export declare const sourceIndentSchema: {
     anyOf: ({
         type: string;
@@ -11,8 +11,12 @@ export declare const sourceIndentSchema: {
         enum: string[];
     })[];
 };
-export declare function sourceCommentText(comment: Pick<ESTree.Comment, 'type' | 'value'>): string;
+export declare function sourceCommentText(comment: Pick<PluginsTypes.ESTree.Comment, 'type' | 'value'>): string;
 export declare function sourceIsDirective(text: string): boolean;
 export declare function sourceLineIndent(text: string, offset: number): string;
 export declare function sourceIndentUnit(indent?: SourceIndent): string;
 export declare function sourceNewline(text: string): string;
+export declare function sourceLineStart(text: string, offset: number): number;
+export declare function sourceLineEnd(text: string, offset: number): number;
+export declare function sourceItemGaps(open: number, items: readonly PluginsTypes.Ranged[], close: number): PluginsTypes.Range[];
+export declare function sourceRespace(fixer: PluginsTypes.Fixer, text: string, gaps: PluginsTypes.Range[], spacing: (index: number, last: boolean) => string): PluginsTypes.Fix[] | null;

package/dist/vendor/dillon-anti-slop/index.js

@@ -327,6 +327,39 @@ function astSelectorRule(selector, message) {
     }
   });
 }
+function astIsOneLine(node) {
+  return node.loc.start.line === node.loc.end.line;
+}
+function astIsInlineFunction(node) {
+  return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+}
+function astIsCall(node) {
+  return node.type === "CallExpression" || node.type === "NewExpression";
+}
+function astIsPipe(node) {
+  return node.callee.type === "MemberExpression" && astMemberName(node.callee) === "pipe";
+}
+function astChildren(node) {
+  return Object.entries(node).filter(([key]) => !astSkippedKeys.has(key)).map(([, child]) => child);
+}
+function astSome(value, test, enter = () => true) {
+  if (Array.isArray(value)) {
+    return value.some((child) => astSome(child, test, enter));
+  }
+  return astIsNode(value) && (test(value) || enter(value) && astChildren(value).some((child) => astSome(child, test, enter)));
+}
+function astCallDepth(value) {
+  if (Array.isArray(value)) {
+    return Math.max(0, ...value.map(astCallDepth));
+  }
+  if (!astIsNode(value) || astIsInlineFunction(value)) {
+    return 0;
+  }
+  if (astIsCall(value)) {
+    return Math.max(value.arguments.length === 0 ? 0 : 1 + astCallDepth(value.arguments), astCallDepth(value.callee));
+  }
+  return astCallDepth(astChildren(value));
+}
 
 // src/vendor/dillon-anti-slop/shared/type-reference-name.ts
 function typeReferenceName(type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.12.3",
+  "version": "0.12.4",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",