eslint-plugin-react-debug 3.0.0-next.8 → 3.0.0-next.81

package/dist/index.d.ts

@@ -1,20 +1,9 @@
-import * as _eslint_react_shared0 from "@eslint-react/shared";
+import { ESLint, Linter } from "eslint";
 
 //#region src/index.d.ts
-declare const _default: {
-  configs: {
-    all: {
-      plugins: {};
-      name?: string;
-      rules?: Record<string, _eslint_react_shared0.RuleConfig>;
-      settings?: _eslint_react_shared0.SettingsConfig;
-    };
-  };
-  meta: {
-    name: string;
-    version: string;
-  };
-  rules: Record<string, _eslint_react_shared0.CompatibleRule>;
+type ConfigName = "all";
+declare const finalPlugin: ESLint.Plugin & {
+  configs: Record<ConfigName, Linter.Config>;
 };
 //#endregion
-export { _default as default };
+export { finalPlugin as default };

package/dist/index.js

@@ -1,7 +1,7 @@
-import { DEFAULT_ESLINT_REACT_SETTINGS, WEBSITE_URL, defineRuleListener, getConfigAdapters, getSettingsFromContext, report } from "@eslint-react/shared";
+import { DEFAULT_ESLINT_REACT_SETTINGS, WEBSITE_URL, defineRuleListener, getSettingsFromContext, report } from "@eslint-react/shared";
 import * as core from "@eslint-react/core";
+import { JsxEmit, JsxInspector } from "@eslint-react/core";
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import { flow } from "@eslint-react/eff";
 import { AST_NODE_TYPES as AST_NODE_TYPES$1 } from "@typescript-eslint/types";
 import { P, match } from "ts-pattern";
 
@@ -21,28 +21,10 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 
-//#endregion
-//#region src/configs/all.ts
-var all_exports = /* @__PURE__ */ __exportAll({
-	name: () => name$1,
-	rules: () => rules,
-	settings: () => settings
-});
-const name$1 = "react-debug/all";
-const rules = {
-	"react-debug/class-component": "warn",
-	"react-debug/function-component": "warn",
-	"react-debug/hook": "warn",
-	"react-debug/is-from-react": "warn",
-	"react-debug/is-from-ref": "warn",
-	"react-debug/jsx": "warn"
-};
-const settings = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };
-
 //#endregion
 //#region package.json
-var name = "eslint-plugin-react-debug";
-var version = "3.0.0-next.8";
+var name$1 = "eslint-plugin-react-debug";
+var version = "3.0.0-next.81";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -58,7 +40,7 @@ function stringify(value) {
 }
 
 //#endregion
