@rdjperron/lint 0.1.0 → 0.2.0

package/dist/{anti-slop.mjs → index.mjs}

@@ -97,89 +97,6 @@ const noArrayFilterMapRule = defineRule({
 	}
 });
 //#endregion
-//#region src/anti-slop/rules/no-reduce-accumulator-copy.ts
-function enclosingReducer(node) {
-	let parent = node.parent;
-	while (parent !== null) {
-		if (parent.type === "FunctionDeclaration") return null;
-		if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
-			const callback = parent;
-			let owner = callback.parent;
-			while (owner !== null && unwrapArrayExpression(owner) === callback) owner = owner.parent;
-			if (owner?.type !== "CallExpression") return null;
-			const method = arrayMethodTarget(owner.callee);
-			const firstArgument = owner.arguments[0];
-			if (method === null || method.name !== "reduce" && method.name !== "reduceRight" || owner.arguments.length > 2 || firstArgument === void 0 || unwrapArrayExpression(firstArgument) !== callback) return null;
-			const firstParameter = callback.params[0];
-			const accumulator = firstParameter?.type === "AssignmentPattern" ? firstParameter.left : firstParameter;
-			if (accumulator?.type !== "Identifier") return null;
-			return {
-				callback,
-				accumulator,
-				initialValue: owner.arguments[1]
-			};
-		}
-		parent = parent.parent;
-	}
-	return null;
-}
-function referencesAccumulator(sourceCode, node, accumulator, visited = /* @__PURE__ */ new Set()) {
-	const variable = resolveArrayBinding(sourceCode, node);
-	if (variable === null || visited.has(variable)) return false;
-	if (variable === accumulator) return true;
-	visited.add(variable);
-	if (variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
-	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && definition.node.init !== null && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") return referencesAccumulator(sourceCode, definition.node.init, accumulator, visited);
-	return false;
-}
-function isGlobalCopyOwner(sourceCode, node, name) {
-	node = unwrapArrayExpression(node);
-	if (node.type !== "Identifier" || node.name !== name) return false;
-	const variable = resolveArrayBinding(sourceCode, node);
-	return variable === null || variable.defs.length === 0;
-}
-/** Reject non-spread copies of reducer accumulators; pair with oxc/no-accumulating-spread. */
-const noReduceAccumulatorCopyRule = defineRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallow copying growing reducer accumulators with Object.assign, Array.from, or array copy methods." },
-		messages: { accumulatorCopy: "Do not copy the reducer accumulator on every iteration; growing copies can cause quadratic work. Mutate a fresh, locally owned accumulator and return it, or use an iterator pipeline/flatMap." }
-	},
-	createOnce(context) {
-		return { CallExpression(node) {
-			const method = arrayMethodTarget(node.callee);
-			if (method === null) return;
-			const reducer = enclosingReducer(node);
-			if (reducer === null) return;
-			const accumulator = context.sourceCode.getDeclaredVariables(reducer.callback).find((variable) => variable.identifiers.some((identifier) => identifier.start === reducer.accumulator.start));
-			if (accumulator === void 0) return;
-			const isAccumulator = (expression) => referencesAccumulator(context.sourceCode, expression, accumulator);
-			let copiesAccumulator = false;
-			if (method.name === "assign" && isGlobalCopyOwner(context.sourceCode, method.object, "Object")) {
-				const target = node.arguments[0];
-				copiesAccumulator = target !== void 0 && unwrapArrayExpression(target).type === "ObjectExpression" && node.arguments.slice(1).some(isAccumulator);
-			} else if (method.name === "from" && isGlobalCopyOwner(context.sourceCode, method.object, "Array")) {
-				const source = node.arguments[0];
-				copiesAccumulator = source !== void 0 && isAccumulator(source);
-			} else if ([
-				"concat",
-				"slice",
-				"toSpliced",
-				"toSorted",
-				"toReversed",
-				"with"
-			].includes(method.name)) {
-				const initialValue = reducer.initialValue;
-				copiesAccumulator = initialValue !== void 0 && isKnownArrayExpression(context.sourceCode, initialValue) && isAccumulator(method.object);
-			}
-			if (copiesAccumulator) context.report({
-				node,
-				messageId: "accumulatorCopy"
-			});
-		} };
-	}
-});
-//#endregion
 //#region src/anti-slop/rules/no-chained-type-assertions.ts
 function isTypeAssertionExpression(node) {
 	return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
@@ -934,7 +851,7 @@ const moduleMockMethods = /* @__PURE__ */ new Set([
 	"mock",
 	"unstable_mockModule"
 ]);
-function importedName(node) {
+function importedName$1(node) {
 	if (node.type !== "ImportSpecifier") return null;
 	return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
 }
@@ -946,7 +863,7 @@ function isTestFrameworkObject(sourceCode, expression) {
 	return variable.defs.some((definition) => {
 		if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") return false;
 		const source = definition.parent.source.value;
-		const name = importedName(definition.node);
+		const name = importedName$1(definition.node);
 		return source === "vitest" && name === "vi" || source === "@jest/globals" && name === "jest";
 	});
 }
@@ -1020,6 +937,89 @@ const noObjectParametersRule = defineRule({
 	}
 });
 //#endregion
+//#region src/anti-slop/rules/no-reduce-accumulator-copy.ts
+function enclosingReducer(node) {
+	let parent = node.parent;
+	while (parent !== null) {
+		if (parent.type === "FunctionDeclaration") return null;
+		if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
+			const callback = parent;
+			let owner = callback.parent;
+			while (owner !== null && unwrapArrayExpression(owner) === callback) owner = owner.parent;
+			if (owner?.type !== "CallExpression") return null;
+			const method = arrayMethodTarget(owner.callee);
+			const firstArgument = owner.arguments[0];
+			if (method === null || method.name !== "reduce" && method.name !== "reduceRight" || owner.arguments.length > 2 || firstArgument === void 0 || unwrapArrayExpression(firstArgument) !== callback) return null;
+			const firstParameter = callback.params[0];
+			const accumulator = firstParameter?.type === "AssignmentPattern" ? firstParameter.left : firstParameter;
+			if (accumulator?.type !== "Identifier") return null;
+			return {
+				callback,
+				accumulator,
+				initialValue: owner.arguments[1]
+			};
+		}
+		parent = parent.parent;
+	}
+	return null;
+}
+function referencesAccumulator(sourceCode, node, accumulator, visited = /* @__PURE__ */ new Set()) {
+	const variable = resolveArrayBinding(sourceCode, node);
+	if (variable === null || visited.has(variable)) return false;
+	if (variable === accumulator) return true;
+	visited.add(variable);
+	if (variable.references.some((reference) => reference.isWrite() && !reference.init)) return false;
+	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && definition.node.init !== null && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") return referencesAccumulator(sourceCode, definition.node.init, accumulator, visited);
+	return false;
+}
+function isGlobalCopyOwner(sourceCode, node, name) {
+	node = unwrapArrayExpression(node);
+	if (node.type !== "Identifier" || node.name !== name) return false;
+	const variable = resolveArrayBinding(sourceCode, node);
+	return variable === null || variable.defs.length === 0;
+}
+/** Reject non-spread copies of reducer accumulators; pair with oxc/no-accumulating-spread. */
+const noReduceAccumulatorCopyRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow copying growing reducer accumulators with Object.assign, Array.from, or array copy methods." },
+		messages: { accumulatorCopy: "Do not copy the reducer accumulator on every iteration; growing copies can cause quadratic work. Mutate a fresh, locally owned accumulator and return it, or use an iterator pipeline/flatMap." }
+	},
+	createOnce(context) {
+		return { CallExpression(node) {
+			const method = arrayMethodTarget(node.callee);
+			if (method === null) return;
+			const reducer = enclosingReducer(node);
+			if (reducer === null) return;
+			const accumulator = context.sourceCode.getDeclaredVariables(reducer.callback).find((variable) => variable.identifiers.some((identifier) => identifier.start === reducer.accumulator.start));
+			if (accumulator === void 0) return;
+			const isAccumulator = (expression) => referencesAccumulator(context.sourceCode, expression, accumulator);
+			let copiesAccumulator = false;
+			if (method.name === "assign" && isGlobalCopyOwner(context.sourceCode, method.object, "Object")) {
+				const target = node.arguments[0];
+				copiesAccumulator = target !== void 0 && unwrapArrayExpression(target).type === "ObjectExpression" && node.arguments.slice(1).some(isAccumulator);
+			} else if (method.name === "from" && isGlobalCopyOwner(context.sourceCode, method.object, "Array")) {
+				const source = node.arguments[0];
+				copiesAccumulator = source !== void 0 && isAccumulator(source);
+			} else if ([
+				"concat",
+				"slice",
+				"toSpliced",
+				"toSorted",
+				"toReversed",
+				"with"
+			].includes(method.name)) {
+				const initialValue = reducer.initialValue;
+				copiesAccumulator = initialValue !== void 0 && isKnownArrayExpression(context.sourceCode, initialValue) && isAccumulator(method.object);
+			}
+			if (copiesAccumulator) context.report({
+				node,
+				messageId: "accumulatorCopy"
+			});
+		} };
+	}
+});
+//#endregion
 //#region src/anti-slop/shared/reflect-method.ts
 function isGlobalReflect(sourceCode, expression) {
 	if (expression.type !== "Identifier" || expression.name !== "Reflect") return false;
@@ -1664,31 +1664,190 @@ const requireSafetyCommentForTypeAssertionRule = defineRule({
 	}
 });
 //#endregion
