@rdjperron/lint 0.1.0 → 0.3.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;
@@ -1125,8 +1125,9 @@ const noRuntimeTypeofRule = defineRule({
 //#endregion
 //#region src/anti-slop/rules/no-shape-in-symbol-names.ts
 const FORBIDDEN_SYMBOL_NAME = "shape";
+const IDENTIFIER_WORD = /[A-Z]+(?![a-z])|[A-Z]?[a-z]+|\d+/gu;
 function containsForbiddenSymbolName(name) {
-	return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
+	return (name.match(IDENTIFIER_WORD) ?? []).some((word) => word.toLowerCase().startsWith(FORBIDDEN_SYMBOL_NAME));
 }
 /** Return whether an identifier names a statically accessed member owned by another value. */
 function isBorrowedMemberName(node) {
@@ -1134,11 +1135,11 @@ function isBorrowedMemberName(node) {
 	if (parent === null || parent.type !== "MemberExpression") return false;
 	return parent.property === node && parent.computed === false;
 }
-/** Ban the case-insensitive substring "shape" in every JavaScript and TypeScript symbol name. */
+/** Ban the word "shape" in every JavaScript and TypeScript symbol name. */
 const noForbiddenTermInSymbolNamesRule = defineRule({
 	meta: {
 		type: "problem",
-		docs: { description: "Disallow the case-insensitive substring \"shape\" in JavaScript, TypeScript, private, and JSX symbol names." },
+		docs: { description: "Disallow the word \"shape\" in JavaScript, TypeScript, private, and JSX symbol names." },
 		messages: { forbiddenSymbolName: "Rename symbol \"{{name}}\" for its domain role; \"shape\" describes structure rather than ownership." }
 	},
 	createOnce(context) {
@@ -1664,31 +1665,223 @@ 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 name a member expression reads, written `.useEffect` or `["useEffect"]`; null when the key is not a literal name. */
+function memberPropertyName(node) {
+	const { property } = node;
+	if (!node.computed) return property.type === "Identifier" ? property.name : null;
+	return property.type === "Literal" && typeof property.value === "string" ? property.value : null;
+}
+/** The effect hook a call reaches, called bare (`useEffect(...)`) or through a member (`React.useEffect(...)`, `React["useEffect"](...)`). */
+function calledEffectHook(callee) {
+	if (callee.type === "Identifier") return effectHooks.has(callee.name) ? callee.name : null;
+	if (callee.type !== "MemberExpression") return null;
+	const name = memberPropertyName(callee);
+	return name !== null && effectHooks.has(name) ? 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
+/** The name a member expression reads, the way Babel's `toComputedKey` does: `.NAME` and `["NAME"]` only. */
+function literalKeyName(node) {
+	const { property } = node;
+	if (!node.computed) return property.type === "Identifier" ? property.name : null;
+	return property.type === "Literal" && typeof property.value === "string" ? property.value : null;
+}
+/** Whether a member expression is `process.env` or `process["env"]`, the object the inliner matches. */
+function isProcessEnv(node) {
+	return node.object.type === "Identifier" && node.object.name === "process" && literalKeyName(node) === "env";
+}
+/** Whether a pattern takes `process.env` apart, in a declaration or in an assignment. */
+function isDestructured(node) {
+	const { parent } = node;
+	let target = null;
+	if (parent.type === "VariableDeclarator" && parent.init === node) target = parent.id;
+	if (parent.type === "AssignmentExpression" && parent.right === node) target = parent.left;
+	return target !== null && (target.type === "ObjectPattern" || target.type === "ArrayPattern");
+}
+/** What is wrong with a `process.env.KEY` read, or null when Expo replaces that exact shape. */
+function readProblem(env, read) {
+	const { parent } = read;
+	if (parent.type === "AssignmentExpression" && parent.left === read) return "assigned";
+	if (env.optional || read.optional) return "optionalChain";
+	if (literalKeyName(read) !== null) return null;
+	return read.property.type === "Literal" || read.property.type === "TemplateLiteral" ? "literalKey" : "computed";
+}
+/** Reject every use of `process.env` that Expo's textual inlining cannot see. */
+const staticPublicEnvRule = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Allow only the `process.env` reads Expo replaces at bundle time; 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 key it has to evaluate is undefined on the device. Read the variable as `process.env.NAME` with the name spelled out.",
+			literalKey: "Expo reads a computed key only when it is a string literal, so a template or a number leaves the read in the bundle and it is undefined on the device. Read the variable as `process.env.NAME`.",
+			optionalChain: "Expo's inliner never sees an optional chain, so `process.env?.NAME` survives into the bundle and is undefined on the device. Read the variable as `process.env.NAME`.",
+			assigned: "Expo replaces reads, not writes: an assignment to `process.env` stays in the bundle and no inlined read will ever see it. Set the variable in the environment the bundler reads.",
+			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) {
+				const problem = readProblem(node, parent);
+				if (problem !== null) context.report({
+					node: parent,
+					messageId: problem
+				});
+				return;
+			}
+			if (isDestructured(node)) {
+				context.report({
+					node: parent,
+					messageId: "destructured"
+				});
+				return;
+			}
+			context.report({
+				node,
+				messageId: "bareValue"
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/index.ts
+const rdjperronPlugin = eslintCompatPlugin({
+	meta: { name: "rdjperron" },
 	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 { rdjperronPlugin as default };
 
-//# sourceMappingURL=anti-slop.mjs.map
+//# sourceMappingURL=index.mjs.map