adamantite 0.41.0 → 0.43.0

package/dist/presets/lint/plugin/rules/no-react-state-hooks.d.ts

@@ -0,0 +1,10 @@
+import { Rule } from "@oxlint/plugins";
+//#region presets/lint/plugin/rules/no-react-state-hooks.d.ts
+/**
+ * Convert a glob to a regular expression that matches a whole path with forward slashes. Supports
+ * `**`, `*`, `?`, `[a-z]` and `[!a-z]` character classes, and `{a,b}` alternation.
+ */
+export declare function globToRegExp(glob: string): RegExp;
+declare const rule: Rule;
+//#endregion
+export { rule as default };

package/dist/presets/lint/plugin/rules/no-react-state-hooks.js

@@ -0,0 +1,128 @@
+import { findImportedCalls } from "../imports.js";
+import { readStringArrayOption } from "../options.js";
+//#region presets/lint/plugin/rules/no-react-state-hooks.ts
+const HOOK_MESSAGES = /* @__PURE__ */ new Map([
+	["useCallback", "memoization"],
+	["useEffect", "effect"],
+	["useLayoutEffect", "effect"],
+	["useMemo", "memoization"],
+	["useReducer", "localState"],
+	["useState", "localState"],
+	["useSyncExternalStore", "externalStore"]
+]);
+const DEFAULT_HOOKS = [...HOOK_MESSAGES.keys()];
+/**
+* Modules where hooks are permitted: hook modules such as `useCart.ts` or `use-cart.ts`, and
+* everything under a `hooks` directory. Everything else is feature code, including files such as
+* `userProfile.tsx`.
+*/
+const DEFAULT_ALLOW = [
+	"**/use[A-Z]*.{ts,tsx}",
+	"**/use-*.{ts,tsx}",
+	"**/hooks/**"
+];
+const REACT_MODULE = "react";
+function escapeRegExp(text) {
+	return text.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw`\$&`);
+}
+/**
+* Convert a glob to a regular expression that matches a whole path with forward slashes. Supports
+* `**`, `*`, `?`, `[a-z]` and `[!a-z]` character classes, and `{a,b}` alternation.
+*/
+function globToRegExp(glob) {
+	let source = "";
+	let index = 0;
+	while (index < glob.length) {
+		const rest = glob.slice(index);
+		if (rest.startsWith("**/")) {
+			source += "(?:.*/)?";
+			index += 3;
+		} else if (rest === "/**") {
+			source += "(?:/.*)?";
+			index += 3;
+		} else if (rest.startsWith("**")) {
+			source += ".*";
+			index += 2;
+		} else if (rest.startsWith("*")) {
+			source += "[^/]*";
+			index += 1;
+		} else if (rest.startsWith("?")) {
+			source += "[^/]";
+			index += 1;
+		} else if (rest.startsWith("[") && rest.indexOf("]") > 1) {
+			const end = rest.indexOf("]");
+			const negated = rest.startsWith("[!");
+			const characters = rest.slice(negated ? 2 : 1, end).replaceAll(/[\\^]/g, String.raw`\$&`);
+			source += `[${negated ? "^" : ""}${characters}]`;
+			index += end + 1;
+		} else if (rest.startsWith("{") && rest.includes("}")) {
+			const end = rest.indexOf("}");
+			const alternatives = rest.slice(1, end).split(",").map((alternative) => escapeRegExp(alternative));
+			source += `(?:${alternatives.join("|")})`;
+			index += end + 1;
+		} else {
+			source += escapeRegExp(glob.charAt(index));
+			index += 1;
+		}
+	}
+	return new RegExp(`^${source}$`);
+}
+function toPosixPath(path) {
+	return path.replaceAll("\\", "/");
+}
+/**
+* The path that `allow` globs match: relative to the working directory when the file is inside it,
+* and absolute otherwise.
+*/
+function getMatchPath(context) {
+	const filename = toPosixPath(context.filename);
+	const cwd = toPosixPath(context.cwd).replace(/\/$/, "");
+	return filename.startsWith(`${cwd}/`) ? filename.slice(cwd.length + 1) : filename;
+}
+const rule = {
+	create(context) {
+		const hooks = new Set(readStringArrayOption(context.options, "hooks") ?? DEFAULT_HOOKS);
+		const allow = (readStringArrayOption(context.options, "allow") ?? DEFAULT_ALLOW).map((glob) => globToRegExp(glob));
+		const matchPath = getMatchPath(context);
+		if (allow.some((pattern) => pattern.test(matchPath))) return {};
+		return { ImportDeclaration(node) {
+			if (node.source.value !== REACT_MODULE) return;
+			for (const { call, name } of findImportedCalls(context, node, hooks)) context.report({
+				data: { hook: name },
+				messageId: HOOK_MESSAGES.get(name) ?? "banned",
+				node: call
+			});
+		} };
+	},
+	meta: {
+		defaultOptions: [{
+			allow: [...DEFAULT_ALLOW],
+			hooks: [...DEFAULT_HOOKS]
+		}],
+		docs: { description: "Disallow React state, effect, and memoization hooks in feature code. Hooks stay allowed in hook modules." },
+		messages: {
+			banned: "`{{hook}}` is not allowed in feature code. Move it into a hook module.",
+			effect: "`{{hook}}` runs a side effect in feature code. Move the side effect to a loader, an action, or an event handler.",
+			externalStore: "`{{hook}}` subscribes to an external store in feature code. Subscribe through a query or a store abstraction instead.",
+			localState: "`{{hook}}` keeps local state in feature code. Derive the value from loader data or URL params instead.",
+			memoization: "`{{hook}}` memoizes by hand. Remove it: the React Compiler handles memoization."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				allow: {
+					items: { type: "string" },
+					type: "array"
+				},
+				hooks: {
+					items: { type: "string" },
+					type: "array"
+				}
+			},
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+};
+//#endregion
+export { rule as default, globToRegExp };

package/dist/presets/lint/plugin/rules/query-from-loader.d.ts

@@ -0,0 +1,5 @@
+import { Rule } from "@oxlint/plugins";
+//#region presets/lint/plugin/rules/query-from-loader.d.ts
+declare const rule: Rule;
+//#endregion
+export { rule as default };

package/dist/presets/lint/plugin/rules/query-from-loader.js

@@ -0,0 +1,110 @@
+import { findImportedCalls } from "../imports.js";
+//#region presets/lint/plugin/rules/query-from-loader.ts
+const QUERY_MODULE = "@tanstack/react-query";
+const ROUTER_MODULE = "@tanstack/react-router";
+const QUERY_HOOKS = /* @__PURE__ */ new Set([
+	"useInfiniteQuery",
+	"useQuery",
+	"useSuspenseInfiniteQuery",
+	"useSuspenseQuery"
+]);
+const INFINITE_QUERY_HOOKS = /* @__PURE__ */ new Set(["useInfiniteQuery", "useSuspenseInfiniteQuery"]);
+const OPTIONS_FACTORIES = /* @__PURE__ */ new Set(["infiniteQueryOptions", "queryOptions"]);
+/**
+* A file that calls one of these defines a route, in file-based or code-based routing. Only route
+* files have a loader that can preload a query, so the rule checks only them.
+*/
+const ROUTE_FACTORIES = /* @__PURE__ */ new Set([
+	"createFileRoute",
+	"createLazyFileRoute",
+	"createLazyRoute",
+	"createRootRoute",
+	"createRootRouteWithContext",
+	"createRoute"
+]);
+function findVariable(context, identifier) {
+	let scope = context.sourceCode.getScope(identifier);
+	while (scope !== null && !scope.set.has(identifier.name)) scope = scope.upper;
+	return scope?.set.get(identifier.name);
+}
+/**
+* The initializer of a `const` that declares `variable` with a plain identifier, such as `const
+* options = { ... }`. Destructured, `let`, and imported bindings have none.
+*/
+function getConstInit(variable) {
+	const [definition] = variable.defs;
+	if (variable.defs.length !== 1 || definition?.type !== "Variable") return;
+	const { node, parent } = definition;
+	if (node.type !== "VariableDeclarator" || node.id.type !== "Identifier" || parent?.type !== "VariableDeclaration" || parent.kind !== "const") return;
+	return node.init ?? void 0;
+}
+function isModuleScope(variable) {
+	return variable.scope.type === "module" || variable.scope.type === "global";
+}
+const rule = {
+	create(context) {
+		const hookCalls = [];
+		const factoryCalls = /* @__PURE__ */ new Set();
+		let isRouteFile = false;
+		/**
+		* Why `options` does not come from a shared definition, or `undefined` when it does or when the
+		* rule cannot tell. `inModule` is true when the expression sits at module scope.
+		*/
+		function classify(options, inModule) {
+			if (options.type === "TSAsExpression" || options.type === "TSNonNullExpression" || options.type === "TSSatisfiesExpression" || options.type === "TSTypeAssertion") return classify(options.expression, inModule);
+			if (options.type === "ObjectExpression") return options.properties.some((property) => property.type === "SpreadElement") ? void 0 : "plainObject";
+			if (options.type === "CallExpression" && factoryCalls.has(options)) return inModule ? void 0 : "localOptions";
+			if (options.type === "Identifier") {
+				const variable = findVariable(context, options);
+				const init = variable === void 0 ? void 0 : getConstInit(variable);
+				return variable === void 0 || init === void 0 ? void 0 : classify(init, isModuleScope(variable));
+			}
+		}
+		return {
+			ImportDeclaration(node) {
+				if (node.source.value === ROUTER_MODULE) {
+					isRouteFile ||= findImportedCalls(context, node, ROUTE_FACTORIES).length > 0;
+					return;
+				}
+				if (node.source.value !== QUERY_MODULE) return;
+				hookCalls.push(...findImportedCalls(context, node, QUERY_HOOKS));
+				for (const { call } of findImportedCalls(context, node, OPTIONS_FACTORIES)) factoryCalls.add(call);
+			},
+			"Program:exit"() {
+				if (!isRouteFile) return;
+				for (const { call, name } of hookCalls) {
+					const [options] = call.arguments;
+					if (options === void 0) continue;
+					const messageId = classify(options, false);
+					if (messageId !== void 0) {
+						const data = INFINITE_QUERY_HOOKS.has(name) ? {
+							factory: "infiniteQueryOptions",
+							hook: name,
+							preload: "ensureInfiniteQueryData"
+						} : {
+							factory: "queryOptions",
+							hook: name,
+							preload: "ensureQueryData"
+						};
+						context.report({
+							data,
+							messageId,
+							node: options
+						});
+					}
+				}
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Require TanStack Query hooks in route files to take options defined once with `queryOptions()` or `infiniteQueryOptions()`, so the route loader can preload the same query." },
+		messages: {
+			localOptions: "`{{hook}}` takes query options created inside a function, so the route loader cannot preload the same query. Move the `{{factory}}()` call to module scope, or into an exported factory such as `userQuery(id)`, preload it in this route's loader with `queryClient.{{preload}}()`, and pass the same options here.",
+			plainObject: "`{{hook}}` takes a plain options object instead of options defined with `{{factory}}()`. Define the options once with `{{factory}}()` at module scope or in a shared module, preload them in this route's loader with `queryClient.{{preload}}()`, and pass the same options here."
+		},
+		schema: [],
+		type: "suggestion"
+	}
+};
+//#endregion
+export { rule as default };

package/dist/presets/lint/react-doctor.d.ts

@@ -0,0 +1,5 @@
+import { OxlintConfig } from "oxlint";
+//#region presets/lint/react-doctor.d.ts
+declare const config: OxlintConfig;
+//#endregion
+export { config as default };

package/dist/presets/lint/react-doctor.js

@@ -0,0 +1,20 @@
+//#region presets/lint/react-doctor.ts
+const config = {
+	jsPlugins: ["oxlint-plugin-react-doctor"],
+	rules: {
+		"react-doctor/no-create-store-in-render": "error",
+		"react-doctor/no-direct-state-mutation": "error",
+		"react-doctor/no-eager-new-in-use-state-initializer": "error",
+		"react-doctor/no-impure-state-updater": "error",
+		"react-doctor/no-mutating-reducer-state": "error",
+		"react-doctor/effect-observer-needs-disconnect": "error",
+		"react-doctor/effect-raf-loop-needs-cancel": "error",
+		"react-doctor/no-effect-event-handler": "error",
+		"react-doctor/no-event-trigger-state": "error",
+		"react-doctor/no-fetch-in-effect": "error",
+		"react-doctor/no-pass-live-state-to-parent": "error",
+		"react-doctor/no-set-state-after-await-in-effect": "error"
+	}
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/react-strict.d.ts

@@ -0,0 +1,5 @@
+import { OxlintConfig } from "oxlint";
+//#region presets/lint/react-strict.d.ts
+declare const config: OxlintConfig;
+//#endregion
+export { config as default };

package/dist/presets/lint/react-strict.js

@@ -0,0 +1,11 @@
+//#region presets/lint/react-strict.ts
+const PLUGIN_EXTENSION = import.meta.url.endsWith(".ts") ? "ts" : "js";
+const config = {
+	jsPlugins: [{
+		name: "adamantite",
+		specifier: new URL(`plugin/index.${PLUGIN_EXTENSION}`, import.meta.url).href
+	}],
+	rules: { "adamantite/no-react-state-hooks": "error" }
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/shadcn.d.ts

@@ -0,0 +1,5 @@
+import { OxlintConfig } from "oxlint";
+//#region presets/lint/shadcn.d.ts
+declare const config: OxlintConfig;
+//#endregion
+export { config as default };

package/dist/presets/lint/shadcn.js

@@ -0,0 +1,22 @@
+//#region presets/lint/shadcn.ts
+const config = {
+	jsPlugins: ["@shadcn/lint"],
+	overrides: [{
+		files: ["**/components/ui/**"],
+		rules: {
+			"shadcn/no-arbitrary-values": "off",
+			"shadcn/no-restyle": "off",
+			"shadcn/require-static-classes": "off"
+		}
+	}],
+	rules: {
+		"shadcn/no-arbitrary-values": ["error", { allow: ["layout"] }],
+		"shadcn/no-inline-styles": "error",
+		"shadcn/no-raw-colors": "error",
+		"shadcn/no-restyle": ["error", { allow: ["layout"] }],
+		"shadcn/no-unknown-classes": "error",
+		"shadcn/require-static-classes": "error"
+	}
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/strict.d.ts

@@ -0,0 +1,5 @@
+import { OxlintConfig } from "oxlint";
+//#region presets/lint/strict.d.ts
+declare const config: OxlintConfig;
+//#endregion
+export { config as default };

package/dist/presets/lint/strict.js

@@ -0,0 +1,18 @@
+//#region presets/lint/strict.ts
+const PLUGIN_EXTENSION = import.meta.url.endsWith(".ts") ? "ts" : "js";
+const config = {
+	jsPlugins: [{
+		name: "adamantite",
+		specifier: new URL(`plugin/index.${PLUGIN_EXTENSION}`, import.meta.url).href
+	}],
+	overrides: [{
+		files: ["**/*.{test,spec}.{ts,tsx,mts,cts}", "**/__tests__/**"],
+		rules: { "typescript/consistent-type-assertions": "error" }
+	}],
+	rules: {
+		"adamantite/no-overzealous-destructuring": "error",
+		"typescript/consistent-type-assertions": ["error", { assertionStyle: "never" }]
+	}
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/tanstack.d.ts

@@ -0,0 +1,5 @@
+import { OxlintConfig } from "oxlint";
+//#region presets/lint/tanstack.d.ts
+declare const config: OxlintConfig;
+//#endregion
+export { config as default };

package/dist/presets/lint/tanstack.js

@@ -0,0 +1,14 @@
+//#region presets/lint/tanstack.ts
+const PLUGIN_EXTENSION = import.meta.url.endsWith(".ts") ? "ts" : "js";
+const config = {
+	jsPlugins: [{
+		name: "adamantite",
+		specifier: new URL(`plugin/index.${PLUGIN_EXTENSION}`, import.meta.url).href
+	}],
+	rules: {
+		"adamantite/no-query-data-in-state": "error",
+		"adamantite/query-from-loader": "error"
+	}
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/vendor/antislop/plugin.d.mts

@@ -1,11 +1,27 @@
 // Generated by scripts/vendor-plugins.ts — do not edit by hand.
 interface VendoredPluginRule {
-  readonly create: (context: never) => Record<string, never>
+  readonly create: (context: object) => Record<string, never>
 }
 
 declare const vendoredPlugin: {
   readonly meta: { readonly name: string }
-  readonly rules: { readonly [ruleName: string]: VendoredPluginRule }
+  readonly rules: {
+    readonly "no-chained-type-assertions": VendoredPluginRule
+    readonly "no-conditional-empty-object-spread": VendoredPluginRule
+    readonly "no-known-value-widening": VendoredPluginRule
+    readonly "no-module-mocking": VendoredPluginRule
+    readonly "no-object-parameters": VendoredPluginRule
+    readonly "no-reflect-apply": VendoredPluginRule
+    readonly "no-reflect-get": VendoredPluginRule
+    readonly "no-runtime-typeof": VendoredPluginRule
+    readonly "no-shape-in-symbol-names": VendoredPluginRule
+    readonly "no-unknown-parameters": VendoredPluginRule
+    readonly "no-unknown-returns": VendoredPluginRule
+    readonly "no-unknown-type-aliases": VendoredPluginRule
+    readonly "no-unsafe-dictionary-type": VendoredPluginRule
+    readonly "no-widen-then-assert": VendoredPluginRule
+    readonly "require-safety-comment-for-type-assertion": VendoredPluginRule
+  }
 }
 
 export default vendoredPlugin

package/dist/presets/rules/index.d.ts

@@ -0,0 +1,9 @@
+import { Context, Diagnostic, ESTree, Fix, Fixer, Node, Options, Plugin, Rule, RuleMeta, SourceCode, Visitor, VisitorWithHooks, defineRule } from "@oxlint/plugins";
+//#region presets/rules/index.d.ts
+/**
+ * Import every rule file in a rules folder and return them as one Oxlint plugin. The entry module
+ * that `custom()` writes calls this function.
+ */
+export declare function loadRules(dir: string, name?: string): Promise<Plugin>;
+//#endregion
+export { type Context, type Diagnostic, type ESTree, type Fix, type Fixer, type Node, type Options, type Rule, type RuleMeta, type SourceCode, type Visitor, type VisitorWithHooks, defineRule };

package/dist/presets/rules/index.js

@@ -0,0 +1,29 @@
+import { DEFAULT_PLUGIN_NAME, getRuleName, listRuleFiles } from "../lint/custom.js";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { defineRule } from "@oxlint/plugins";
+//#region presets/rules/index.ts
+async function importRule(path) {
+	let module;
+	try {
+		module = await import(pathToFileURL(path).href);
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		throw new Error(`Custom rule ${path} failed to load: ${reason}\nRule files run with type stripping, so use erasable TypeScript only: no enum, namespace, or parameter properties.`, { cause: error });
+	}
+	if (module.default === void 0) throw new Error(`Custom rule ${path} has no default export. Export the rule as default.`);
+	return module.default;
+}
+/**
+* Import every rule file in a rules folder and return them as one Oxlint plugin. The entry module
+* that `custom()` writes calls this function.
+*/
+async function loadRules(dir, name = DEFAULT_PLUGIN_NAME) {
+	const rules = await Promise.all(listRuleFiles(dir).map(async (file) => [getRuleName(file), await importRule(join(dir, file))]));
+	return {
+		meta: { name },
+		rules: Object.fromEntries(rules)
+	};
+}
+//#endregion
+export { defineRule, loadRules };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adamantite",
-  "version": "0.41.0",
+  "version": "0.43.0",
   "description": "An strict and opinionated set of presets for modern TypeScript applications",
   "keywords": [
     "adamantite",
@@ -54,38 +54,45 @@
       "types": "./dist/presets/lint/*.d.ts",
       "default": "./dist/presets/lint/*.js"
     },
+    "./rules": {
+      "types": "./dist/presets/rules/index.d.ts",
+      "default": "./dist/presets/rules/index.js"
+    },
     "./typescript": "./dist/presets/tsconfig.json"
   },
   "dependencies": {
-    "@clack/prompts": "1.7.0",
-    "@effect/platform-node": "4.0.0-rc.115",
+    "@clack/prompts": "1.8.1",
+    "@effect/platform-node": "4.0.0",
+    "@oxlint/plugins": "1.86.0",
     "defu": "6.1.7",
-    "effect": "4.0.0-rc.115",
-    "esrap": "2.3.6",
+    "effect": "4.0.0",
     "jsonc-parser": "3.3.1",
-    "nypm": "0.6.9",
-    "oxc-parser": "^0.147.0"
+    "nypm": "0.6.10",
+    "oxc-parser": "0.152.0"
   },
   "devDependencies": {
-    "@changesets/changelog-github": "1.0.0",
-    "@changesets/cli": "3.0.1",
-    "@effect/vitest": "4.0.0-rc.115",
-    "@tanstack/intent": "0.3.7",
+    "@changesets/changelog-github": "1.0.1",
+    "@changesets/cli": "3.0.3",
+    "@effect/tsgo": "0.48.0",
+    "@effect/vitest": "4.0.0",
+    "@shadcn/lint": "0.2.0",
+    "@tanstack/intent": "0.5.0",
     "@types/figlet": "1.7.0",
-    "@types/node": "22.20.1",
-    "@vitest/coverage-v8": "5.0.1",
-    "@vitest/ui": "5.0.1",
-    "figlet": "1.11.4",
-    "knip": "6.32.2",
-    "oxfmt": "0.65.0",
-    "oxlint": "1.83.0",
-    "oxlint-tsgolint": "7.0.2001",
+    "@types/node": "22.20.5",
+    "@vitest/coverage-v8": "5.0.3",
+    "@vitest/ui": "5.0.3",
+    "figlet": "1.12.0",
+    "knip": "6.39.0",
+    "oxfmt": "0.71.0",
+    "oxlint": "1.86.0",
+    "oxlint-plugin-react-doctor": "0.9.14",
+    "oxlint-tsgolint": "7.0.2003",
     "sherif": "1.13.0",
-    "tsdown": "0.22.14",
-    "type-fest": "5.8.0",
+    "tsdown": "0.23.0",
+    "type-fest": "5.10.0",
     "typescript": "7.0.2",
     "unplugin-macros": "0.23.2",
-    "vitest": "5.0.1"
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
     "typescript": ">=7"
@@ -107,7 +114,9 @@
     "test:build": "node scripts/test-build.ts",
     "test:coverage": "vitest run --coverage",
     "test:dist": "pnpm run build && pnpm run test:build && pnpm run test:smoke",
+    "test:presets": "vitest run --project presets",
     "test:smoke": "node scripts/test-smoke.ts",
+    "test:unit": "vitest run --project unit",
     "test:watch": "vitest",
     "version": "changeset version"
   }