eslint-plugin-react-hooks-extra 1.5.18 → 1.5.19-beta.1

package/dist/index.mjs

@@ -1,13 +1,17 @@
 import { useHookCollector, isReactHookCall, isUseCallbackCall, isReactHookCallWithNameLoose, isUseMemoCall, isUseStateCall } from '@eslint-react/core';
-import { createRuleForPlugin, ESLintSettingsSchema } from '@eslint-react/shared';
+import { createRuleForPlugin, getESLintReactSettings } from '@eslint-react/shared';
 import { NodeType, is, getNestedCallExpressions } from '@eslint-react/ast';
 import { findVariable, getVariableInit } from '@eslint-react/var';
-import { Function, Option } from 'effect';
-import { parse } from 'valibot';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all2) => {
+  for (var name2 in all2)
+    __defProp(target, name2, { get: all2[name2], enumerable: true });
+};
 
 // package.json
 var name = "eslint-plugin-react-hooks-extra";
-var version = "1.5.18";
+var version = "1.5.19-beta.1";
 var createRule = createRuleForPlugin("hooks-extra");
 
 // src/rules/ensure-custom-hooks-using-other-hooks.ts
@@ -47,6 +51,944 @@ var ensure_custom_hooks_using_other_hooks_default = createRule({
   defaultOptions: []
 });
 
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Function.js
+var Function_exports = {};
+__export(Function_exports, {
+  SK: () => SK,
+  absurd: () => absurd,
+  apply: () => apply,
+  compose: () => compose,
+  constFalse: () => constFalse,
+  constNull: () => constNull,
+  constTrue: () => constTrue,
+  constUndefined: () => constUndefined,
+  constVoid: () => constVoid,
+  constant: () => constant,
+  dual: () => dual,
+  flip: () => flip,
+  flow: () => flow,
+  hole: () => hole,
+  identity: () => identity,
+  isFunction: () => isFunction,
+  pipe: () => pipe,
+  satisfies: () => satisfies,
+  tupled: () => tupled,
+  unsafeCoerce: () => unsafeCoerce,
+  untupled: () => untupled
+});
+var isFunction = (input) => typeof input === "function";
+var dual = function(arity, body) {
+  if (typeof arity === "function") {
+    return function() {
+      if (arity(arguments)) {
+        return body.apply(this, arguments);
+      }
+      return (self) => body(self, ...arguments);
+    };
+  }
+  switch (arity) {
+    case 0:
+    case 1:
+      throw new RangeError(`Invalid arity ${arity}`);
+    case 2:
+      return function(a, b2) {
+        if (arguments.length >= 2) {
+          return body(a, b2);
+        }
+        return function(self) {
+          return body(self, a);
+        };
+      };
+    case 3:
+      return function(a, b2, c2) {
+        if (arguments.length >= 3) {
+          return body(a, b2, c2);
+        }
+        return function(self) {
+          return body(self, a, b2);
+        };
+      };
+    case 4:
+      return function(a, b2, c2, d2) {
+        if (arguments.length >= 4) {
+          return body(a, b2, c2, d2);
+        }
+        return function(self) {
+          return body(self, a, b2, c2);
+        };
+      };
+    case 5:
+      return function(a, b2, c2, d2, e2) {
+        if (arguments.length >= 5) {
+          return body(a, b2, c2, d2, e2);
+        }
+        return function(self) {
+          return body(self, a, b2, c2, d2);
+        };
+      };
+    default:
+      return function() {
+        if (arguments.length >= arity) {
+          return body.apply(this, arguments);
+        }
+        const args = arguments;
+        return function(self) {
+          return body(self, ...args);
+        };
+      };
+  }
+};
+var apply = (a) => (self) => self(a);
+var identity = (a) => a;
+var satisfies = () => (b2) => b2;
+var unsafeCoerce = identity;
+var constant = (value) => () => value;
+var constTrue = /* @__PURE__ */ constant(true);
+var constFalse = /* @__PURE__ */ constant(false);
+var constNull = /* @__PURE__ */ constant(null);
+var constUndefined = /* @__PURE__ */ constant(void 0);
+var constVoid = constUndefined;
+var flip = (f) => (...b2) => (...a) => f(...a)(...b2);
+var compose = /* @__PURE__ */ dual(2, (ab, bc) => (a) => bc(ab(a)));
+var absurd = (_2) => {
+  throw new Error("Called `absurd` function which should be uncallable");
+};
+var tupled = (f) => (a) => f(...a);
+var untupled = (f) => (...a) => f(a);
+function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
+  switch (arguments.length) {
+    case 1:
+      return a;
+    case 2:
+      return ab(a);
+    case 3:
+      return bc(ab(a));
+    case 4:
+      return cd(bc(ab(a)));
+    case 5:
+      return de(cd(bc(ab(a))));
+    case 6:
+      return ef(de(cd(bc(ab(a)))));
+    case 7:
+      return fg(ef(de(cd(bc(ab(a))))));
+    case 8:
+      return gh(fg(ef(de(cd(bc(ab(a)))))));
+    case 9:
+      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+    default: {
+      let ret = arguments[0];
+      for (let i2 = 1; i2 < arguments.length; i2++) {
+        ret = arguments[i2](ret);
+      }
+      return ret;
+    }
+  }
+}
+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)))))))));
+      };
+  }
+  return;
+}
+var hole = /* @__PURE__ */ unsafeCoerce(absurd);
+var SK = (_2, b2) => b2;
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Equivalence.js
+var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/internal/doNotation.js
+var let_ = (map2) => dual(3, (self, name2, f) => map2(self, (a) => Object.assign({}, a, {
+  [name2]: f(a)
+})));
+var bindTo = (map2) => dual(2, (self, name2) => map2(self, (a) => ({
+  [name2]: a
+})));
+var bind = (map2, flatMap2) => dual(3, (self, name2, f) => flatMap2(self, (a) => map2(f(a), (b2) => Object.assign({}, a, {
+  [name2]: b2
+}))));
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.4.5";
+var getCurrentVersion = () => moduleVersion;
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/GlobalValue.js
+var globalStoreId = /* @__PURE__ */ Symbol.for(`effect/GlobalValue/globalStoreId/${/* @__PURE__ */ getCurrentVersion()}`);
+if (!(globalStoreId in globalThis)) {
+  globalThis[globalStoreId] = /* @__PURE__ */ new Map();
+}
+var globalStore = globalThis[globalStoreId];
+var globalValue = (id, compute) => {
+  if (!globalStore.has(id)) {
+    globalStore.set(id, compute());
+  }
+  return globalStore.get(id);
+};
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Predicate.js
+var isFunction2 = isFunction;
+var isRecordOrArray = (input) => typeof input === "object" && input !== null;
+var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
+var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/internal/errors.js
+var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Utils.js
+var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
+var isGenKind = (u2) => isObject(u2) && GenKindTypeId in u2;
+var GenKindImpl = class {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _F() {
+    return identity;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _R() {
+    return (_2) => _2;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _O() {
+    return (_2) => _2;
+  }
+  /**
+   * @since 2.0.0
+   */
+  get _E() {
+    return (_2) => _2;
+  }
+  /**
+   * @since 2.0.0
+   */
+  [GenKindTypeId] = GenKindTypeId;
+  /**
+   * @since 2.0.0
+   */
+  [Symbol.iterator]() {
+    return new SingleShotGen(this);
+  }
+};
+var SingleShotGen = class _SingleShotGen {
+  self;
+  called = false;
+  constructor(self) {
+    this.self = self;
+  }
+  /**
+   * @since 2.0.0
+   */
+  next(a) {
+    return this.called ? {
+      value: a,
+      done: true
+    } : (this.called = true, {
+      value: this.self,
+      done: false
+    });
+  }
+  /**
+   * @since 2.0.0
+   */
+  return(a) {
+    return {
+      value: a,
+      done: true
+    };
+  }
+  /**
+   * @since 2.0.0
+   */
+  throw(e2) {
+    throw e2;
+  }
+  /**
+   * @since 2.0.0
+   */
+  [Symbol.iterator]() {
+    return new _SingleShotGen(this.self);
+  }
+};
+var adapter = () => function() {
+  let x2 = arguments[0];
+  for (let i2 = 1; i2 < arguments.length; i2++) {
+    x2 = arguments[i2](x2);
+  }
+  return new GenKindImpl(x2);
+};
+var YieldWrapTypeId = /* @__PURE__ */ Symbol.for("effect/Utils/YieldWrap");
+var YieldWrap = class {
+  /**
+   * @since 3.0.6
+   */
+  #value;
+  constructor(value) {
+    this.#value = value;
+  }
+  /**
+   * @since 3.0.6
+   */
+  [YieldWrapTypeId]() {
+    return this.#value;
+  }
+};
+function yieldWrapGet(self) {
+  if (typeof self === "object" && self !== null && YieldWrapTypeId in self) {
+    return self[YieldWrapTypeId]();
+  }
+  throw new Error(getBugErrorMessage("yieldWrapGet"));
+}
+var structuralRegionState = /* @__PURE__ */ globalValue("effect/Utils/isStructuralRegion", () => ({
+  enabled: false,
+  tester: void 0
+}));
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Hash.js
+var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
+var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
+var hash = (self) => {
+  if (structuralRegionState.enabled === true) {
+    return 0;
+  }
+  switch (typeof self) {
+    case "number":
+      return number(self);
+    case "bigint":
+      return string(self.toString(10));
+    case "boolean":
+      return string(String(self));
+    case "symbol":
+      return string(String(self));
+    case "string":
+      return string(self);
+    case "undefined":
+      return string("undefined");
+    case "function":
+    case "object": {
+      if (self === null) {
+        return string("null");
+      } else if (self instanceof Date) {
+        return hash(self.toISOString());
+      } else if (isHash(self)) {
+        return self[symbol]();
+      } else {
+        return random(self);
+      }
+    }
+    default:
+      throw new Error(`BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`);
+  }
+};
+var random = (self) => {
+  if (!randomHashCache.has(self)) {
+    randomHashCache.set(self, number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));
+  }
+  return randomHashCache.get(self);
+};
+var combine = (b2) => (self) => self * 53 ^ b2;
+var optimize = (n2) => n2 & 3221225471 | n2 >>> 1 & 1073741824;
+var isHash = (u2) => hasProperty(u2, symbol);
+var number = (n2) => {
+  if (n2 !== n2 || n2 === Infinity) {
+    return 0;
+  }
+  let h = n2 | 0;
+  if (h !== n2) {
+    h ^= n2 * 4294967295;
+  }
+  while (n2 > 4294967295) {
+    h ^= n2 /= 4294967295;
+  }
+  return optimize(n2);
+};
+var string = (str) => {
+  let h = 5381, i2 = str.length;
+  while (i2) {
+    h = h * 33 ^ str.charCodeAt(--i2);
+  }
+  return optimize(h);
+};
+var cached = function() {
+  if (arguments.length === 1) {
+    const self2 = arguments[0];
+    return function(hash3) {
+      Object.defineProperty(self2, symbol, {
+        value() {
+          return hash3;
+        },
+        enumerable: false
+      });
+      return hash3;
+    };
+  }
+  const self = arguments[0];
+  const hash2 = arguments[1];
+  Object.defineProperty(self, symbol, {
+    value() {
+      return hash2;
+    },
+    enumerable: false
+  });
+  return hash2;
+};
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Equal.js
+var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
+function equals() {
+  if (arguments.length === 1) {
+    return (self) => compareBoth(self, arguments[0]);
+  }
+  return compareBoth(arguments[0], arguments[1]);
+}
+function compareBoth(self, that) {
+  if (self === that) {
+    return true;
+  }
+  const selfType = typeof self;
+  if (selfType !== typeof that) {
+    return false;
+  }
+  if (selfType === "object" || selfType === "function") {
+    if (self !== null && that !== null) {
+      if (isEqual(self) && isEqual(that)) {
+        if (hash(self) === hash(that) && self[symbol2](that)) {
+          return true;
+        } else {
+          return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+        }
+      } else if (self instanceof Date && that instanceof Date) {
+        return self.toISOString() === that.toISOString();
+      }
+    }
+    if (structuralRegionState.enabled) {
+      if (Array.isArray(self) && Array.isArray(that)) {
+        return self.length === that.length && self.every((v2, i2) => compareBoth(v2, that[i2]));
+      }
+      if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(self) === Object.prototype) {
+        const keysSelf = Object.keys(self);
+        const keysThat = Object.keys(that);
+        if (keysSelf.length === keysThat.length) {
+          for (const key of keysSelf) {
+            if (!(key in that && compareBoth(self[key], that[key]))) {
+              return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+            }
+          }
+          return true;
+        }
+      }
+      return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+    }
+  }
+  return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
+}
+var isEqual = (u2) => hasProperty(u2, symbol2);
+var equivalence = () => equals;
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Inspectable.js
+var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var toJSON = (x2) => {
+  if (hasProperty(x2, "toJSON") && isFunction2(x2["toJSON"]) && x2["toJSON"].length === 0) {
+    return x2.toJSON();
+  } else if (Array.isArray(x2)) {
+    return x2.map(toJSON);
+  }
+  return x2;
+};
+var format = (x2) => JSON.stringify(x2, null, 2);
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Pipeable.js
+var pipeArguments = (self, args) => {
+  switch (args.length) {
+    case 1:
+      return args[0](self);
+    case 2:
+      return args[1](args[0](self));
+    case 3:
+      return args[2](args[1](args[0](self)));
+    case 4:
+      return args[3](args[2](args[1](args[0](self))));
+    case 5:
+      return args[4](args[3](args[2](args[1](args[0](self)))));
+    case 6:
+      return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
+    case 7:
+      return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
+    case 8:
+      return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
+    case 9:
+      return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
+    default: {
+      let ret = self;
+      for (let i2 = 0, len = args.length; i2 < len; i2++) {
+        ret = args[i2](ret);
+      }
+      return ret;
+    }
+  }
+};
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/internal/effectable.js
+var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
+var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
+var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
+var ChannelTypeId = /* @__PURE__ */ Symbol.for("effect/Channel");
+var effectVariance = {
+  /* c8 ignore next */
+  _R: (_2) => _2,
+  /* c8 ignore next */
+  _E: (_2) => _2,
+  /* c8 ignore next */
+  _A: (_2) => _2,
+  _V: /* @__PURE__ */ getCurrentVersion()
+};
+var sinkVariance = {
+  /* c8 ignore next */
+  _A: (_2) => _2,
+  /* c8 ignore next */
+  _In: (_2) => _2,
+  /* c8 ignore next */
+  _L: (_2) => _2,
+  /* c8 ignore next */
+  _E: (_2) => _2,
+  /* c8 ignore next */
+  _R: (_2) => _2
+};
+var channelVariance = {
+  /* c8 ignore next */
+  _Env: (_2) => _2,
+  /* c8 ignore next */
+  _InErr: (_2) => _2,
+  /* c8 ignore next */
+  _InElem: (_2) => _2,
+  /* c8 ignore next */
+  _InDone: (_2) => _2,
+  /* c8 ignore next */
+  _OutErr: (_2) => _2,
+  /* c8 ignore next */
+  _OutElem: (_2) => _2,
+  /* c8 ignore next */
+  _OutDone: (_2) => _2
+};
+var EffectPrototype = {
+  [EffectTypeId]: effectVariance,
+  [StreamTypeId]: effectVariance,
+  [SinkTypeId]: sinkVariance,
+  [ChannelTypeId]: channelVariance,
+  [symbol2](that) {
+    return this === that;
+  },
+  [symbol]() {
+    return cached(this, random(this));
+  },
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/internal/option.js
+var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
+var CommonProto = {
+  ...EffectPrototype,
+  [TypeId]: {
+    _A: (_2) => _2
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return format(this.toJSON());
+  }
+};
+var SomeProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
+  _tag: "Some",
+  _op: "Some",
+  [symbol2](that) {
+    return isOption(that) && isSome(that) && equals(this.value, that.value);
+  },
+  [symbol]() {
+    return cached(this, combine(hash(this._tag))(hash(this.value)));
+  },
+  toJSON() {
+    return {
+      _id: "Option",
+      _tag: this._tag,
+      value: toJSON(this.value)
+    };
+  }
+});
+var NoneHash = /* @__PURE__ */ hash("None");
+var NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
+  _tag: "None",
+  _op: "None",
+  [symbol2](that) {
+    return isOption(that) && isNone(that);
+  },
+  [symbol]() {
+    return NoneHash;
+  },
+  toJSON() {
+    return {
+      _id: "Option",
+      _tag: this._tag
+    };
+  }
+});
+var isOption = (input) => hasProperty(input, TypeId);
+var isNone = (fa) => fa._tag === "None";
+var isSome = (fa) => fa._tag === "Some";
+var none = /* @__PURE__ */ Object.create(NoneProto);
+var some = (value) => {
+  const a = Object.create(SomeProto);
+  a.value = value;
+  return a;
+};
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/internal/either.js
+var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
+var CommonProto2 = {
+  ...EffectPrototype,
+  [TypeId2]: {
+    _R: (_2) => _2
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  toString() {
+    return format(this.toJSON());
+  }
+};
+var RightProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Right",
+  _op: "Right",
+  [symbol2](that) {
+    return isEither(that) && isRight(that) && equals(this.right, that.right);
+  },
+  [symbol]() {
+    return combine(hash(this._tag))(hash(this.right));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      right: toJSON(this.right)
+    };
+  }
+});
+var LeftProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
+  _tag: "Left",
+  _op: "Left",
+  [symbol2](that) {
+    return isEither(that) && isLeft(that) && equals(this.left, that.left);
+  },
+  [symbol]() {
+    return combine(hash(this._tag))(hash(this.left));
+  },
+  toJSON() {
+    return {
+      _id: "Either",
+      _tag: this._tag,
+      left: toJSON(this.left)
+    };
+  }
+});
+var isEither = (input) => hasProperty(input, TypeId2);
+var isLeft = (ma) => ma._tag === "Left";
+var isRight = (ma) => ma._tag === "Right";
+var left = (left2) => {
+  const a = Object.create(LeftProto);
+  a.left = left2;
+  return a;
+};
+var right = (right2) => {
+  const a = Object.create(RightProto);
+  a.right = right2;
+  return a;
+};
+var getLeft = (self) => isRight(self) ? none : some(self.left);
+var getRight = (self) => isLeft(self) ? none : some(self.right);
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Option.js
+var Option_exports = {};
+__export(Option_exports, {
+  Do: () => Do,
+  TypeId: () => TypeId3,
+  all: () => all,
+  andThen: () => andThen,
+  ap: () => ap,
+  as: () => as,
+  asVoid: () => asVoid,
+  bind: () => bind2,
+  bindTo: () => bindTo2,
+  composeK: () => composeK,
+  contains: () => contains,
+  containsWith: () => containsWith,
+  exists: () => exists,
+  filter: () => filter,
+  filterMap: () => filterMap,
+  firstSomeOf: () => firstSomeOf,
+  flatMap: () => flatMap,
+  flatMapNullable: () => flatMapNullable,
+  flatten: () => flatten,
+  fromIterable: () => fromIterable,
+  fromNullable: () => fromNullable,
+  gen: () => gen,
+  getEquivalence: () => getEquivalence,
+  getLeft: () => getLeft2,
+  getOrElse: () => getOrElse,
+  getOrNull: () => getOrNull,
+  getOrThrow: () => getOrThrow,
+  getOrThrowWith: () => getOrThrowWith,
+  getOrUndefined: () => getOrUndefined,
+  getOrder: () => getOrder,
+  getRight: () => getRight2,
+  isNone: () => isNone2,
+  isOption: () => isOption2,
+  isSome: () => isSome2,
+  let: () => let_2,
+  lift2: () => lift2,
+  liftNullable: () => liftNullable,
+  liftPredicate: () => liftPredicate,
+  liftThrowable: () => liftThrowable,
+  map: () => map,
+  match: () => match,
+  none: () => none2,
+  orElse: () => orElse,
+  orElseEither: () => orElseEither,
+  orElseSome: () => orElseSome,
+  partitionMap: () => partitionMap,
+  product: () => product,
+  productMany: () => productMany,
+  reduceCompact: () => reduceCompact,
+  some: () => some2,
+  tap: () => tap,
+  toArray: () => toArray,
+  toRefinement: () => toRefinement,
+  void: () => void_,
+  zipLeft: () => zipLeft,
+  zipRight: () => zipRight,
+  zipWith: () => zipWith
+});
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Order.js
+var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
+
+// ../../../node_modules/.pnpm/effect@3.4.5/node_modules/effect/dist/esm/Option.js
+var TypeId3 = /* @__PURE__ */ Symbol.for("effect/Option");
+var none2 = () => none;
+var some2 = some;
+var isOption2 = isOption;
+var isNone2 = isNone;
+var isSome2 = isSome;
+var match = /* @__PURE__ */ dual(2, (self, {
+  onNone,
+  onSome
+}) => isNone2(self) ? onNone() : onSome(self.value));
+var toRefinement = (f) => (a) => isSome2(f(a));
+var fromIterable = (collection) => {
+  for (const a of collection) {
+    return some2(a);
+  }
+  return none2();
+};
+var getRight2 = getRight;
+var getLeft2 = getLeft;
+var getOrElse = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
+var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
+var orElseSome = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? some2(onNone()) : self);
+var orElseEither = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? map(that(), right) : map(self, left));
+var firstSomeOf = (collection) => {
+  let out = none2();
+  for (out of collection) {
+    if (isSome2(out)) {
+      return out;
+    }
+  }
+  return out;
+};
+var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
+var liftNullable = (f) => (...a) => fromNullable(f(...a));
+var getOrNull = /* @__PURE__ */ getOrElse(constNull);
+var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
+var liftThrowable = (f) => (...a) => {
+  try {
+    return some2(f(...a));
+  } catch (e2) {
+    return none2();
+  }
+};
+var getOrThrowWith = /* @__PURE__ */ dual(2, (self, onNone) => {
+  if (isSome2(self)) {
+    return self.value;
+  }
+  throw onNone();
+});
+var getOrThrow = /* @__PURE__ */ getOrThrowWith(() => new Error("getOrThrow called on a None"));
+var map = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
+var as = /* @__PURE__ */ dual(2, (self, b2) => map(self, () => b2));
+var asVoid = /* @__PURE__ */ as(void 0);
+var void_ = /* @__PURE__ */ some2(void 0);
+var flatMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
+var andThen = /* @__PURE__ */ dual(2, (self, f) => flatMap(self, (a) => {
+  const b2 = isFunction(f) ? f(a) : f;
+  return isOption2(b2) ? b2 : some2(b2);
+}));
+var flatMapNullable = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : fromNullable(f(self.value)));
+var flatten = /* @__PURE__ */ flatMap(identity);
+var zipRight = /* @__PURE__ */ dual(2, (self, that) => flatMap(self, () => that));
+var composeK = /* @__PURE__ */ dual(2, (afb, bfc) => (a) => flatMap(afb(a), bfc));
+var zipLeft = /* @__PURE__ */ dual(2, (self, that) => tap(self, () => that));
+var tap = /* @__PURE__ */ dual(2, (self, f) => flatMap(self, (a) => map(f(a), () => a)));
+var product = (self, that) => isSome2(self) && isSome2(that) ? some2([self.value, that.value]) : none2();
+var productMany = (self, collection) => {
+  if (isNone2(self)) {
+    return none2();
+  }
+  const out = [self.value];
+  for (const o2 of collection) {
+    if (isNone2(o2)) {
+      return none2();
+    }
+    out.push(o2.value);
+  }
+  return some2(out);
+};
+var all = (input) => {
+  if (Symbol.iterator in input) {
+    const out2 = [];
+    for (const o2 of input) {
+      if (isNone2(o2)) {
+        return none2();
+      }
+      out2.push(o2.value);
+    }
+    return some2(out2);
+  }
+  const out = {};
+  for (const key of Object.keys(input)) {
+    const o2 = input[key];
+    if (isNone2(o2)) {
+      return none2();
+    }
+    out[key] = o2.value;
+  }
+  return some2(out);
+};
+var zipWith = /* @__PURE__ */ dual(3, (self, that, f) => map(product(self, that), ([a, b2]) => f(a, b2)));
+var ap = /* @__PURE__ */ dual(2, (self, that) => zipWith(self, that, (f, a) => f(a)));
+var reduceCompact = /* @__PURE__ */ dual(3, (self, b2, f) => {
+  let out = b2;
+  for (const oa of self) {
+    if (isSome2(oa)) {
+      out = f(out, oa.value);
+    }
+  }
+  return out;
+});
+var toArray = (self) => isNone2(self) ? [] : [self.value];
+var partitionMap = /* @__PURE__ */ dual(2, (self, f) => {
+  if (isNone2(self)) {
+    return [none2(), none2()];
+  }
+  const e2 = f(self.value);
+  return isLeft(e2) ? [some2(e2.left), none2()] : [none2(), some2(e2.right)];
+});
+var filterMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => filterMap(self, (b2) => predicate(b2) ? some(b2) : none));
+var getEquivalence = (isEquivalent) => make((x2, y2) => isNone2(x2) ? isNone2(y2) : isNone2(y2) ? false : isEquivalent(x2.value, y2.value));
+var getOrder = (O) => make2((self, that) => isSome2(self) ? isSome2(that) ? O(self.value, that.value) : 1 : -1);
+var lift2 = (f) => dual(2, (self, that) => zipWith(self, that, f));
+var liftPredicate = /* @__PURE__ */ dual(2, (b2, predicate) => predicate(b2) ? some2(b2) : none2());
+var containsWith = (isEquivalent) => dual(2, (self, a) => isNone2(self) ? false : isEquivalent(self.value, a));
+var _equivalence = /* @__PURE__ */ equivalence();
+var contains = /* @__PURE__ */ containsWith(_equivalence);
+var exists = /* @__PURE__ */ dual(2, (self, refinement) => isNone2(self) ? false : refinement(self.value));
+var bindTo2 = /* @__PURE__ */ bindTo(map);
+var let_2 = /* @__PURE__ */ let_(map);
+var bind2 = /* @__PURE__ */ bind(map, flatMap);
+var Do = /* @__PURE__ */ some2({});
+var adapter2 = /* @__PURE__ */ adapter();
+var gen = (...args) => {
+  let f;
+  if (args.length === 1) {
+    f = args[0];
+  } else {
+    f = args[1].bind(args[0]);
+  }
+  const iterator = f(adapter2);
+  let state = iterator.next();
+  if (state.done) {
+    return some2(state.value);
+  } else {
+    let current = state.value;
+    if (isGenKind(current)) {
+      current = current.value;
+    } else {
+      current = yieldWrapGet(current);
+    }
+    if (isNone2(current)) {
+      return current;
+    }
+    while (!state.done) {
+      state = iterator.next(current.value);
+      if (!state.done) {
+        current = state.value;
+        if (isGenKind(current)) {
+          current = current.value;
+        } else {
+          current = yieldWrapGet(current);
+        }
+        if (isNone2(current)) {
+          return current;
+        }
+      }
+    }
+    return some2(state.value);
+  }
+};
+
 // ../../../node_modules/.pnpm/ts-pattern@5.2.0/node_modules/ts-pattern/dist/index.js
 var t = Symbol.for("@ts-pattern/matcher");
 var e = Symbol.for("@ts-pattern/isVariadic");
