eslint-plugin-react-x 1.20.2-beta.1 → 1.20.2-beta.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.js +198 -196
  2. package/dist/index.mjs +7 -5
  3. package/package.json +9 -9
package/dist/index.js CHANGED
@@ -1,7 +1,7 @@
1
1
  'use strict';
2
2
 
3
+ var eff = require('@eslint-react/eff');
3
4
  var JSX8 = require('@eslint-react/jsx');
4
- var tools = require('@eslint-react/tools');
5
5
  var shared = require('@eslint-react/shared');
6
6
  var AST11 = require('@eslint-react/ast');
7
7
  var core = require('@eslint-react/core');
@@ -41,7 +41,7 @@ var ts__default = /*#__PURE__*/_interopDefault(ts);
41
41
 
42
42
  // package.json
43
43
  var name = "eslint-plugin-react-x";
44
- var version = "1.20.2-beta.1";
44
+ var version = "1.20.2-beta.3";
45
45
  var createRule = shared.createRuleForPlugin("x");
46
46
 
47
47
  // src/rules/avoid-shorthand-boolean.ts
@@ -65,7 +65,7 @@ var avoid_shorthand_boolean_default = createRule({
65
65
  name: RULE_NAME,
66
66
  create(context) {
67
67
  function getReportDescriptor(node) {
68
- return node.value ? tools.O.none() : tools.O.some({
68
+ return node.value ? eff.O.none() : eff.O.some({
69
69
  messageId: "avoidShorthandBoolean",
70
70
  node,
71
71
  data: {
@@ -75,7 +75,7 @@ var avoid_shorthand_boolean_default = createRule({
75
75
  });
76
76
  }
77
77
  return {
78
- JSXAttribute: tools.F.flow(getReportDescriptor, tools.O.map(context.report))
78
+ JSXAttribute: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
79
79
  };
80
80
  },
81
81
  defaultOptions: []
@@ -169,7 +169,7 @@ var jsx_no_duplicate_props_default = createRule({
169
169
  for (const attr of node.attributes) {
170
170
  if (attr.type === types.AST_NODE_TYPES.JSXSpreadAttribute) continue;
171
171
  const name2 = attr.name.name;
172
- if (!tools.isString(name2)) continue;
172
+ if (!eff.isString(name2)) continue;
173
173
  if (!props.includes(name2)) {
174
174
  props.push(name2);
175
175
  continue;
@@ -205,17 +205,17 @@ var jsx_uses_vars_default = createRule({
205
205
  function getName5(node) {
206
206
  switch (node.type) {
207
207
  case types.AST_NODE_TYPES.JSXIdentifier:
208
- return tools.O.some(node.name);
208
+ return eff.O.some(node.name);
209
209
  case types.AST_NODE_TYPES.JSXMemberExpression:
210
210
  return getName5(node.object);
211
211
  default:
212
- return tools.O.none();
212
+ return eff.O.none();
213
213
  }
214
214
  }
215
215
  return {
216
216
  JSXOpeningElement(node) {
217
217
  if (node.name.type === types.AST_NODE_TYPES.JSXIdentifier && /^[a-z]/u.test(node.name.name)) return;
218
- tools.O.map(getName5(node.name), (name2) => {
218
+ eff.O.map(getName5(node.name), (name2) => {
219
219
  context.sourceCode.markVariableAsUsed(name2, node);
220
220
  });
221
221
  }
@@ -232,15 +232,15 @@ function getName(node) {
232
232
  return getName(node.expression);
233
233
  }
234
234
  if (node.type === types.AST_NODE_TYPES.Identifier || node.type === types.AST_NODE_TYPES.PrivateIdentifier) {
235
- return tools.O.some(node.name);
235
+ return eff.O.some(node.name);
236
236
  }
237
237
  if (node.type === types.AST_NODE_TYPES.Literal) {
238
- return tools.O.some(String(node.value));
238
+ return eff.O.some(String(node.value));
239
239
  }
240
240
  if (node.type === types.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
241
- return tools.O.fromNullable(node.quasis[0]?.value.raw);
241
+ return eff.O.fromNullable(node.quasis[0]?.value.raw);
242
242
  }
243
- return tools.O.none();
243
+ return eff.O.none();
244
244
  }
245
245
  var no_access_state_in_setstate_default = createRule({
246
246
  meta: {
@@ -289,7 +289,7 @@ var no_access_state_in_setstate_default = createRule({
289
289
  if (!currMethod || isStatic) return;
290
290
  const [setState, hasThisState] = setStateStack.at(-1) ?? [];
291
291
  if (!setState || hasThisState) return;
292
- if (!tools.O.exists(getName(node.property), (name2) => name2 === "state")) return;
292
+ if (!eff.O.exists(getName(node.property), (name2) => name2 === "state")) return;
293
293
  context.report({ messageId: "noAccessStateInSetstate", node });
294
294
  },
295
295
  MethodDefinition(node) {
@@ -314,7 +314,7 @@ var no_access_state_in_setstate_default = createRule({
314
314
  if (!(node.init && AST11__namespace.isThisExpression(node.init) && node.id.type === types.AST_NODE_TYPES.ObjectPattern)) return;
315
315
  const hasState = node.id.properties.some((prop) => {
316
316
  if (prop.type === types.AST_NODE_TYPES.Property && AST11__namespace.isKeyLiteralLike(prop, prop.key)) {
317
- return tools.O.exists(getName(prop.key), (name2) => name2 === "state");
317
+ return eff.O.exists(getName(prop.key), (name2) => name2 === "state");
318
318
  }
319
319
  return false;
320
320
  });
@@ -373,21 +373,21 @@ function isUsingReactChildren(node, context) {
373
373
  }
374
374
  function getMapIndexParamName(node, context) {
375
375
  const { callee } = node;
376
- if (callee.type !== types.AST_NODE_TYPES.MemberExpression) return tools.O.none();
377
- if (callee.property.type !== types.AST_NODE_TYPES.Identifier) return tools.O.none();
376
+ if (callee.type !== types.AST_NODE_TYPES.MemberExpression) return eff.O.none();
377
+ if (callee.property.type !== types.AST_NODE_TYPES.Identifier) return eff.O.none();
378
378
  const { name: name2 } = callee.property;
379
- if (!iteratorFunctionIndexParamPosition.has(name2)) return tools.O.none();
379
+ if (!iteratorFunctionIndexParamPosition.has(name2)) return eff.O.none();
380
380
  const callbackArg = node.arguments[isUsingReactChildren(node, context) ? 1 : 0];
381
- if (!callbackArg) return tools.O.none();
381
+ if (!callbackArg) return eff.O.none();
382
382
  if (!AST11__namespace.isOneOf([types.AST_NODE_TYPES.ArrowFunctionExpression, types.AST_NODE_TYPES.FunctionExpression])(callbackArg)) {
383
- return tools.O.none();
383
+ return eff.O.none();
384
384
  }
385
385
  const { params } = callbackArg;
386
386
  const indexParamPosition = iteratorFunctionIndexParamPosition.get(name2);
387
- if (tools.isNullable(indexParamPosition)) return tools.O.none();
388
- if (params.length < indexParamPosition + 1) return tools.O.none();
387
+ if (eff.isNullable(indexParamPosition)) return eff.O.none();
388
+ if (params.length < indexParamPosition + 1) return eff.O.none();
389
389
  const param = params.at(indexParamPosition);
390
- return param && "name" in param ? tools.O.some(param.name) : tools.O.none();
390
+ return param && "name" in param ? eff.O.some(param.name) : eff.O.none();
391
391
  }
392
392
  var no_array_index_key_default = createRule({
393
393
  meta: {
@@ -405,7 +405,7 @@ var no_array_index_key_default = createRule({
405
405
  create(context) {
406
406
  const indexParamNames = [];
407
407
  function isArrayIndex(node) {
408
- return node.type === types.AST_NODE_TYPES.Identifier && indexParamNames.some(tools.O.exists((name2) => name2 === node.name));
408
+ return node.type === types.AST_NODE_TYPES.Identifier && indexParamNames.some(eff.O.exists((name2) => name2 === node.name));
409
409
  }
410
410
  function isCreateOrCloneElementCall(node) {
411
411
  return core.isCreateElementCall(node, context) || core.isCloneElementCall(node, context);
@@ -615,8 +615,8 @@ var no_children_prop_default = createRule({
615
615
  JSXElement(node) {
616
616
  const initialScope = context.sourceCode.getScope(node);
617
617
  const prop = JSX8__namespace.getProp(node.openingElement.attributes, "children", initialScope);
618
- const reportDescriptor = tools.O.map(prop, (prop2) => ({ messageId: "noChildrenProp", node: prop2 }));
619
- tools.O.map(reportDescriptor, context.report);
618
+ const reportDescriptor = eff.O.map(prop, (prop2) => ({ messageId: "noChildrenProp", node: prop2 }));
619
+ eff.O.map(reportDescriptor, context.report);
620
620
  }
621
621
  };
622
622
  },
@@ -700,7 +700,7 @@ var no_class_component_default = createRule({
700
700
  node: component,
701
701
  data: {
702
702
  // eslint-disable-next-line eslint-plugin/no-unused-placeholders
703
- name: tools.O.getOrElse(tools.F.constant("anonymous"))(name2)
703
+ name: eff.O.getOrElse(eff.F.constant("anonymous"))(name2)
704
704
  }
705
705
  });
706
706
  }
@@ -763,15 +763,15 @@ var no_comment_textnodes_default = createRule({
763
763
  return /^\s*\/(?:\/|\*)/mu.test(rawValue);
764
764
  }
765
765
  const getReportDescriptor = (node) => {
766
- if (!AST11__namespace.isOneOf([types.AST_NODE_TYPES.JSXElement, types.AST_NODE_TYPES.JSXFragment])(node.parent)) return tools.O.none();
767
- if (!hasCommentLike(node)) return tools.O.none();
768
- if (!node.parent.type.includes("JSX")) return tools.O.none();
769
- return tools.O.some({
766
+ if (!AST11__namespace.isOneOf([types.AST_NODE_TYPES.JSXElement, types.AST_NODE_TYPES.JSXFragment])(node.parent)) return eff.O.none();
767
+ if (!hasCommentLike(node)) return eff.O.none();
768
+ if (!node.parent.type.includes("JSX")) return eff.O.none();
769
+ return eff.O.some({
770
770
  messageId: "noCommentTextnodes",
771
771
  node
772
772
  });
773
773
  };
774
- const ruleFunction = tools.F.flow(getReportDescriptor, tools.O.map(context.report), tools.F.constVoid);
774
+ const ruleFunction = eff.F.flow(getReportDescriptor, eff.O.map(context.report), eff.F.constVoid);
775
775
  return {
776
776
  JSXText: ruleFunction,
777
777
  Literal: ruleFunction
@@ -799,14 +799,14 @@ var no_complex_conditional_rendering_default = createRule({
799
799
  create(context) {
800
800
  function getReportDescriptor(node) {
801
801
  const jsxExpContainer = node.parent?.parent;
802
- if (!AST11__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer)(jsxExpContainer)) return tools.O.none();
802
+ if (!AST11__namespace.is(types.AST_NODE_TYPES.JSXExpressionContainer)(jsxExpContainer)) return eff.O.none();
803
803
  if (!AST11__namespace.isOneOf([types.AST_NODE_TYPES.JSXElement, types.AST_NODE_TYPES.JSXFragment])(jsxExpContainer.parent)) {
804
- return tools.O.none();
804
+ return eff.O.none();
805
805
  }
806
- if (!jsxExpContainer.parent.children.includes(jsxExpContainer)) return tools.O.none();
807
- return tools.O.some({ messageId: "noComplexConditionalRendering", node: jsxExpContainer });
806
+ if (!jsxExpContainer.parent.children.includes(jsxExpContainer)) return eff.O.none();
807
+ return eff.O.some({ messageId: "noComplexConditionalRendering", node: jsxExpContainer });
808
808
  }
809
- const ruleFunction = tools.F.flow(getReportDescriptor, tools.O.map(context.report), tools.F.constVoid);
809
+ const ruleFunction = eff.F.flow(getReportDescriptor, eff.O.map(context.report), eff.F.constVoid);
810
810
  return {
811
811
  "JSXExpressionContainer > ConditionalExpression > ConditionalExpression": ruleFunction,
812
812
  "JSXExpressionContainer > ConditionalExpression > LogicalExpression": ruleFunction,
@@ -1031,7 +1031,7 @@ var no_create_ref_default = createRule({
1031
1031
  return {
1032
1032
  CallExpression(node) {
1033
1033
  if (!core.isCreateRefCall(node, context)) return;
1034
- if (tools.O.isSome(AST11__namespace.traverseUp(node, core.isClassComponent))) return;
1034
+ if (eff.O.isSome(AST11__namespace.traverseUp(node, core.isClassComponent))) return;
1035
1035
  context.report({ messageId: "noCreateRef", node });
1036
1036
  }
1037
1037
  };
@@ -1064,10 +1064,10 @@ var no_default_props_default = createRule({
1064
1064
  if (object.type !== types.AST_NODE_TYPES.Identifier) return;
1065
1065
  if (property.type !== types.AST_NODE_TYPES.Identifier || property.name !== "defaultProps") return;
1066
1066
  if (!core.isComponentName(object.name)) return;
1067
- const isComponent = tools.F.pipe(
1067
+ const isComponent = eff.F.pipe(
1068
1068
  VAR__namespace.findVariable(object.name, context.sourceCode.getScope(node)),
1069
- tools.O.flatMap(VAR__namespace.getVariableNode(0)),
1070
- tools.O.exists((n) => AST11__namespace.isFunction(n) || core.isClassComponent(n))
1069
+ eff.O.flatMap(VAR__namespace.getVariableNode(0)),
1070
+ eff.O.exists((n) => AST11__namespace.isFunction(n) || core.isClassComponent(n))
1071
1071
  );
1072
1072
  if (!isComponent) return;
1073
1073
  context.report({ messageId: "noDefaultProps", node: property });
@@ -1090,19 +1090,19 @@ function getName2(node) {
1090
1090
  return getName2(node.expression);
1091
1091
  }
1092
1092
  if (node.type === types.AST_NODE_TYPES.Identifier || node.type === types.AST_NODE_TYPES.PrivateIdentifier) {
1093
- return tools.O.some(node.name);
1093
+ return eff.O.some(node.name);
1094
1094
  }
1095
1095
  if (node.type === types.AST_NODE_TYPES.Literal) {
1096
- return tools.O.some(String(node.value));
1096
+ return eff.O.some(String(node.value));
1097
1097
  }
1098
1098
  if (node.type === types.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
1099
- return tools.O.fromNullable(node.quasis[0]?.value.raw);
1099
+ return eff.O.fromNullable(node.quasis[0]?.value.raw);
1100
1100
  }
1101
- return tools.O.none();
1101
+ return eff.O.none();
1102
1102
  }
1103
1103
  function isAssignmentToThisState(node) {
1104
1104
  const { left } = node;
1105
- return left.type === types.AST_NODE_TYPES.MemberExpression && AST11__namespace.isThisExpression(left.object) && tools.O.exists(getName2(left.property), (name2) => name2 === "state");
1105
+ return left.type === types.AST_NODE_TYPES.MemberExpression && AST11__namespace.isThisExpression(left.object) && eff.O.exists(getName2(left.property), (name2) => name2 === "state");
1106
1106
  }
1107
1107
  function isConstructorFunction(node) {
1108
1108
  return AST11__namespace.isOneOf([types.AST_NODE_TYPES.FunctionDeclaration, types.AST_NODE_TYPES.FunctionExpression])(node) && AST11__namespace.isOneOf([types.AST_NODE_TYPES.MethodDefinition, types.AST_NODE_TYPES.PropertyDefinition])(node.parent) && node.parent.key.type === types.AST_NODE_TYPES.Identifier && node.parent.key.name === "constructor";
@@ -1122,23 +1122,23 @@ var no_direct_mutation_state_default = createRule({
1122
1122
  name: RULE_NAME24,
1123
1123
  create(context) {
1124
1124
  function getReportDescriptor(node) {
1125
- if (!isAssignmentToThisState(node)) return tools.O.none();
1125
+ if (!isAssignmentToThisState(node)) return eff.O.none();
1126
1126
  const maybeParentClass = AST11__namespace.traverseUpGuard(
1127
1127
  node,
1128
1128
  AST11__namespace.isOneOf([types.AST_NODE_TYPES.ClassDeclaration, types.AST_NODE_TYPES.ClassExpression])
1129
1129
  );
1130
- if (tools.O.isNone(maybeParentClass)) return tools.O.none();
1130
+ if (eff.O.isNone(maybeParentClass)) return eff.O.none();
1131
1131
  const parentClass = maybeParentClass.value;
1132
- if (!core.isClassComponent(parentClass)) return tools.O.none();
1132
+ if (!core.isClassComponent(parentClass)) return eff.O.none();
1133
1133
  const maybeParentConstructor = AST11__namespace.traverseUpGuard(node, isConstructorFunction);
1134
- if (tools.O.exists(maybeParentConstructor, (n) => context.sourceCode.getScope(node).block === n)) return tools.O.none();
1135
- return tools.O.some({
1134
+ if (eff.O.exists(maybeParentConstructor, (n) => context.sourceCode.getScope(node).block === n)) return eff.O.none();
1135
+ return eff.O.some({
1136
1136
  messageId: "noDirectMutationState",
1137
1137
  node
1138
1138
  });
1139
1139
  }
1140
1140
  return {
1141
- AssignmentExpression: tools.F.flow(getReportDescriptor, tools.O.map(context.report))
1141
+ AssignmentExpression: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
1142
1142
  };
1143
1143
  },
1144
1144
  defaultOptions: []
@@ -1161,53 +1161,53 @@ var no_duplicate_key_default = createRule({
1161
1161
  },
1162
1162
  name: RULE_NAME25,
1163
1163
  create(context) {
1164
- const isWithinChildrenToArrayRef = tools.MutRef.make(false);
1164
+ const isWithinChildrenToArrayRef = eff.MutRef.make(false);
1165
1165
  function isKeyEqual(a, b) {
1166
1166
  return VAR__namespace.isNodeValueEqual(a, b, [context.sourceCode.getScope(a), context.sourceCode.getScope(b)]);
1167
1167
  }
1168
1168
  function checkIteratorElement(node) {
1169
- if (node.type !== types.AST_NODE_TYPES.JSXElement) return tools.O.none();
1169
+ if (node.type !== types.AST_NODE_TYPES.JSXElement) return eff.O.none();
1170
1170
  const initialScope = context.sourceCode.getScope(node);
1171
- return tools.F.pipe(
1171
+ return eff.F.pipe(
1172
1172
  JSX8__namespace.findPropInAttributes(node.openingElement.attributes, initialScope)("key"),
1173
- tools.O.flatMap((k) => "value" in k ? tools.O.fromNullable(k.value) : tools.O.none()),
1174
- tools.O.flatMap((v) => {
1175
- return isKeyEqual(v, v) ? tools.O.some({
1173
+ eff.O.flatMap((k) => "value" in k ? eff.O.fromNullable(k.value) : eff.O.none()),
1174
+ eff.O.flatMap((v) => {
1175
+ return isKeyEqual(v, v) ? eff.O.some({
1176
1176
  messageId: "noDuplicateKey",
1177
1177
  node: v,
1178
1178
  data: {
1179
1179
  value: context.sourceCode.getText(v)
1180
1180
  }
1181
- }) : tools.O.none();
1181
+ }) : eff.O.none();
1182
1182
  })
1183
1183
  );
1184
1184
  }
1185
1185
  function checkExpression(node) {
1186
1186
  switch (node.type) {
1187
1187
  case types.AST_NODE_TYPES.ConditionalExpression:
1188
- if (!("consequent" in node)) return tools.O.none();
1189
- return tools.F.pipe(
1188
+ if (!("consequent" in node)) return eff.O.none();
1189
+ return eff.F.pipe(
1190
1190
  checkIteratorElement(node.consequent),
1191
- tools.O.orElse(() => checkIteratorElement(node.alternate))
1191
+ eff.O.orElse(() => checkIteratorElement(node.alternate))
1192
1192
  );
1193
1193
  case types.AST_NODE_TYPES.JSXElement:
1194
1194
  case types.AST_NODE_TYPES.JSXFragment:
1195
1195
  return checkIteratorElement(node);
1196
1196
  case types.AST_NODE_TYPES.LogicalExpression:
1197
- if (!("left" in node)) return tools.O.none();
1198
- return tools.F.pipe(
1197
+ if (!("left" in node)) return eff.O.none();
1198
+ return eff.F.pipe(
1199
1199
  checkIteratorElement(node.left),
1200
- tools.O.orElse(() => checkIteratorElement(node.right))
1200
+ eff.O.orElse(() => checkIteratorElement(node.right))
1201
1201
  );
1202
1202
  default:
1203
- return tools.O.none();
1203
+ return eff.O.none();
1204
1204
  }
1205
1205
  }
1206
1206
  function checkBlockStatement(node) {
1207
1207
  return AST11__namespace.getNestedReturnStatements(node).reduce((acc, statement) => {
1208
1208
  if (!statement.argument) return acc;
1209
1209
  const maybeDescriptor = checkIteratorElement(statement.argument);
1210
- if (tools.O.isNone(maybeDescriptor)) return acc;
1210
+ if (eff.O.isNone(maybeDescriptor)) return acc;
1211
1211
  const descriptor = maybeDescriptor.value;
1212
1212
  return [...acc, descriptor];
1213
1213
  }, []);
@@ -1215,7 +1215,7 @@ var no_duplicate_key_default = createRule({
1215
1215
  const seen = /* @__PURE__ */ new WeakSet();
1216
1216
  return {
1217
1217
  "ArrayExpression, JSXElement > JSXElement"(node) {
1218
- if (tools.MutRef.get(isWithinChildrenToArrayRef)) return;
1218
+ if (eff.MutRef.get(isWithinChildrenToArrayRef)) return;
1219
1219
  const elements = tsPattern.match(node).with({ type: types.AST_NODE_TYPES.ArrayExpression }, ({ elements: elements2 }) => elements2).with({ type: types.AST_NODE_TYPES.JSXElement }, ({ parent }) => "children" in parent ? parent.children : []).otherwise(() => []).filter(AST11__namespace.is(types.AST_NODE_TYPES.JSXElement)).filter((element) => !seen.has(element));
1220
1220
  const keys = elements.reduce(
1221
1221
  (acc, element) => {
@@ -1246,7 +1246,7 @@ var no_duplicate_key_default = createRule({
1246
1246
  }
1247
1247
  },
1248
1248
  CallExpression(node) {
1249
- if (core.isChildrenToArrayCall(node, context)) tools.MutRef.set(isWithinChildrenToArrayRef, true);
1249
+ if (core.isChildrenToArrayCall(node, context)) eff.MutRef.set(isWithinChildrenToArrayRef, true);
1250
1250
  const isMapCall = AST11__namespace.isMapCallLoose(node);
1251
1251
  const isArrayFromCall = tsPattern.isMatching({
1252
1252
  type: types.AST_NODE_TYPES.CallExpression,
@@ -1258,7 +1258,7 @@ var no_duplicate_key_default = createRule({
1258
1258
  }
1259
1259
  }, node);
1260
1260
  if (!isMapCall && !isArrayFromCall) return;
1261
- if (tools.MutRef.get(isWithinChildrenToArrayRef)) return;
1261
+ if (eff.MutRef.get(isWithinChildrenToArrayRef)) return;
1262
1262
  const fn = node.arguments[isMapCall ? 0 : 1];
1263
1263
  if (!AST11__namespace.isOneOf([types.AST_NODE_TYPES.ArrowFunctionExpression, types.AST_NODE_TYPES.FunctionExpression])(fn)) return;
1264
1264
  if (fn.body.type === types.AST_NODE_TYPES.BlockStatement) {
@@ -1267,10 +1267,10 @@ var no_duplicate_key_default = createRule({
1267
1267
  }
1268
1268
  return;
1269
1269
  }
1270
- tools.O.map(checkExpression(fn.body), context.report);
1270
+ eff.O.map(checkExpression(fn.body), context.report);
1271
1271
  },
1272
1272
  "CallExpression:exit"(node) {
1273
- if (core.isChildrenToArrayCall(node, context)) tools.MutRef.set(isWithinChildrenToArrayRef, false);
1273
+ if (core.isChildrenToArrayCall(node, context)) eff.MutRef.set(isWithinChildrenToArrayRef, false);
1274
1274
  }
1275
1275
  };
1276
1276
  },
@@ -1335,9 +1335,9 @@ function getComponentPropsFixes(node, typeArguments, fixer, context) {
1335
1335
  const [arg0, arg1] = node.params;
1336
1336
  const [typeArg0, typeArg1] = typeArguments;
1337
1337
  if (!arg0) return [];
1338
- const fixedArg0Text = tsPattern.match(arg0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => tools.O.some(`...${n.name}`)).with({ type: types.AST_NODE_TYPES.ObjectPattern }, (n) => tools.O.some(n.properties.map(getText).join(", "))).otherwise(tools.O.none);
1339
- const fixedArg1Text = tsPattern.match(arg1).with(tsPattern.P.nullish, () => tools.O.some("ref")).with({ type: types.AST_NODE_TYPES.Identifier, name: "ref" }, () => tools.O.some("ref")).with({ type: types.AST_NODE_TYPES.Identifier, name: tsPattern.P.not("ref") }, (n) => tools.O.some(`ref: ${n.name}`)).otherwise(tools.O.none);
1340
- if (tools.O.isNone(fixedArg0Text) || tools.O.isNone(fixedArg1Text)) return [];
1338
+ const fixedArg0Text = tsPattern.match(arg0).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => eff.O.some(`...${n.name}`)).with({ type: types.AST_NODE_TYPES.ObjectPattern }, (n) => eff.O.some(n.properties.map(getText).join(", "))).otherwise(eff.O.none);
1339
+ const fixedArg1Text = tsPattern.match(arg1).with(tsPattern.P.nullish, () => eff.O.some("ref")).with({ type: types.AST_NODE_TYPES.Identifier, name: "ref" }, () => eff.O.some("ref")).with({ type: types.AST_NODE_TYPES.Identifier, name: tsPattern.P.not("ref") }, (n) => eff.O.some(`ref: ${n.name}`)).otherwise(eff.O.none);
1340
+ if (eff.O.isNone(fixedArg0Text) || eff.O.isNone(fixedArg1Text)) return [];
1341
1341
  const fixedPropsText = fixedArg0Text.value;
1342
1342
  const fixedRefText = fixedArg1Text.value;
1343
1343
  if (!typeArg0 || !typeArg1) {
@@ -1397,13 +1397,13 @@ var no_implicit_key_default = createRule({
1397
1397
  const keyPropOnElement = node.attributes.some(
1398
1398
  (n) => AST11__namespace.is(types.AST_NODE_TYPES.JSXAttribute)(n) && n.name.name === "key"
1399
1399
  );
1400
- if (tools.O.isSome(keyPropFound) && !keyPropOnElement) {
1401
- return tools.O.some({ messageId: "noImplicitKey", node: keyPropFound.value });
1400
+ if (eff.O.isSome(keyPropFound) && !keyPropOnElement) {
1401
+ return eff.O.some({ messageId: "noImplicitKey", node: keyPropFound.value });
1402
1402
  }
1403
- return tools.O.none();
1403
+ return eff.O.none();
1404
1404
  }
1405
1405
  return {
1406
- JSXOpeningElement: tools.F.flow(getReportDescriptor, tools.O.map(context.report))
1406
+ JSXOpeningElement: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
1407
1407
  };
1408
1408
  },
1409
1409
  defaultOptions: []
@@ -1474,10 +1474,10 @@ function inspectVariantTypes(types) {
1474
1474
  switch (true) {
1475
1475
  case (booleans.length === 1 && !!booleans[0]): {
1476
1476
  const [first] = booleans;
1477
- const evaluated = tools.F.pipe(
1478
- tsPattern.match(first).when(isTrueLiteralType, () => tools.O.some("truthy boolean")).when(isFalseLiteralType, () => tools.O.some("falsy boolean")).otherwise(tools.O.none)
1477
+ const evaluated = eff.F.pipe(
1478
+ tsPattern.match(first).when(isTrueLiteralType, () => eff.O.some("truthy boolean")).when(isFalseLiteralType, () => eff.O.some("falsy boolean")).otherwise(eff.O.none)
1479
1479
  );
1480
- tools.O.map(evaluated, (v) => variantTypes.add(v));
1480
+ eff.O.map(evaluated, (v) => variantTypes.add(v));
1481
1481
  break;
1482
1482
  }
1483
1483
  case booleans.length === 2: {
@@ -1487,17 +1487,17 @@ function inspectVariantTypes(types) {
1487
1487
  }
1488
1488
  const strings = types.filter(tsHelpers.isStringType);
1489
1489
  if (strings.length > 0) {
1490
- const evaluated = tsPattern.match(strings).when((types2) => types2.every(tsHelpers.isTruthyStringType), tools.F.constant("truthy string")).when((types2) => types2.every(tsHelpers.isFalsyStringType), tools.F.constant("falsy string")).otherwise(tools.F.constant("string"));
1490
+ const evaluated = tsPattern.match(strings).when((types2) => types2.every(tsHelpers.isTruthyStringType), eff.F.constant("truthy string")).when((types2) => types2.every(tsHelpers.isFalsyStringType), eff.F.constant("falsy string")).otherwise(eff.F.constant("string"));
1491
1491
  variantTypes.add(evaluated);
1492
1492
  }
1493
1493
  const bigints = types.filter(tsHelpers.isBigIntType);
1494
1494
  if (bigints.length > 0) {
1495
- const evaluated = tsPattern.match(bigints).when((types2) => types2.every(tsHelpers.isTruthyBigIntType), tools.F.constant("truthy bigint")).when((types2) => types2.every(tsHelpers.isFalsyBigIntType), tools.F.constant("falsy bigint")).otherwise(tools.F.constant("bigint"));
1495
+ const evaluated = tsPattern.match(bigints).when((types2) => types2.every(tsHelpers.isTruthyBigIntType), eff.F.constant("truthy bigint")).when((types2) => types2.every(tsHelpers.isFalsyBigIntType), eff.F.constant("falsy bigint")).otherwise(eff.F.constant("bigint"));
1496
1496
  variantTypes.add(evaluated);
1497
1497
  }
1498
1498
  const numbers = types.filter(tsHelpers.isNumberType);
1499
1499
  if (numbers.length > 0) {
1500
- const evaluated = tsPattern.match(numbers).when((types2) => types2.every(tsHelpers.isTruthyNumberType), tools.F.constant("truthy number")).when((types2) => types2.every(tsHelpers.isFalsyNumberType), tools.F.constant("falsy number")).otherwise(tools.F.constant("number"));
1500
+ const evaluated = tsPattern.match(numbers).when((types2) => types2.every(tsHelpers.isTruthyNumberType), eff.F.constant("truthy number")).when((types2) => types2.every(tsHelpers.isFalsyNumberType), eff.F.constant("falsy number")).otherwise(eff.F.constant("number"));
1501
1501
  variantTypes.add(evaluated);
1502
1502
  }
1503
1503
  if (types.some(tsHelpers.isEnumType)) {
@@ -1519,13 +1519,13 @@ function isInitExpression(node) {
1519
1519
  }
1520
1520
  function getVariableInitExpression(at) {
1521
1521
  return (variable) => {
1522
- return tools.F.pipe(
1523
- tools.O.some(variable),
1524
- tools.O.flatMapNullable((v) => v.defs.at(at)),
1525
- tools.O.flatMap(
1526
- (d) => "init" in d.node ? tools.O.fromNullable(d.node.init) : tools.O.none()
1522
+ return eff.F.pipe(
1523
+ eff.O.some(variable),
1524
+ eff.O.flatMapNullable((v) => v.defs.at(at)),
1525
+ eff.O.flatMap(
1526
+ (d) => "init" in d.node ? eff.O.fromNullable(d.node.init) : eff.O.none()
1527
1527
  ),
1528
- tools.O.filter(isInitExpression)
1528
+ eff.O.filter(isInitExpression)
1529
1529
  );
1530
1530
  };
1531
1531
  }
@@ -1559,13 +1559,13 @@ var no_leaked_conditional_rendering_default = createRule({
1559
1559
  ];
1560
1560
  const services = utils.ESLintUtils.getParserServices(context, false);
1561
1561
  function getReportDescriptor(node) {
1562
- return tsPattern.match(node).when(AST11__namespace.isJSX, tools.O.none).with({ type: types.AST_NODE_TYPES.LogicalExpression, operator: "&&" }, ({ left, right }) => {
1562
+ return tsPattern.match(node).when(AST11__namespace.isJSX, eff.O.none).with({ type: types.AST_NODE_TYPES.LogicalExpression, operator: "&&" }, ({ left, right }) => {
1563
1563
  const isLeftUnaryNot = tsPattern.isMatching({ type: types.AST_NODE_TYPES.UnaryExpression, operator: "!" }, left);
1564
1564
  if (isLeftUnaryNot) return getReportDescriptor(right);
1565
1565
  const initialScope = context.sourceCode.getScope(left);
1566
- const isLeftNan = tsPattern.isMatching({ type: types.AST_NODE_TYPES.Identifier, name: "NaN" }, left) || tools.O.exists(VAR__namespace.getStaticValue(left, initialScope), (v) => v === "NaN");
1566
+ const isLeftNan = tsPattern.isMatching({ type: types.AST_NODE_TYPES.Identifier, name: "NaN" }, left) || eff.O.exists(VAR__namespace.getStaticValue(left, initialScope), (v) => v === "NaN");
1567
1567
  if (isLeftNan) {
1568
- return tools.O.some({
1568
+ return eff.O.some({
1569
1569
  messageId: "noLeakedConditionalRendering",
1570
1570
  node: left,
1571
1571
  data: { value: context.sourceCode.getText(left) }
@@ -1575,22 +1575,22 @@ var no_leaked_conditional_rendering_default = createRule({
1575
1575
  const leftTypeVariants = inspectVariantTypes(unionTypeParts(leftType));
1576
1576
  const isLeftValid = Array.from(leftTypeVariants.values()).every((type) => allowedVariants.some((allowed) => allowed === type));
1577
1577
  if (isLeftValid) return getReportDescriptor(right);
1578
- return tools.O.some({
1578
+ return eff.O.some({
1579
1579
  messageId: "noLeakedConditionalRendering",
1580
1580
  node: left,
1581
1581
  data: { value: context.sourceCode.getText(left) }
1582
1582
  });
1583
1583
  }).with({ type: types.AST_NODE_TYPES.ConditionalExpression }, ({ alternate, consequent }) => {
1584
- return tools.O.orElse(getReportDescriptor(consequent), () => getReportDescriptor(alternate));
1584
+ return eff.O.orElse(getReportDescriptor(consequent), () => getReportDescriptor(alternate));
1585
1585
  }).with({ type: types.AST_NODE_TYPES.Identifier }, (n) => {
1586
- return tools.F.pipe(
1586
+ return eff.F.pipe(
1587
1587
  VAR__namespace.findVariable(n.name, context.sourceCode.getScope(n)),
1588
- tools.O.flatMap(getVariableInitExpression(0)),
1589
- tools.O.flatMap(getReportDescriptor)
1588
+ eff.O.flatMap(getVariableInitExpression(0)),
1589
+ eff.O.flatMap(getReportDescriptor)
1590
1590
  );
1591
- }).otherwise(tools.O.none);
1591
+ }).otherwise(eff.O.none);
1592
1592
  }
1593
- const ruleFunction = tools.F.flow(getReportDescriptor, tools.O.map(context.report), tools.F.constVoid);
1593
+ const ruleFunction = eff.F.flow(getReportDescriptor, eff.O.map(context.report), eff.F.constVoid);
1594
1594
  return {
1595
1595
  "JSXExpressionContainer > ConditionalExpression": ruleFunction,
1596
1596
  "JSXExpressionContainer > LogicalExpression": ruleFunction
@@ -1624,9 +1624,9 @@ var no_missing_component_display_name_default = createRule({
1624
1624
  const components = ctx.getAllComponents(node);
1625
1625
  for (const { node: node2, displayName, flag } of components.values()) {
1626
1626
  const isMemoOrForwardRef = Boolean(flag & core.ERFunctionComponentFlag.ForwardRef) || Boolean(flag & core.ERFunctionComponentFlag.Memo);
1627
- if (tools.O.isSome(AST11__namespace.getFunctionIdentifier(node2))) continue;
1627
+ if (eff.O.isSome(AST11__namespace.getFunctionIdentifier(node2))) continue;
1628
1628
  if (!isMemoOrForwardRef) continue;
1629
- if (tools.O.isNone(displayName)) {
1629
+ if (eff.O.isNone(displayName)) {
1630
1630
  context.report({
1631
1631
  messageId: "noMissingComponentDisplayName",
1632
1632
  node: node2
@@ -1657,56 +1657,56 @@ var no_missing_key_default = createRule({
1657
1657
  },
1658
1658
  name: RULE_NAME30,
1659
1659
  create(context) {
1660
- const isWithinChildrenToArrayRef = tools.MutRef.make(false);
1660
+ const isWithinChildrenToArrayRef = eff.MutRef.make(false);
1661
1661
  function checkIteratorElement(node) {
1662
1662
  switch (node.type) {
1663
1663
  case types.AST_NODE_TYPES.JSXElement: {
1664
1664
  const initialScope = context.sourceCode.getScope(node);
1665
1665
  if (!JSX8__namespace.hasProp(node.openingElement.attributes, "key", initialScope)) {
1666
- return tools.O.some({
1666
+ return eff.O.some({
1667
1667
  messageId: "noMissingKey",
1668
1668
  node
1669
1669
  });
1670
1670
  }
1671
- return tools.O.none();
1671
+ return eff.O.none();
1672
1672
  }
1673
1673
  case types.AST_NODE_TYPES.JSXFragment: {
1674
- return tools.O.some({
1674
+ return eff.O.some({
1675
1675
  messageId: "noMissingKeyWithFragment",
1676
1676
  node
1677
1677
  });
1678
1678
  }
1679
1679
  default:
1680
- return tools.O.none();
1680
+ return eff.O.none();
1681
1681
  }
1682
1682
  }
1683
1683
  function checkExpression(node) {
1684
1684
  switch (node.type) {
1685
1685
  case types.AST_NODE_TYPES.ConditionalExpression:
1686
- if (!("consequent" in node)) return tools.O.none();
1687
- return tools.O.orElse(checkIteratorElement(node.consequent), () => checkIteratorElement(node.alternate));
1686
+ if (!("consequent" in node)) return eff.O.none();
1687
+ return eff.O.orElse(checkIteratorElement(node.consequent), () => checkIteratorElement(node.alternate));
1688
1688
  case types.AST_NODE_TYPES.JSXElement:
1689
1689
  case types.AST_NODE_TYPES.JSXFragment:
1690
1690
  return checkIteratorElement(node);
1691
1691
  case types.AST_NODE_TYPES.LogicalExpression:
1692
- if (!("left" in node)) return tools.O.none();
1693
- return tools.O.orElse(checkIteratorElement(node.left), () => checkIteratorElement(node.right));
1692
+ if (!("left" in node)) return eff.O.none();
1693
+ return eff.O.orElse(checkIteratorElement(node.left), () => checkIteratorElement(node.right));
1694
1694
  default:
1695
- return tools.O.none();
1695
+ return eff.O.none();
1696
1696
  }
1697
1697
  }
1698
1698
  function checkBlockStatement(node) {
1699
1699
  return AST11__namespace.getNestedReturnStatements(node).reduce((acc, statement) => {
1700
1700
  if (!statement.argument) return acc;
1701
1701
  const maybeDescriptor = checkIteratorElement(statement.argument);
1702
- if (tools.O.isNone(maybeDescriptor)) return acc;
1702
+ if (eff.O.isNone(maybeDescriptor)) return acc;
1703
1703
  const descriptor = maybeDescriptor.value;
1704
1704
  return [...acc, descriptor];
1705
1705
  }, []);
1706
1706
  }
1707
1707
  return {
1708
1708
  ArrayExpression(node) {
1709
- if (tools.MutRef.get(isWithinChildrenToArrayRef)) return;
1709
+ if (eff.MutRef.get(isWithinChildrenToArrayRef)) return;
1710
1710
  const elements = node.elements.filter(AST11__namespace.is(types.AST_NODE_TYPES.JSXElement));
1711
1711
  if (elements.length === 0) return;
1712
1712
  const initialScope = context.sourceCode.getScope(node);
@@ -1720,7 +1720,7 @@ var no_missing_key_default = createRule({
1720
1720
  }
1721
1721
  },
1722
1722
  CallExpression(node) {
1723
- if (core.isChildrenToArrayCall(node, context)) tools.MutRef.set(isWithinChildrenToArrayRef, true);
1723
+ if (core.isChildrenToArrayCall(node, context)) eff.MutRef.set(isWithinChildrenToArrayRef, true);
1724
1724
  const isMapCall = AST11__namespace.isMapCallLoose(node);
1725
1725
  const isArrayFromCall = tsPattern.isMatching({
1726
1726
  type: types.AST_NODE_TYPES.CallExpression,
@@ -1732,7 +1732,7 @@ var no_missing_key_default = createRule({
1732
1732
  }
1733
1733
  }, node);
1734
1734
  if (!isMapCall && !isArrayFromCall) return;
1735
- if (tools.MutRef.get(isWithinChildrenToArrayRef)) return;
1735
+ if (eff.MutRef.get(isWithinChildrenToArrayRef)) return;
1736
1736
  const fn = node.arguments[isMapCall ? 0 : 1];
1737
1737
  if (!AST11__namespace.isOneOf([types.AST_NODE_TYPES.ArrowFunctionExpression, types.AST_NODE_TYPES.FunctionExpression])(fn)) return;
1738
1738
  if (fn.body.type === types.AST_NODE_TYPES.BlockStatement) {
@@ -1741,13 +1741,13 @@ var no_missing_key_default = createRule({
1741
1741
  }
1742
1742
  return;
1743
1743
  }
1744
- tools.O.map(checkExpression(fn.body), context.report);
1744
+ eff.O.map(checkExpression(fn.body), context.report);
1745
1745
  },
1746
1746
  "CallExpression:exit"(node) {
1747
- if (core.isChildrenToArrayCall(node, context)) tools.MutRef.set(isWithinChildrenToArrayRef, false);
1747
+ if (core.isChildrenToArrayCall(node, context)) eff.MutRef.set(isWithinChildrenToArrayRef, false);
1748
1748
  },
1749
1749
  JSXFragment(node) {
1750
- if (tools.MutRef.get(isWithinChildrenToArrayRef)) return;
1750
+ if (eff.MutRef.get(isWithinChildrenToArrayRef)) return;
1751
1751
  if (node.parent.type === types.AST_NODE_TYPES.ArrayExpression) {
1752
1752
  context.report({
1753
1753
  messageId: "noMissingKeyWithFragment",
@@ -1795,10 +1795,10 @@ var no_nested_components_default = createRule({
1795
1795
  };
1796
1796
  for (const { name: componentName, node: component } of functionComponents) {
1797
1797
  if (core.isDirectValueOfRenderPropertyLoose(component)) continue;
1798
- if (tools.O.isNone(componentName)) continue;
1798
+ if (eff.O.isNone(componentName)) continue;
1799
1799
  const name2 = componentName.value;
1800
1800
  const isInsideProperty = component.parent.type === types.AST_NODE_TYPES.Property;
1801
- const isInsideJSXPropValue = component.parent.type === types.AST_NODE_TYPES.JSXAttribute || tools.O.isSome(JSX8__namespace.traverseUpProp(node, (n) => n.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer));
1801
+ const isInsideJSXPropValue = component.parent.type === types.AST_NODE_TYPES.JSXAttribute || eff.O.isSome(JSX8__namespace.traverseUpProp(node, (n) => n.value?.type === types.AST_NODE_TYPES.JSXExpressionContainer));
1802
1802
  if (isInsideJSXPropValue) {
1803
1803
  if (!core.isDeclaredInRenderPropLoose(component)) {
1804
1804
  context.report({
@@ -1822,7 +1822,7 @@ var no_nested_components_default = createRule({
1822
1822
  continue;
1823
1823
  }
1824
1824
  const maybeParentComponent = AST11__namespace.traverseUpGuard(component, isFunctionComponent);
1825
- if (tools.O.isSome(maybeParentComponent) && !core.isDirectValueOfRenderPropertyLoose(maybeParentComponent.value)) {
1825
+ if (eff.O.isSome(maybeParentComponent) && !core.isDirectValueOfRenderPropertyLoose(maybeParentComponent.value)) {
1826
1826
  context.report({
1827
1827
  messageId: isInsideProperty ? "nestedComponentInProps" : "nestedComponent",
1828
1828
  node: component,
@@ -1844,14 +1844,14 @@ var no_nested_components_default = createRule({
1844
1844
  }
1845
1845
  }
1846
1846
  for (const { name: name2, node: component } of classComponents) {
1847
- if (tools.O.isNone(AST11__namespace.traverseUp(component, (node2) => isClassComponent11(node2) || isFunctionComponent(node2)))) {
1847
+ if (eff.O.isNone(AST11__namespace.traverseUp(component, (node2) => isClassComponent11(node2) || isFunctionComponent(node2)))) {
1848
1848
  continue;
1849
1849
  }
1850
1850
  context.report({
1851
1851
  messageId: "nestedComponent",
1852
1852
  node: component,
1853
1853
  data: {
1854
- name: tools.O.getOrElse(() => "unknown")(name2)
1854
+ name: eff.O.getOrElse(() => "unknown")(name2)
1855
1855
  }
1856
1856
  });
1857
1857
  }
@@ -1886,10 +1886,10 @@ var no_prop_types_default = createRule({
1886
1886
  if (object.type !== types.AST_NODE_TYPES.Identifier) return;
1887
1887
  if (property.type !== types.AST_NODE_TYPES.Identifier || property.name !== "propTypes") return;
1888
1888
  if (!core.isComponentName(object.name)) return;
1889
- const isComponent = tools.F.pipe(
1889
+ const isComponent = eff.F.pipe(
1890
1890
  VAR__namespace.findVariable(object.name, context.sourceCode.getScope(node)),
1891
- tools.O.flatMap(VAR__namespace.getVariableNode(0)),
1892
- tools.O.exists((n) => AST11__namespace.isFunction(n) || core.isClassComponent(n))
1891
+ eff.O.flatMap(VAR__namespace.getVariableNode(0)),
1892
+ eff.O.exists((n) => AST11__namespace.isFunction(n) || core.isClassComponent(n))
1893
1893
  );
1894
1894
  if (!isComponent) return;
1895
1895
  context.report({ messageId: "noPropTypes", node: property });
@@ -1939,7 +1939,7 @@ var no_redundant_should_component_update_default = createRule({
1939
1939
  messageId: "noRedundantShouldComponentUpdate",
1940
1940
  node: member,
1941
1941
  data: {
1942
- componentName: tools.O.getOrElse(() => "PureComponent")(name2)
1942
+ componentName: eff.O.getOrElse(() => "PureComponent")(name2)
1943
1943
  }
1944
1944
  });
1945
1945
  }
@@ -1973,26 +1973,26 @@ var no_set_state_in_component_did_mount_default = createRule({
1973
1973
  create(context) {
1974
1974
  if (!context.sourceCode.text.includes("componentDidMount")) return {};
1975
1975
  function getReportDescriptor(node) {
1976
- if (!core.isThisSetState(node)) return tools.O.none();
1976
+ if (!core.isThisSetState(node)) return eff.O.none();
1977
1977
  const maybeParentClass = AST11__namespace.traverseUp(
1978
1978
  node,
1979
1979
  AST11__namespace.isOneOf([types.AST_NODE_TYPES.ClassDeclaration, types.AST_NODE_TYPES.ClassExpression])
1980
1980
  );
1981
- if (tools.O.isNone(maybeParentClass)) return tools.O.none();
1981
+ if (eff.O.isNone(maybeParentClass)) return eff.O.none();
1982
1982
  const parentClass = maybeParentClass.value;
1983
- if (!core.isClassComponent(parentClass)) return tools.O.none();
1983
+ if (!core.isClassComponent(parentClass)) return eff.O.none();
1984
1984
  const maybeParentMethod = AST11__namespace.traverseUp(node, isComponentDidMount);
1985
- if (tools.O.isNone(maybeParentMethod)) return tools.O.none();
1985
+ if (eff.O.isNone(maybeParentMethod)) return eff.O.none();
1986
1986
  const parentMethod = maybeParentMethod.value;
1987
- if (parentMethod.parent !== parentClass.body) return tools.O.none();
1988
- if (context.sourceCode.getScope(node).upper !== context.sourceCode.getScope(parentMethod)) return tools.O.none();
1989
- return tools.O.some({
1987
+ if (parentMethod.parent !== parentClass.body) return eff.O.none();
1988
+ if (context.sourceCode.getScope(node).upper !== context.sourceCode.getScope(parentMethod)) return eff.O.none();
1989
+ return eff.O.some({
1990
1990
  messageId: "noSetStateInComponentDidMount",
1991
1991
  node
1992
1992
  });
1993
1993
  }
1994
1994
  return {
1995
- CallExpression: tools.F.flow(getReportDescriptor, tools.O.map(context.report))
1995
+ CallExpression: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
1996
1996
  };
1997
1997
  },
1998
1998
  defaultOptions: []
@@ -2020,26 +2020,26 @@ var no_set_state_in_component_did_update_default = createRule({
2020
2020
  create(context) {
2021
2021
  if (!context.sourceCode.text.includes("componentDidUpdate")) return {};
2022
2022
  function getReportDescriptor(node) {
2023
- if (!core.isThisSetState(node)) return tools.O.none();
2023
+ if (!core.isThisSetState(node)) return eff.O.none();
2024
2024
  const maybeParentClass = AST11__namespace.traverseUp(
2025
2025
  node,
2026
2026
  AST11__namespace.isOneOf([types.AST_NODE_TYPES.ClassDeclaration, types.AST_NODE_TYPES.ClassExpression])
2027
2027
  );
2028
- if (tools.O.isNone(maybeParentClass)) return tools.O.none();
2028
+ if (eff.O.isNone(maybeParentClass)) return eff.O.none();
2029
2029
  const parentClass = maybeParentClass.value;
2030
- if (!core.isClassComponent(parentClass)) return tools.O.none();
2030
+ if (!core.isClassComponent(parentClass)) return eff.O.none();
2031
2031
  const maybeParentMethod = AST11__namespace.traverseUp(node, isComponentDidUpdate);
2032
- if (tools.O.isNone(maybeParentMethod)) return tools.O.none();
2032
+ if (eff.O.isNone(maybeParentMethod)) return eff.O.none();
2033
2033
  const parentMethod = maybeParentMethod.value;
2034
- if (parentMethod.parent !== parentClass.body) return tools.O.none();
2035
- if (context.sourceCode.getScope(node).upper !== context.sourceCode.getScope(parentMethod)) return tools.O.none();
2036
- return tools.O.some({
2034
+ if (parentMethod.parent !== parentClass.body) return eff.O.none();
2035
+ if (context.sourceCode.getScope(node).upper !== context.sourceCode.getScope(parentMethod)) return eff.O.none();
2036
+ return eff.O.some({
2037
2037
  messageId: "noSetStateInComponentDidUpdate",
2038
2038
  node
2039
2039
  });
2040
2040
  }
2041
2041
  return {
2042
- CallExpression: tools.F.flow(getReportDescriptor, tools.O.map(context.report))
2042
+ CallExpression: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
2043
2043
  };
2044
2044
  },
2045
2045
  defaultOptions: []
@@ -2067,26 +2067,26 @@ var no_set_state_in_component_will_update_default = createRule({
2067
2067
  create(context) {
2068
2068
  if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
2069
2069
  function getReportDescriptor(node) {
2070
- if (!core.isThisSetState(node)) return tools.O.none();
2070
+ if (!core.isThisSetState(node)) return eff.O.none();
2071
2071
  const maybeParentClass = AST11__namespace.traverseUp(
2072
2072
  node,
2073
2073
  AST11__namespace.isOneOf([types.AST_NODE_TYPES.ClassDeclaration, types.AST_NODE_TYPES.ClassExpression])
2074
2074
  );
2075
- if (tools.O.isNone(maybeParentClass)) return tools.O.none();
2075
+ if (eff.O.isNone(maybeParentClass)) return eff.O.none();
2076
2076
  const parentClass = maybeParentClass.value;
2077
- if (!core.isClassComponent(parentClass)) return tools.O.none();
2077
+ if (!core.isClassComponent(parentClass)) return eff.O.none();
2078
2078
  const maybeParentMethod = AST11__namespace.traverseUp(node, isComponentWillUpdate3);
2079
- if (tools.O.isNone(maybeParentMethod)) return tools.O.none();
2079
+ if (eff.O.isNone(maybeParentMethod)) return eff.O.none();
2080
2080
  const parentMethod = maybeParentMethod.value;
2081
- if (parentMethod.parent !== parentClass.body) return tools.O.none();
2082
- if (context.sourceCode.getScope(node).upper !== context.sourceCode.getScope(parentMethod)) return tools.O.none();
2083
- return tools.O.some({
2081
+ if (parentMethod.parent !== parentClass.body) return eff.O.none();
2082
+ if (context.sourceCode.getScope(node).upper !== context.sourceCode.getScope(parentMethod)) return eff.O.none();
2083
+ return eff.O.some({
2084
2084
  messageId: "noSetStateInComponentWillUpdate",
2085
2085
  node
2086
2086
  });
2087
2087
  }
2088
2088
  return {
2089
- CallExpression: tools.F.flow(getReportDescriptor, tools.O.map(context.report))
2089
+ CallExpression: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
2090
2090
  };
2091
2091
  },
2092
2092
  defaultOptions: []
@@ -2096,11 +2096,11 @@ var RULE_FEATURES37 = [
2096
2096
  "CHK"
2097
2097
  ];
2098
2098
  function containsStringLiteral({ value }) {
2099
- return value?.type === types.AST_NODE_TYPES.Literal && tools.isString(value.value);
2099
+ return value?.type === types.AST_NODE_TYPES.Literal && eff.isString(value.value);
2100
2100
  }
2101
2101
  function containsStringExpressionContainer({ value }) {
2102
2102
  if (value?.type !== types.AST_NODE_TYPES.JSXExpressionContainer) return false;
2103
- if (value.expression.type === types.AST_NODE_TYPES.Literal) return tools.isString(value.expression.value);
2103
+ if (value.expression.type === types.AST_NODE_TYPES.Literal) return eff.isString(value.expression.value);
2104
2104
  return value.expression.type === types.AST_NODE_TYPES.TemplateLiteral;
2105
2105
  }
2106
2106
  var no_string_refs_default = createRule({
@@ -2288,19 +2288,19 @@ var no_unstable_context_value_default = createRule({
2288
2288
  const openingElementName = node.name;
2289
2289
  if (openingElementName.type !== types.AST_NODE_TYPES.JSXMemberExpression) return;
2290
2290
  if (openingElementName.property.name !== "Provider") return;
2291
- const maybeJSXValueAttribute = tools.O.fromNullable(
2291
+ const maybeJSXValueAttribute = eff.O.fromNullable(
2292
2292
  node.attributes.find((attribute) => {
2293
2293
  return attribute.type === types.AST_NODE_TYPES.JSXAttribute && attribute.name.name === "value";
2294
2294
  })
2295
2295
  );
2296
- if (tools.O.isNone(maybeJSXValueAttribute) || !("value" in maybeJSXValueAttribute.value)) return;
2296
+ if (eff.O.isNone(maybeJSXValueAttribute) || !("value" in maybeJSXValueAttribute.value)) return;
2297
2297
  const valueNode = maybeJSXValueAttribute.value.value;
2298
2298
  if (valueNode?.type !== types.AST_NODE_TYPES.JSXExpressionContainer) return;
2299
2299
  const valueExpression = valueNode.expression;
2300
2300
  const initialScope = context.sourceCode.getScope(valueExpression);
2301
2301
  const construction = VAR__namespace.inspectConstruction(valueExpression, initialScope);
2302
2302
  if (construction._tag === "None") return;
2303
- tools.O.map(
2303
+ eff.O.map(
2304
2304
  ctx.getCurrentFunction(),
2305
2305
  ([_, currentFn]) => possibleValueConstructions.set(currentFn, [
2306
2306
  ...possibleValueConstructions.get(currentFn) ?? [],
@@ -2388,7 +2388,7 @@ var no_unstable_default_props_default = createRule({
2388
2388
  }
2389
2389
  },
2390
2390
  "VariableDeclarator[id.type='ObjectPattern'][init.type='Identifier']"(node) {
2391
- tools.O.map(
2391
+ eff.O.map(
2392
2392
  ctx.getCurrentFunction(),
2393
2393
  ([_, currentFn]) => possibleDestructuringDeclarators.set(currentFn, [
2394
2394
  ...possibleDestructuringDeclarators.get(currentFn) ?? [],
@@ -2426,15 +2426,15 @@ function getName3(node) {
2426
2426
  return getName3(node.expression);
2427
2427
  }
2428
2428
  if (node.type === types.AST_NODE_TYPES.Identifier || node.type === types.AST_NODE_TYPES.PrivateIdentifier) {
2429
- return tools.O.some(node.name);
2429
+ return eff.O.some(node.name);
2430
2430
  }
2431
2431
  if (node.type === types.AST_NODE_TYPES.Literal) {
2432
- return tools.O.some(String(node.value));
2432
+ return eff.O.some(String(node.value));
2433
2433
  }
2434
2434
  if (node.type === types.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
2435
- return tools.O.fromNullable(node.quasis[0]?.value.raw);
2435
+ return eff.O.fromNullable(node.quasis[0]?.value.raw);
2436
2436
  }
2437
- return tools.O.none();
2437
+ return eff.O.none();
2438
2438
  }
2439
2439
  var no_unused_class_component_members_default = createRule({
2440
2440
  meta: {
@@ -2463,19 +2463,19 @@ var no_unused_class_component_members_default = createRule({
2463
2463
  function classExit() {
2464
2464
  const currentClass = classStack.pop();
2465
2465
  if (!currentClass || !core.isClassComponent(currentClass)) return;
2466
- const className = tools.O.map(AST11__namespace.getClassIdentifier(currentClass), (id) => id.name);
2466
+ const className = eff.O.map(AST11__namespace.getClassIdentifier(currentClass), (id) => id.name);
2467
2467
  const defs = propertyDefs.get(currentClass);
2468
2468
  const usages = propertyUsages.get(currentClass);
2469
2469
  if (!defs) return;
2470
2470
  for (const def of defs) {
2471
2471
  const name2 = getName3(def);
2472
- if (tools.O.isNone(name2)) continue;
2472
+ if (eff.O.isNone(name2)) continue;
2473
2473
  if (usages?.has(name2.value) || LIFECYCLE_METHODS.has(name2.value)) continue;
2474
2474
  context.report({
2475
2475
  messageId: "noUnusedClassComponentMembers",
2476
2476
  node: def,
2477
2477
  data: {
2478
- className: tools.O.getOrElse(className, () => "Component"),
2478
+ className: eff.O.getOrElse(className, () => "Component"),
2479
2479
  methodName: name2.value
2480
2480
  }
2481
2481
  });
@@ -2508,7 +2508,7 @@ var no_unused_class_component_members_default = createRule({
2508
2508
  propertyDefs.get(currentClass)?.add(node.property);
2509
2509
  return;
2510
2510
  }
2511
- tools.O.map(getName3(node.property), (name2) => propertyUsages.get(currentClass)?.add(name2));
2511
+ eff.O.map(getName3(node.property), (name2) => propertyUsages.get(currentClass)?.add(name2));
2512
2512
  },
2513
2513
  MethodDefinition: methodEnter,
2514
2514
  "MethodDefinition:exit": methodExit,
@@ -2522,7 +2522,7 @@ var no_unused_class_component_members_default = createRule({
2522
2522
  if (node.init && AST11__namespace.isThisExpression(node.init) && node.id.type === types.AST_NODE_TYPES.ObjectPattern) {
2523
2523
  for (const prop of node.id.properties) {
2524
2524
  if (prop.type === types.AST_NODE_TYPES.Property && AST11__namespace.isKeyLiteralLike(prop, prop.key)) {
2525
- tools.O.map(getName3(prop.key), (name2) => propertyUsages.get(currentClass)?.add(name2));
2525
+ eff.O.map(getName3(prop.key), (name2) => propertyUsages.get(currentClass)?.add(name2));
2526
2526
  }
2527
2527
  }
2528
2528
  }
@@ -2540,19 +2540,19 @@ function getName4(node) {
2540
2540
  return getName4(node.expression);
2541
2541
  }
2542
2542
  if (node.type === types.AST_NODE_TYPES.Identifier || node.type === types.AST_NODE_TYPES.PrivateIdentifier) {
2543
- return tools.O.some(node.name);
2543
+ return eff.O.some(node.name);
2544
2544
  }
2545
2545
  if (node.type === types.AST_NODE_TYPES.Literal) {
2546
- return tools.O.some(String(node.value));
2546
+ return eff.O.some(String(node.value));
2547
2547
  }
2548
2548
  if (node.type === types.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
2549
- return tools.O.fromNullable(node.quasis[0]?.value.raw);
2549
+ return eff.O.fromNullable(node.quasis[0]?.value.raw);
2550
2550
  }
2551
- return tools.O.none();
2551
+ return eff.O.none();
2552
2552
  }
2553
2553
  function isAssignmentToThisState2(node) {
2554
2554
  const { left } = node;
2555
- return left.type === types.AST_NODE_TYPES.MemberExpression && AST11__namespace.isThisExpression(left.object) && tools.O.exists(getName4(left.property), (name2) => name2 === "state");
2555
+ return left.type === types.AST_NODE_TYPES.MemberExpression && AST11__namespace.isThisExpression(left.object) && eff.O.exists(getName4(left.property), (name2) => name2 === "state");
2556
2556
  }
2557
2557
  var isGetDerivedStateFromProps = tsPattern.isMatching({
2558
2558
  key: {
@@ -2587,14 +2587,14 @@ var no_unused_state_default = createRule({
2587
2587
  function classExit() {
2588
2588
  const currentClass = classStack.pop();
2589
2589
  if (!currentClass || !core.isClassComponent(currentClass)) return;
2590
- const className = tools.O.map(AST11__namespace.getClassIdentifier(currentClass), (id) => id.name);
2591
- const [def, isUsed] = stateDefs.get(currentClass) ?? [tools.O.none(), false];
2592
- if (tools.O.isNone(def) || isUsed) return;
2590
+ const className = eff.O.map(AST11__namespace.getClassIdentifier(currentClass), (id) => id.name);
2591
+ const [def, isUsed] = stateDefs.get(currentClass) ?? [eff.O.none(), false];
2592
+ if (eff.O.isNone(def) || isUsed) return;
2593
2593
  context.report({
2594
2594
  messageId: "noUnusedState",
2595
2595
  node: def.value,
2596
2596
  data: {
2597
- className: tools.O.getOrElse(className, () => "Component")
2597
+ className: eff.O.getOrElse(className, () => "Component")
2598
2598
  }
2599
2599
  });
2600
2600
  }
@@ -2604,13 +2604,13 @@ var no_unused_state_default = createRule({
2604
2604
  if (!currentClass || !core.isClassComponent(currentClass)) return;
2605
2605
  if (node.static) {
2606
2606
  if (isGetDerivedStateFromProps(node) && node.value.params.length > 1) {
2607
- const [def] = stateDefs.get(currentClass) ?? [tools.O.none()];
2607
+ const [def] = stateDefs.get(currentClass) ?? [eff.O.none()];
2608
2608
  stateDefs.set(currentClass, [def, true]);
2609
2609
  }
2610
2610
  return;
2611
2611
  }
2612
- if (tools.O.exists(getName4(node.key), (name2) => name2 === "state")) {
2613
- stateDefs.set(currentClass, [tools.O.some(node.key), false]);
2612
+ if (eff.O.exists(getName4(node.key), (name2) => name2 === "state")) {
2613
+ stateDefs.set(currentClass, [eff.O.some(node.key), false]);
2614
2614
  }
2615
2615
  }
2616
2616
  function methodExit() {
@@ -2629,8 +2629,8 @@ var no_unused_state_default = createRule({
2629
2629
  if (!currentClass || !core.isClassComponent(currentClass)) return;
2630
2630
  const currentConstructor = constructorStack.at(-1);
2631
2631
  if (!currentConstructor || !currentClass.body.body.includes(currentConstructor)) return;
2632
- const [_, isUsed] = stateDefs.get(currentClass) ?? [tools.O.none(), false];
2633
- stateDefs.set(currentClass, [tools.O.some(node.left), isUsed]);
2632
+ const [_, isUsed] = stateDefs.get(currentClass) ?? [eff.O.none(), false];
2633
+ stateDefs.set(currentClass, [eff.O.some(node.left), isUsed]);
2634
2634
  },
2635
2635
  ClassDeclaration: classEnter,
2636
2636
  "ClassDeclaration:exit": classExit,
@@ -2638,14 +2638,14 @@ var no_unused_state_default = createRule({
2638
2638
  "ClassExpression:exit": classExit,
2639
2639
  MemberExpression(node) {
2640
2640
  if (!AST11__namespace.isThisExpression(node.object)) return;
2641
- if (!tools.O.exists(getName4(node.property), (name2) => name2 === "state")) return;
2641
+ if (!eff.O.exists(getName4(node.property), (name2) => name2 === "state")) return;
2642
2642
  const currentClass = classStack.at(-1);
2643
2643
  if (!currentClass || !core.isClassComponent(currentClass)) return;
2644
2644
  const currentMethod = methodStack.at(-1);
2645
2645
  if (!currentMethod || currentMethod.static) return;
2646
2646
  if (currentMethod === constructorStack.at(-1)) return;
2647
2647
  if (!currentClass.body.body.includes(currentMethod)) return;
2648
- const [def] = stateDefs.get(currentClass) ?? [tools.O.none(), false];
2648
+ const [def] = stateDefs.get(currentClass) ?? [eff.O.none(), false];
2649
2649
  stateDefs.set(currentClass, [def, true]);
2650
2650
  },
2651
2651
  MethodDefinition: methodEnter,
@@ -2664,12 +2664,12 @@ var no_unused_state_default = createRule({
2664
2664
  if (!(node.init && AST11__namespace.isThisExpression(node.init) && node.id.type === types.AST_NODE_TYPES.ObjectPattern)) return;
2665
2665
  const hasState = node.id.properties.some((prop) => {
2666
2666
  if (prop.type === types.AST_NODE_TYPES.Property && AST11__namespace.isKeyLiteralLike(prop, prop.key)) {
2667
- return tools.O.exists(getName4(prop.key), (name2) => name2 === "state");
2667
+ return eff.O.exists(getName4(prop.key), (name2) => name2 === "state");
2668
2668
  }
2669
2669
  return false;
2670
2670
  });
2671
2671
  if (!hasState) return;
2672
- const [def] = stateDefs.get(currentClass) ?? [tools.O.none(), false];
2672
+ const [def] = stateDefs.get(currentClass) ?? [eff.O.none(), false];
2673
2673
  stateDefs.set(currentClass, [def, true]);
2674
2674
  }
2675
2675
  };
@@ -2697,9 +2697,13 @@ function check(node, context, allowExpressions) {
2697
2697
  if (tsPattern.isMatching({ type: types.AST_NODE_TYPES.JSXExpressionContainer, expression: tsPattern.P.not(types.AST_NODE_TYPES.CallExpression) }, first)) return;
2698
2698
  context.report({ messageId: "noUselessFragment", node });
2699
2699
  }
2700
+ var defaultOptions = [{
2701
+ allowExpressions: true
2702
+ }];
2700
2703
  var no_useless_fragment_default = createRule({
2701
2704
  meta: {
2702
2705
  type: "problem",
2706
+ defaultOptions: [...defaultOptions],
2703
2707
  docs: {
2704
2708
  description: "disallow unnecessary fragments"
2705
2709
  },
@@ -2731,9 +2735,7 @@ var no_useless_fragment_default = createRule({
2731
2735
  }
2732
2736
  };
2733
2737
  },
2734
- defaultOptions: [{
2735
- allowExpressions: true
2736
- }]
2738
+ defaultOptions
2737
2739
  });
2738
2740
  var RULE_NAME46 = "prefer-destructuring-assignment";
2739
2741
  var RULE_FEATURES45 = [
@@ -2771,7 +2773,7 @@ var prefer_destructuring_assignment_default = createRule({
2771
2773
  function isFunctionComponent(block) {
2772
2774
  if (!AST11__namespace.isFunction(block)) return false;
2773
2775
  const maybeId = AST11__namespace.getFunctionIdentifier(block);
2774
- return tools.O.isSome(maybeId) && core.isComponentName(maybeId.value.name) && components.some((component) => component.node === block);
2776
+ return eff.O.isSome(maybeId) && core.isComponentName(maybeId.value.name) && components.some((component) => component.node === block);
2775
2777
  }
2776
2778
  for (const [initialScope, memberExpression] of memberExpressionWithNames) {
2777
2779
  let scope = initialScope;
@@ -2932,8 +2934,8 @@ var prefer_shorthand_boolean_default = createRule({
2932
2934
  const { value } = node;
2933
2935
  const propName = JSX8__namespace.getPropName(node);
2934
2936
  const hasValueTrue = value?.type === types.AST_NODE_TYPES.JSXExpressionContainer && value.expression.type === types.AST_NODE_TYPES.Literal && value.expression.value === true;
2935
- if (!hasValueTrue) return tools.O.none();
2936
- return tools.O.some({
2937
+ if (!hasValueTrue) return eff.O.none();
2938
+ return eff.O.some({
2937
2939
  messageId: "preferShorthandBoolean",
2938
2940
  node,
2939
2941
  data: {
@@ -2943,7 +2945,7 @@ var prefer_shorthand_boolean_default = createRule({
2943
2945
  });
2944
2946
  }
2945
2947
  return {
2946
- JSXAttribute: tools.F.flow(getReportDescriptor, tools.O.map(context.report))
2948
+ JSXAttribute: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
2947
2949
  };
2948
2950
  },
2949
2951
  defaultOptions: []
@@ -2967,16 +2969,16 @@ var prefer_shorthand_fragment_default = createRule({
2967
2969
  name: RULE_NAME50,
2968
2970
  create(context) {
2969
2971
  function getReportDescriptor(node) {
2970
- if (!core.isFragmentElement(node, context)) return tools.O.none();
2972
+ if (!core.isFragmentElement(node, context)) return eff.O.none();
2971
2973
  const hasAttributes = node.openingElement.attributes.length > 0;
2972
- if (hasAttributes) return tools.O.none();
2973
- return tools.O.some({
2974
+ if (hasAttributes) return eff.O.none();
2975
+ return eff.O.some({
2974
2976
  messageId: "preferShorthandFragment",
2975
2977
  node
2976
2978
  });
2977
2979
  }
2978
2980
  return {
2979
- JSXElement: tools.F.flow(getReportDescriptor, tools.O.map(context.report))
2981
+ JSXElement: eff.F.flow(getReportDescriptor, eff.O.map(context.report))
2980
2982
  };
2981
2983
  },
2982
2984
  defaultOptions: []
package/dist/index.mjs CHANGED
@@ -1,5 +1,5 @@
1
+ import { F, O, isString, MutRef, isNullable } from '@eslint-react/eff';
1
2
  import * as JSX8 from '@eslint-react/jsx';
2
- import { F, O, isString, MutRef, isNullable } from '@eslint-react/tools';
3
3
  import { createRuleForPlugin, normalizeSettings, decodeSettings, unsafeReadSettings } from '@eslint-react/shared';
4
4
  import * as AST11 from '@eslint-react/ast';
5
5
  import { isForwardRefCall, isThisSetState, isClassComponent, isChildrenCount, isChildrenForEach, isChildrenMap, isChildrenOnly, isChildrenToArray, useComponentCollectorLegacy, isCloneElementCall, isCreateRefCall, isComponentName, isChildrenToArrayCall, useComponentCollector, ERFunctionComponentFlag, ERComponentHint, isDirectValueOfRenderPropertyLoose, isDeclaredInRenderPropLoose, isInsideCreateElementProps, isInsideRenderMethod, ERClassComponentFlag, isFragmentElement, isCreateElementCall, isInitializedFromReact } from '@eslint-react/core';
@@ -14,7 +14,7 @@ import { getTypeImmutability, isUnknown, isImmutable, isReadonlyShallow, isReado
14
14
 
15
15
  // package.json
16
16
  var name = "eslint-plugin-react-x";
17
- var version = "1.20.2-beta.1";
17
+ var version = "1.20.2-beta.3";
18
18
  var createRule = createRuleForPlugin("x");
19
19
 
20
20
  // src/rules/avoid-shorthand-boolean.ts
@@ -2670,9 +2670,13 @@ function check(node, context, allowExpressions) {
2670
2670
  if (isMatching({ type: AST_NODE_TYPES.JSXExpressionContainer, expression: P.not(AST_NODE_TYPES.CallExpression) }, first)) return;
2671
2671
  context.report({ messageId: "noUselessFragment", node });
2672
2672
  }
2673
+ var defaultOptions = [{
2674
+ allowExpressions: true
2675
+ }];
2673
2676
  var no_useless_fragment_default = createRule({
2674
2677
  meta: {
2675
2678
  type: "problem",
2679
+ defaultOptions: [...defaultOptions],
2676
2680
  docs: {
2677
2681
  description: "disallow unnecessary fragments"
2678
2682
  },
@@ -2704,9 +2708,7 @@ var no_useless_fragment_default = createRule({
2704
2708
  }
2705
2709
  };
2706
2710
  },
2707
- defaultOptions: [{
2708
- allowExpressions: true
2709
- }]
2711
+ defaultOptions
2710
2712
  });
2711
2713
  var RULE_NAME46 = "prefer-destructuring-assignment";
2712
2714
  var RULE_FEATURES45 = [
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "eslint-plugin-react-x",
3
- "version": "1.20.2-beta.1",
3
+ "version": "1.20.2-beta.3",
4
4
  "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
5
5
  "keywords": [
6
6
  "react",
@@ -49,16 +49,16 @@
49
49
  "compare-versions": "^6.1.1",
50
50
  "is-immutable-type": "^5.0.0",
51
51
  "ts-pattern": "^5.6.0",
52
- "@eslint-react/ast": "1.20.2-beta.1",
53
- "@eslint-react/jsx": "1.20.2-beta.1",
54
- "@eslint-react/shared": "1.20.2-beta.1",
55
- "@eslint-react/core": "1.20.2-beta.1",
56
- "@eslint-react/tools": "1.20.2-beta.1",
57
- "@eslint-react/types": "1.20.2-beta.1",
58
- "@eslint-react/var": "1.20.2-beta.1"
52
+ "@eslint-react/ast": "1.20.2-beta.3",
53
+ "@eslint-react/core": "1.20.2-beta.3",
54
+ "@eslint-react/eff": "1.20.2-beta.3",
55
+ "@eslint-react/jsx": "1.20.2-beta.3",
56
+ "@eslint-react/shared": "1.20.2-beta.3",
57
+ "@eslint-react/types": "1.20.2-beta.3",
58
+ "@eslint-react/var": "1.20.2-beta.3"
59
59
  },
60
60
  "devDependencies": {
61
- "@types/react": "^19.0.1",
61
+ "@types/react": "^19.0.2",
62
62
  "@types/react-dom": "^19.0.2",
63
63
  "string-ts": "^2.2.0",
64
64
  "ts-api-utils": "^2.0.0",