@dcf-micro/eslint-config 5.0.0

package/dist/chunks/index9.mjs

@@ -0,0 +1,194 @@
+import { g as getDefaultExportFromCjs } from '../shared/eslint-config.BDBLGvXj.mjs';
+
+function _mergeNamespaces(n, m) {
+	for (var i = 0; i < m.length; i++) {
+		const e = m[i];
+		if (typeof e !== 'string' && !Array.isArray(e)) { for (const k in e) {
+			if (k !== 'default' && !(k in n)) {
+				n[k] = e[k];
+			}
+		} }
+	}
+	return n;
+}
+
+/**
+ * @fileoverview Rule to flag use of .only in tests, preventing focused tests being committed accidentally
+ * @author Levi Buzolic
+ */
+
+var noOnlyTests;
+var hasRequiredNoOnlyTests;
+
+function requireNoOnlyTests () {
+	if (hasRequiredNoOnlyTests) return noOnlyTests;
+	hasRequiredNoOnlyTests = 1;
+	/** @typedef {{block?: string[], focus?: string[], functions?: string[], fix?: boolean}} Options */
+
+	/** @type {Options} */
+	const defaultOptions = {
+		block: [
+			"describe",
+			"it",
+			"context",
+			"test",
+			"tape",
+			"fixture",
+			"serial",
+			"Feature",
+			"Scenario",
+			"Given",
+			"And",
+			"When",
+			"Then",
+		],
+		focus: ["only"],
+		functions: [],
+		fix: false,
+	};
+
+	/** @type {import('eslint').Rule.RuleModule} */
+	noOnlyTests = {
+		meta: {
+			docs: {
+				description: "disallow .only blocks in tests",
+				category: "Possible Errors",
+				recommended: true,
+				url: "https://github.com/levibuzolic/eslint-plugin-no-only-tests",
+			},
+			fixable: "code",
+			schema: [
+				{
+					type: "object",
+					properties: {
+						block: {
+							type: "array",
+							items: {
+								type: "string",
+							},
+							uniqueItems: true,
+							default: defaultOptions.block,
+						},
+						focus: {
+							type: "array",
+							items: {
+								type: "string",
+							},
+							uniqueItems: true,
+							default: defaultOptions.focus,
+						},
+						functions: {
+							type: "array",
+							items: {
+								type: "string",
+							},
+							uniqueItems: true,
+							default: defaultOptions.functions,
+						},
+						fix: {
+							type: "boolean",
+							default: defaultOptions.fix,
+						},
+					},
+					additionalProperties: false,
+				},
+			],
+		},
+		create(context) {
+			/** @type {Options} */
+			const options = Object.assign({}, defaultOptions, context.options[0]);
+			const blocks = options.block || [];
+			const focus = options.focus || [];
+			const functions = options.functions || [];
+			const fix = !!options.fix;
+
+			return {
+				Identifier(node) {
+					if (functions.length && functions.indexOf(node.name) > -1) {
+						context.report({
+							node,
+							message: `${node.name} not permitted`,
+						});
+					}
+
+					const parentObject =
+						"object" in node.parent ? node.parent.object : undefined;
+					if (parentObject == null) return;
+					if (focus.indexOf(node.name) === -1) return;
+
+					const callPath = getCallPath(node.parent).join(".");
+
+					// comparison guarantees that matching is done with the beginning of call path
+					if (
+						blocks.find((block) => {
+							// Allow wildcard tail matching of blocks when ending in a `*`
+							if (block.endsWith("*"))
+								return callPath.startsWith(block.replace(/\*$/, ""));
+							return callPath.startsWith(`${block}.`);
+						})
+					) {
+						const rangeStart = node.range?.[0];
+						const rangeEnd = node.range?.[1];
+
+						context.report({
+							node,
+							message: `${callPath} not permitted`,
+							fix:
+								fix && rangeStart != null && rangeEnd != null
+									? (fixer) => fixer.removeRange([rangeStart - 1, rangeEnd])
+									: undefined,
+						});
+					}
+				},
+			};
+		},
+	};
+
+	/**
+	 *
+	 * @param {import('estree').Node} node
+	 * @param {string[]} path
+	 * @returns
+	 */
+	function getCallPath(node, path = []) {
+		if (node) {
+			const nodeName =
+				"name" in node && node.name
+					? node.name
+					: "property" in node && node.property && "name" in node.property
+						? node.property?.name
+						: undefined;
+			if ("object" in node && node.object && nodeName)
+				return getCallPath(node.object, [nodeName, ...path]);
+			if ("callee" in node && node.callee) return getCallPath(node.callee, path);
+			if (nodeName) return [nodeName, ...path];
+			return path;
+		}
+		return path;
+	}
+	return noOnlyTests;
+}
+
+var eslintPluginNoOnlyTests;
+var hasRequiredEslintPluginNoOnlyTests;
+
+function requireEslintPluginNoOnlyTests () {
+	if (hasRequiredEslintPluginNoOnlyTests) return eslintPluginNoOnlyTests;
+	hasRequiredEslintPluginNoOnlyTests = 1;
+	eslintPluginNoOnlyTests = {
+		rules: {
+			"no-only-tests": requireNoOnlyTests(),
+		},
+	};
+	return eslintPluginNoOnlyTests;
+}
+
+var eslintPluginNoOnlyTestsExports = requireEslintPluginNoOnlyTests();
+const index = /*@__PURE__*/getDefaultExportFromCjs(eslintPluginNoOnlyTestsExports);
+
+const index$1 = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null,
+	default: index
+}, [eslintPluginNoOnlyTestsExports]);
+
+export { index$1 as i };