adamantite 0.42.0 → 0.43.0

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

@@ -13,7 +13,9 @@ import { OxlintConfig } from "oxlint";
  * })
  * ```
  */
-declare const ignorePatterns: string[];
-declare const config: OxlintConfig;
+export declare const ignorePatterns: string[];
+declare const config: OxlintConfig & {
+  ignorePatterns: string[];
+};
 //#endregion
-export { config as default, ignorePatterns };
+export { config as default };

package/dist/presets/lint/core.js

@@ -308,6 +308,7 @@ const config = {
 		"typescript/no-extraneous-class": "error",
 		"typescript/no-floating-promises": "error",
 		"typescript/no-for-in-array": "error",
+		"typescript/no-generated-empty-object-type": "error",
 		"typescript/no-implied-eval": "error",
 		"typescript/no-import-type-side-effects": "error",
 		"typescript/no-inferrable-types": "error",

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

@@ -0,0 +1,60 @@
+import { DummyRule, OxlintConfig } from "oxlint";
+//#region presets/lint/custom.d.ts
+/**
+ * The plugin name that `custom()` uses when no `name` is given.
+ */
+export declare const DEFAULT_PLUGIN_NAME = "project";
+/**
+ * The rule name that a rule file defines: its file name without the extension.
+ */
+export declare function getRuleName(file: string): string;
+/**
+ * Whether a file in a rules folder is a rule: it has a JavaScript or TypeScript extension, is not a
+ * declaration file, and does not start with `_`.
+ */
+export declare function isRuleFile(name: string): boolean;
+/**
+ * The rule files in a rules folder. Subfolders are not read, so helpers can also live there.
+ */
+export declare function listRuleFiles(dir: string): string[];
+export interface CustomRulesOptions {
+  /**
+   * The rules folder. A relative path resolves from the file that calls `custom()`, not from the
+   * working directory. Default: `.adamantite/rules`.
+   */
+  readonly dir?: string;
+  /**
+   * The plugin name, which prefixes every rule, as in `project/no-process-env`. Oxlint rejects two
+   * plugins with the same name in one run, so give each rules folder in a monorepo its own name.
+   * Default: `project`.
+   */
+  readonly name?: string;
+  /**
+   * Severity or options for a rule, by rule name without the plugin prefix. Every rule is enabled
+   * as `"error"` by default.
+   */
+  readonly rules?: Readonly<Record<string, DummyRule>>;
+}
+/**
+ * The first file in a stack trace that is not `ownFile`: the module that called into `ownFile`.
+ * Undefined when the stack names no such file.
+ */
+export declare function findCallerFile(stack: string, ownFile: string): string | undefined;
+/**
+ * Load the custom rules in a rules folder and enable each one as `error`. A rule file
+ * `no-process-env.ts` becomes the rule `project/no-process-env`. Files that start with `_` are
+ * helpers, not rules.
+ *
+ * Without a rules folder, or with an empty one, the result is an empty config, so every project can
+ * extend it.
+ *
+ * ```ts
+ * import { defineConfig } from "oxlint"
+ * import core from "adamantite/lint"
+ * import custom from "adamantite/lint/custom"
+ *
+ * export default defineConfig({ extends: [core, custom()] })
+ * ```
+ */
+export default function custom(options?: CustomRulesOptions): OxlintConfig;
+//#endregion

package/dist/presets/lint/custom.js

@@ -0,0 +1,142 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region presets/lint/custom.ts
+const MODULE_EXTENSION = import.meta.url.endsWith(".ts") ? "ts" : "js";
+const RULES_MODULE_URL = new URL(`../rules/index.${MODULE_EXTENSION}`, import.meta.url).href;
+const DEFAULT_DIRECTORY = ".adamantite/rules";
+const CACHE_DIRECTORY = join("node_modules", ".cache", "adamantite");
+/**
+* The plugin name that `custom()` uses when no `name` is given.
+*/
+const DEFAULT_PLUGIN_NAME = "project";
+const RULE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".js",
+	".mjs",
+	".mts",
+	".ts"
+]);
+/**
+* The rule name that a rule file defines: its file name without the extension.
+*/
+function getRuleName(file) {
+	return file.slice(0, -extname(file).length);
+}
+/**
+* Whether a file in a rules folder is a rule: it has a JavaScript or TypeScript extension, is not a
+* declaration file, and does not start with `_`.
+*/
+function isRuleFile(name) {
+	return RULE_FILE_EXTENSIONS.has(extname(name)) && !name.startsWith("_") && !/\.d\.m?ts$/.test(name);
+}
+/**
+* The rule files in a rules folder. Subfolders are not read, so helpers can also live there.
+*/
+function listRuleFiles(dir) {
+	return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isFile() && isRuleFile(entry.name)).map((entry) => entry.name);
+}
+/**
+* Normalize a file from a stack frame: drop the query string and hash, which Oxlint adds to bypass
+* the module cache, and convert a file URL to a path.
+*/
+function toFramePath(location) {
+	if (location.startsWith("file://")) {
+		const url = new URL(location);
+		url.search = "";
+		url.hash = "";
+		return fileURLToPath(url);
+	}
+	return location.replace(/[?#].*$/, "");
+}
+const OWN_FILE = toFramePath(import.meta.url);
+const FRAME_LOCATION = /(?:\(|at )((?:file:\/\/|\/|[A-Za-z]:[\\/]).+?):\d+:\d+\)?\s*$/;
+/**
+* The first file in a stack trace that is not `ownFile`: the module that called into `ownFile`.
+* Undefined when the stack names no such file.
+*/
+function findCallerFile(stack, ownFile) {
+	for (const line of stack.split("\n").slice(1)) {
+		const location = FRAME_LOCATION.exec(line)?.[1];
+		if (location === void 0) continue;
+		const file = toFramePath(location);
+		if (file !== ownFile) return file;
+	}
+}
+function resolveRulesDirectory(dir, stack) {
+	if (isAbsolute(dir)) return dir;
+	const caller = findCallerFile(stack, OWN_FILE);
+	if (caller === void 0) throw new Error(`custom() could not find the file that called it, so it cannot resolve "${dir}". Pass an absolute \`dir\`, such as \`join(import.meta.dirname, "${dir}")\`.`);
+	return resolve(dirname(caller), dir);
+}
+function findNodeModules(from) {
+	for (let current = from;; current = dirname(current)) {
+		if (existsSync(join(current, "node_modules"))) return current;
+		if (dirname(current) === current) return;
+	}
+}
+function writeIfChanged(path, content) {
+	if (existsSync(path) && readFileSync(path, "utf8") === content) return;
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, content);
+}
+/**
+* Write the entry module for a rules folder and return its file URL. The module goes to
+* `node_modules/.cache/adamantite` above the folder, or to the OS temporary directory when no
+* `node_modules` folder is found or it cannot be written.
+*/
+function writeEntryModule(dir, name) {
+	const fileName = `rules-${createHash("sha256").update(`${dir}\0${name}`).digest("hex").slice(0, 16)}.mjs`;
+	const content = [
+		`import { loadRules } from ${JSON.stringify(RULES_MODULE_URL)}`,
+		"",
+		`export default await loadRules(${JSON.stringify(dir)}, ${JSON.stringify(name)})`,
+		""
+	].join("\n");
+	const root = findNodeModules(dir);
+	const candidates = [...root === void 0 ? [] : [join(root, CACHE_DIRECTORY, fileName)], join(tmpdir(), "adamantite", fileName)];
+	const failures = [];
+	for (const path of candidates) try {
+		writeIfChanged(path, content);
+		return pathToFileURL(path).href;
+	} catch (error) {
+		failures.push(error);
+	}
+	throw new AggregateError(failures, `custom() could not write the entry module for ${dir}.`);
+}
+/**
+* Load the custom rules in a rules folder and enable each one as `error`. A rule file
+* `no-process-env.ts` becomes the rule `project/no-process-env`. Files that start with `_` are
+* helpers, not rules.
+*
+* Without a rules folder, or with an empty one, the result is an empty config, so every project can
+* extend it.
+*
+* ```ts
+* import { defineConfig } from "oxlint"
+* import core from "adamantite/lint"
+* import custom from "adamantite/lint/custom"
+*
+* export default defineConfig({ extends: [core, custom()] })
+* ```
+*/
+function custom(options = {}) {
+	const name = options.name ?? "project";
+	const dir = resolveRulesDirectory(options.dir ?? DEFAULT_DIRECTORY, (/* @__PURE__ */ new Error("custom()")).stack ?? "");
+	if (!existsSync(dir)) return {};
+	const files = listRuleFiles(dir);
+	if (files.length === 0) return {};
+	const rules = {};
+	for (const file of files) rules[`${name}/${getRuleName(file)}`] = "error";
+	for (const [rule, setting] of Object.entries(options.rules ?? {})) rules[`${name}/${rule}`] = setting;
+	return {
+		jsPlugins: [{
+			name,
+			specifier: writeEntryModule(dir, name)
+		}],
+		rules
+	};
+}
+//#endregion
+export { DEFAULT_PLUGIN_NAME, custom as default, findCallerFile, getRuleName, isRuleFile, listRuleFiles };

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

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

