@rdjperron/lint 0.2.0 → 0.5.0

package/dist/config.mjs

@@ -1,218 +1,2 @@
-//#region src/config.ts
-/**
-* The plugin entry. The alias is `rdj`, which is also the prefix in every
-* diagnostic and every disable comment, so a consumer that renames it renames
-* its own rule keys too.
-*/
-const plugin = {
-	name: "rdj",
-	specifier: "@rdjperron/lint"
-};
-/** Every rule the plugin registers, prefixed. `fixtures()` and the verify bin read this list. */
-const RULE_IDS = [
-	"rdj/no-array-filter-map",
-	"rdj/no-chained-type-assertions",
-	"rdj/no-conditional-empty-object-spread",
-	"rdj/no-hardcoded-jsx-text",
-	"rdj/no-known-value-widening",
-	"rdj/no-module-mocking",
-	"rdj/no-object-parameters",
-	"rdj/no-reduce-accumulator-copy",
-	"rdj/no-reflect-apply",
-	"rdj/no-reflect-get",
-	"rdj/no-runtime-typeof",
-	"rdj/no-shape-in-symbol-names",
-	"rdj/no-unknown-parameters",
-	"rdj/no-unknown-returns",
-	"rdj/no-unknown-type-aliases",
-	"rdj/no-unsafe-dictionary-type",
-	"rdj/no-use-effect",
-	"rdj/no-widen-then-assert",
-	"rdj/require-safety-comment-for-type-assertion",
-	"rdj/static-public-env"
-];
-/**
-* The base config, for `lint: { extends: [recommended] }`.
-*
-* Measured through `extends` on vite-plus 0.3.1 / oxlint 1.81.0 (2026-09-17):
-* `jsPlugins`, `rules`, `overrides`, `plugins`, `categories` and `options` are
-* inherited by the consumer's config, and the consumer's own entries win.
-* `env`, `settings` and `ignorePatterns` are not inherited, which is why this
-* object carries none of them and the consumer keeps writing its own.
-*/
-const recommended = {
-	jsPlugins: [plugin],
-	rules: {
-		"rdj/no-array-filter-map": "error",
-		"rdj/no-chained-type-assertions": "error",
-		"rdj/no-conditional-empty-object-spread": "error",
-		"rdj/no-known-value-widening": "error",
-		"rdj/no-module-mocking": "error",
-		"rdj/no-object-parameters": "error",
-		"rdj/no-reduce-accumulator-copy": "error",
-		"rdj/no-reflect-apply": "error",
-		"rdj/no-reflect-get": "error",
-		"rdj/no-runtime-typeof": ["error", { allowInTypeGuards: true }],
-		"rdj/no-shape-in-symbol-names": "error",
-		"rdj/no-unknown-parameters": "error",
-		"rdj/no-unknown-returns": "error",
-		"rdj/no-unknown-type-aliases": "error",
-		"rdj/no-unsafe-dictionary-type": "error",
-		"rdj/no-widen-then-assert": "error",
-		"rdj/require-safety-comment-for-type-assertion": "error",
-		"rdj/no-use-effect": "error",
-		"typescript/no-floating-promises": "error",
-		"typescript/no-misused-promises": "error",
-		"typescript/await-thenable": "error",
-		"typescript/no-unnecessary-type-assertion": "error",
-		"typescript/no-misused-spread": "error",
-		"typescript/require-array-sort-compare": "error",
-		"typescript/no-explicit-any": "warn",
-		"prefer-const": ["error", { destructuring: "all" }],
-		"no-unused-vars": ["error", {
-			argsIgnorePattern: "^_",
-			varsIgnorePattern: "^_"
-		}],
-		"no-underscore-dangle": "off",
-		eqeqeq: [
-			"error",
-			"always",
-			{ null: "ignore" }
-		],
-		"typescript/no-unsafe-type-assertion": "off",
-		"no-await-in-loop": "off",
-		"unicorn/consistent-function-scoping": "off",
-		"promise/always-return": "off"
-	}
-};
-/**
-* The React file set: browser globals, the hooks rules, and the compiler's own
-* judgement. A consumer appends its own entries after these, because an override
-* that changes a `react/*` rule must repeat `plugins: ["react"]` or oxlint
-* silently drops the entry.
-*/
-function react(files, options = {}) {
-	const { useEffectAllowedIn } = options;
-	const rules = {
-		"react/rules-of-hooks": "error",
-		"react/exhaustive-deps": "warn",
-		"react/react-in-jsx-scope": "off",
-		"react/immutability": "error",
-		"react/refs": "error",
-		"react/purity": "error",
-		"react/only-export-components": "error"
-	};
-	const overrides = [{
-		files,
-		plugins: ["react"],
-		env: { browser: true },
-		rules
-	}];
-	if (useEffectAllowedIn !== void 0) {
-		rules["rdj/no-use-effect"] = ["error", { hint: `The one sanctioned wrapper is ${useEffectAllowedIn}.` }];
-		overrides.push({
-			files: [useEffectAllowedIn],
-			rules: { "rdj/no-use-effect": "off" }
-		});
-	}
-	return overrides;
-}
-/** Files whose JSX text belongs in a catalogue rather than in the source. */
-function i18n(files, options = {}) {
-	const { pattern } = options;
-	return [{
-		files,
-		rules: { "rdj/no-hardcoded-jsx-text": pattern === void 0 ? "error" : ["error", { pattern }] }
-	}];
-}
-/** Files Expo's bundler inlines `process.env` into, where only `process.env.NAME` survives. */
-function expo(files) {
-	return [{
-		files,
-		rules: { "rdj/static-public-env": "error" }
-	}];
-}
-/** Test files: four rules whose premise a test does not hold. */
-function tests(files) {
-	return [{
-		files,
-		rules: {
-			"typescript/no-explicit-any": "off",
-			"typescript/no-non-null-assertion": "off",
-			"rdj/no-runtime-typeof": "off",
-			"rdj/require-safety-comment-for-type-assertion": "off"
-		}
-	}];
-}
-/** Every rule of the plugin at `error`, so none of them can be missing from the list. */
-const FIXTURE_RULES = {
-	"rdj/no-array-filter-map": "error",
-	"rdj/no-chained-type-assertions": "error",
-	"rdj/no-conditional-empty-object-spread": "error",
-	"rdj/no-hardcoded-jsx-text": "error",
-	"rdj/no-known-value-widening": "error",
-	"rdj/no-module-mocking": "error",
-	"rdj/no-object-parameters": "error",
-	"rdj/no-reduce-accumulator-copy": "error",
-	"rdj/no-reflect-apply": "error",
-	"rdj/no-reflect-get": "error",
-	"rdj/no-runtime-typeof": "error",
-	"rdj/no-shape-in-symbol-names": "error",
-	"rdj/no-unknown-parameters": "error",
-	"rdj/no-unknown-returns": "error",
-	"rdj/no-unknown-type-aliases": "error",
-	"rdj/no-unsafe-dictionary-type": "error",
-	"rdj/no-use-effect": "error",
-	"rdj/no-widen-then-assert": "error",
-	"rdj/require-safety-comment-for-type-assertion": "error",
-	"rdj/static-public-env": "error"
-};
-/**
-* The view the verify command lints the shipped fixtures through. Without this
-* override every rule the consumer leaves off reports nothing there, and "no
-* findings" is exactly what a dead rule looks like.
-*/
-function fixtures(view = "scripts/.lint-fixtures/**") {
-	return [{
-		files: [view],
-		rules: { ...FIXTURE_RULES }
-	}];
-}
-/** The formatting both consumers settled on. Spread it and add what is yours. */
-const fmt = {
-	printWidth: 100,
-	singleQuote: false,
-	semi: true,
-	tabWidth: 2,
-	useTabs: false
-};
-/**
-* Paths no linter and no formatter should walk: build output, dependencies, the
-* directories AI coding agents scribble in, and the Vitest JSON report. Spread
-* it into `ignorePatterns` and append the repo's own.
-*/
-const ignore = [
-	"node_modules/**",
-	"**/node_modules/**",
-	"dist/**",
-	"**/dist/**",
-	...[
-		".agents",
-		".claude",
-		".codex",
-		".continue",
-		".cursor",
-		".gemini",
-		".opencode",
-		".pi",
-		".roo",
-		".windsurf"
-	].flatMap((dir) => [`${dir}/**`, `**/${dir}/**`]),
-	"**/test-results.json"
-];
-/** The pre-commit entry: `vp check --fix` is defined for JS and TS sources, nothing else. */
-const staged = { "*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}": "vp check --fix" };
-//#endregion
-export { RULE_IDS, expo, fixtures, fmt, i18n, ignore, plugin, react, recommended, staged, tests };
-
-//# sourceMappingURL=config.mjs.map
+import { a as i18n, c as react, d as staged, f as tests, i as fmt, l as recommended, n as decoders, o as ignore, r as expo, s as plugin, t as RULE_IDS, u as restrictedImports } from "./config-CD2iCM6L.mjs";
+export { RULE_IDS, decoders, expo, fmt, i18n, ignore, plugin, react, recommended, restrictedImports, staged, tests };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 //#region src/index.d.ts
-declare const rdjPlugin: import("@oxlint/plugins").Plugin;
+declare const rdjperronPlugin: import("@oxlint/plugins").Plugin;
 //#endregion
