eslint-plugin-baseline-js 0.7.3 → 0.7.4

package/README.md

@@ -26,7 +26,7 @@ This plugin delegates detection to eslint-plugin-es-x and ESLint core (plus a fe
 - yarn: `yarn add -D eslint-plugin-baseline-js`
 
 Recommended
-- ESLint >= 8.57 (Flat Config)
+- ESLint >= 9.29.0 and < 11 (Flat Config)
 
 ## Quick Start (Flat Config)
 

package/dist/index.mjs

@@ -64403,71 +64403,45 @@ function addTypedInstanceMemberDetector(context, d, report) {
 //#region src/rules/feature-usage/builder.ts
 function buildListeners(context, opt) {
 	const listeners = {};
-	function report(node, featureId) {
-		const msg = opt.messages[featureId] ?? `Feature '${featureId}' exceeds configured Baseline.`;
-		context.report({
-			node,
-			message: msg
-		});
-	}
 	const ctxLike = context;
 	const services = ctxLike.parserServices || ctxLike.sourceCode?.parserServices || {};
 	const checker = services.program?.getTypeChecker?.();
 	const useTyped = !!opt.typed && !!checker && !!services.esTreeNodeToTSNodeMap;
-	for (const d of opt.descriptors) switch (d.kind) {
-		case "newIdent":
-			mergeRuleListeners(listeners, addNewIdentDetector(context, d, report));
-			break;
-		case "newMember":
-			mergeRuleListeners(listeners, addNewMemberDetector(context, d, report));
-			break;
-		case "callStatic":
-			mergeRuleListeners(listeners, addCallStaticDetector(context, d, report));
-			break;
-		case "callGlobal":
-			mergeRuleListeners(listeners, addCallGlobalDetector(context, d, report));
-			break;
-		case "member":
-			mergeRuleListeners(listeners, addMemberDetector(context, d, report));
-			break;
-		case "staticMember":
-			mergeRuleListeners(listeners, addStaticMemberDetector(context, d, report));
-			break;
-		case "instanceMember":
-			if (useTyped) mergeRuleListeners(listeners, addTypedInstanceMemberDetector(context, d, report));
-			break;
-		case "callMemberWithArgs":
-			mergeRuleListeners(listeners, addCallMemberWithArgsDetector(context, d, report));
-			break;
-		case "newWithOptions": mergeRuleListeners(listeners, addNewWithOptionsDetector(context, d, report));
+	for (const d of opt.descriptors) {
+		function report(node) {
+			opt.report(node, d);
+		}
+		switch (d.kind) {
+			case "newIdent":
+				mergeRuleListeners(listeners, addNewIdentDetector(context, d, report));
+				break;
+			case "newMember":
+				mergeRuleListeners(listeners, addNewMemberDetector(context, d, report));
+				break;
+			case "callStatic":
+				mergeRuleListeners(listeners, addCallStaticDetector(context, d, report));
+				break;
+			case "callGlobal":
+				mergeRuleListeners(listeners, addCallGlobalDetector(context, d, report));
+				break;
+			case "member":
+				mergeRuleListeners(listeners, addMemberDetector(context, d, report));
+				break;
+			case "staticMember":
+				mergeRuleListeners(listeners, addStaticMemberDetector(context, d, report));
+				break;
+			case "instanceMember":
+				if (useTyped) mergeRuleListeners(listeners, addTypedInstanceMemberDetector(context, d, report));
+				break;
+			case "callMemberWithArgs":
+				mergeRuleListeners(listeners, addCallMemberWithArgsDetector(context, d, report));
+				break;
+			case "newWithOptions": mergeRuleListeners(listeners, addNewWithOptionsDetector(context, d, report));
+		}
 	}
 	return listeners;
 }
 //#endregion
-//#region src/rules/feature-usage/index.ts
-const rule$6 = {
-	meta: {
-		type: "problem",
-		docs: { description: "Detect usage of Web APIs and JS builtins beyond configured Baseline (data-driven)." },
-		schema: [{
-			type: "object",
-			properties: {
-				descriptors: { type: "array" },
-				messages: { type: "object" }
-			},
-			additionalProperties: false
-		}]
-	},
-	create(context) {
-		const opt = context.options?.[0] ?? {};
-		return buildListeners(context, {
-			descriptors: opt.descriptors ?? [],
-			messages: opt.messages ?? {},
-			typed: !!opt.typed
-		});
-	}
-};
-//#endregion
 //#region src/rules/no-atomics-pause/index.ts
 const rule$5 = {
 	meta: {
@@ -64713,6 +64687,52 @@ function listResolverPlugins() {
 	return Object.keys(registry).sort();
 }
 //#endregion
+//#region src/orchestrator/messages.ts
+function baselineMessage(featureId, baseline, subject) {
+	const feature = getFeatureRecord(featureId);
+	const label = subject ?? `'${feature?.name ?? featureId}'`;
+	if (baseline === "widely") return `${label} is not Baseline Widely available (${featureId}).`;
+	if (baseline === "newly") return `${label} is not Baseline Newly available (${featureId}).`;
+	if (feature?.status?.baseline === false) return `${label} has Limited availability and exceeds ${baseline} (${featureId}).`;
+	return `${label} became Baseline in ${baselineYearLabel(feature?.status) ?? "unknown"} and exceeds ${baseline} (${featureId}).`;
+}
+function delegateSubject(name) {
+	const separator = name.lastIndexOf(".");
+	if (separator === -1) return `'${name}'`;
+	const owner = name.slice(0, separator).replace(/\.prototype$/, "");
+	return memberSubject(name.slice(separator + 1), owner);
+}
+function descriptorSubject(descriptor) {
+	switch (descriptor.kind) {
+		case "newIdent":
+		case "callGlobal": return `'${descriptor.name}'`;
+		case "newMember":
+		case "callStatic":
+		case "member":
+		case "staticMember": return memberSubject(descriptor.prop, descriptor.base);
+		case "instanceMember": return memberSubject(descriptor.prop, descriptor.iface);
+		case "callMemberWithArgs":
+		case "newWithOptions": return callSubject(descriptor);
+	}
+}
+function memberSubject(name, owner) {
+	return `'${name}' on ${owner}`;
+}
+function callSubject(descriptor) {
+	const args = [];
+	const objectArg = descriptor.objectArg;
+	if (descriptor.kind === "callMemberWithArgs" && descriptor.stringArg) args[descriptor.stringArg.index] = descriptor.stringArg.values.map((value) => JSON.stringify(value)).join(" | ");
+	if (objectArg) {
+		const properties = /* @__PURE__ */ new Map();
+		for (const key of objectArg.hasKeys ?? []) properties.set(key, "...");
+		for (const { key, values } of objectArg.keyValues ?? []) properties.set(key, values?.map((value) => JSON.stringify(value)).join(" | ") || "...");
+		args[objectArg.index] = `{ ${Array.from(properties, ([key, value]) => `${key}: ${value}`).join(", ")} }`;
+	}
+	const argumentsText = Array.from(args, (argument) => argument ?? "...").join(", ");
+	if (descriptor.kind === "newWithOptions") return `new ${descriptor.name}(${argumentsText})`;
+	return `${descriptor.viaCall ? `${descriptor.viaCall.prop}().` : ""}${descriptor.prop}(${argumentsText})`;
+}
+//#endregion
 //#region src/orchestrator/use-baseline.ts
 function buildDelegateContext(ctx, overrides) {
 	const src = ctx;
@@ -64732,15 +64752,6 @@ registerSelfRules({
 	"no-math-sum-precise": rule$2,
 	"no-temporal": rule$1
 });
-function baselineMessage(featureId, baseline) {
-	const rec = getFeatureRecord(featureId);
-	const label = rec?.name || featureId;
-	const idSuffix = rec?.name ? ` (${featureId})` : "";
-	if (baseline === "widely") return `Feature '${label}'${idSuffix} is not a widely available Baseline feature.`;
-	if (baseline === "newly") return `Feature '${label}'${idSuffix} is not a newly available Baseline feature.`;
-	if (rec?.status?.baseline === false) return `Feature '${label}'${idSuffix} has Limited availability and exceeds ${baseline}.`;
-	return `Feature '${label}'${idSuffix} became Baseline in ${baselineYearLabel(rec?.status) ?? "unknown"} and exceeds ${baseline}.`;
-}
 const rule = {
 	meta: {
 		type: "problem",
@@ -64896,14 +64907,16 @@ const rule = {
 				},
 				options: delegateOptions,
 				report(arg) {
-					const node = typeof arg === "object" && arg !== null && "node" in arg ? arg.node : arg;
-					if (matchIgnoreNodeType) {
-						const t = node?.type;
-						if (t && matchIgnoreNodeType(t)) return;
-					}
-					ctx.report({
-						node,
-						message: baselineMessage(featureId, baseline)
+					if ("node" in arg && matchIgnoreNodeType?.(arg.node.type)) return;
+					const subject = arg.data?.name ? delegateSubject(String(arg.data.name)) : void 0;
+					const message = baselineMessage(featureId, baseline, subject);
+					if ("node" in arg) ctx.report({
+						node: arg.node,
+						message
+					});
+					else ctx.report({
+						loc: arg.loc,
+						message
 					});
 				}
 			});
@@ -64934,35 +64947,17 @@ const rule = {
 		const useTypesJs = resolveUseTypes(includeJsBuiltins);
 		const typedEnabled = (useTypesWeb === "require" || useTypesJs === "require" || useTypesWeb === "auto" || useTypesJs === "auto") && typedAvailable;
 		if (!typedEnabled) descriptors = descriptors.filter((d) => d.kind !== "instanceMember" && !d.typedOnly);
-		if (descriptors.length > 0) {
-			const messages = {};
-			for (const d of descriptors) messages[d.featureId] = baselineMessage(d.featureId, baseline);
-			const delegateCtx = buildDelegateContext(ctx, {
-				options: [typedEnabled ? {
-					descriptors,
-					messages,
-					typed: true
-				} : {
-					descriptors,
-					messages
-				}],
-				report(arg) {
-					const isObj = typeof arg === "object" && arg !== null;
-					const node = isObj && "node" in arg ? arg.node : arg;
-					if (matchIgnoreNodeType) {
-						const t = node?.type;
-						if (t && matchIgnoreNodeType(t)) return;
-					}
-					let msg;
-					if (isObj && typeof arg.message === "string") msg = arg.message;
-					ctx.report({
-						node,
-						message: msg
-					});
-				}
-			});
-			mergeRuleListeners(listeners, rule$6.create(delegateCtx));
-		}
+		if (descriptors.length > 0) mergeRuleListeners(listeners, buildListeners(ctx, {
+			descriptors,
+			typed: typedEnabled,
+			report(node, descriptor) {
+				if (matchIgnoreNodeType?.(node.type)) return;
+				ctx.report({
+					node,
+					message: baselineMessage(descriptor.featureId, baseline, descriptorSubject(descriptor))
+				});
+			}
+		}));
 		return listeners;
 	}
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-baseline-js",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "Enforce JavaScript Baseline (widely/newly/year) browser compatibility with a single ESLint rule. Prevent runtime errors by catching unsupported JavaScript features during development.",
   "license": "MIT",
   "type": "module",