package/dist/presets/lint/effect.js

@@ -0,0 +1,106 @@
+//#region presets/lint/effect.ts
+const config = {
+	options: { typeAware: true },
+	plugins: ["effecttsgo"],
+	rules: {
+		"effecttsgo/any-unknown-in-error-context": "error",
+		"effecttsgo/class-self-mismatch": "error",
+		"effecttsgo/duplicate-package": "error",
+		"effecttsgo/effect-fn-implicit-any": "error",
+		"effecttsgo/experimental-api-usage": "error",
+		"effecttsgo/floating-effect": "error",
+		"effecttsgo/floating-effect-in-vitest": "error",
+		"effecttsgo/generic-effect-services": "error",
+		"effecttsgo/missing-effect-context": "error",
+		"effecttsgo/missing-effect-error": "error",
+		"effecttsgo/missing-layer-context": "error",
+		"effecttsgo/missing-return-yield-star": "error",
+		"effecttsgo/missing-star-in-yield-effect-gen": "error",
+		"effecttsgo/non-object-effect-service-type": "error",
+		"effecttsgo/obsolete-match-import": "error",
+		"effecttsgo/obsolete-schema-import": "error",
+		"effecttsgo/outdated-api": "error",
+		"effecttsgo/overridden-schema-constructor": "error",
+		"effecttsgo/promise-in-effect-success": "error",
+		"effecttsgo/schema-literal-non-finite": "error",
+		"effecttsgo/schema-opaque-instance-member": "error",
+		"effecttsgo/unsafe-effect-type-assertion": "error",
+		"effecttsgo/unstable-api-usage": "error",
+		"effecttsgo/catch-unfailable-effect": "error",
+		"effecttsgo/effect-fn-iife": "error",
+		"effecttsgo/effect-gen-uses-adapter": "error",
+		"effecttsgo/effect-in-failure": "error",
+		"effecttsgo/effect-in-void-success": "error",
+		"effecttsgo/global-error-in-effect-catch": "error",
+		"effecttsgo/global-error-in-effect-failure": "error",
+		"effecttsgo/layer-merge-all-with-dependencies": "error",
+		"effecttsgo/lazy-effect": "error",
+		"effecttsgo/lazy-promise-in-effect-sync": "error",
+		"effecttsgo/leaking-requirements": "error",
+		"effecttsgo/multiple-effect-provide": "error",
+		"effecttsgo/prefer-unsafe-constructor": "error",
+		"effecttsgo/return-effect-in-gen": "error",
+		"effecttsgo/run-effect-inside-effect": "error",
+		"effecttsgo/schema-sync-in-effect": "error",
+		"effecttsgo/scope-in-layer-effect": "error",
+		"effecttsgo/try-catch-in-effect-gen": "error",
+		"effecttsgo/unknown-in-effect-catch": "error",
+		"effecttsgo/abort-controller-in-effect": "error",
+		"effecttsgo/crypto-random-uuid-in-effect": "error",
+		"effecttsgo/global-console-in-effect": "error",
+		"effecttsgo/global-date-in-effect": "error",
+		"effecttsgo/global-fetch-in-effect": "error",
+		"effecttsgo/global-random-in-effect": "error",
+		"effecttsgo/global-timers-in-effect": "error",
+		"effecttsgo/instance-of-schema": "error",
+		"effecttsgo/process-env-in-effect": "error",
+		"effecttsgo/acquire-release-disposable": "error",
+		"effecttsgo/all-of-map-to-for-each": "error",
+		"effecttsgo/catch-all-tag-dispatch-to-catch-tag": "error",
+		"effecttsgo/catch-all-to-map-error": "error",
+		"effecttsgo/catch-chain-to-first-success-of": "error",
+		"effecttsgo/catch-conditional-refail-to-catch-if": "error",
+		"effecttsgo/catch-die-to-or-die": "error",
+		"effecttsgo/catch-if-tag-to-catch-tag": "error",
+		"effecttsgo/catch-refail-to-tap-error": "error",
+		"effecttsgo/catch-tag-to-catch-reason": "error",
+		"effecttsgo/catch-to-ignore": "error",
+		"effecttsgo/catch-to-or-else-succeed": "error",
+		"effecttsgo/effect-do-notation": "error",
+		"effecttsgo/effect-fn-opportunity": "error",
+		"effecttsgo/effect-map-flatten": "error",
+		"effecttsgo/effect-map-void": "error",
+		"effecttsgo/effect-succeed-with-void": "error",
+		"effecttsgo/flat-map-conditional-to-filter-or-fail": "error",
+		"effecttsgo/flat-map-ignored-param-to-and-then": "error",
+		"effecttsgo/flat-map-to-map": "error",
+		"effecttsgo/map-some-to-as-some": "error",
+		"effecttsgo/match-effect-to-map-both": "error",
+		"effecttsgo/match-effect-to-match": "error",
+		"effecttsgo/multiple-catch-tag": "error",
+		"effecttsgo/nested-effect-gen-yield": "error",
+		"effecttsgo/option-match-to-from-option": "error",
+		"effecttsgo/prefer-schema-type-property": "error",
+		"effecttsgo/prefer-succeed-some-or-none": "error",
+		"effecttsgo/prefer-typed-schema-decoder": "error",
+		"effecttsgo/provide-layer-succeed-to-provide-service": "error",
+		"effecttsgo/race-first-with-sleep-to-timeout": "error",
+		"effecttsgo/redundant-map-error": "error",
+		"effecttsgo/redundant-or-die": "error",
+		"effecttsgo/redundant-schema-tag-identifier": "error",
+		"effecttsgo/run-of-exit-to-run-exit": "error",
+		"effecttsgo/schema-number": "error",
+		"effecttsgo/schema-struct-with-tag": "error",
+		"effecttsgo/schema-union-of-literals": "error",
+		"effecttsgo/service-not-as-class": "error",
+		"effecttsgo/sync-to-succeed": "error",
+		"effecttsgo/timeout-catch-tag-to-timeout-or-else": "error",
+		"effecttsgo/unnecessary-effect-gen": "error",
+		"effecttsgo/unnecessary-fail-yieldable-error": "error",
+		"effecttsgo/unnecessary-pipe": "error",
+		"effecttsgo/unnecessary-pipe-chain": "error",
+		"effecttsgo/unnecessary-typeof-type": "error"
+	}
+};
+//#endregion
+export { config as default };