-export { rdjPlugin as default };
+export { rdjperronPlugin as default };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -454,7 +454,8 @@ function unsafeDirectValue(type, environment, substitutions, resolvingAliases) {
 	if (unwrapped.type === "TSIntersectionType") {
 		const unsafeMembers = unwrapped.types.map((member) => unsafeDirectValue(member, environment, substitutions, resolvingAliases));
 		if (unsafeMembers.includes("any")) return "any";
-		return unsafeMembers.length > 0 && unsafeMembers.every((member) => member !== null) ? unsafeMembers[0] : null;
+		const first = unsafeMembers[0];
+		return first !== void 0 && unsafeMembers.every((member) => member !== null) ? first : null;
 	}
 	if (unwrapped.type !== "TSTypeReference") return null;
 	const name = typeReferenceName$2(unwrapped);
@@ -1103,10 +1104,16 @@ const noRuntimeTypeofRule = defineRule({
 	meta: {
 		type: "problem",
 		docs: { description: "Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary." },
-		messages: { runtimeTypeof: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value." },
+		messages: {
+			runtimeTypeof: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value.",
+			runtimeTypeofWithHint: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value. {{hint}}"
+		},
 		schema: [{
 			type: "object",
-			properties: { allowInTypeGuards: { type: "boolean" } },
+			properties: {
+				allowInTypeGuards: { type: "boolean" },
+				hint: { type: "string" }
+			},
 			additionalProperties: false
 		}],
 		defaultOptions: [{ allowInTypeGuards: false }]
@@ -1114,19 +1121,29 @@ const noRuntimeTypeofRule = defineRule({
 	createOnce(context) {
 		return { UnaryExpression(node) {
 			const option = context.options?.[0];
-			const allowInTypeGuards = typeof option === "object" && option !== null && !Array.isArray(option) && option.allowInTypeGuards === true;
-			if (node.operator === "typeof" && !isExistenceProbe(node) && (!allowInTypeGuards || !isInsideTypeGuard(node))) context.report({
-				node,
-				messageId: "runtimeTypeof"
-			});
+			const configured = typeof option === "object" && option !== null && !Array.isArray(option);
+			const allowInTypeGuards = configured && option.allowInTypeGuards === true;
+			const hint = configured && typeof option.hint === "string" ? option.hint : void 0;
+			if (node.operator === "typeof" && !isExistenceProbe(node) && (!allowInTypeGuards || !isInsideTypeGuard(node))) {
+				if (hint === void 0) context.report({
+					node,
+					messageId: "runtimeTypeof"
+				});
+				else context.report({
+					node,
+					messageId: "runtimeTypeofWithHint",
+					data: { hint }
+				});
+			}
 		} };
 	}
 });
 //#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 +1151,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) {
@@ -1168,21 +1185,39 @@ const noUnknownParametersRule = defineRule({
 	meta: {
 		type: "problem",
 		docs: { description: "Disallow explicitly unknown function parameters except `cause` and type-predicate subjects; decode unknown input at its I/O boundary instead." },
-		messages: { unknownParameter: "Parameter `{{parameter}}` leaves input unparsed. Accept a named domain type; run the expected schema or parser at the I/O boundary before calling this function." }
+		messages: {
+			unknownParameter: "Parameter `{{parameter}}` leaves input unparsed. Accept a named domain type; run the expected schema or parser at the I/O boundary before calling this function.",
+			unknownParameterWithHint: "Parameter `{{parameter}}` leaves input unparsed. Accept a named domain type; run the expected schema or parser at the I/O boundary before calling this function. {{hint}}"
+		},
+		schema: [{
+			type: "object",
+			properties: { hint: { type: "string" } },
+			additionalProperties: false
+		}]
 	},
 	createOnce(context) {
 		const checkParameters = (node) => {
+			const option = context.options?.[0];
+			const hint = typeof option === "object" && option !== null && !Array.isArray(option) && typeof option.hint === "string" ? option.hint : void 0;
 			for (const parameter of node.params) {
 				const annotation = functionParameterTypeAnnotation(parameter);
 				if (annotation === null || annotation === void 0) continue;
 				if (!containsUnknownType(annotation.typeAnnotation)) continue;
 				const name = functionParameterBindingName(parameter, context.sourceCode);
 				if (name === "cause" || isTypePredicateSubject(node, name)) continue;
-				context.report({
+				if (hint === void 0) context.report({
 					node: annotation.typeAnnotation,
 					messageId: "unknownParameter",
 					data: { parameter: name }
 				});
+				else context.report({
+					node: annotation.typeAnnotation,
+					messageId: "unknownParameterWithHint",
+					data: {
+						parameter: name,
+						hint
+					}
+				});
 			}
 		};
 		return {
@@ -1720,12 +1755,18 @@ const noHardcodedJsxTextRule = defineRule({
 //#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(...)`). */
+/** 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" || callee.computed) return null;
-	const { property } = callee;
-	return property.type === "Identifier" && effectHooks.has(property.name) ? property.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;
@@ -1781,17 +1822,43 @@ const noUseEffectRule = defineRule({
 });
 //#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.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "process" && node.property.type === "Identifier" && node.property.name === "env";
+	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 static `process.env.NAME` reads; Expo replaces each one textually at bundle time and everything else is undefined on the device." },
+		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 computed key is undefined on the device. Read the variable as `process.env.NAME` with the name spelled out.",
+			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`."
 		}
 	},
@@ -1800,13 +1867,14 @@ const staticPublicEnvRule = defineRule({
 			if (!isProcessEnv(node)) return;
 			const { parent } = node;
 			if (parent.type === "MemberExpression" && parent.object === node) {
-				if (parent.computed) context.report({
+				const problem = readProblem(node, parent);
+				if (problem !== null) context.report({
 					node: parent,
-					messageId: "computed"
+					messageId: problem
 				});
 				return;
 			}
-			if (parent.type === "VariableDeclarator" && parent.id.type === "ObjectPattern") {
+			if (isDestructured(node)) {
 				context.report({
 					node: parent,
 					messageId: "destructured"
@@ -1822,8 +1890,8 @@ const staticPublicEnvRule = defineRule({
 });
 //#endregion
 //#region src/index.ts
-const rdjPlugin = eslintCompatPlugin({
-	meta: { name: "rdj" },
+const rdjperronPlugin = eslintCompatPlugin({
+	meta: { name: "rdjperron" },
 	rules: {
 		"no-array-filter-map": noArrayFilterMapRule,
 		"no-chained-type-assertions": noChainedTypeAssertionsRule,
@@ -1848,6 +1916,6 @@ const rdjPlugin = eslintCompatPlugin({
 	}
 });
 //#endregion
-export { rdjPlugin as default };
+export { rdjperronPlugin as default };
 
 //# sourceMappingURL=index.mjs.map