-//#region src/rules/class-component.ts
+//#region src/rules/class-component/class-component.ts
 const RULE_NAME$5 = "class-component";
 var class_component_default = createRule({
 	meta: {
@@ -75,15 +57,15 @@ function create$5(context) {
 	const { ctx, visitor } = core.useComponentCollectorLegacy(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
 		for (const { name = "anonymous", node: component } of ctx.getAllComponents(program)) context.report({
+			data: { json: stringify({ name }) },
 			messageId: "default",
-			node: component,
-			data: { json: stringify({ name }) }
+			node: component
 		});
 	} });
 }
 
 //#endregion
-//#region src/rules/function-component.ts
+//#region src/rules/function-component/function-component.ts
 const RULE_NAME$4 = "function-component";
 var function_component_default = createRule({
 	meta: {
@@ -102,22 +84,22 @@ function create$4(context) {
 		hint: core.DEFAULT_COMPONENT_DETECTION_HINT
 	});
 	return defineRuleListener(visitor, { "Program:exit"(program) {
-		for (const { name = "anonymous", node, displayName, flag, hookCalls } of ctx.getAllComponents(program)) context.report({
-			messageId: "default",
-			node,
+		for (const { name, displayName, flag, hookCalls, node } of ctx.getAllComponents(program)) context.report({
 			data: { json: stringify({
-				name,
+				name: name ?? "anonymous",
 				displayName: displayName == null ? "none" : context.sourceCode.getText(displayName),
 				forwardRef: (flag & core.ComponentFlag.ForwardRef) > 0n,
 				hookCalls: hookCalls.length,
 				memo: (flag & core.ComponentFlag.Memo) > 0n
-			}) }
+			}) },
+			messageId: "default",
+			node
 		});
 	} });
 }
 
 //#endregion
-//#region src/rules/hook.ts
+//#region src/rules/hook/hook.ts
 const RULE_NAME$3 = "hook";
 var hook_default = createRule({
 	meta: {
@@ -133,19 +115,19 @@ var hook_default = createRule({
 function create$3(context) {
 	const { ctx, visitor } = core.useHookCollector(context);
 	return defineRuleListener(visitor, { "Program:exit"(program) {
-		for (const { name, node, hookCalls } of ctx.getAllHooks(program)) context.report({
-			messageId: "default",
-			node,
+		for (const { name, hookCalls, node } of ctx.getAllHooks(program)) context.report({
 			data: { json: stringify({
 				name,
 				hookCalls: hookCalls.length
-			}) }
+			}) },
+			messageId: "default",
+			node
 		});
 	} });
 }
 
 //#endregion
-//#region src/rules/is-from-react.ts
+//#region src/rules/is-from-react/is-from-react.ts
 const RULE_NAME$2 = "is-from-react";
 var is_from_react_default = createRule({
 	meta: {
@@ -165,12 +147,12 @@ function create$2(context) {
 		const name = node.name;
 		if (!isFromReact(node, context.sourceCode.getScope(node), importSource)) return;
 		context.report({
-			messageId: "default",
-			node,
 			data: { json: stringify({
 				name,
 				importSource
-			}) }
+			}) },
+			messageId: "default",
+			node
 		});
 	}
 	return defineRuleListener({
@@ -195,7 +177,7 @@ function isFromReact(node, initialScope, importSource = "react") {
 }
 
 //#endregion
-//#region src/rules/is-from-ref.ts
+//#region src/rules/is-from-ref/is-from-ref.ts
 const RULE_NAME$1 = "is-from-ref";
 var is_from_ref_default = createRule({
 	meta: {
@@ -217,9 +199,9 @@ function create$1(context) {
 				init: context.sourceCode.getText(refInit)
 			});
 			context.report({
+				data: { json },
 				messageId: "default",
-				node,
-				data: { json }
+				node
 			});
 		}
 	}
@@ -238,8 +220,154 @@ function getRefInitNode(node, initialScope) {
 }
 
 //#endregion
-//#region src/rules/jsx.ts
-const { JsxEmit } = core;
+//#region ../../../.pkgs/eff/dist/index.js
+/**
+* Creates a function that can be used in a data-last (aka `pipe`able) or
+* data-first style.
+*
+* The first parameter to `dual` is either the arity of the uncurried function
+* or a predicate that determines if the function is being used in a data-first
+* or data-last style.
+*
+* Using the arity is the most common use case, but there are some cases where
+* you may want to use a predicate. For example, if you have a function that
+* takes an optional argument, you can use a predicate to determine if the
+* function is being used in a data-first or data-last style.
+*
+* You can pass either the arity of the uncurried function or a predicate
+* which determines if the function is being used in a data-first or
+* data-last style.
+*
+* **Example** (Using arity to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(2, (self, that) => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using call signatures to define the overloads)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = dual(2, (self: number, that: number): number => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using a predicate to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(
+*   (args) => args.length === 2,
+*   (self, that) => self + that
+* )
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
+* @param body - The function to be curried.
+* @since 1.0.0
+*/
+const dual = function(arity, body) {
+	if (typeof arity === "function") return function() {
+		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
+	};
+	switch (arity) {
+		case 0:
+		case 1: throw new RangeError(`Invalid arity ${arity}`);
+		case 2: return function(a, b) {
+			if (arguments.length >= 2) return body(a, b);
+			return function(self) {
+				return body(self, a);
+			};
+		};
+		case 3: return function(a, b, c) {
+			if (arguments.length >= 3) return body(a, b, c);
+			return function(self) {
+				return body(self, a, b);
+			};
+		};
+		default: return function() {
+			if (arguments.length >= arity) return body.apply(this, arguments);
+			const args = arguments;
+			return function(self) {
+				return body(self, ...args);
+			};
+		};
+	}
+};
+/**
+* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
+* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
+*
+* @param self - The first function to apply (or the composed function in data-last style).
+* @param bc - The second function to apply.
+* @returns A composed function that applies both functions in sequence.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { compose } from "effect/Function"
+*
+* const increment = (n: number) => n + 1;
+* const square = (n: number) => n * n;
+*
+* assert.strictEqual(compose(increment, square)(2), 9);
+* ```
+*
+* @since 1.0.0
+*/
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
+	switch (arguments.length) {
+		case 1: return ab;
+		case 2: return function() {
+			return bc(ab.apply(this, arguments));
+		};
+		case 3: return function() {
+			return cd(bc(ab.apply(this, arguments)));
+		};
+		case 4: return function() {
+			return de(cd(bc(ab.apply(this, arguments))));
+		};
+		case 5: return function() {
+			return ef(de(cd(bc(ab.apply(this, arguments)))));
+		};
+		case 6: return function() {
+			return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+		};
+		case 7: return function() {
+			return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+		};
+		case 8: return function() {
+			return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+		};
+		case 9: return function() {
+			return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+		};
+	}
+}
+
+//#endregion
+//#region src/rules/jsx/jsx.ts
 const RULE_NAME = "jsx";
 var jsx_default = createRule({
 	meta: {
@@ -248,30 +376,26 @@ var jsx_default = createRule({
 		messages: { default: "{{json}}" },
 		schema: []
 	},
-	name: RULE_NAME,
+	name: "jsx",
 	create,
 	defaultOptions: []
 });
 function create(context) {
-	const jsxConfigFromContext = core.getJsxConfigFromContext(context);
-	const jsxConfigFromAnnotation = core.getJsxConfigFromAnnotation(context);
-	const jsxConfig = {
-		...jsxConfigFromContext,
-		...jsxConfigFromAnnotation
-	};
+	const jsx = JsxInspector.from(context);
+	const jsxConfig = jsx.jsxConfig;
 	function getReportDescriptor(context) {
 		return (node) => ({
-			messageId: "default",
-			node,
 			data: { json: stringify({
-				kind: match(node).with({ type: AST_NODE_TYPES$1.JSXElement }, (n) => core.isJsxFragmentElement(context, n, jsxConfig) ? "fragment" : "element").with({ type: AST_NODE_TYPES$1.JSXFragment }, () => "fragment").exhaustive(),
-				type: core.getJsxElementType(context, node),
+				kind: match(node).with({ type: AST_NODE_TYPES$1.JSXElement }, (n) => jsx.isFragmentElement(n) ? "fragment" : "element").with({ type: AST_NODE_TYPES$1.JSXFragment }, () => "fragment").exhaustive(),
+				type: jsx.getElementType(node),
 				jsx: match(jsxConfig.jsx).with(JsxEmit.None, () => "none").with(JsxEmit.ReactJSX, () => "react-jsx").with(JsxEmit.ReactJSXDev, () => "react-jsx-dev").with(JsxEmit.React, () => "react").with(JsxEmit.ReactNative, () => "react-native").with(JsxEmit.Preserve, () => "preserve").otherwise(() => "unknown"),
 				jsxFactory: jsxConfig.jsxFactory,
 				jsxFragmentFactory: jsxConfig.jsxFragmentFactory,
 				jsxImportSource: jsxConfig.jsxImportSource,
 				jsxRuntime: match(jsxConfig.jsx).with(P.union(JsxEmit.None, JsxEmit.ReactJSX, JsxEmit.ReactJSXDev), () => "automatic").otherwise(() => "classic")
-			}) }
+			}) },
+			messageId: "default",
+			node
 		});
 	}
 	return defineRuleListener({ "JSXElement, JSXFragment": flow(getReportDescriptor(context), report(context)) });
@@ -281,7 +405,7 @@ function create(context) {
 //#region src/plugin.ts
 const plugin = {
 	meta: {
-		name,
+		name: name$1,
 		version
 	},
 	rules: {
@@ -294,13 +418,32 @@ const plugin = {
 	}
 };
 
+//#endregion
+//#region src/configs/all.ts
+var all_exports = /* @__PURE__ */ __exportAll({
+	name: () => name,
+	plugins: () => plugins,
+	rules: () => rules,
+	settings: () => settings
+});
+const name = "react-debug/all";
+const rules = {
+	"react-debug/class-component": "warn",
+	"react-debug/function-component": "warn",
+	"react-debug/hook": "warn",
+	"react-debug/is-from-react": "warn",
+	"react-debug/is-from-ref": "warn",
+	"react-debug/jsx": "warn"
+};
+const plugins = { "react-debug": plugin };
+const settings = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };
+
 //#endregion
 //#region src/index.ts
-const { toFlatConfig } = getConfigAdapters("react-debug", plugin);
-var src_default = {
+const finalPlugin = {
 	...plugin,
-	configs: { ["all"]: toFlatConfig(all_exports) }
+	configs: { ["all"]: all_exports }
 };
 
 //#endregion
-export { src_default as default };
+export { finalPlugin as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-debug",
-  "version": "3.0.0-next.8",
+  "version": "3.0.0-next.81",
   "description": "ESLint React's ESLint plugin for debugging related rules.",
   "keywords": [
     "react",
@@ -43,21 +43,22 @@
     "@typescript-eslint/types": "canary",
     "@typescript-eslint/utils": "canary",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "3.0.0-next.8",
-    "@eslint-react/core": "3.0.0-next.8",
-    "@eslint-react/shared": "3.0.0-next.8",
-    "@eslint-react/eff": "3.0.0-next.8",
-    "@eslint-react/var": "3.0.0-next.8"
+    "@eslint-react/shared": "3.0.0-next.81",
+    "@eslint-react/var": "3.0.0-next.81",
+    "@eslint-react/ast": "3.0.0-next.81",
+    "@eslint-react/core": "3.0.0-next.81"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
-    "tsdown": "^0.20.3",
+    "eslint": "^10.0.3",
+    "tsdown": "^0.21.0",
+    "@local/eff": "3.0.0-beta.72",
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
-    "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-    "typescript": ">=4.8.4 <6.0.0"
+    "eslint": "^10.0.0",
+    "typescript": "*"
   },
   "engines": {
     "node": ">=22.0.0"
@@ -68,6 +69,6 @@
   "scripts": {
     "build": "tsdown",
     "lint:publish": "publint",
-    "lint:ts": "tsc --noEmit"
+    "lint:ts": "tsl"
   }
 }