package/dist/presets/lint/plugin/imports.d.ts

@@ -0,0 +1,19 @@
+import { Context, ESTree } from "@oxlint/plugins";
+//#region presets/lint/plugin/imports.d.ts
+/**
+ * A call of a module export, such as `useState(0)` or `React.useState(0)`.
+ */
+export interface ImportedCall {
+  readonly call: ESTree.CallExpression;
+  /**
+   * The export name, which stays the same when the import is aliased.
+   */
+  readonly name: string;
+}
+/**
+ * Find the calls of the exports in `names` that `node` imports: direct calls through a named
+ * import, including aliased ones, and member calls such as `React.useState(0)` through a default or
+ * namespace import. Type-only imports give no calls.
+ */
+export declare function findImportedCalls(context: Context, node: ESTree.ImportDeclaration, names: ReadonlySet<string>): ImportedCall[];
+//#endregion

package/dist/presets/lint/plugin/imports.js

@@ -0,0 +1,53 @@
+//#region presets/lint/plugin/imports.ts
+function getImportedName(specifier) {
+	return specifier.imported.type === "Literal" ? specifier.imported.value : specifier.imported.name;
+}
+function isStringLiteral(node) {
+	return node.type === "Literal" && typeof node.value === "string";
+}
+function getPropertyName(member) {
+	if (!member.computed) return member.property.type === "Identifier" ? member.property.name : void 0;
+	return isStringLiteral(member.property) ? member.property.value : void 0;
+}
+function getCall(node) {
+	const { parent } = node;
+	return parent?.type === "CallExpression" && parent.callee === node ? parent : void 0;
+}
+/**
+* Find the calls of the exports in `names` that `node` imports: direct calls through a named
+* import, including aliased ones, and member calls such as `React.useState(0)` through a default or
+* namespace import. Type-only imports give no calls.
+*/
+function findImportedCalls(context, node, names) {
+	if (node.importKind === "type") return [];
+	const calls = [];
+	for (const specifier of node.specifiers) {
+		if (specifier.type === "ImportSpecifier" && specifier.importKind === "type") continue;
+		const identifiers = context.sourceCode.getDeclaredVariables(specifier).flatMap((variable) => variable.references).map((reference) => reference.identifier);
+		if (specifier.type === "ImportSpecifier") {
+			const name = getImportedName(specifier);
+			if (!names.has(name)) continue;
+			for (const identifier of identifiers) {
+				const call = getCall(identifier);
+				if (call !== void 0) calls.push({
+					call,
+					name
+				});
+			}
+			continue;
+		}
+		for (const identifier of identifiers) {
+			const member = identifier.parent;
+			if (member.type !== "MemberExpression" || member.object !== identifier) continue;
+			const name = getPropertyName(member);
+			const call = getCall(member);
+			if (name !== void 0 && names.has(name) && call !== void 0) calls.push({
+				call,
+				name
+			});
+		}
+	}
+	return calls;
+}
+//#endregion
+export { findImportedCalls };

