adamantite 0.41.0 → 0.43.0

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

@@ -0,0 +1,17 @@
+import { Plugin, Rule } from "@oxlint/plugins";
+//#region presets/lint/plugin/index.d.ts
+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;
+  };
+}
+/**
+ * Adamantite's first-party Oxlint plugin. Presets load it by file URL, so target projects install
+ * nothing extra.
+ */
+declare const plugin: AdamantitePlugin;
+//#endregion
+export { plugin as default };

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

@@ -0,0 +1,20 @@
+import rule from "./rules/no-overzealous-destructuring.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
+* nothing extra.
+*/
+const plugin = {
+	meta: { name: "adamantite" },
+	rules: {
+		"no-overzealous-destructuring": rule,
+		"no-query-data-in-state": rule$1,
+		"no-react-state-hooks": rule$2,
+		"query-from-loader": rule$3
+	}
+};
+//#endregion
+export { plugin as default };

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

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

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

@@ -0,0 +1,33 @@
+//#region presets/lint/plugin/options.ts
+function isOptionObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => isString(entry));
+}
+function isPositiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function readOption(options, key) {
+	const [first] = options;
+	return isOptionObject(first) ? first[key] : void 0;
+}
+/**
+* Read a string array from the rule's first option object.
+*/
+function readStringArrayOption(options, key) {
+	const value = readOption(options, key);
+	return isStringArray(value) ? value : void 0;
+}
+/**
+* Read a positive integer from the rule's first option object.
+*/
+function readPositiveIntegerOption(options, key) {
+	const value = readOption(options, key);
+	return isPositiveInteger(value) ? value : void 0;
+}
+//#endregion
+export { readPositiveIntegerOption, readStringArrayOption };

package/dist/presets/lint/plugin/rules/no-overzealous-destructuring.d.ts

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

package/dist/presets/lint/plugin/rules/no-overzealous-destructuring.js

@@ -0,0 +1,92 @@
+import { readPositiveIntegerOption } from "../options.js";
+//#region presets/lint/plugin/rules/no-overzealous-destructuring.ts
+/**
+* `const { data: { user } } = query` nests two patterns, which stays allowed.
+*/
+const DEFAULT_MAX_DEPTH = 2;
+/**
+* Five properties cover typical component props. A rest element does not count.
+*/
+const DEFAULT_MAX_PROPERTIES = 5;
+function isPattern(node) {
+	return node.type === "ObjectPattern" || node.type === "ArrayPattern";
+}
+/**
+* The pattern that directly contains `pattern`, through a property, a default value, or a rest
+* element. A root pattern, such as a declaration target or a parameter, has none.
+*/
+function getParentPattern(pattern) {
+	let node = pattern.parent;
+	while (node.type === "AssignmentPattern" || node.type === "RestElement") node = node.parent;
+	if (node.type === "Property" && node.parent.type === "ObjectPattern") return node.parent;
+	return isPattern(node) ? node : void 0;
+}
+function getDepth(pattern) {
+	let depth = 1;
+	let parent = getParentPattern(pattern);
+	while (parent !== void 0) {
+		depth += 1;
+		parent = getParentPattern(parent);
+	}
+	return depth;
+}
+const rule = {
+	create(context) {
+		const maxDepth = readPositiveIntegerOption(context.options, "maxDepth") ?? DEFAULT_MAX_DEPTH;
+		const maxProperties = readPositiveIntegerOption(context.options, "maxProperties") ?? DEFAULT_MAX_PROPERTIES;
+		function checkDepth(node) {
+			const depth = getDepth(node);
+			if (depth === maxDepth + 1) context.report({
+				data: {
+					depth: String(depth),
+					maxDepth: String(maxDepth)
+				},
+				messageId: "tooDeep",
+				node
+			});
+		}
+		return {
+			ArrayPattern: checkDepth,
+			ObjectPattern(node) {
+				checkDepth(node);
+				const count = node.properties.filter((property) => property.type === "Property").length;
+				if (count > maxProperties) context.report({
+					data: {
+						count: String(count),
+						maxProperties: String(maxProperties)
+					},
+					messageId: "tooManyProperties",
+					node
+				});
+			}
+		};
+	},
+	meta: {
+		defaultOptions: [{
+			maxDepth: DEFAULT_MAX_DEPTH,
+			maxProperties: DEFAULT_MAX_PROPERTIES
+		}],
+		docs: { description: "Disallow destructuring patterns that nest too deep or take too many properties from one object." },
+		messages: {
+			tooDeep: "This destructuring pattern is nested {{depth}} levels deep. The limit is {{maxDepth}}. Keep the outer object and read its members, or split the pattern into separate declarations.",
+			tooManyProperties: "This destructuring pattern takes {{count}} properties from one object. The limit is {{maxProperties}}. Keep the object and read its members where you use them, or split the pattern."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				maxDepth: {
+					minimum: 1,
+					type: "integer"
+				},
+				maxProperties: {
+					minimum: 1,
+					type: "integer"
+				}
+			},
+			type: "object"
+		}],
+		type: "suggestion"
+	}
+};
+//#endregion
+export { rule as default };

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