oxlint-plugin-effector 0.0.1

package/dist/index.js

@@ -0,0 +1,2031 @@
+// src/shared/ast.ts
+var NodeType = {
+  ArrayExpression: "ArrayExpression",
+  ArrayPattern: "ArrayPattern",
+  ArrowFunctionExpression: "ArrowFunctionExpression",
+  AssignmentExpression: "AssignmentExpression",
+  AssignmentPattern: "AssignmentPattern",
+  CallExpression: "CallExpression",
+  ExpressionStatement: "ExpressionStatement",
+  FunctionDeclaration: "FunctionDeclaration",
+  FunctionExpression: "FunctionExpression",
+  Identifier: "Identifier",
+  Literal: "Literal",
+  MemberExpression: "MemberExpression",
+  ObjectExpression: "ObjectExpression",
+  ObjectPattern: "ObjectPattern",
+  Property: "Property",
+  RestElement: "RestElement",
+  SpreadElement: "SpreadElement",
+  VariableDeclarator: "VariableDeclarator"
+};
+
+// src/shared/services.ts
+import { dirname, resolve } from "node:path";
+import * as ts from "typescript";
+function getParserServices(context) {
+  const existing = context.sourceCode?.parserServices;
+  if (existing?.program && existing.esTreeNodeToTSNodeMap) return existing;
+  return buildServices(context);
+}
+var programCache = /* @__PURE__ */ new Map();
+function buildServices(context) {
+  const filename = context.filename ?? context.physicalFilename;
+  const program = getProgram(filename);
+  const sourceFile = program.getSourceFile(filename);
+  if (!sourceFile)
+    throw new Error(
+      `oxlint-plugin-effector: cannot load "${filename}" into a TypeScript program`
+    );
+  const checker = program.getTypeChecker();
+  const byRange = indexByRange(sourceFile);
+  const toTSNode = (node) => {
+    const [start, end] = node.range;
+    return byRange.get(key(start, end)) ?? deepestContaining(sourceFile, start, end);
+  };
+  return {
+    program,
+    esTreeNodeToTSNodeMap: { get: toTSNode, has: () => true },
+    tsNodeToESTreeNodeMap: { get: () => void 0, has: () => false },
+    getTypeAtLocation: (node) => checker.getTypeAtLocation(toTSNode(node)),
+    getSymbolAtLocation: (node) => checker.getSymbolAtLocation(toTSNode(node))
+  };
+}
+var FALLBACK_OPTIONS = {
+  allowJs: true,
+  jsx: ts.JsxEmit.Preserve,
+  module: ts.ModuleKind.ESNext,
+  moduleResolution: ts.ModuleResolutionKind.Bundler,
+  target: ts.ScriptTarget.ESNext,
+  skipLibCheck: true
+};
+var norm = (p) => p.replace(/\\/g, "/");
+var parseConfig = (configPath) => ts.getParsedCommandLineOfConfigFile(configPath, {}, ts.sys) ?? void 0;
+function projectContaining(configPath, filename, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(norm(configPath))) return void 0;
+  seen.add(norm(configPath));
+  const parsed = parseConfig(configPath);
+  if (!parsed) return void 0;
+  if (parsed.fileNames.some((f) => norm(f) === norm(filename))) return parsed;
+  for (const ref of parsed.projectReferences ?? []) {
+    const found = projectContaining(
+      ts.resolveProjectReferencePath(ref),
+      filename,
+      seen
+    );
+    if (found) return found;
+  }
+  return void 0;
+}
+function getProgram(filename) {
+  const override = process.env.OXLINT_EFFECTOR_TSCONFIG;
+  const rootConfig = override ? resolve(override) : ts.findConfigFile(dirname(filename), ts.sys.fileExists) ?? "";
+  const parsed = rootConfig ? projectContaining(rootConfig, filename) ?? parseConfig(rootConfig) : void 0;
+  const cacheKey = parsed?.options.configFilePath ?? rootConfig ?? filename;
+  const cached = programCache.get(cacheKey);
+  if (cached) return cached;
+  const options = parsed?.options ?? FALLBACK_OPTIONS;
+  const inProject = parsed?.fileNames.some((f) => norm(f) === norm(filename)) ?? false;
+  let rootNames = [filename];
+  if (parsed && parsed.fileNames.length)
+    rootNames = inProject ? parsed.fileNames : [...parsed.fileNames, filename];
+  const program = ts.createProgram({ rootNames, options });
+  programCache.set(cacheKey, program);
+  return program;
+}
+function deepestContaining(sourceFile, start, end) {
+  let best = sourceFile;
+  const visit = (node) => {
+    if (node.getStart(sourceFile) <= start && node.getEnd() >= end) {
+      best = node;
+      node.forEachChild(visit);
+    }
+  };
+  sourceFile.forEachChild(visit);
+  return best;
+}
+var key = (start, end) => `${start}:${end}`;
+function indexByRange(sourceFile) {
+  const map = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    map.set(key(node.getStart(sourceFile), node.getEnd()), node);
+    node.forEachChild(visit);
+  };
+  visit(sourceFile);
+  return map;
+}
+
+// src/shared/create.ts
+var docsUrl = (name) => `https://eslint.effector.dev/rules/${name}`;
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var mergeDeep = (base, override) => {
+  if (override === void 0) return base;
+  if (!isPlainObject(base) || !isPlainObject(override)) return override;
+  const result = { ...base };
+  for (const key2 of Object.keys(override))
+    result[key2] = mergeDeep(base[key2], override[key2]);
+  return result;
+};
+var applyDefaults = (provided, defaults) => {
+  const user = Array.isArray(provided) ? provided : [];
+  return defaults.map(
+    (value, index) => mergeDeep(value, user[index])
+  );
+};
+function createRule(rule) {
+  return {
+    meta: {
+      ...rule.meta,
+      docs: { ...rule.meta.docs, url: docsUrl(rule.name) }
+    },
+    defaultOptions: rule.defaultOptions,
+    create(context) {
+      return rule.create(
+        context,
+        applyDefaults(context.options, rule.defaultOptions)
+      );
+    }
+  };
+}
+
+// src/shared/is.ts
+import "typescript";
+var symbolMatches = (symbol, names, from) => {
+  if (!names.includes(symbol.getName())) return false;
+  const declarations = symbol.declarations ?? [];
+  return declarations.map((decl) => decl.getSourceFile().fileName).some((fname) => fname.includes("node_modules") && fname.includes(from));
+};
+var typeMatches = (type, names, from, depth = 0) => {
+  if (depth > 10) return false;
+  const symbol = type.getSymbol() ?? type.aliasSymbol;
+  if (symbol && symbolMatches(symbol, names, from)) return true;
+  if (type.isUnion() || type.isIntersection())
+    return type.types.some(
+      (member) => typeMatches(member, names, from, depth + 1)
+    );
+  return false;
+};
+var isType = {
+  store: (type) => typeMatches(type, ["Store", "StoreWritable"], "effector"),
+  event: (type) => typeMatches(type, ["Event", "EventCallable"], "effector"),
+  effect: (type) => typeMatches(type, ["Effect"], "effector"),
+  domain: (type) => typeMatches(type, ["Domain"], "effector"),
+  unit: (type) => typeMatches(
+    type,
+    ["Store", "StoreWritable", "Event", "EventCallable", "Effect", "Domain"],
+    "effector"
+  ),
+  // Gate is an intersection type, which TypeScript erases from existence
+  gate: (type) => typeMatches(type, ["Gate"], "effector"),
+  jsx: (type) => typeMatches(type, ["Element", "ReactNode", "ReactElement"], "react"),
+  component: (type) => typeMatches(
+    type,
+    [
+      "FC",
+      "FunctionComponent",
+      "ComponentType",
+      "ComponentClass",
+      "ForwardRefRenderFunction"
+    ],
+    "react"
+  )
+};
+
+// src/rules/enforce-effect-naming-convention/enforce-effect-naming-convention.ts
+var enforce_effect_naming_convention_default = createRule({
+  name: "enforce-effect-naming-convention",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce Fx as a suffix for any Effector Effect."
+    },
+    messages: {
+      invalid: 'Effect "{{ current }}" should be named with `Fx` suffix, rename it to "{{ fixed }}"',
+      rename: 'Rename "{{ current }}" to "{{ fixed }}"'
+    },
+    schema: [],
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const services = getParserServices(context);
+    const identifierSelectors = [
+      selector.variable,
+      selector.array.identifier,
+      selector.array.assignment,
+      selector.function.identifier,
+      selector.function.assignment
+    ].join(", ");
+    return {
+      [identifierSelectors]: (node) => {
+        const type = services.getTypeAtLocation(node);
+        const isEffect = isType.effect(type);
+        if (!isEffect) return;
+        const data = { current: node.name, fixed: node.name + "Fx" };
+        if (node.typeAnnotation)
+          return context.report({ node, messageId: "invalid", data });
+        const suggestion = {
+          messageId: "rename",
+          data: { current: node.name, fixed: data.fixed },
+          fix: (fixer) => fixer.replaceText(node, data.fixed)
+        };
+        context.report({
+          node,
+          messageId: "invalid",
+          data,
+          suggest: [suggestion]
+        });
+      },
+      [`${selector.shape.identifier}, ${selector.shape.assignment}`]: (node) => {
+        const type = services.getTypeAtLocation(node.value);
+        const ident = node.value.type === NodeType.Identifier ? node.value : node.value.left;
+        const isEffect = isType.effect(type);
+        if (!isEffect) return;
+        const data = { current: ident.name, fixed: ident.name + "Fx" };
+        const suggestion = {
+          messageId: "rename",
+          data: { current: ident.name, fixed: data.fixed },
+          fix: (fixer) => node.shorthand ? fixer.insertTextAfter(node.key, `: ${data.fixed}`) : fixer.replaceText(ident, data.fixed)
+        };
+        context.report({
+          node: ident,
+          messageId: "invalid",
+          data,
+          suggest: [suggestion]
+        });
+      }
+    };
+  }
+});
+var FxRegex = /Fx$/;
+var selector = {
+  variable: `VariableDeclarator > Identifier.id[name!=${FxRegex}]`,
+  array: {
+    identifier: `ArrayPattern > Identifier.elements[name!=${FxRegex}]`,
+    assignment: `ArrayPattern > AssignmentPattern > Identifier.left[name!=${FxRegex}]`
+  },
+  shape: {
+    identifier: `ObjectPattern > Property:has(> Identifier.value[name!=${FxRegex}])`,
+    assignment: `ObjectPattern > Property:has(> AssignmentPattern:has(> Identifier.left[name!=${FxRegex}]))`
+  },
+  function: {
+    identifier: `:function > Identifier.params[name!=${FxRegex}]`,
+    assignment: `:function > AssignmentPattern > Identifier.left[name!=${FxRegex}]`
+  }
+};
+
+// src/shared/package.ts
+var PACKAGE_NAME = {
+  core: /^effector(?:\u002Fcompat)?$/,
+  react: /^effector-react$/,
+  storage: /^@?effector-storage(\u002F[\w-]+)*$/
+};
+var fromPackage = (pkg) => `ImportDeclaration[source.value=${pkg}]`;
+
+// src/rules/enforce-exhaustive-useUnit-destructuring/enforce-exhaustive-useUnit-destructuring.ts
+var enforce_exhaustive_useUnit_destructuring_default = createRule({
+  name: "enforce-exhaustive-useUnit-destructuring",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure all units passed to useUnit are properly destructured."
+    },
+    messages: {
+      unusedKey: 'Property "{{name}}" is passed but not destructured.',
+      missingKey: 'Property "{{name}}" is destructured but not passed in the unit object.'
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const importedAs = /* @__PURE__ */ new Set();
+    return {
+      [selector2.import]: (node) => void importedAs.add(node.local.name),
+      [`${selector2.variable.shape}:has(> ${selector2.call}:has(${selector2.arg.shape}))`](node) {
+        if (!importedAs.has(node.init.callee.name)) return;
+        const provided = shapeToKeyMap(node.init.arguments[0]);
+        const consumed = shapeToKeyMap(node.id);
+        if (provided === null || consumed === null) return;
+        for (const { type, name } of check(provided, consumed))
+          if (type === "unused")
+            context.report({
+              node: node.init.arguments[0],
+              messageId: "unusedKey",
+              data: { name }
+            });
+          else
+            context.report({
+              node: node.id,
+              messageId: "missingKey",
+              data: { name }
+            });
+      },
+      [`${selector2.variable.list}:has(> ${selector2.call}:has(${selector2.arg.list}))`](node) {
+        if (!importedAs.has(node.init.callee.name)) return;
+        const provided = listToKeyMap(node.init.arguments[0]);
+        const consumed = listToKeyMap(node.id);
+        if (provided === null || consumed === null) return;
+        for (const { type, name } of check(provided, consumed))
+          if (type === "unused")
+            context.report({
+              node: node.init.arguments[0],
+              messageId: "unusedKey",
+              data: { name }
+            });
+          else
+            context.report({
+              node: node.id,
+              messageId: "missingKey",
+              data: { name }
+            });
+      }
+    };
+  }
+});
+var selector2 = {
+  import: `ImportDeclaration[source.value=${PACKAGE_NAME.react}] > ImportSpecifier[imported.name=useUnit]`,
+  variable: {
+    shape: "VariableDeclarator[id.type=ObjectPattern]",
+    list: "VariableDeclarator[id.type=ArrayPattern]"
+  },
+  call: "CallExpression.init[arguments.length=1][callee.type=Identifier]",
+  arg: {
+    shape: "ObjectExpression.arguments",
+    list: "ArrayExpression.arguments"
+  }
+};
+function toName(key2, node) {
+  if (node.type === NodeType.Identifier) return node.name;
+  if (node.type === NodeType.Literal) return String(node.value);
+  if (node.type === NodeType.MemberExpression && node.property.type === NodeType.Identifier)
+    return `${toName(key2, node.object)}.${node.property.name}`;
+  return `<unknown at ${key2}>`;
+}
+function toKey(prop) {
+  if (prop.computed) return null;
+  else if (prop.key.type === NodeType.Identifier) return prop.key.name;
+  else return prop.key.value;
+}
+function* check(provided, consumed) {
+  for (const [key2, node] of provided)
+    if (!consumed.has(key2)) yield { type: "unused", name: toName(key2, node) };
+  for (const [key2, node] of consumed)
+    if (!provided.has(key2)) yield { type: "missing", name: toName(key2, node) };
+}
+function shapeToKeyMap(shape) {
+  const map = /* @__PURE__ */ new Map();
+  for (const prop of shape.properties) {
+    if (prop.type !== NodeType.Property) return null;
+    const key2 = toKey(prop);
+    if (key2 === null) return null;
+    else map.set(key2, prop.key);
+  }
+  return map;
+}
+function listToKeyMap(list) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [index, element] of list.elements.entries()) {
+    if (element === null) continue;
+    if (element.type === NodeType.RestElement || element.type === NodeType.SpreadElement)
+      return null;
+    map.set(index, element);
+  }
+  return map;
+}
+
+// src/rules/enforce-gate-naming-convention/enforce-gate-naming-convention.ts
+var enforce_gate_naming_convention_default = createRule({
+  name: "enforce-gate-naming-convention",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce a Gate is named capitalized like a React Component"
+    },
+    messages: {
+      invalid: 'Gate "{{ current }}" should be named with first capital letter, rename it to "{{ fixed }}"',
+      rename: 'Rename "{{ current }}" to "{{ fixed }}"'
+    },
+    schema: [],
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const services = getParserServices(context);
+    return {
+      [`VariableDeclarator[id.name=${GateRegex}]`]: (node) => {
+        const type = services.getTypeAtLocation(node);
+        const isGate = isType.gate(type);
+        if (!isGate) return;
+        const current = node.id.name;
+        const fixed = current[0].toUpperCase() + current.slice(1);
+        const data = { current, fixed };
+        const suggestion = {
+          messageId: "rename",
+          data: { current, fixed },
+          fix: (fixer) => fixer.replaceText(node.id, fixed)
+        };
+        context.report({
+          node: node.id,
+          messageId: "invalid",
+          data,
+          suggest: [suggestion]
+        });
+      }
+    };
+  }
+});
+var GateRegex = /^[^A-Z]/;
+
+// src/rules/enforce-store-naming-convention/enforce-store-naming-convention.ts
+var enforce_store_naming_convention_default = createRule({
+  name: "enforce-store-naming-convention",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce $ as a prefix/postfix for any Effector `Store`"
+    },
+    messages: {
+      invalid: 'Store "{{ current }}" should be named with a `$` {{ convention }}, rename it to "{{ fixed }}"',
+      rename: 'Rename "{{ current }}" to "{{ fixed }}"'
+    },
+    schema: [
+      {
+        type: "object",
+        properties: { mode: { type: "string", enum: ["prefix", "postfix"] } }
+      }
+    ],
+    hasSuggestions: true
+  },
+  defaultOptions: [{ mode: "prefix" }],
+  create: (context, [options]) => {
+    const services = getParserServices(context);
+    const selector16 = createSelector(
+      options.mode === "prefix" ? PrefixRegex : PostfixRegex
+    );
+    const rename = (node) => {
+      const trimmed = node.name.replace(
+        options.mode === "prefix" ? /\$+$/g : /^\$+/g,
+        ""
+      );
+      const fixed = options.mode === "prefix" ? `$${trimmed}` : `${trimmed}$`;
+      return { current: node.name, convention: options.mode, fixed };
+    };
+    const identifierSelectors = [
+      selector16.variable,
+      selector16.array.identifier,
+      selector16.array.assignment,
+      selector16.function.identifier,
+      selector16.function.assignment
+    ].join(", ");
+    return {
+      [identifierSelectors]: (node) => {
+        const type = services.getTypeAtLocation(node);
+        const isStore = isType.store(type);
+        if (!isStore) return;
+        const data = rename(node);
+        if (node.typeAnnotation)
+          return context.report({ node, messageId: "invalid", data });
+        const suggestion = {
+          messageId: "rename",
+          data: { current: node.name, fixed: data.fixed },
+          fix: (fixer) => fixer.replaceText(node, data.fixed)
+        };
+        context.report({
+          node,
+          messageId: "invalid",
+          data,
+          suggest: [suggestion]
+        });
+      },
+      [`${selector16.shape.identifier}, ${selector16.shape.assignment}`]: (node) => {
+        const type = services.getTypeAtLocation(node.value);
+        const ident = node.value.type === NodeType.Identifier ? node.value : node.value.left;
+        const isStore = isType.store(type);
+        if (!isStore) return;
+        const data = rename(ident);
+        const suggestion = {
+          messageId: "rename",
+          data: { current: ident.name, fixed: data.fixed },
+          fix: (fixer) => (
+            // { x } -> { x: $x }  /  { x: y } -> { x: $y }
+            node.shorthand ? fixer.insertTextAfter(node.key, `: ${data.fixed}`) : fixer.replaceText(ident, data.fixed)
+          )
+        };
+        context.report({
+          node: ident,
+          messageId: "invalid",
+          data,
+          suggest: [suggestion]
+        });
+      }
+    };
+  }
+});
+var PrefixRegex = /^[^$]/;
+var PostfixRegex = /[^$]$/;
+var createSelector = (regex) => ({
+  variable: `VariableDeclarator > Identifier.id[name=${regex}]`,
+  array: {
+    identifier: `ArrayPattern > Identifier.elements[name=${regex}]`,
+    assignment: `ArrayPattern > AssignmentPattern > Identifier.left[name=${regex}]`
+  },
+  shape: {
+    identifier: `ObjectPattern > Property:has(> Identifier.value[name=${regex}])`,
+    assignment: `ObjectPattern > Property:has(> AssignmentPattern:has(> Identifier.left[name=${regex}]))`
+  },
+  function: {
+    identifier: `:function > Identifier.params[name=${regex}]`,
+    assignment: `:function > AssignmentPattern > Identifier.left[name=${regex}]`
+  }
+});
+
+// src/rules/keep-options-order/keep-options-order.ts
+var keep_options_order_default = createRule({
+  name: "keep-options-order",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce options order for Effector methods"
+    },
+    messages: {
+      invalidOrder: `Order of options should be \`{{ correctOrder }}\`, but found \`{{ currentOrder }}\`.`,
+      changeOrder: "Sort options to follow the recommended order."
+    },
+    schema: [],
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const source = context.sourceCode;
+    const imports = /* @__PURE__ */ new Set();
+    const importSelector = fromPackage(PACKAGE_NAME.core);
+    return {
+      [`${importSelector} > ${selector3.method}`]: (node) => imports.add(node.local.name),
+      [`CallExpression${selector3.call}:has(${selector3.argument})`]: (node) => {
+        if (!imports.has(node.callee.name)) return;
+        const [config] = node.arguments;
+        const hasWeirdProperty = config.properties.some(
+          (prop) => prop.type === NodeType.SpreadElement || prop.key.type !== NodeType.Identifier
+        );
+        if (hasWeirdProperty) return;
+        const properties = config.properties;
+        const current = properties.map((prop) => prop.key.name);
+        if (isCorrectOrder(current)) return;
+        const correctOrder = TRUE_ORDER.filter(
+          (item) => current.includes(item)
+        );
+        const othersOrder = current.filter(
+          (item) => !TRUE_ORDER.includes(item)
+        );
+        const order = [...correctOrder, ...othersOrder];
+        const snippets = properties.toSorted(
+          (a, b) => order.indexOf(a.key.name) - order.indexOf(b.key.name)
+        ).map((prop) => source.getText(prop));
+        const suggestion = {
+          messageId: "changeOrder",
+          fix: (fixer) => [
+            fixer.replaceText(config, `{ ${snippets.join(", ")} }`)
+          ]
+        };
+        const data = {
+          correctOrder: correctOrder.join(" -> "),
+          currentOrder: current.join(" -> ")
+        };
+        context.report({
+          node: config,
+          messageId: "invalidOrder",
+          data,
+          suggest: [suggestion]
+        });
+      }
+    };
+  }
+});
+var TRUE_ORDER = [
+  "clock",
+  "source",
+  "filter",
+  "fn",
+  "target",
+  "greedy",
+  "batch",
+  "name"
+];
+var selector3 = {
+  method: `ImportSpecifier[imported.name=/(sample|guard)/]`,
+  call: `[callee.type="Identifier"][arguments.length=1]`,
+  argument: `ObjectExpression.arguments`
+};
+var isCorrectOrder = (current) => {
+  let seen = -1;
+  for (const item of current) {
+    const index = TRUE_ORDER.indexOf(item);
+    const placement = index === -1 ? Infinity : index;
+    if (placement <= seen) return false;
+    seen = placement;
+  }
+  return true;
+};
+
+// src/rules/mandatory-scope-binding/mandatory-scope-binding.ts
+import ts2 from "typescript";
+
+// src/shared/name.ts
+function functionToName(node) {
+  if (node.id) return node.id;
+  if (node.parent.type === NodeType.VariableDeclarator && node.parent.id.type === NodeType.Identifier)
+    return node.parent.id;
+  if (node.parent.type === NodeType.AssignmentExpression && node.parent.left.type === NodeType.Identifier)
+    return node.parent.left;
+  if (node.parent.type === NodeType.Property && node.parent.key.type === NodeType.Identifier)
+    return node.parent.key;
+  if (node.parent.type === NodeType.AssignmentPattern && node.parent.left.type === NodeType.Identifier)
+    return node.parent.left;
+  return null;
+}
+function calleeToName(callee) {
+  if (callee.type === NodeType.Identifier) return callee;
+  else if (callee.type === NodeType.MemberExpression && callee.property.type === NodeType.Identifier)
+    return callee.property;
+  else return null;
+}
+function simpleExpressionToName(node) {
+  if (node.type === NodeType.Identifier) return node.name;
+  if (node.type === NodeType.MemberExpression && !node.computed)
+    return node.property.name;
+  return null;
+}
+var nameOf = {
+  function: functionToName,
+  callee: calleeToName,
+  expression: { simple: simpleExpressionToName }
+};
+
+// src/rules/mandatory-scope-binding/mandatory-scope-binding.ts
+var mandatory_scope_binding_default = createRule({
+  name: "mandatory-scope-binding",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid `Event` and `Effect` usage without `useUnit` in React."
+    },
+    messages: {
+      useUnitNeeded: '"{{ name }}" must be wrapped with `useUnit` from `effector-react` before usage inside React.'
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const services = getParserServices(context);
+    const checker = services.program.getTypeChecker();
+    const inRender = [];
+    const inHook = [];
+    const isExpectingUnit = (slot) => {
+      const tsnode = services.esTreeNodeToTSNodeMap.get(slot);
+      const type = checker.getContextualType(tsnode);
+      if (type) return isType.event(type) || isType.effect(type);
+      else return false;
+    };
+    const check2 = (mode, node) => {
+      const rendering = inRender.at(-1) ?? false;
+      if (!rendering) return;
+      const type = services.getTypeAtLocation(node);
+      if (!isType.event(type) && !isType.effect(type)) return;
+      if (mode === "call") return report(node);
+      const delegated = isExpectingUnit(node), eligible = mode === "jsx" || (inHook.at(-1) ?? false);
+      if (eligible && delegated) return;
+      else return report(node);
+    };
+    const report = (node) => {
+      const name = nameOf.expression.simple(node) ?? "<expression>";
+      context.report({ node, messageId: "useUnitNeeded", data: { name } });
+    };
+    return {
+      // detect react render contexts
+      [`:matches(${selector4.function})`]: (node) => {
+        const current = inRender.at(-1) ?? false;
+        if (current) return void inRender.push(true);
+        const name = nameOf.function(node);
+        if (name && UseRegex.test(name.name)) return void inRender.push(true);
+        const tsnode = services.esTreeNodeToTSNodeMap.get(node);
+        const signature = checker.getSignatureFromDeclaration(tsnode);
+        const returnType = signature ? checker.getReturnTypeOfSignature(signature) : void 0;
+        const isJSX = matchesType(returnType, (type) => isType.jsx(type));
+        if (isJSX) return void inRender.push(true);
+        const inferred = ts2.isExpression(tsnode) ? checker.getContextualType(tsnode) : void 0;
+        const isComponent = matchesType(
+          inferred,
+          (type) => isType.component(type)
+        );
+        if (isComponent) return void inRender.push(true);
+        return void inRender.push(false);
+      },
+      [`:matches(${selector4.function}):exit`]: () => void inRender.pop(),
+      // bail from tracking classes
+      ClassDeclaration: () => void inRender.push(false),
+      "ClassDeclaration:exit": () => void inRender.pop(),
+      // detect contexts where we may delegate `useUnit` binding to the callee
+      CallExpression: (node) => {
+        const id = nameOf.callee(node.callee), isEnteringHook = id !== null && UseRegex.test(id.name);
+        inHook.push(isEnteringHook);
+      },
+      "CallExpression:exit": () => void inHook.pop(),
+      // direct invocation site `event()` & `model.event()`
+      // - receiver is being invoked directly, always dangerous
+      [`${selector4.callee.direct}, ${selector4.callee.member}`]: (node) => check2("call", node),
+      // argument position `fn(event)` & `fn(model.event)`
+      // - dangerous unless scope binding delegated (arg expects unit)
+      [`${selector4.arg.direct}, ${selector4.arg.member}`]: (node) => check2("arg", node),
+      // one-level-deep object-property position `fn({ key: event })` & `fn({
+      // key: model.event })`
+      // - dangerous unless scope binding delegated (key expects unit)
+      [`${selector4.prop.direct}, ${selector4.prop.member}`]: (node) => check2("prop", node),
+      // jsx expression slot `<C prop={event}>`, `<C prop={model.event}>`
+      // - dangerous unless scope binding delegated (prop expects unit)
+      [`${selector4.jsx.direct}, ${selector4.jsx.member}`]: (node) => check2("jsx", node)
+    };
+  }
+});
+var matchesType = (type, predicate) => {
+  if (!type) return false;
+  if (type.isUnion()) return type.types.some(predicate);
+  return predicate(type);
+};
+var UseRegex = /^use[A-Z0-9].*$/;
+var selector4 = {
+  function: "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression",
+  callee: {
+    direct: "CallExpression > Identifier.callee",
+    member: "CallExpression > MemberExpression[computed=false].callee"
+  },
+  arg: {
+    direct: "CallExpression > Identifier:not(.callee)",
+    member: "CallExpression > MemberExpression[computed=false]:not(.callee)"
+  },
+  prop: {
+    direct: "CallExpression > ObjectExpression > Property > Identifier.value",
+    member: "CallExpression > ObjectExpression > Property > MemberExpression[computed=false].value"
+  },
+  jsx: {
+    direct: "JSXExpressionContainer > Identifier",
+    member: "JSXExpressionContainer > MemberExpression[computed=false]"
+  }
+};
+
+// src/shared/locate.ts
+var property = (key2, node) => node.properties.find(
+  (prop) => prop.type == NodeType.Property && prop.key.type === NodeType.Identifier && prop.key.name === key2
+);
+var locate = { property };
+
+// src/rules/no-ambiguity-target/no-ambiguity-target.ts
+var no_ambiguity_target_default = createRule({
+  name: "no-ambiguity-target",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid ambiguous target in `sample` and `guard`."
+    },
+    messages: {
+      ambiguous: "Method `{{ method }}` both specifies `target` option and assigns the result to a variable. Consider removing one of them."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const imports = /* @__PURE__ */ new Set();
+    const importSelector = fromPackage(PACKAGE_NAME.core);
+    const usageStack = [];
+    return {
+      ReturnStatement: () => usageStack.push(true),
+      "ReturnStatement:exit": () => usageStack.pop(),
+      VariableDeclarator: () => usageStack.push(true),
+      "VariableDeclarator:exit": () => usageStack.pop(),
+      ObjectExpression: () => usageStack.push(true),
+      "ObjectExpression:exit": () => usageStack.pop(),
+      BlockStatement: () => usageStack.push(false),
+      "BlockStatement:exit": () => usageStack.pop(),
+      [`${importSelector} > ${selector5.method}`]: (node) => imports.add(node.local.name),
+      [`CallExpression[callee.type="Identifier"]`]: (node) => {
+        const isTracked = imports.has(node.callee.name);
+        if (!isTracked) return;
+        const isUsed = usageStack.at(-1) ?? false;
+        if (!isUsed) return;
+        const [config] = node.arguments;
+        if (config?.type !== NodeType.ObjectExpression)
+          return;
+        const target = locate.property("target", config);
+        if (!target) return;
+        context.report({
+          node,
+          messageId: "ambiguous",
+          data: { method: node.callee.name }
+        });
+      }
+    };
+  }
+});
+var selector5 = {
+  method: `ImportSpecifier[imported.name=/(sample|guard)/]`
+};
+
+// src/rules/no-domain-unit-creators/no-domain-unit-creators.ts
+var no_domain_unit_creators_default = createRule({
+  name: "no-domain-unit-creators",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow using Domain methods to create units."
+    },
+    messages: {
+      avoid: "Avoid using `.{{ method }}` on a Domain instance. Use a standard factory unit creator `{{ factory }}` with a `domain` option instead."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const services = getParserServices(context);
+    return {
+      [`CallExpression:has(> ${selector6.member})`]: (node) => {
+        const name = node.callee.property.name;
+        if (!METHODS.has(name)) return;
+        const type = services.getTypeAtLocation(node.callee.object);
+        if (!isType.domain(type)) return;
+        const factory = ALIAS_MAP.get(name) ?? name;
+        context.report({
+          node,
+          messageId: "avoid",
+          data: { method: name, factory }
+        });
+      }
+    };
+  }
+});
+var ALIAS_MAP = (/* @__PURE__ */ new Map()).set("event", "createEvent").set("store", "createStore").set("effect", "createEffect").set("domain", "createDomain");
+var METHODS = /* @__PURE__ */ new Set([...ALIAS_MAP.values(), ...ALIAS_MAP.keys()]);
+var selector6 = {
+  member: `MemberExpression.callee[property.type="Identifier"]`
+};
+
+// src/rules/no-duplicate-clock-or-source-array-values/no-duplicate-clock-or-source-array-values.ts
+var no_duplicate_clock_or_source_array_values_default = createRule({
+  name: "no-duplicate-clock-or-source-array-values",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid providing duplicate units in `clock` and `source` arrays in `sample` and `guard`."
+    },
+    messages: {
+      duplicate: "`{{ field }}` contains a duplicate unit `{{ unit }}`.",
+      remove: "Remove duplicate unit `{{ unit }}`."
+    },
+    schema: [],
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const imports = /* @__PURE__ */ new Set();
+    const importSelector = fromPackage(PACKAGE_NAME.core);
+    const analyze = (node, field) => {
+      const seen = /* @__PURE__ */ new Map();
+      const entries = node.elements.filter((item) => item !== null).filter((item) => item.type !== NodeType.SpreadElement);
+      for (const entry of entries) {
+        const root = traverseToRoot(entry);
+        if (!root) continue;
+        const name = [root.node.name, ...root.path].join(".");
+        if (seen.has(name)) report(entry, name, field);
+        else seen.set(name, entry);
+      }
+    };
+    const report = (node, name, field) => {
+      const data = { field, unit: name };
+      const suggestion = {
+        messageId: "remove",
+        data: { unit: name },
+        fix: function* (fixer) {
+          yield fixer.remove(node);
+          const before = context.sourceCode.getTokenBefore(node);
+          if (before?.value === ",") yield fixer.remove(before);
+        }
+      };
+      context.report({
+        node,
+        messageId: "duplicate",
+        data,
+        suggest: [suggestion]
+      });
+    };
+    return {
+      [`${importSelector} > ${selector7.method}`]: (node) => imports.add(node.local.name),
+      [`CallExpression${selector7.call}:has(${selector7.argument})`]: (node) => {
+        if (!imports.has(node.callee.name)) return;
+        const [config] = node.arguments;
+        const clock = locate.property("clock", config);
+        const source = locate.property("source", config);
+        if (clock?.value?.type === NodeType.ArrayExpression)
+          analyze(clock.value, "clock");
+        if (source?.value?.type === NodeType.ArrayExpression)
+          analyze(source.value, "source");
+      }
+    };
+  }
+});
+var selector7 = {
+  method: `ImportSpecifier[imported.name=/(sample|guard)/]`,
+  call: `[callee.type="Identifier"][arguments.length=1]`,
+  argument: `ObjectExpression.arguments`
+};
+function traverseToRoot(node, path = []) {
+  if (node.type === NodeType.Identifier) return { node, path };
+  if (node.type === NodeType.MemberExpression && node.property.type === NodeType.Identifier)
+    return traverseToRoot(node.object, [node.property.name, ...path]);
+  return null;
+}
+
+// src/rules/no-duplicate-on/no-duplicate-on.ts
+var no_duplicate_on_default = createRule({
+  name: "no-duplicate-on",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid duplicate `.on` calls on Stores."
+    },
+    messages: {
+      duplicate: "Method `.on` is called on store `{{ store }}` more than once for `{{ unit }}`."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const services = getParserServices(context);
+    const map = /* @__PURE__ */ new Map();
+    return {
+      [`CallExpression[callee.property.name="on"]`]: (node) => {
+        const type = services.getTypeAtLocation(node.callee.object);
+        const isStore = isType.store(type);
+        if (!isStore) return;
+        const arg = node.arguments[0];
+        if (!arg || arg.type === NodeType.SpreadElement) return;
+        const units = arg.type === NodeType.ArrayExpression ? arg.elements.filter(
+          (item) => item !== null && item.type !== NodeType.SpreadElement
+        ) : [arg];
+        const scope2 = context.sourceCode.getScope(node);
+        const store = identify("store", node.callee.object, scope2);
+        if (!store) return;
+        const set = map.get(store.id) ?? /* @__PURE__ */ new Set();
+        for (const unit of units) {
+          const instance = identify("unit", unit, scope2);
+          if (!instance) continue;
+          if (set.has(instance.id)) {
+            const data = { store: store.name, unit: instance.name };
+            context.report({ messageId: "duplicate", node: unit, data });
+          } else set.add(instance.id);
+        }
+        map.set(store.id, set);
+      }
+    };
+  }
+});
+function traverseToRoot2(node, path = []) {
+  if (node.type === NodeType.Identifier) return { node, path };
+  if (node.type === NodeType.MemberExpression && node.property.type === NodeType.Identifier)
+    return traverseToRoot2(node.object, [node.property.name, ...path]);
+  return null;
+}
+var STORE_METHODS = ["on", "reset"];
+function traverseStoreToRoot(node, path = []) {
+  if (node.type === NodeType.Identifier) return { node, path };
+  if (node.type === NodeType.MemberExpression && node.property.type === NodeType.Identifier)
+    return traverseStoreToRoot(node.object, [node.property.name, ...path]);
+  if (node.type === NodeType.CallExpression && node.callee.type === NodeType.MemberExpression) {
+    if (node.callee.property.type === NodeType.Identifier && STORE_METHODS.includes(node.callee.property.name))
+      return traverseStoreToRoot(node.callee.object, path);
+  }
+  return null;
+}
+function raiseStoreToVariable(node) {
+  let current = node;
+  while (current.parent) {
+    if (current.parent.type === NodeType.VariableDeclarator)
+      return current.parent;
+    if (current.parent.type !== NodeType.MemberExpression || current.parent.object !== current)
+      return null;
+    if (current.parent.property.type !== NodeType.Identifier || !STORE_METHODS.includes(current.parent.property.name))
+      return null;
+    const grandparent = current.parent.parent;
+    if (grandparent?.type !== NodeType.CallExpression || grandparent.callee !== current.parent)
+      return null;
+    current = current.parent.parent;
+  }
+  return null;
+}
+function findSuitableRoot(type, node) {
+  if (type === "unit") return traverseToRoot2(node);
+  const root = traverseStoreToRoot(node);
+  if (root) return root;
+  const declarator = raiseStoreToVariable(node);
+  if (declarator && declarator.id.type === NodeType.Identifier)
+    return { node: declarator.id, path: [] };
+  return null;
+}
+function identify(type, node, scope2) {
+  const root = findSuitableRoot(type, node);
+  if (!root) return null;
+  const variable = findVariable(scope2, root.node.name);
+  if (!variable) return null;
+  return {
+    id: `${variableId(variable)}+${root.path.join(".")}`,
+    name: [variable.name, ...root.path].join(".")
+  };
+}
+function findVariable(scope2, name) {
+  for (let current = scope2; current; current = current.upper) {
+    const variable = current.set.get(name);
+    if (variable) return variable;
+  }
+  return null;
+}
+var variableCounter = 0;
+var variableIds = /* @__PURE__ */ new WeakMap();
+function variableId(variable) {
+  let id = variableIds.get(variable);
+  if (id === void 0) variableIds.set(variable, id = ++variableCounter);
+  return id;
+}
+
+// src/rules/no-forward/no-forward.ts
+import esquery from "esquery";
+var no_forward_default = createRule({
+  name: "no-forward",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer `sample` over `forward`."
+    },
+    messages: {
+      noForward: "Use `sample` operator instead of `forward` as a more universal approach.",
+      replaceWithSample: "Replace `forward` with `sample`."
+    },
+    hasSuggestions: true,
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    let sample;
+    const forwards = /* @__PURE__ */ new Map();
+    const source = context.sourceCode;
+    const visitorKeys = source.visitorKeys;
+    const importSelector = fromPackage(PACKAGE_NAME.core);
+    return {
+      [`${importSelector} > ${selector8.forward}`]: (node) => forwards.set(node.local.name, node),
+      [`${importSelector} > ${selector8.sample}`]: (node) => sample = node.local.name,
+      [`CallExpression${selector8.call}:has(${selector8.argument})`]: (node) => {
+        if (!forwards.has(node.callee.name)) return;
+        const config = {};
+        const arg = node.arguments[0];
+        config.clock = locate.property("from", arg)?.value;
+        config.target = locate.property("to", arg)?.value;
+        if (config.target) {
+          const [call] = esquery.match(config.target, query.prepend, { visitorKeys }).map((match) => match).filter((match) => match === config.target);
+          if (call)
+            [config.target, config.fn] = [
+              call.callee.object,
+              call.arguments[0]
+            ];
+        }
+        if (config.clock && !config.fn) {
+          const [call] = esquery.match(config.clock, query.map, { visitorKeys }).map((match) => match).filter((match) => match === config.clock);
+          if (call)
+            [config.clock, config.fn] = [call.callee.object, call.arguments[0]];
+        }
+        const code = ["clock", "fn", "target"].filter((key2) => config[key2] !== void 0).map((key2) => `${key2}: ${source.getText(config[key2])}`).join(", ");
+        const suggestion = {
+          messageId: "replaceWithSample",
+          fix: function* (fixer) {
+            const fn = sample ?? "sample";
+            yield fixer.replaceText(node, `${fn}({ ${code} })`);
+            if (!sample)
+              yield fixer.insertTextAfter(
+                forwards.get(node.callee.name),
+                `, sample`
+              );
+          }
+        };
+        context.report({
+          messageId: "noForward",
+          node: node.callee,
+          suggest: [suggestion]
+        });
+      }
+    };
+  }
+});
+var selector8 = {
+  forward: `ImportSpecifier[imported.name="forward"]`,
+  sample: `ImportSpecifier[imported.name="sample"]`,
+  call: `[callee.type="Identifier"][arguments.length=1]`,
+  argument: `ObjectExpression.arguments`
+};
+var query = {
+  map: esquery.parse(
+    "CallExpression[arguments.length=1]:has(> :first-child:expression.arguments):has(> MemberExpression.callee:has(Identifier.property[name='map']))"
+  ),
+  prepend: esquery.parse(
+    "CallExpression[arguments.length=1]:has(> :first-child:expression.arguments):has(> MemberExpression.callee:has(Identifier.property[name='prepend']))"
+  )
+};
+
+// src/rules/no-getState/no-getState.ts
+var no_getState_default = createRule({
+  name: "no-getState",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid `.getState` calls on Effector stores."
+    },
+    messages: {
+      named: "Method `.getState` used on store `{{ name }}` can lead to race conditions. Replace with with `sample` or `attach`.",
+      anonymous: "Method `.getState` used on store can lead to race conditions. Replace with with `sample` or `attach`."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const services = getParserServices(context);
+    return {
+      [`CallExpression[callee.type="MemberExpression"][callee.property.name="getState"]`]: (node) => {
+        const type = services.getTypeAtLocation(node.callee.object);
+        const isStore = isType.store(type);
+        if (!isStore) return;
+        const name = nameOf.expression.simple(node.callee.object);
+        if (name) context.report({ node, messageId: "named", data: { name } });
+        else context.report({ node, messageId: "anonymous" });
+      }
+    };
+  }
+});
+
+// src/rules/no-guard/no-guard.ts
+import esquery2 from "esquery";
+var no_guard_default = createRule({
+  name: "no-guard",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer `sample` over `guard`."
+    },
+    messages: {
+      noGuard: "Use `sample` operator instead of `guard` as a more universal approach.",
+      replaceWithSample: "Replace `guard` with `sample`."
+    },
+    hasSuggestions: true,
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    let sample;
+    const guards = /* @__PURE__ */ new Map();
+    const source = context.sourceCode;
+    const visitorKeys = source.visitorKeys;
+    const importSelector = fromPackage(PACKAGE_NAME.core);
+    return {
+      [`${importSelector} > ${selector9.guard}`]: (node) => guards.set(node.local.name, node),
+      [`${importSelector} > ${selector9.sample}`]: (node) => sample = node.local.name,
+      [`CallExpression${selector9.call}`]: (node) => {
+        if (!guards.has(node.callee.name)) return;
+        const config = {};
+        if (node.arguments.length === 1 && node.arguments[0].type === NodeType.ObjectExpression) {
+          const [arg] = node.arguments;
+          for (const key2 of ["clock", "source", "filter", "target"])
+            config[key2] = locate.property(key2, arg)?.value;
+        } else if (node.arguments.length === 2 && node.arguments[1].type === NodeType.ObjectExpression) {
+          const [clock, arg] = node.arguments;
+          config.clock = clock;
+          for (const key2 of ["source", "filter", "target"])
+            config[key2] = locate.property(key2, arg)?.value;
+        } else return;
+        if (config.target) {
+          const [call] = esquery2.match(config.target, query2.prepend, { visitorKeys }).map((match) => match).filter((match) => match === config.target);
+          if (call)
+            [config.target, config.fn] = [
+              call.callee.object,
+              call.arguments[0]
+            ];
+        }
+        const code = ["clock", "source", "filter", "fn", "target"].filter((key2) => config[key2] !== void 0).map((key2) => `${key2}: ${source.getText(config[key2])}`).join(", ");
+        const suggestion = {
+          messageId: "replaceWithSample",
+          fix: function* (fixer) {
+            const fn = sample ?? "sample";
+            yield fixer.replaceText(node, `${fn}({ ${code} })`);
+            if (!sample)
+              yield fixer.insertTextAfter(
+                guards.get(node.callee.name),
+                `, sample`
+              );
+          }
+        };
+        context.report({
+          messageId: "noGuard",
+          node: node.callee,
+          suggest: [suggestion]
+        });
+      }
+    };
+  }
+});
+var selector9 = {
+  guard: `ImportSpecifier[imported.name="guard"]`,
+  sample: `ImportSpecifier[imported.name="sample"]`,
+  call: `[callee.type="Identifier"]`
+};
+var query2 = {
+  prepend: esquery2.parse(
+    "CallExpression[arguments.length=1]:has(:first-child:expression.arguments):has(> MemberExpression.callee:has(Identifier.property[name='prepend']))"
+  )
+};
+
+// src/rules/no-patronum-debug/no-patronum-debug.ts
+var no_patronum_debug_default = createRule({
+  name: "no-patronum-debug",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow the use of `patronum` `debug`."
+    },
+    messages: {
+      unexpected: "Unexpected `debug` call.",
+      remove: "Remove this `debug` call."
+    },
+    schema: [],
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const debugs = /* @__PURE__ */ new Set();
+    const importSelector = `ImportDeclaration[source.value=${PACKAGE_NAME2}]`;
+    return {
+      [`${importSelector} > ${selector10.debug}`]: (node) => debugs.add(node.local.name),
+      [`CallExpression:matches(${selector10.call})`]: (node) => {
+        const name = toName2(node);
+        if (!debugs.has(name)) return;
+        const suggestion = {
+          messageId: "remove",
+          fix: (fixer) => {
+            if (node.parent.type === NodeType.ExpressionStatement)
+              return fixer.remove(node.parent);
+            else return fixer.replaceText(node, "undefined");
+          }
+        };
+        context.report({
+          messageId: "unexpected",
+          node: node.callee,
+          suggest: [suggestion]
+        });
+      }
+    };
+  }
+});
+var PACKAGE_NAME2 = /^patronum(?:\u002Fdebug)?$/;
+var selector10 = {
+  debug: `ImportSpecifier[imported.name="debug"]`,
+  call: `[callee.type=Identifier], [callee.object.type=Identifier]`
+};
+var toName2 = (node) => {
+  switch (node.callee.type) {
+    case NodeType.Identifier:
+      return node.callee.name;
+    case NodeType.MemberExpression:
+      return node.callee.object.name;
+  }
+};
+
+// src/rules/no-units-spawn-in-render/no-units-spawn-in-render.ts
+import {
+  isExpression
+} from "typescript";
+var EFFECTOR_FACTORIES = /* @__PURE__ */ new Set([
+  "createStore",
+  "createEvent",
+  "createEffect",
+  "createDomain",
+  "createApi",
+  "restore"
+]);
+var EFFECTOR_OPERATORS = /* @__PURE__ */ new Set([
+  "sample",
+  "guard",
+  "forward",
+  "merge",
+  "split",
+  "combine",
+  "attach"
+]);
+var REACT_HOOKS_SPEC = {
+  from: "package",
+  package: "react",
+  name: [
+    "useState",
+    "useEffect",
+    "useLayoutEffect",
+    "useCallback",
+    "useMemo",
+    "useRef",
+    "useReducer",
+    "useImperativeHandle",
+    "useDebugValue",
+    "useDeferredValue",
+    "useTransition",
+    "useId",
+    "useSyncExternalStore",
+    "useInsertionEffect",
+    "useContext"
+  ]
+};
+var EFFECTOR_FACTORY_SPEC = {
+  from: "package",
+  package: "effector",
+  name: [...EFFECTOR_FACTORIES]
+};
+var EFFECTOR_OPERATOR_SPEC = {
+  from: "package",
+  package: "effector",
+  name: [...EFFECTOR_OPERATORS]
+};
+var EFFECTOR_FACTORIO_SHAPE = [
+  "useModel",
+  "createModel",
+  "Provider",
+  "@@unitShape"
+];
+var no_units_spawn_in_render_default = createRule({
+  name: "no-units-spawn-in-render",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid creating Effector units or calling operators inside React components or hooks."
+    },
+    messages: {
+      noFactoryInRender: 'Creating Effector units with "{{ name }}" inside React component or hook is forbidden, since it may cause memory leaks and other bugs.',
+      noOperatorInRender: 'Using Effector operator "{{ name }}" inside React component or hook is forbidden, since it may cause memory leaks and other bugs.',
+      noCustomFactoryInRender: 'Creating Effector units with "{{ name }}" inside React component or hook is forbidden, since it may cause memory leaks and other bugs. If this is a false positive, add "{{ name }}" to the allowlist in the detectCustomFactories option.'
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          detectCustomFactories: {
+            oneOf: [
+              { type: "boolean" },
+              {
+                type: "object",
+                properties: {
+                  allowlist: {
+                    type: "array",
+                    items: { type: "string" },
+                    uniqueItems: true
+                  }
+                },
+                required: ["allowlist"],
+                additionalProperties: false
+              }
+            ]
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [{ detectCustomFactories: true }],
+  create: (context, [options]) => {
+    const services = getParserServices(context);
+    const checker = services.program.getTypeChecker();
+    const { detectCustomFactories } = options;
+    const allowlist = typeof detectCustomFactories === "object" ? new Set(detectCustomFactories.allowlist) : void 0;
+    const stack = { render: [] };
+    const effectorImports = /* @__PURE__ */ new Map();
+    const importSelector = fromPackage(PACKAGE_NAME.core);
+    return {
+      // ── Phase 1: Collect effector imports ──────────────────────────────────
+      [`${importSelector} > ImportSpecifier[imported.type="Identifier"]`]: (node) => {
+        const imported = node.imported.name;
+        const local = node.local.name;
+        if (EFFECTOR_FACTORIES.has(imported)) {
+          effectorImports.set(local, "factory");
+        } else if (EFFECTOR_OPERATORS.has(imported)) {
+          effectorImports.set(local, "operator");
+        }
+      },
+      // ── Phase 2: Track render scope via function enter/exit ────────────────
+      //
+      // Determines if a function is a render context using a series of
+      // heuristics,
+      // ordered from cheapest to most expensive:
+      // 1. Inherit from parent — if already inside render, every nested scope
+      // is too
+      //   2. Name check — `useXxx` convention means a custom hook
+      //   3. Return type — if the function returns JSX, it's a component
+      // 4. Contextual type — if the function is used where a component type is
+      // expected
+      // (e.g. React.memo, forwardRef), it's a component even without explicit
+      // annotation
+      [`FunctionDeclaration, FunctionExpression, ArrowFunctionExpression`]: (node) => {
+        const current = stack.render.at(-1) ?? false;
+        if (current) return void stack.render.push(true);
+        const name = nameOf.function(node);
+        if (name && UseRegex2.test(name.name))
+          return void stack.render.push(true);
+        const tsnode = services.esTreeNodeToTSNodeMap.get(node);
+        const signature = checker.getSignatureFromDeclaration(tsnode);
+        const returnType = signature ? checker.getReturnTypeOfSignature(signature) : void 0;
+        const isJSX = matchesType2(returnType, (type) => isType.jsx(type));
+        if (isJSX) return void stack.render.push(true);
+        const inferred = isExpression(tsnode) ? checker.getContextualType(tsnode) : void 0;
+        const isComponent = matchesType2(
+          inferred,
+          (type) => isType.component(type)
+        );
+        if (isComponent) return void stack.render.push(true);
+        return void stack.render.push(false);
+      },
+      [`:matches(FunctionDeclaration, FunctionExpression, ArrowFunctionExpression):exit`]: () => void stack.render.pop(),
+      // Class bodies are never render contexts themselves — class methods (like
+      // render())
+      // will get their own stack entry and be evaluated independently.
+      ClassDeclaration: () => void stack.render.push(false),
+      "ClassDeclaration:exit": () => void stack.render.pop(),
+      // ── Phase 3: Flag violating calls inside render ────────────────────────
+      //
+      // Detection is done in two tiers, ordered so we can avoid expensive type
+      // analysis when possible and catch operators whose return type is not a
+      // unit:
+      //
+      //   Tier 1 — Import-based (no type analysis):
+      // If the callee was imported from effector (tracked in Phase 1), we know
+      // its kind immediately. This is essential for operators like `forward`
+      //     and `guard` that return Subscription instead of a unit.
+      //
+      //   Tier 2 — Type-based (requires type checker):
+      // For everything else, check if the call's return type contains effector
+      //     units. If it does, classify the callee via typeMatchesSpecifier:
+      //     - Known React hooks are excluded to avoid double-reporting: e.g.
+      //       `useMemo(() => createStore(0), [])` returns Store, but the inner
+      // `createStore` and the like is already flagged — reporting `useMemo` too
+      // would be noise.
+      // `useContext` is excluded because it legitimately retrieves pre-created
+      // units.
+      // - effector-factorio's `factory.useModel()` is excluded — it retrieves
+      //       pre-created units from React context, similar to useContext
+      // - Namespaced effector calls (e.g. `effector.createStore`) are matched
+      //       by callee type against the effector package
+      //     - Anything remaining is treated as a custom factory
+      CallExpression: (node) => {
+        const isWithinRender = stack.render.at(-1) ?? false;
+        if (!isWithinRender) return;
+        const calleeName = getCalleeName(node.callee);
+        const importType = calleeName ? effectorImports.get(calleeName) : void 0;
+        switch (importType) {
+          case "factory":
+            return context.report({
+              node,
+              messageId: "noFactoryInRender",
+              data: { name: calleeName }
+            });
+          case "operator":
+            return context.report({
+              node,
+              messageId: "noOperatorInRender",
+              data: { name: calleeName }
+            });
+        }
+        if (detectCustomFactories === false) return;
+        const returnType = services.getTypeAtLocation(node);
+        const ctx = {
+          node: services.esTreeNodeToTSNodeMap.get(node),
+          checker,
+          program: services.program
+        };
+        if (!hasEffectorUnitInType(ctx, returnType)) return;
+        const calleeType = services.getTypeAtLocation(node.callee);
+        const displayName = calleeName ?? "<expression>";
+        if (typeMatches(
+          calleeType,
+          REACT_HOOKS_SPEC.name,
+          REACT_HOOKS_SPEC.package
+        ))
+          return;
+        if (isEffectorFactorioHook(node.callee, services.getTypeAtLocation))
+          return;
+        if (typeMatches(
+          calleeType,
+          EFFECTOR_FACTORY_SPEC.name,
+          EFFECTOR_FACTORY_SPEC.package
+        ))
+          return context.report({
+            node,
+            messageId: "noFactoryInRender",
+            data: { name: displayName }
+          });
+        if (typeMatches(
+          calleeType,
+          EFFECTOR_OPERATOR_SPEC.name,
+          EFFECTOR_OPERATOR_SPEC.package
+        ))
+          return context.report({
+            node,
+            messageId: "noOperatorInRender",
+            data: { name: displayName }
+          });
+        if (allowlist && calleeName && allowlist.has(calleeName)) return;
+        context.report({
+          node,
+          messageId: "noCustomFactoryInRender",
+          data: { name: displayName }
+        });
+      }
+    };
+  }
+});
+var UseRegex2 = /^use[A-Z0-9].*$/;
+var matchesType2 = (type, predicate) => {
+  if (!type) return false;
+  if (type.isUnion()) return type.types.some(predicate);
+  return predicate(type);
+};
+function getCalleeName(callee) {
+  if (callee.type === NodeType.Identifier) return callee.name;
+  if (callee.type === NodeType.MemberExpression && callee.property.type === NodeType.Identifier)
+    return callee.property.name;
+  else return null;
+}
+function hasEffectorUnitInType(ctx, type, depth = 3) {
+  if (isType.unit(type)) return true;
+  if (depth <= 0) return false;
+  if (type.isUnion())
+    return type.types.some(
+      (member) => hasEffectorUnitInType(ctx, member, depth)
+    );
+  for (const property2 of type.getProperties()) {
+    const propertyType = ctx.checker.getTypeOfSymbolAtLocation(
+      property2,
+      ctx.node
+    );
+    if (hasEffectorUnitInType(ctx, propertyType, depth - 1)) return true;
+  }
+  return false;
+}
+function isEffectorFactorioHook(callee, getTypeAtLocation) {
+  if (callee.type !== NodeType.MemberExpression) return false;
+  if (callee.property.type !== NodeType.Identifier) return false;
+  if (callee.property.name !== "useModel")
+    return false;
+  const objectType = getTypeAtLocation(callee.object);
+  const propertyNames = new Set(
+    objectType.getProperties().map((p) => p.getName())
+  );
+  return EFFECTOR_FACTORIO_SHAPE.every((name) => propertyNames.has(name));
+}
+
+// src/rules/no-unnecessary-combination/no-unnecessary-combination.ts
+var no_unnecessary_combination_default = createRule({
+  name: "no-unnecessary-combination",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Forbid unnecessary combinations in `clock` and `source`."
+    },
+    messages: {
+      unnecessary: "{{ method }} is used under the hood of {{ property }} in {{ operator }}, you can omit it."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const services = getParserServices(context);
+    const operators = /* @__PURE__ */ new Set();
+    const combinators = /* @__PURE__ */ new Map();
+    const importSelector = fromPackage(PACKAGE_NAME.core);
+    return {
+      [`${importSelector} > ${selector11.operator}`]: (node) => operators.add(node.local.name),
+      [`${importSelector} > ${selector11.combinator}`]: (node) => combinators.set(
+        node.local.name,
+        node.imported.name
+      ),
+      [`CallExpression${selector11.call}:has(${selector11.argument})`]: (node) => {
+        if (!operators.has(node.callee.name)) return;
+        const [config] = node.arguments;
+        const clock = locate.property("clock", config)?.value;
+        const source = locate.property("source", config)?.value;
+        if (clock?.type === NodeType.CallExpression && clock.callee.type === NodeType.Identifier) {
+          const method = combinators.get(clock.callee.name);
+          if (method === "merge") {
+            const data = {
+              method: clock.callee.name,
+              property: "clock",
+              operator: node.callee.name
+            };
+            context.report({ node: clock, messageId: "unnecessary", data });
+          }
+        }
+        if (source?.type === NodeType.CallExpression && source.callee.type === NodeType.Identifier) {
+          const method = combinators.get(source.callee.name);
+          if (!method) return;
+          if (method === "combine" && source.arguments.length > 1 && isFunction(source.arguments.at(-1), services))
+            return;
+          const data = {
+            method: source.callee.name,
+            property: "source",
+            operator: node.callee.name
+          };
+          context.report({ node: source, messageId: "unnecessary", data });
+        }
+      }
+    };
+  }
+});
+var selector11 = {
+  operator: `ImportSpecifier[imported.name=/(sample|guard)/]`,
+  combinator: `ImportSpecifier[imported.name=/(combine|merge)/]`,
+  call: `[callee.type="Identifier"][arguments.length=1]`,
+  argument: `ObjectExpression.arguments`
+};
+function isFunction(node, services) {
+  if (node.type === NodeType.ArrowFunctionExpression) return true;
+  else if (node.type === NodeType.FunctionExpression) return true;
+  else if (node.type === NodeType.Identifier) {
+    const checker = services.program.getTypeChecker();
+    const tsnode = services.esTreeNodeToTSNodeMap.get(node);
+    const type = checker.getTypeAtLocation(tsnode);
+    const signatures = type.getCallSignatures();
+    return signatures.length > 0;
+  } else return false;
+}
+
+// src/rules/no-unnecessary-duplication/no-unnecessary-duplication.ts
+var no_unnecessary_duplication_default = createRule({
+  name: "no-unnecessary-duplication",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid duplicate `source` and `clock` in `sample` and `guard`."
+    },
+    messages: {
+      duplicate: "Method `{{ method }}` has the same value for `source` and `clock`. Consider using only one of them.",
+      removeClock: "Remove the `clock`",
+      removeSource: "Remove the `source`"
+    },
+    schema: [],
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const imports = /* @__PURE__ */ new Set();
+    const importSelector = fromPackage(PACKAGE_NAME.core);
+    return {
+      [`${importSelector} > ${selector12.method}`]: (node) => imports.add(node.local.name),
+      [`CallExpression${selector12.call}:has(${selector12.argument})`]: (node) => {
+        if (!imports.has(node.callee.name)) return;
+        const [config] = node.arguments;
+        const source = locate.property("source", config)?.value;
+        if (!source) return;
+        const clock = locate.property("clock", config)?.value;
+        if (!clock) return;
+        const equal = compare(clock, source);
+        if (!equal) return;
+        const suggestions = [
+          {
+            messageId: "removeClock",
+            fix: function* (fixer) {
+              yield fixer.remove(clock.parent);
+              const after = context.sourceCode.getTokenAfter(clock.parent);
+              if (after?.value === ",") yield fixer.remove(after);
+            }
+          },
+          {
+            messageId: "removeSource",
+            fix: function* (fixer) {
+              yield fixer.remove(source.parent);
+              const after = context.sourceCode.getTokenAfter(source.parent);
+              if (after?.value === ",") yield fixer.remove(after);
+            }
+          }
+        ];
+        const data = { method: node.callee.name };
+        context.report({
+          node: config,
+          messageId: "duplicate",
+          data,
+          suggest: suggestions
+        });
+      }
+    };
+  }
+});
+var selector12 = {
+  method: `ImportSpecifier[imported.name=/(sample|guard)/]`,
+  call: `[callee.type="Identifier"][arguments.length=1]`,
+  argument: `ObjectExpression.arguments`
+};
+function compare(clock, source, limit = 5) {
+  if (limit <= 0) return false;
+  if (clock.type === NodeType.Identifier)
+    return source.type === NodeType.Identifier && clock.name === source.name;
+  if (clock.type === NodeType.ArrayExpression) {
+    if (clock.elements.length !== 1) return false;
+    let a, b;
+    if (source.type === NodeType.ArrayExpression)
+      if (source.elements.length !== 1)
+        return false;
+      else
+        [a, b] = [
+          clock.elements[0],
+          source.elements[0]
+        ];
+    else [a, b] = [clock.elements[0], source];
+    return a.type === NodeType.Identifier && b.type === NodeType.Identifier && a.name === b.name;
+  }
+  if (clock.type === NodeType.MemberExpression) {
+    if (source.type !== NodeType.MemberExpression) return false;
+    if (clock.computed || source.computed) return false;
+    if (clock.property.name !== source.property.name) return false;
+    return compare(clock.object, source.object, limit - 1);
+  }
+  return false;
+}
+
+// src/rules/no-useless-methods/no-useless-methods.ts
+import esquery3 from "esquery";
+var no_useless_methods_default = createRule({
+  name: "no-useless-methods",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid useless calls of `sample` and `guard`."
+    },
+    messages: {
+      uselessMethod: "Method `{{ method }}` does nothing in this case. You should assign the result to variable or pass `target` to it."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const imports = /* @__PURE__ */ new Set();
+    const source = context.sourceCode;
+    const visitorKeys = source.visitorKeys;
+    const importSelector = fromPackage(PACKAGE_NAME.core);
+    const usageStack = [];
+    return {
+      ReturnStatement: () => usageStack.push(true),
+      "ReturnStatement:exit": () => usageStack.pop(),
+      VariableDeclarator: () => usageStack.push(true),
+      "VariableDeclarator:exit": () => usageStack.pop(),
+      ObjectExpression: () => usageStack.push(true),
+      "ObjectExpression:exit": () => usageStack.pop(),
+      BlockStatement: () => usageStack.push(false),
+      "BlockStatement:exit": () => usageStack.pop(),
+      [`${importSelector} > ${selector13.method}`]: (node) => imports.add(node.local.name),
+      [`CallExpression[callee.type="Identifier"]`]: (node) => {
+        const isTracked = imports.has(node.callee.name);
+        if (!isTracked) return;
+        const isUsed = usageStack.at(-1) ?? false;
+        if (isUsed) return;
+        if (node.parent.type === NodeType.CallExpression)
+          return;
+        const [config] = node.arguments;
+        if (config?.type === NodeType.ObjectExpression) {
+          const target = locate.property("target", config)?.value;
+          if (target) return;
+        }
+        const grandparent = node.parent.parent;
+        const ancestry = source.getAncestors(grandparent);
+        const isWatched = esquery3.matches(
+          grandparent,
+          query3.watch,
+          ancestry,
+          { visitorKeys }
+        );
+        if (isWatched) return;
+        const method = node.callee.name;
+        context.report({ node, messageId: "uselessMethod", data: { method } });
+      }
+    };
+  }
+});
+var selector13 = {
+  method: `ImportSpecifier[imported.name=/(sample|guard)/]`
+};
+var query3 = {
+  // https://github.com/estools/esquery/pull/146
+  watch: esquery3.parse(
+    "CallExpression:has(> MemberExpression.callee[property.name=watch]:has(> CallExpression.object))"
+  )
+};
+
+// src/rules/no-watch/no-watch.ts
+var no_watch_default = createRule({
+  name: "no-watch",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Restrict usage of `.watch` on any Effector Unit."
+    },
+    messages: {
+      restricted: "Using `.watch` method leads to imperative code. Replace it with an operator `sample` or use the `target` parameter of `sample` operator."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const services = getParserServices(context);
+    return {
+      [`CallExpression[callee.type="MemberExpression"][callee.property.name="watch"]`]: (node) => {
+        const type = services.getTypeAtLocation(node.callee.object);
+        const isUnit = isType.unit(type);
+        if (!isUnit) return;
+        context.report({ node, messageId: "restricted" });
+      }
+    };
+  }
+});
+
+// src/rules/prefer-useUnit/prefer-useUnit.ts
+var prefer_useUnit_default = createRule({
+  name: "prefer-useUnit",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer `useUnit` over deprecated `useStore` and `useEvent` hooks."
+    },
+    messages: {
+      useUseUnit: "`{{ name }}` should be replaced with `useUnit`."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const imports = /* @__PURE__ */ new Map();
+    const importSelector = fromPackage(PACKAGE_NAME.react);
+    return {
+      [`${importSelector} > ${selector14.useStore}`]: (node) => void imports.set(node.local.name, "useStore"),
+      [`${importSelector} > ${selector14.useEvent}`]: (node) => void imports.set(node.local.name, "useEvent"),
+      [`CallExpression[callee.type="Identifier"]`]: (node) => {
+        const hook = imports.get(node.callee.name);
+        if (!hook) return;
+        context.report({ node, messageId: "useUseUnit", data: { name: hook } });
+      }
+    };
+  }
+});
+var selector14 = {
+  useStore: `ImportSpecifier[imported.name=useStore]`,
+  useEvent: `ImportSpecifier[imported.name=useEvent]`
+};
+
+// src/rules/require-pickup-in-persist/require-pickup-in-persist.ts
+var require_pickup_in_persist_default = createRule({
+  name: "require-pickup-in-persist",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require every `persist` call of `effector-storage` to use `pickup`."
+    },
+    messages: {
+      missing: "This `persist` call does not specify a `pickup` event that is required for scoped usage of `effector-storage`."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const imports = /* @__PURE__ */ new Set();
+    const importSelector = fromPackage(PACKAGE_NAME.storage);
+    return {
+      [`${importSelector} > ${selector15.persist}`]: (node) => imports.add(node.local.name),
+      [`CallExpression${selector15.call}${selector15.config}`]: (node) => {
+        if (!imports.has(node.callee.name)) return;
+        const config = node.arguments[0];
+        if (config.properties.filter((prop) => prop.type === NodeType.Property).map((prop) => prop.key).filter((key2) => key2.type === NodeType.Identifier).some((key2) => key2.name === "pickup"))
+          return;
+        context.report({ node, messageId: "missing" });
+      }
+    };
+  }
+});
+var selector15 = {
+  persist: `ImportSpecifier[imported.name="persist"]`,
+  call: `[callee.type="Identifier"]`,
+  config: `[arguments.length=1][arguments.0.type="ObjectExpression"]`
+};
+
+// src/rules/strict-effect-handlers/strict-effect-handlers.ts
+var strict_effect_handlers_default = createRule({
+  name: "strict-effect-handlers",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid mixing calls to both regular async functions and Effects in the same function."
+    },
+    messages: {
+      mixed: "This function can lead to losing Scope in Effector Fork API."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const services = getParserServices(context);
+    const stack = [];
+    const track = (node) => {
+      const current = stack.at(-1);
+      if (!current) return;
+      const callee = node.argument.callee;
+      const type = services.getTypeAtLocation(callee);
+      const isEffect = isType.effect(type);
+      if (isEffect) return current.effect = true;
+      else return current.regular = true;
+    };
+    const enter = () => {
+      stack.push({ effect: false, regular: false });
+    };
+    const exit = (node) => {
+      const scope2 = stack.pop();
+      if (scope2.effect && scope2.regular)
+        context.report({ node, messageId: "mixed" });
+    };
+    return {
+      ArrowFunctionExpression: enter,
+      "ArrowFunctionExpression:exit": exit,
+      FunctionExpression: enter,
+      "FunctionExpression:exit": exit,
+      FunctionDeclaration: enter,
+      "FunctionDeclaration:exit": exit,
+      [`AwaitExpression:matches([argument.type='CallExpression'], [argument.type='NewExpression'])`]: track
+    };
+  }
+});
+
+// src/ruleset.ts
+var recommended = {
+  "effector/enforce-effect-naming-convention": "error",
+  "effector/enforce-store-naming-convention": "error",
+  "effector/keep-options-order": "warn",
+  "effector/no-ambiguity-target": "warn",
+  "effector/no-duplicate-on": "error",
+  "effector/no-forward": "error",
+  "effector/no-getState": "error",
+  "effector/no-guard": "error",
+  "effector/no-unnecessary-combination": "warn",
+  "effector/no-unnecessary-duplication": "warn",
+  "effector/no-useless-methods": "error",
+  "effector/no-watch": "warn"
+};
+var patronum = {
+  "effector/no-patronum-debug": "warn"
+};
+var scope = {
+  "effector/require-pickup-in-persist": "error",
+  "effector/strict-effect-handlers": "error"
+};
+var react = {
+  "effector/enforce-gate-naming-convention": "error",
+  "effector/enforce-exhaustive-useUnit-destructuring": "warn",
+  "effector/mandatory-scope-binding": "error",
+  "effector/no-units-spawn-in-render": "error",
+  "effector/prefer-useUnit": "error"
+};
+var future = {
+  "effector/no-domain-unit-creators": "warn"
+};
+var ruleset = { recommended, patronum, scope, react, future };
+
+// src/index.ts
+var plugin = {
+  meta: { name: "effector", version: "0.0.1" },
+  rules: {
+    "enforce-effect-naming-convention": enforce_effect_naming_convention_default,
+    "enforce-exhaustive-useUnit-destructuring": enforce_exhaustive_useUnit_destructuring_default,
+    "enforce-gate-naming-convention": enforce_gate_naming_convention_default,
+    "enforce-store-naming-convention": enforce_store_naming_convention_default,
+    "keep-options-order": keep_options_order_default,
+    "mandatory-scope-binding": mandatory_scope_binding_default,
+    "no-ambiguity-target": no_ambiguity_target_default,
+    "no-domain-unit-creators": no_domain_unit_creators_default,
+    "no-duplicate-clock-or-source-array-values": no_duplicate_clock_or_source_array_values_default,
+    "no-duplicate-on": no_duplicate_on_default,
+    "no-forward": no_forward_default,
+    "no-getState": no_getState_default,
+    "no-guard": no_guard_default,
+    "no-patronum-debug": no_patronum_debug_default,
+    "no-units-spawn-in-render": no_units_spawn_in_render_default,
+    "no-unnecessary-combination": no_unnecessary_combination_default,
+    "no-unnecessary-duplication": no_unnecessary_duplication_default,
+    "no-useless-methods": no_useless_methods_default,
+    "no-watch": no_watch_default,
+    "prefer-useUnit": prefer_useUnit_default,
+    "require-pickup-in-persist": require_pickup_in_persist_default,
+    "strict-effect-handlers": strict_effect_handlers_default
+  },
+  configs: ruleset
+};
+var index_default = plugin;
+export {
+  index_default as default
+};