package/dist/presets/lint/plugin/index.d.ts

@@ -3,7 +3,9 @@ import { Plugin, Rule } from "@oxlint/plugins";
 interface AdamantitePlugin extends Plugin {
   readonly rules: {
     readonly "no-overzealous-destructuring": Rule;
+    readonly "no-query-data-in-state": Rule;
     readonly "no-react-state-hooks": Rule;
+    readonly "query-from-loader": Rule;
   };
 }
 /**

package/dist/presets/lint/plugin/index.js

@@ -1,5 +1,7 @@
 import rule from "./rules/no-overzealous-destructuring.js";
-import rule$1 from "./rules/no-react-state-hooks.js";
+import rule$1 from "./rules/no-query-data-in-state.js";
+import rule$2 from "./rules/no-react-state-hooks.js";
+import rule$3 from "./rules/query-from-loader.js";
 //#region presets/lint/plugin/index.ts
 /**
 * Adamantite's first-party Oxlint plugin. Presets load it by file URL, so target projects install
@@ -9,7 +11,9 @@ const plugin = {
 	meta: { name: "adamantite" },
 	rules: {
 		"no-overzealous-destructuring": rule,
-		"no-react-state-hooks": rule$1
+		"no-query-data-in-state": rule$1,
+		"no-react-state-hooks": rule$2,
+		"query-from-loader": rule$3
 	}
 };
 //#endregion

package/dist/presets/lint/plugin/options.d.ts

@@ -3,10 +3,9 @@ import { Options } from "@oxlint/plugins";
 /**
  * Read a string array from the rule's first option object.
  */
