@rdjperron/lint 0.3.0 → 0.6.0

package/dist/config.mjs

@@ -1,218 +1,2 @@
-//#region src/config.ts
-/**
-* The plugin entry. The alias is `rdjperron`, 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: "rdjperron",
-	specifier: "@rdjperron/lint"
-};
-/** Every rule the plugin registers, prefixed. `fixtures()` and the verify bin read this list. */
-const RULE_IDS = [
-	"rdjperron/no-array-filter-map",
-	"rdjperron/no-chained-type-assertions",
-	"rdjperron/no-conditional-empty-object-spread",
-	"rdjperron/no-hardcoded-jsx-text",
-	"rdjperron/no-known-value-widening",
-	"rdjperron/no-module-mocking",
-	"rdjperron/no-object-parameters",
-	"rdjperron/no-reduce-accumulator-copy",
-	"rdjperron/no-reflect-apply",
-	"rdjperron/no-reflect-get",
-	"rdjperron/no-runtime-typeof",
-	"rdjperron/no-shape-in-symbol-names",
-	"rdjperron/no-unknown-parameters",
-	"rdjperron/no-unknown-returns",
-	"rdjperron/no-unknown-type-aliases",
-	"rdjperron/no-unsafe-dictionary-type",
-	"rdjperron/no-use-effect",
-	"rdjperron/no-widen-then-assert",
-	"rdjperron/require-safety-comment-for-type-assertion",
-	"rdjperron/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: {
-		"rdjperron/no-array-filter-map": "error",
-		"rdjperron/no-chained-type-assertions": "error",
-		"rdjperron/no-conditional-empty-object-spread": "error",
-		"rdjperron/no-known-value-widening": "error",
-		"rdjperron/no-module-mocking": "error",
-		"rdjperron/no-object-parameters": "error",
-		"rdjperron/no-reduce-accumulator-copy": "error",
-		"rdjperron/no-reflect-apply": "error",
-		"rdjperron/no-reflect-get": "error",
-		"rdjperron/no-runtime-typeof": ["error", { allowInTypeGuards: true }],
-		"rdjperron/no-shape-in-symbol-names": "error",
-		"rdjperron/no-unknown-parameters": "error",
-		"rdjperron/no-unknown-returns": "error",
-		"rdjperron/no-unknown-type-aliases": "error",
-		"rdjperron/no-unsafe-dictionary-type": "error",
-		"rdjperron/no-widen-then-assert": "error",
-		"rdjperron/require-safety-comment-for-type-assertion": "error",
-		"rdjperron/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: the 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 { env = { browser: true }, 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,
-		rules
-	}];
-	if (useEffectAllowedIn !== void 0) {
-		rules["rdjperron/no-use-effect"] = ["error", { hint: `The one sanctioned wrapper is ${useEffectAllowedIn}.` }];
-		overrides.push({
-			files: [useEffectAllowedIn],
-			rules: { "rdjperron/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: { "rdjperron/no-hardcoded-jsx-text": pattern === void 0 ? "error" : ["error", { pattern }] }
-	}];
-}
-/** Files Expo's bundler inlines `process.env` into, where only the reads it replaces survive. */
-function expo(files) {
-	return [{
-		files,
-		rules: { "rdjperron/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",
-			"rdjperron/no-runtime-typeof": "off",
-			"rdjperron/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 = {
-	"rdjperron/no-array-filter-map": "error",
-	"rdjperron/no-chained-type-assertions": "error",
-	"rdjperron/no-conditional-empty-object-spread": "error",
-	"rdjperron/no-hardcoded-jsx-text": "error",
-	"rdjperron/no-known-value-widening": "error",
-	"rdjperron/no-module-mocking": "error",
-	"rdjperron/no-object-parameters": "error",
-	"rdjperron/no-reduce-accumulator-copy": "error",
-	"rdjperron/no-reflect-apply": "error",
-	"rdjperron/no-reflect-get": "error",
-	"rdjperron/no-runtime-typeof": "error",
-	"rdjperron/no-shape-in-symbol-names": "error",
-	"rdjperron/no-unknown-parameters": "error",
-	"rdjperron/no-unknown-returns": "error",
-	"rdjperron/no-unknown-type-aliases": "error",
-	"rdjperron/no-unsafe-dictionary-type": "error",
-	"rdjperron/no-use-effect": "error",
-	"rdjperron/no-widen-then-assert": "error",
-	"rdjperron/require-safety-comment-for-type-assertion": "error",
-	"rdjperron/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.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,11 +1121,20 @@ 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 }
+				});
+			}
 		} };
 	}
 });
@@ -1169,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 {