-//#region src/anti-slop/index.ts
-/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
-const antiSlopPlugin = eslintCompatPlugin({
-	meta: { name: "anti-slop" },
+//#region src/shared/rule-options.ts
+/**
+* Rule options arrive as parsed JSON from the linter config, so this is the one
+* place their shape is checked. Returns the first option when it is an object.
+*/
+function firstOptionObject(options) {
+	const first = options[0];
+	return typeof first === "object" && first !== null && !Array.isArray(first) ? first : {};
+}
+/** A string-valued key of the first option object, or undefined when absent or not a string. */
+function stringOption(options, key) {
+	const value = firstOptionObject(options)[key];
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+//#region src/rules/no-hardcoded-jsx-text.ts
+const defaultWordPattern = String.raw`\p{L}{3,}`;
+/** A string literal that is the whole expression of `{...}` placed among an element's children. */
+function isChildStringLiteral(node) {
+	const { expression, parent } = node;
+	if (expression.type !== "Literal" || typeof expression.value !== "string") return false;
+	return parent.type === "JSXElement" || parent.type === "JSXFragment";
+}
+/** Reject words written straight into JSX instead of coming from the translation dictionary. */
+const noHardcodedJsxTextRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow literal words in JSX children; every string on screen comes from the translation dictionary." },
+		messages: { hardcodedText: "Do not write words straight into JSX. Every string on screen comes from the translation dictionary." },
+		schema: [{
+			type: "object",
+			properties: { pattern: { type: "string" } },
+			additionalProperties: false
+		}]
+	},
+	create(context) {
+		const word = new RegExp(stringOption(context.options, "pattern") ?? defaultWordPattern, "u");
+		return {
+			JSXText(node) {
+				if (word.test(node.value)) context.report({
+					node,
+					messageId: "hardcodedText"
+				});
+			},
+			JSXExpressionContainer(node) {
+				if (isChildStringLiteral(node) && word.test(node.expression.value)) context.report({
+					node: node.expression,
+					messageId: "hardcodedText"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/no-use-effect.ts
+const effectHooks = /* @__PURE__ */ new Set(["useEffect", "useLayoutEffect"]);
+/** The effect hook a call reaches, whether called bare (`useEffect(...)`) or through a member (`React.useEffect(...)`). */
+function calledEffectHook(callee) {
+	if (callee.type === "Identifier") return effectHooks.has(callee.name) ? callee.name : null;
+	if (callee.type !== "MemberExpression" || callee.computed) return null;
+	const { property } = callee;
+	return property.type === "Identifier" && effectHooks.has(property.name) ? property.name : null;
+}
+function importedName(specifier) {
+	return specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+}
+function isTypeOnly(specifier) {
+	const declaration = specifier.parent;
+	return specifier.importKind === "type" || declaration.type === "ImportDeclaration" && declaration.importKind === "type";
+}
+/** Reject `useEffect` and `useLayoutEffect`, called or imported. */
+const noUseEffectRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow useEffect and useLayoutEffect; derive during render, act in the event handler, or subscribe through a reactive query." },
+		messages: {
+			noEffect: "Do not call {{name}}. Derive the value during render, do the work in the event handler, or subscribe through a reactive query.",
+			noEffectWithHint: "Do not call {{name}}. Derive the value during render, do the work in the event handler, or subscribe through a reactive query. {{hint}}"
+		},
+		schema: [{
+			type: "object",
+			properties: { hint: { type: "string" } },
+			additionalProperties: false
+		}]
+	},
+	create(context) {
+		const hint = stringOption(context.options, "hint");
+		const report = (node, name) => {
+			if (hint === void 0) context.report({
+				node,
+				messageId: "noEffect",
+				data: { name }
+			});
+			else context.report({
+				node,
+				messageId: "noEffectWithHint",
+				data: {
+					name,
+					hint
+				}
+			});
+		};
+		return {
+			CallExpression(node) {
+				const name = calledEffectHook(node.callee);
+				if (name !== null) report(node, name);
+			},
+			ImportSpecifier(node) {
+				if (isTypeOnly(node)) return;
+				const name = importedName(node);
+				if (effectHooks.has(name)) report(node, name);
+			}
+		};
+	}
+});
+//#endregion
+//#region src/rules/static-public-env.ts
+function isProcessEnv(node) {
+	return node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "process" && node.property.type === "Identifier" && node.property.name === "env";
+}
+/** Reject every use of `process.env` that Expo's textual inlining cannot see. */
+const staticPublicEnvRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Allow only static `process.env.NAME` reads; Expo replaces each one textually at bundle time and everything else is undefined on the device." },
+		messages: {
+			destructured: "Expo replaces each `process.env.EXPO_PUBLIC_*` read textually at bundle time, so there is no `process.env` object to destructure on the device. Read each variable as `process.env.NAME`.",
+			computed: "Expo replaces each `process.env.EXPO_PUBLIC_*` read textually at bundle time, so a computed key is undefined on the device. Read the variable as `process.env.NAME` with the name spelled out.",
+			bareValue: "Expo replaces each `process.env.EXPO_PUBLIC_*` read textually at bundle time, so `process.env` passed around as a value is empty on the device. Read each variable as `process.env.NAME`."
+		}
+	},
+	create(context) {
+		return { MemberExpression(node) {
+			if (!isProcessEnv(node)) return;
+			const { parent } = node;
+			if (parent.type === "MemberExpression" && parent.object === node) {
+				if (parent.computed) context.report({
+					node: parent,
+					messageId: "computed"
+				});
+				return;
+			}
+			if (parent.type === "VariableDeclarator" && parent.id.type === "ObjectPattern") {
+				context.report({
+					node: parent,
+					messageId: "destructured"
+				});
+				return;
+			}
+			context.report({
+				node,
+				messageId: "bareValue"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/index.ts
+const rdjPlugin = eslintCompatPlugin({
+	meta: { name: "rdj" },
 	rules: {
 		"no-array-filter-map": noArrayFilterMapRule,
-		"no-reduce-accumulator-copy": noReduceAccumulatorCopyRule,
 		"no-chained-type-assertions": noChainedTypeAssertionsRule,
 		"no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
+		"no-hardcoded-jsx-text": noHardcodedJsxTextRule,
 		"no-known-value-widening": noKnownValueWideningRule,
 		"no-module-mocking": noModuleMockingRule,
 		"no-object-parameters": noObjectParametersRule,
+		"no-reduce-accumulator-copy": noReduceAccumulatorCopyRule,
 		"no-reflect-apply": noReflectApplyRule,
 		"no-reflect-get": noReflectGetRule,
 		"no-runtime-typeof": noRuntimeTypeofRule,
-		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
 		"no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
 		"no-unknown-parameters": noUnknownParametersRule,
 		"no-unknown-returns": noUnknownReturnsRule,
 		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
+		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+		"no-use-effect": noUseEffectRule,
 		"no-widen-then-assert": noWidenThenAssertRule,
-		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule
+		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
+		"static-public-env": staticPublicEnvRule
 	}
 });
 //#endregion
-export { antiSlopPlugin as default };
+export { rdjPlugin as default };
 
-//# sourceMappingURL=anti-slop.mjs.map
+//# sourceMappingURL=index.mjs.map