-declare function readStringArrayOption(options: Readonly<Options>, key: string): string[] | undefined;
+export declare function readStringArrayOption(options: Readonly<Options>, key: string): string[] | undefined;
 /**
  * Read a positive integer from the rule's first option object.
  */
-declare function readPositiveIntegerOption(options: Readonly<Options>, key: string): number | undefined;
-//#endregion
-export { readPositiveIntegerOption, readStringArrayOption };
+export declare function readPositiveIntegerOption(options: Readonly<Options>, key: string): number | undefined;
+//#endregion

package/dist/presets/lint/plugin/rules/no-query-data-in-state.d.ts

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

package/dist/presets/lint/plugin/rules/no-query-data-in-state.js

@@ -0,0 +1,85 @@
+import { findImportedCalls } from "../imports.js";
+//#region presets/lint/plugin/rules/no-query-data-in-state.ts
+const QUERY_MODULE = "@tanstack/react-query";
+const REACT_MODULE = "react";
+const QUERY_HOOKS = /* @__PURE__ */ new Set([
+	"useInfiniteQuery",
+	"useQuery",
+	"useSuspenseInfiniteQuery",
+	"useSuspenseQuery"
+]);
+const STATE_HOOKS = /* @__PURE__ */ new Set(["useState"]);
+function isDataKey(property) {
+	return !property.computed && property.key.type === "Identifier" && property.key.name === "data";
+}
+function getReferences(context, declarator, name) {
+	return context.sourceCode.getDeclaredVariables(declarator).filter((variable) => variable.name === name).flatMap((variable) => variable.references).map((reference) => reference.identifier);
+}
+/**
+* The expressions that read the data of the query result that `call` returns: `query.data` for
+* `const query = useQuery(...)`, and each `data` read for `const { data } = useQuery(...)`.
+*/
+function findDataReads(context, call) {
+	const declarator = call.parent;
+	if (declarator.type !== "VariableDeclarator" || declarator.init !== call) return [];
+	const { id } = declarator;
+	if (id.type === "Identifier") return getReferences(context, declarator, id.name).flatMap((identifier) => {
+		const member = identifier.parent;
+		return member.type === "MemberExpression" && member.object === identifier && !member.computed && member.property.name === "data" ? [member] : [];
+	});
+	if (id.type !== "ObjectPattern") return [];
+	return id.properties.flatMap((property) => {
+		if (property.type !== "Property" || !isDataKey(property)) return [];
+		const binding = property.value.type === "AssignmentPattern" ? property.value.left : property.value;
+		return binding.type === "Identifier" ? getReferences(context, declarator, binding.name) : [];
+	});
+}
+/**
+* Whether `node` evaluates to query data or to a value inside it, such as `query.data`,
+* `data.user.name`, `data ?? []`, or `() => data`.
+*/
+function readsData(node, dataReads) {
+	if (dataReads.has(node)) return true;
+	switch (node.type) {
+		case "ArrowFunctionExpression": return node.expression && node.body.type !== "BlockStatement" && readsData(node.body, dataReads);
+		case "ChainExpression":
+		case "TSAsExpression":
+		case "TSNonNullExpression":
+		case "TSSatisfiesExpression": return readsData(node.expression, dataReads);
+		case "LogicalExpression": return readsData(node.left, dataReads) || readsData(node.right, dataReads);
+		case "MemberExpression": return readsData(node.object, dataReads);
+		default: return false;
+	}
+}
+const rule = {
+	create(context) {
+		const queryCalls = [];
+		const stateCalls = [];
+		return {
+			ImportDeclaration(node) {
+				if (node.source.value === QUERY_MODULE) queryCalls.push(...findImportedCalls(context, node, QUERY_HOOKS));
+				else if (node.source.value === REACT_MODULE) stateCalls.push(...findImportedCalls(context, node, STATE_HOOKS));
+			},
+			"Program:exit"() {
+				if (queryCalls.length === 0 || stateCalls.length === 0) return;
+				const dataReads = new Set(queryCalls.flatMap(({ call }) => findDataReads(context, call)));
+				for (const { call, name } of stateCalls) {
+					const [initial] = call.arguments;
+					if (initial !== void 0 && readsData(initial, dataReads)) context.report({
+						data: { hook: name },
+						messageId: "copiedData",
+						node: call
+					});
+				}
+			}
+		};
+	},
+	meta: {
+		docs: { description: "Disallow copying TanStack Query data into React state, where the copy stops updating when the query refetches." },
+		messages: { copiedData: "`{{hook}}` copies query data into local state, so the copy stops updating when the query refetches or another component updates the cache. Read the value from the query result where you use it. To edit it, keep only the user's changes in state and merge them with the query data during render." },
+		schema: [],
+		type: "problem"
+	}
+};
+//#endregion
+export { rule as default };

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