@@ -216,6 +1158,8 @@ var z = class _z {
     return this;
   }
 };
+
+// src/rules/ensure-use-callback-has-non-empty-deps.ts
 var RULE_NAME2 = "ensure-use-callback-has-non-empty-deps";
 var ensure_use_callback_has_non_empty_deps_default = createRule({
   meta: {
@@ -231,12 +1175,12 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
   },
   name: RULE_NAME2,
   create(context) {
-    const alias = parse(ESLintSettingsSchema, context.settings).reactOptions?.additionalHooks?.useCallback ?? [];
+    const alias = getESLintReactSettings(context.settings).additionalHooks?.useCallback ?? [];
     return {
       CallExpression(node) {
         const initialScope = context.sourceCode.getScope(node);
         if (!isReactHookCall(node)) return;
-        if (!isUseCallbackCall(node, context) && !alias.some(Function.flip(isReactHookCallWithNameLoose)(node))) {
+        if (!isUseCallbackCall(node, context) && !alias.some(Function_exports.flip(isReactHookCallWithNameLoose)(node))) {
           return;
         }
         const [_2, deps] = node.arguments;
@@ -247,21 +1191,21 @@ var ensure_use_callback_has_non_empty_deps_default = createRule({
           });
           return;
         }
-        const maybeDescriptor = Function.pipe(
-          $(deps).with({ type: NodeType.ArrayExpression }, Option.some).with({ type: NodeType.Identifier }, (n2) => {
-            return Function.pipe(
+        const maybeDescriptor = Function_exports.pipe(
+          $(deps).with({ type: NodeType.ArrayExpression }, Option_exports.some).with({ type: NodeType.Identifier }, (n2) => {
+            return Function_exports.pipe(
               findVariable(n2.name, initialScope),
-              Option.flatMap(getVariableInit(0)),
-              Option.filter(is(NodeType.ArrayExpression))
+              Option_exports.flatMap(getVariableInit(0)),
+              Option_exports.filter(is(NodeType.ArrayExpression))
             );
-          }).otherwise(Option.none),
-          Option.filter((x2) => x2.elements.length === 0),
-          Option.map(() => ({
+          }).otherwise(Option_exports.none),
+          Option_exports.filter((x2) => x2.elements.length === 0),
+          Option_exports.map(() => ({
             messageId: "ENSURE_USE_CALLBACK_HAS_NON_EMPTY_DEPS",
             node
           }))
         );
-        Option.map(maybeDescriptor, context.report);
+        Option_exports.map(maybeDescriptor, context.report);
       }
     };
   },
@@ -282,12 +1226,12 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
   },
   name: RULE_NAME3,
   create(context) {
-    const alias = parse(ESLintSettingsSchema, context.settings).reactOptions?.additionalHooks?.useMemo ?? [];
+    const alias = getESLintReactSettings(context.settings).additionalHooks?.useMemo ?? [];
     return {
       CallExpression(node) {
         const initialScope = context.sourceCode.getScope(node);
         if (!isReactHookCall(node)) return;
-        if (!isUseMemoCall(node, context) && !alias.some(Function.flip(isReactHookCallWithNameLoose)(node))) return;
+        if (!isUseMemoCall(node, context) && !alias.some(Function_exports.flip(isReactHookCallWithNameLoose)(node))) return;
         const [_2, deps] = node.arguments;
         if (!deps) {
           context.report({
@@ -296,21 +1240,21 @@ var ensure_use_memo_has_non_empty_deps_default = createRule({
           });
           return;
         }
-        const maybeDescriptor = Function.pipe(
-          $(deps).with({ type: NodeType.ArrayExpression }, Option.some).with({ type: NodeType.Identifier }, (n2) => {
-            return Function.pipe(
+        const maybeDescriptor = Function_exports.pipe(
+          $(deps).with({ type: NodeType.ArrayExpression }, Option_exports.some).with({ type: NodeType.Identifier }, (n2) => {
+            return Function_exports.pipe(
               findVariable(n2.name, initialScope),
-              Option.flatMap(getVariableInit(0)),
-              Option.filter(is(NodeType.ArrayExpression))
+              Option_exports.flatMap(getVariableInit(0)),
+              Option_exports.filter(is(NodeType.ArrayExpression))
             );
-          }).otherwise(Option.none),
-          Option.filter((x2) => x2.elements.length === 0),
-          Option.map(() => ({
+          }).otherwise(Option_exports.none),
+          Option_exports.filter((x2) => x2.elements.length === 0),
+          Option_exports.map(() => ({
             messageId: "ENSURE_USE_MEMO_HAS_NON_EMPTY_DEPS",
             node
           }))
         );
-        Option.map(maybeDescriptor, context.report);
+        Option_exports.map(maybeDescriptor, context.report);
       }
     };
   },
@@ -332,11 +1276,11 @@ var prefer_use_state_lazy_initialization_default = createRule({
   },
   name: RULE_NAME4,
   create(context) {
-    const alias = parse(ESLintSettingsSchema, context.settings).reactOptions?.additionalHooks?.useState ?? [];
+    const alias = getESLintReactSettings(context.settings).additionalHooks?.useState ?? [];
     return {
       CallExpression(node) {
         if (!isReactHookCall(node)) return;
-        if (!isUseStateCall(node, context) && !alias.some(Function.flip(isReactHookCallWithNameLoose)(node))) return;
+        if (!isUseStateCall(node, context) && !alias.some(Function_exports.flip(isReactHookCallWithNameLoose)(node))) return;
         const [useStateInput] = node.arguments;
         if (!useStateInput) return;
         const nestedCallExpressions = getNestedCallExpressions(useStateInput);