@@ -4,7 +4,7 @@ import { Rule } from "@oxlint/plugins";
  * 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.
  */
-declare function globToRegExp(glob: string): RegExp;
+export declare function globToRegExp(glob: string): RegExp;
 declare const rule: Rule;
 //#endregion
-export { rule as default, globToRegExp };
+export { rule as default };

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

@@ -1,3 +1,4 @@
+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([
@@ -78,52 +79,19 @@ function getMatchPath(context) {
 	const cwd = toPosixPath(context.cwd).replace(/\/$/, "");
 	return filename.startsWith(`${cwd}/`) ? filename.slice(cwd.length + 1) : filename;
 }
-function getImportedName(specifier) {
-	return specifier.imported.type === "Literal" ? specifier.imported.value : specifier.imported.name;
-}
-function isStringLiteral(node) {
-	return node.type === "Literal" && typeof node.value === "string";
-}
-function getPropertyName(member) {
-	if (!member.computed) return member.property.type === "Identifier" ? member.property.name : void 0;
-	return isStringLiteral(member.property) ? member.property.value : void 0;
-}
-function isCallee(node) {
-	const { parent } = node;
-	return parent?.type === "CallExpression" && parent.callee === node;
-}
 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 {};
-		function report(node, hook) {
-			context.report({
-				data: { hook },
-				messageId: HOOK_MESSAGES.get(hook) ?? "banned",
-				node
-			});
-		}
-		function getReferences(specifier) {
-			return context.sourceCode.getDeclaredVariables(specifier).flatMap((variable) => variable.references).map((reference) => reference.identifier);
-		}
 		return { ImportDeclaration(node) {
-			if (node.source.value !== REACT_MODULE || node.importKind === "type") return;
-			for (const specifier of node.specifiers) {
-				if (specifier.type === "ImportSpecifier") {
-					const hook = getImportedName(specifier);
-					if (specifier.importKind === "type" || !hooks.has(hook)) continue;
-					for (const identifier of getReferences(specifier)) if (isCallee(identifier)) report(identifier.parent, hook);
-					continue;
-				}
-				for (const identifier of getReferences(specifier)) {
-					const member = identifier.parent;
-					if (member.type !== "MemberExpression" || member.object !== identifier) continue;
-					const hook = getPropertyName(member);
-					if (hook !== void 0 && hooks.has(hook) && isCallee(member)) report(member.parent, hook);
-				}
-			}
+			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: {

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 };