@studiometa/eslint-plugin-js-toolkit 0.1.0 → 3.6.0-beta.1

package/dist/index.js

@@ -0,0 +1,1064 @@
+// ../../node_modules/@oxlint/plugins/index.js
+var EMPTY_VISITOR = {};
+function eslintCompatPlugin(plugin2) {
+  if (typeof plugin2 != "object" || !plugin2) throw Error("Plugin must be an object");
+  let { rules: rules2 } = plugin2;
+  if (typeof rules2 != "object" || !rules2) throw Error("Plugin must have an object as `rules` property");
+  let afterHooksState = new AfterHooksState();
+  for (let ruleName in rules2) Object.hasOwn(rules2, ruleName) && convertRule(rules2[ruleName], afterHooksState);
+  return plugin2;
+}
+var AfterHooksState = class {
+  resetFunctions = [];
+  pendingStates = [];
+  pendingCount = 0;
+  lintFinishedCount = 0;
+  resetIsScheduled = false;
+  sourceCode = null;
+  resetMicrotask = this.resetMicrotaskImpl.bind(this);
+  /**
+  * Register a function to run `after` hook for a rule, and reset state.
+  * @param reset - Function to run `after` hook and reset state
+  * @returns Index of rule
+  */
+  registerResetFunction(reset) {
+    let { pendingStates } = this, index = pendingStates.length;
+    return pendingStates.push(0), this.resetFunctions.push(reset), index;
+  }
+  /**
+  * Register that a rule with `after` hook has completed linting a file.
+  * Called by `onCodePathEnd` CFG event handler which is added to visitor for rules with `after` hooks.
+  *
+  * If all rules with an `after` hook which needs to be run have completed linting the file, run all `after` hooks.
+  */
+  ruleFinished() {
+    this.lintFinishedCount++, this.lintFinishedCount === this.pendingCount && this.reset(false);
+  }
+  /**
+  * Call all reset functions where corresponding entry in `pendingStates` is `AFTER_HOOK_PENDING`.
+  * Should only be called when some `after` hooks are pending.
+  *
+  * @param ignoreErrors - `true` to catch and silently ignore any errors which occur in `after` hooks.
+  *   `false` to throw them,
+  * @throws {unknown} If `ignoreErrors` is `false` and an error occurs in any `after` hooks.
+  */
+  reset(ignoreErrors) {
+    this.pendingCount;
+    let { resetFunctions, pendingStates } = this, hooksLen = pendingStates.length, hasError = false, error;
+    for (let i = 0; i < hooksLen; i++) if (pendingStates[i] !== 0) {
+      pendingStates[i] = 0;
+      try {
+        resetFunctions[i]();
+      } catch (e) {
+        hasError === false && (hasError = true, error = e);
+      }
+    }
+    if (this.pendingCount = 0, this.lintFinishedCount = 0, this.sourceCode = null, hasError === true && ignoreErrors === false) throw error;
+  }
+  /**
+  * Schedule a microtask to run `reset` functions.
+  */
+  scheduleReset() {
+    queueMicrotask(this.resetMicrotask), this.resetIsScheduled = true;
+  }
+  /**
+  * Function which is scheduled as the cleanup microtask.
+  * `scheduleReset` uses `resetMicrotask` which is this method bound to `this`.
+  */
+  resetMicrotaskImpl() {
+    this.resetIsScheduled = false, this.pendingCount !== 0 && this.reset(true);
+  }
+};
+function convertRule(rule, afterHooksState) {
+  if (typeof rule != "object" || !rule) throw Error("Rule must be an object");
+  if ("create" in rule) return;
+  let context = null, visitor, beforeHook, setupAfterHook;
+  rule.create = (eslintContext) => {
+    context === null && ({ context, visitor, beforeHook, setupAfterHook } = createContextAndVisitor(rule, afterHooksState));
+    let eslintFileContext = Object.getPrototypeOf(eslintContext);
+    if (setupAfterHook !== null) {
+      let { sourceCode } = eslintFileContext;
+      afterHooksState.sourceCode !== sourceCode && (afterHooksState.sourceCode = sourceCode, afterHooksState.pendingCount !== 0 && afterHooksState.reset(true));
+    }
+    return Object.defineProperties(context, {
+      id: { value: eslintContext.id },
+      options: { value: eslintContext.options },
+      report: { value: eslintContext.report }
+    }), Object.setPrototypeOf(context, eslintFileContext), beforeHook !== null && beforeHook() === false ? EMPTY_VISITOR : (setupAfterHook !== null && (setupAfterHook(eslintFileContext.sourceCode.ast), afterHooksState.resetIsScheduled === false && afterHooksState.scheduleReset()), visitor);
+  };
+}
+var FILE_CONTEXT = Object.freeze({
+  get filename() {
+    throw Error("Cannot access `context.filename` in `createOnce`");
+  },
+  getFilename() {
+    throw Error("Cannot call `context.getFilename` in `createOnce`");
+  },
+  get physicalFilename() {
+    throw Error("Cannot access `context.physicalFilename` in `createOnce`");
+  },
+  getPhysicalFilename() {
+    throw Error("Cannot call `context.getPhysicalFilename` in `createOnce`");
+  },
+  get cwd() {
+    throw Error("Cannot access `context.cwd` in `createOnce`");
+  },
+  getCwd() {
+    throw Error("Cannot call `context.getCwd` in `createOnce`");
+  },
+  get sourceCode() {
+    throw Error("Cannot access `context.sourceCode` in `createOnce`");
+  },
+  getSourceCode() {
+    throw Error("Cannot call `context.getSourceCode` in `createOnce`");
+  },
+  get languageOptions() {
+    throw Error("Cannot access `context.languageOptions` in `createOnce`");
+  },
+  get settings() {
+    throw Error("Cannot access `context.settings` in `createOnce`");
+  },
+  extend(extension) {
+    return Object.freeze(Object.assign(Object.create(this), extension));
+  },
+  get parserOptions() {
+    throw Error("Cannot access `context.parserOptions` in `createOnce`");
+  },
+  get parserPath() {
+    throw Error("Cannot access `context.parserPath` in `createOnce`");
+  }
+});
+function createContextAndVisitor(rule, afterHooksState) {
+  let { createOnce } = rule;
+  if (createOnce == null) throw Error("Rules must define either a `create` or `createOnce` method");
+  if (typeof createOnce != "function") throw Error("Rule `createOnce` property must be a function");
+  let context = Object.create(FILE_CONTEXT, {
+    id: {
+      value: null,
+      enumerable: true,
+      configurable: true
+    },
+    options: {
+      value: null,
+      enumerable: true,
+      configurable: true
+    },
+    report: {
+      value() {
+        throw Error("Cannot report errors in `createOnce`");
+      },
+      enumerable: true,
+      configurable: true
+    }
+  }), { before: beforeHook, after: afterHook, ...visitor } = createOnce.call(rule, context);
+  if (beforeHook === void 0) beforeHook = null;
+  else if (beforeHook !== null && typeof beforeHook != "function") throw Error("`before` property of visitor must be a function if defined");
+  let setupAfterHook = null;
+  if (afterHook != null) {
+    if (typeof afterHook != "function") throw Error("`after` property of visitor must be a function if defined");
+    let program = null, ruleIndex = afterHooksState.registerResetFunction(() => {
+      program = null, afterHook();
+    });
+    setupAfterHook = (ast) => {
+      program = ast, afterHooksState.pendingStates[ruleIndex] = 1, afterHooksState.pendingCount++;
+    };
+    let onCodePathEnd = visitor.onCodePathEnd;
+    visitor.onCodePathEnd = onCodePathEnd == null ? function(_codePath, node) {
+      node === program && afterHooksState.ruleFinished();
+    } : function(codePath, node) {
+      onCodePathEnd.call(this, codePath, node), node === program && afterHooksState.ruleFinished();
+    };
+  }
+  return {
+    context,
+    visitor,
+    beforeHook,
+    setupAfterHook
+  };
+}
+
+// src/utils/ast.ts
+function createRule(rule) {
+  return rule;
+}
+var LIFECYCLE_METHODS = /* @__PURE__ */ new Set([
+  "mounted",
+  "destroyed",
+  "updated",
+  "terminated",
+  "ticked",
+  "scrolled",
+  "resized",
+  "moved",
+  "loaded",
+  "keyed"
+]);
+var TOOLKIT_PACKAGE = "@studiometa/js-toolkit";
+function isBaseSubclass(node, context) {
+  if (node.type !== "ClassDeclaration" && node.type !== "ClassExpression") {
+    return false;
+  }
+  if (!node.superClass) {
+    return false;
+  }
+  const superName = node.superClass.type === "Identifier" ? node.superClass.name : null;
+  if (!superName) {
+    return false;
+  }
+  if (superName === "Base") {
+    return true;
+  }
+  const sourceCode = context.sourceCode ?? context.getSourceCode?.();
+  const ast = sourceCode?.ast;
+  if (!ast) {
+    return false;
+  }
+  for (const node2 of ast.body) {
+    if (node2.type !== "ImportDeclaration") continue;
+    if (node2.source.value !== TOOLKIT_PACKAGE) continue;
+    for (const specifier of node2.specifiers) {
+      if (specifier.type === "ImportSpecifier" && specifier.local.name === superName) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isCamelCase(value) {
+  return /^[a-z][a-zA-Z0-9]*$/.test(value);
+}
+function isPascalCase(value) {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(value);
+}
+function toCamelCase(value) {
+  return value.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[A-Z]/, (c) => c.toLowerCase());
+}
+function toPascalCase(value) {
+  return value.replace(/[-_](.)/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+function findEnclosingClass(ancestors) {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const node = ancestors[i];
+    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+      return node;
+    }
+  }
+  return null;
+}
+
+// src/rules/require-config.ts
+var requireConfig = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require a static config property on classes extending Base"
+    },
+    messages: {
+      missingConfig: "Classes extending Base must define a static config property.",
+      missingName: "The static config must include a name property."
+    }
+  },
+  createOnce(context) {
+    return {
+      ClassDeclaration(node) {
+        check(node, context);
+      },
+      ClassExpression(node) {
+        check(node, context);
+      }
+    };
+  }
+});
+function check(node, context) {
+  if (!isBaseSubclass(node, context)) return;
+  const body = node.body?.body ?? [];
+  const configProp = body.find(
+    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
+  );
+  if (!configProp) {
+    context.report({ node, messageId: "missingConfig" });
+    return;
+  }
+  const value = configProp.value;
+  if (!value || value.type !== "ObjectExpression") return;
+  const hasName = value.properties?.some(
+    (prop) => prop.type === "Property" && prop.key?.name === "name" && prop.value?.value
+  );
+  if (!hasName) {
+    context.report({ node: configProp, messageId: "missingName" });
+  }
+}
+
+// src/rules/require-config-name-pascal-case.ts
+var requireConfigNamePascalCase = createRule({
+  meta: {
+    type: "problem",
+    fixable: "code",
+    docs: {
+      description: "Require config.name to be PascalCase on classes extending Base"
+    },
+    messages: {
+      notPascalCase: 'config.name "{{name}}" must be PascalCase.'
+    }
+  },
+  createOnce(context) {
+    return {
+      ClassDeclaration(node) {
+        check2(node, context);
+      },
+      ClassExpression(node) {
+        check2(node, context);
+      }
+    };
+  }
+});
+function check2(node, context) {
+  if (!isBaseSubclass(node, context)) return;
+  const body = node.body?.body ?? [];
+  const configProp = body.find(
+    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
+  );
+  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+  const nameProp = configProp.value.properties?.find(
+    (prop) => prop.type === "Property" && prop.key?.name === "name"
+  );
+  if (!nameProp) return;
+  const nameValue = nameProp.value?.value;
+  if (typeof nameValue !== "string") return;
+  if (!isPascalCase(nameValue)) {
+    context.report({
+      node: nameProp.value,
+      messageId: "notPascalCase",
+      data: { name: nameValue },
+      fix: (fixer) => fixer.replaceText(nameProp.value, `'${toPascalCase(nameValue)}'`)
+    });
+  }
+}
+
+// src/rules/refs-camel-case.ts
+var refsCamelCase = createRule({
+  meta: {
+    type: "problem",
+    fixable: "code",
+    docs: {
+      description: "Require ref names in static config to be camelCase"
+    },
+    messages: {
+      notCamelCase: 'Ref name "{{name}}" must be camelCase.'
+    }
+  },
+  createOnce(context) {
+    return {
+      ClassDeclaration(node) {
+        check3(node, context);
+      },
+      ClassExpression(node) {
+        check3(node, context);
+      }
+    };
+  }
+});
+function check3(node, context) {
+  if (!isBaseSubclass(node, context)) return;
+  const body = node.body?.body ?? [];
+  const configProp = body.find(
+    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
+  );
+  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+  const refsProp = configProp.value.properties?.find(
+    (prop) => prop.type === "Property" && prop.key?.name === "refs"
+  );
+  if (!refsProp?.value || refsProp.value.type !== "ArrayExpression") return;
+  for (const element of refsProp.value.elements ?? []) {
+    if (!element || element.type !== "Literal") continue;
+    const raw = element.value;
+    if (typeof raw !== "string") continue;
+    const name = raw.endsWith("[]") ? raw.slice(0, -2) : raw;
+    if (!isCamelCase(name)) {
+      const fixed = toCamelCase(name) + (raw.endsWith("[]") ? "[]" : "");
+      context.report({
+        node: element,
+        messageId: "notCamelCase",
+        data: { name },
+        fix: (fixer) => fixer.replaceText(element, `'${fixed}'`)
+      });
+    }
+  }
+}
+
+// src/rules/options-camel-case.ts
+var optionsCamelCase = createRule({
+  meta: {
+    type: "problem",
+    fixable: "code",
+    docs: {
+      description: "Require option keys in static config to be camelCase"
+    },
+    messages: {
+      notCamelCase: 'Option key "{{name}}" must be camelCase.'
+    }
+  },
+  createOnce(context) {
+    return {
+      ClassDeclaration(node) {
+        check4(node, context);
+      },
+      ClassExpression(node) {
+        check4(node, context);
+      }
+    };
+  }
+});
+function check4(node, context) {
+  if (!isBaseSubclass(node, context)) return;
+  const body = node.body?.body ?? [];
+  const configProp = body.find(
+    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
+  );
+  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+  const optionsProp = configProp.value.properties?.find(
+    (prop) => prop.type === "Property" && prop.key?.name === "options"
+  );
+  if (!optionsProp?.value || optionsProp.value.type !== "ObjectExpression") return;
+  for (const prop of optionsProp.value.properties ?? []) {
+    if (prop.type !== "Property") continue;
+    const name = prop.key?.name ?? prop.key?.value;
+    if (typeof name !== "string") continue;
+    if (!isCamelCase(name)) {
+      const fixed = toCamelCase(name);
+      const fixedText = prop.key.type === "Literal" ? `'${fixed}'` : fixed;
+      context.report({
+        node: prop.key,
+        messageId: "notCamelCase",
+        data: { name },
+        fix: (fixer) => fixer.replaceText(prop.key, fixedText)
+      });
+    }
+  }
+}
+
+// src/rules/async-lifecycle-methods.ts
+var asyncLifecycleMethods = createRule({
+  meta: {
+    type: "problem",
+    fixable: "code",
+    docs: {
+      description: "Require lifecycle methods on Base subclasses to be async"
+    },
+    messages: {
+      notAsync: 'Lifecycle method "{{name}}" must be declared as async.'
+    }
+  },
+  createOnce(context) {
+    return {
+      MethodDefinition(node) {
+        const name = node.key?.name;
+        if (!name || !LIFECYCLE_METHODS.has(name)) return;
+        if (node.value?.async) return;
+        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
+        const enclosingClass = findEnclosingClass(ancestors);
+        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+        context.report({
+          node,
+          messageId: "notAsync",
+          data: { name },
+          fix: (fixer) => fixer.insertTextBefore(node.key, "async ")
+        });
+      }
+    };
+  }
+});
+
+// src/rules/on-handler-naming.ts
+var ON_HANDLER_RE = /^on[A-Z][a-zA-Z0-9]*$/;
+var onHandlerNaming = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require event handler methods to follow the onXxxYyy naming convention"
+    },
+    messages: {
+      invalidName: 'Event handler "{{name}}" must follow the onXxxYyy camelCase convention (e.g. onClickButton).'
+    }
+  },
+  createOnce(context) {
+    return {
+      MethodDefinition(node) {
+        if (node.kind === "get" || node.kind === "set") return;
+        const name = node.key?.name;
+        if (!name || !/^on[A-Z]/.test(name)) return;
+        if (ON_HANDLER_RE.test(name)) return;
+        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
+        const enclosingClass = findEnclosingClass(ancestors);
+        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+        context.report({ node, messageId: "invalidName", data: { name } });
+      }
+    };
+  }
+});
+
+// src/rules/on-global-handler-prefix.ts
+var GLOBAL_ONLY_EVENTS = /* @__PURE__ */ new Set(["Resize"]);
+var onGlobalHandlerPrefix = createRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require global event handlers (resize, scroll, etc.) to be prefixed with onWindow or onDocument"
+    },
+    messages: {
+      missingPrefix: '"{{name}}" looks like a global event handler. Use "onWindow{{event}}" or "onDocument{{event}}" to bind to window/document events.'
+    }
+  },
+  createOnce(context) {
+    return {
+      MethodDefinition(node) {
+        const name = node.key?.name;
+        if (!name || !name.startsWith("on")) return;
+        const suffix = name.slice(2);
+        const event = GLOBAL_ONLY_EVENTS.has(suffix) ? suffix : null;
+        if (!event) return;
+        if (name.startsWith("onWindow") || name.startsWith("onDocument")) return;
+        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
+        const enclosingClass = findEnclosingClass(ancestors);
+        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+        context.report({
+          node,
+          messageId: "missingPrefix",
+          data: { name, event }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-deprecated-properties.ts
+var DEPRECATED = /* @__PURE__ */ new Map([
+  ["$parent", "$closest()"],
+  ["$root", "$closest()"],
+  ["$children", "$query()"]
+]);
+var noDeprecatedProperties = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow deprecated Base properties ($parent, $children, $root)"
+    },
+    messages: {
+      deprecated: '"{{name}}" is deprecated. Use {{replacement}} instead.'
+    }
+  },
+  createOnce(context) {
+    return {
+      MemberExpression(node) {
+        const prop = node.property?.name;
+        if (!prop || !DEPRECATED.has(prop)) return;
+        if (node.object?.type !== "ThisExpression") return;
+        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
+        const enclosingClass = findEnclosingClass(ancestors);
+        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+        const replacement = DEPRECATED.get(prop);
+        context.report({
+          node,
+          messageId: "deprecated",
+          data: { name: prop, replacement }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-dispatch-event.ts
+var noDispatchEvent = createRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow dispatchEvent() in Base subclasses \u2014 use this.$emit() instead"
+    },
+    messages: {
+      useEmit: "Use this.$emit() instead of dispatchEvent() to emit events in a Base component."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        const isDispatchEvent = (
+          // this.dispatchEvent(...)
+          callee.type === "MemberExpression" && callee.object?.type === "ThisExpression" && callee.property?.name === "dispatchEvent" || // this.$el.dispatchEvent(...) or el.dispatchEvent(...)
+          callee.type === "MemberExpression" && callee.property?.name === "dispatchEvent"
+        );
+        if (!isDispatchEvent) return;
+        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
+        const enclosingClass = findEnclosingClass(ancestors);
+        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+        context.report({ node, messageId: "useEmit" });
+      }
+    };
+  }
+});
+
+// src/rules/no-shadow-dom.ts
+var noShadowDom = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow attachShadow() in Base subclasses \u2014 js-toolkit uses Light DOM only"
+    },
+    messages: {
+      noShadow: "Do not use attachShadow() in a Base component. @studiometa/js-toolkit uses Light DOM only."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression" || callee.property?.name !== "attachShadow") {
+          return;
+        }
+        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
+        const enclosingClass = findEnclosingClass(ancestors);
+        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+        context.report({ node, messageId: "noShadow" });
+      }
+    };
+  }
+});
+
+// src/rules/no-create-app.ts
+var noCreateApp = createRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow createApp() \u2014 use registerComponent() instead"
+    },
+    messages: {
+      useRegister: "createApp() is deprecated. Use registerComponent() from @studiometa/js-toolkit instead."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type === "Identifier" && callee.name === "createApp") {
+          context.report({ node, messageId: "useRegister" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-event-listener-methods.ts
+var FORBIDDEN = /* @__PURE__ */ new Set(["addEventListener", "removeEventListener"]);
+var noEventListenerMethods = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow addEventListener/removeEventListener in Base subclasses \u2014 use on* methods instead"
+    },
+    messages: {
+      useOnMethod: '"{{method}}()" should not be used in a Base component. Define an "on<Target><Event>()" method instead \u2014 the framework handles binding and cleanup automatically.'
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression") return;
+        const method = callee.property?.name;
+        if (!method || !FORBIDDEN.has(method)) return;
+        let root = callee.object;
+        while (root?.type === "MemberExpression") root = root.object;
+        const isThis = root?.type === "ThisExpression";
+        const isGlobal = root?.type === "Identifier" && (root.name === "document" || root.name === "window");
+        if (!isThis && !isGlobal) return;
+        const ancestors = context.getAncestors ? context.getAncestors() : context.sourceCode?.getAncestors?.(node) ?? [];
+        const enclosingClass = findEnclosingClass(ancestors);
+        if (!enclosingClass || !isBaseSubclass(enclosingClass, context)) return;
+        context.report({ node, messageId: "useOnMethod", data: { method } });
+      }
+    };
+  }
+});
+
+// src/rules/refs-plural-multiple.ts
+var refsPluralMultiple = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require multiple-ref names (using [] suffix) to be pluralized"
+    },
+    messages: {
+      notPlural: 'Multiple ref "{{name}}" must be pluralized (e.g. "{{name}}s[]").'
+    }
+  },
+  createOnce(context) {
+    return {
+      ClassDeclaration(node) {
+        check5(node, context);
+      },
+      ClassExpression(node) {
+        check5(node, context);
+      }
+    };
+  }
+});
+function check5(node, context) {
+  if (!isBaseSubclass(node, context)) return;
+  const body = node.body?.body ?? [];
+  const configProp = body.find(
+    (member) => member.type === "PropertyDefinition" && member.static === true && member.key?.name === "config"
+  );
+  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return;
+  const refsProp = configProp.value.properties?.find(
+    (prop) => prop.type === "Property" && prop.key?.name === "refs"
+  );
+  if (!refsProp?.value || refsProp.value.type !== "ArrayExpression") return;
+  for (const element of refsProp.value.elements ?? []) {
+    if (!element || element.type !== "Literal") continue;
+    const raw = element.value;
+    if (typeof raw !== "string") continue;
+    if (!raw.endsWith("[]")) continue;
+    const name = raw.slice(0, -2);
+    if (!name.endsWith("s")) {
+      context.report({
+        node: element,
+        messageId: "notPlural",
+        data: { name }
+      });
+    }
+  }
+}
+
+// src/rules/no-deep-utils-import.ts
+var DEEP_UTILS_RE = /^@studiometa\/js-toolkit\/utils\/.+/;
+var noDeepUtilsImport = createRule({
+  meta: {
+    type: "problem",
+    fixable: "code",
+    docs: {
+      description: "Disallow deep imports from @studiometa/js-toolkit/utils/*"
+    },
+    messages: {
+      noDeepImport: 'Import from "{{source}}" should use the public entrypoint "@studiometa/js-toolkit/utils".'
+    }
+  },
+  createOnce(context) {
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        if (!DEEP_UTILS_RE.test(source)) return;
+        context.report({
+          node,
+          messageId: "noDeepImport",
+          data: { source },
+          fix(fixer) {
+            const specifiers = node.specifiers ?? [];
+            const parts = [];
+            for (const s of specifiers) {
+              if (s.type === "ImportDefaultSpecifier") {
+                parts.push(s.local.name);
+              } else if (s.type === "ImportSpecifier") {
+                const imported = s.imported.name;
+                const local = s.local.name;
+                parts.push(imported === local ? imported : `${imported} as ${local}`);
+              }
+            }
+            const named = parts.join(", ");
+            return fixer.replaceText(
+              node,
+              `import { ${named} } from '@studiometa/js-toolkit/utils';`
+            );
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/refs-no-bracket-access.ts
+function isThisRefs(node) {
+  return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$refs";
+}
+var refsNoBracketAccess = createRule({
+  meta: {
+    type: "problem",
+    fixable: "code",
+    docs: {
+      description: "Disallow bracket access with [] suffix on this.$refs"
+    },
+    messages: {
+      noBracketAccess: `Use "this.$refs.{{fixed}}" instead of "this.$refs['{{raw}}']".`
+    }
+  },
+  createOnce(context) {
+    return {
+      MemberExpression(node) {
+        if (!isThisRefs(node.object)) return;
+        if (!node.computed) return;
+        const prop = node.property;
+        if (prop.type !== "Literal" || typeof prop.value !== "string") return;
+        const raw = prop.value;
+        if (!raw.endsWith("[]")) return;
+        const stripped = raw.slice(0, -2);
+        const fixed = toCamelCase(stripped);
+        context.report({
+          node,
+          messageId: "noBracketAccess",
+          data: { raw, fixed },
+          fix(fixer) {
+            const src = context.sourceCode ?? context.getSourceCode?.();
+            const objText = src.getText(node.object);
+            return fixer.replaceText(node, `${objText}.${fixed}`);
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-redundant-with-mount-when-in-view.ts
+var noRedundantWithMountWhenInView = createRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow wrapping withMountWhenInView inside withScrolledInView (redundant)"
+    },
+    messages: {
+      redundant: "withScrolledInView already includes withMountWhenInView internally. Remove the inner withMountWhenInView call."
+    }
+  },
+  createOnce(context) {
+    return {
+      "ClassDeclaration, ClassExpression"(node) {
+        check6(node, context);
+      }
+    };
+  }
+});
+function check6(node, context) {
+  const superClass = node.superClass;
+  if (!superClass || superClass.type !== "CallExpression") return;
+  if (superClass.callee?.name !== "withScrolledInView") return;
+  const arg = superClass.arguments?.[0];
+  if (!arg || arg.type !== "CallExpression") return;
+  if (arg.callee?.name !== "withMountWhenInView") return;
+  context.report({ node: superClass, messageId: "redundant" });
+}
+
+// src/rules/prefer-ref-over-query-selector.ts
+var QUERY_METHODS = /* @__PURE__ */ new Set(["querySelector", "querySelectorAll"]);
+function isThisEl(node) {
+  return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$el";
+}
+var preferRefOverQuerySelector = createRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer this.$refs over this.$el.querySelector() in Base subclasses"
+    },
+    messages: {
+      preferRef: 'Avoid "this.$el.{{method}}()". Declare a ref in static config and use "this.$refs" instead.'
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee?.type !== "MemberExpression") return;
+        if (!isThisEl(callee.object)) return;
+        const method = callee.property?.name;
+        if (!QUERY_METHODS.has(method)) return;
+        const ancestors = context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? [];
+        const cls = findEnclosingClass(ancestors);
+        if (!cls || !isBaseSubclass(cls, context)) return;
+        context.report({ node, messageId: "preferRef", data: { method } });
+      }
+    };
+  }
+});
+
+// src/rules/require-refs-declared-in-config.ts
+function collectDeclaredRefs(classNode) {
+  const body = classNode.body?.body ?? [];
+  const configProp = body.find(
+    (m) => m.type === "PropertyDefinition" && m.static === true && m.key?.name === "config"
+  );
+  if (!configProp?.value || configProp.value.type !== "ObjectExpression") return /* @__PURE__ */ new Set();
+  const refsProp = configProp.value.properties?.find(
+    (p) => p.type === "Property" && p.key?.name === "refs"
+  );
+  if (!refsProp?.value || refsProp.value.type !== "ArrayExpression") return /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Set();
+  for (const el of refsProp.value.elements ?? []) {
+    if (!el || el.type !== "Literal" || typeof el.value !== "string") continue;
+    const raw = el.value;
+    const stripped = raw.endsWith("[]") ? raw.slice(0, -2) : raw;
+    names.add(toCamelCase(stripped));
+  }
+  return names;
+}
+function isThisRefs2(node) {
+  return node.type === "MemberExpression" && node.object?.type === "ThisExpression" && node.property?.name === "$refs";
+}
+var requireRefsDeclaredInConfig = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require all this.$refs accesses to be declared in static config.refs"
+    },
+    messages: {
+      undeclared: 'Ref "{{name}}" is not declared in static config.refs.'
+    }
+  },
+  createOnce(context) {
+    return {
+      "ClassDeclaration, ClassExpression"(classNode) {
+        if (!isBaseSubclass(classNode, context)) return;
+        const declared = collectDeclaredRefs(classNode);
+        walkNode(classNode.body, (node) => {
+          if (node.type !== "MemberExpression") return;
+          if (!isThisRefs2(node.object)) return;
+          let refName = null;
+          if (!node.computed && node.property?.type === "Identifier") {
+            refName = node.property.name;
+          } else if (node.computed && node.property?.type === "Literal" && typeof node.property.value === "string") {
+            const raw = node.property.value;
+            const stripped = raw.endsWith("[]") ? raw.slice(0, -2) : raw;
+            refName = toCamelCase(stripped);
+          }
+          if (refName && !declared.has(refName)) {
+            context.report({
+              node,
+              messageId: "undeclared",
+              data: { name: refName }
+            });
+          }
+        });
+      }
+    };
+  }
+});
+function walkNode(node, visit) {
+  if (!node || typeof node !== "object") return;
+  visit(node);
+  for (const key of Object.keys(node)) {
+    if (key === "parent") continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) walkNode(item, visit);
+    } else if (child && typeof child === "object" && child.type) {
+      walkNode(child, visit);
+    }
+  }
+}
+
+// src/rules/no-manual-intersection-observer.ts
+var noManualIntersectionObserver = createRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow manual IntersectionObserver inside Base subclasses; use withIntersectionObserver or withMountWhenInView instead"
+    },
+    messages: {
+      noManual: 'Avoid manual "new IntersectionObserver()". Use "withIntersectionObserver" or "withMountWhenInView" decorators instead.'
+    }
+  },
+  createOnce(context) {
+    return {
+      NewExpression(node) {
+        if (node.callee?.name !== "IntersectionObserver") return;
+        const ancestors = context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? [];
+        const cls = findEnclosingClass(ancestors);
+        if (!cls || !isBaseSubclass(cls, context)) return;
+        context.report({ node, messageId: "noManual" });
+      }
+    };
+  }
+});
+
+// src/rules/no-manual-mutation-observer.ts
+var noManualMutationObserver = createRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow manual MutationObserver inside Base subclasses; use withMutation decorator instead"
+    },
+    messages: {
+      noManual: 'Avoid manual "new MutationObserver()". Use the "withMutation" decorator instead.'
+    }
+  },
+  createOnce(context) {
+    return {
+      NewExpression(node) {
+        if (node.callee?.name !== "MutationObserver") return;
+        const ancestors = context.getAncestors?.() ?? context.sourceCode?.getAncestors?.(node) ?? [];
+        const cls = findEnclosingClass(ancestors);
+        if (!cls || !isBaseSubclass(cls, context)) return;
+        context.report({ node, messageId: "noManual" });
+      }
+    };
+  }
+});
+
+// src/index.ts
+var PLUGIN_NAME = "js-toolkit";
+var rules = {
+  "require-config": requireConfig,
+  "require-config-name-pascal-case": requireConfigNamePascalCase,
+  "refs-camel-case": refsCamelCase,
+  "refs-plural-multiple": refsPluralMultiple,
+  "options-camel-case": optionsCamelCase,
+  "async-lifecycle-methods": asyncLifecycleMethods,
+  "on-handler-naming": onHandlerNaming,
+  "on-global-handler-prefix": onGlobalHandlerPrefix,
+  "no-deprecated-properties": noDeprecatedProperties,
+  "no-dispatch-event": noDispatchEvent,
+  "no-shadow-dom": noShadowDom,
+  "no-create-app": noCreateApp,
+  "no-event-listener-methods": noEventListenerMethods,
+  "no-deep-utils-import": noDeepUtilsImport,
+  "refs-no-bracket-access": refsNoBracketAccess,
+  "no-redundant-with-mount-when-in-view": noRedundantWithMountWhenInView,
+  "prefer-ref-over-query-selector": preferRefOverQuerySelector,
+  "require-refs-declared-in-config": requireRefsDeclaredInConfig,
+  "no-manual-intersection-observer": noManualIntersectionObserver,
+  "no-manual-mutation-observer": noManualMutationObserver
+};
+var recommendedRules = {
+  [`${PLUGIN_NAME}/require-config`]: "error",
+  [`${PLUGIN_NAME}/require-config-name-pascal-case`]: "error",
+  [`${PLUGIN_NAME}/refs-camel-case`]: "error",
+  [`${PLUGIN_NAME}/refs-plural-multiple`]: "error",
+  [`${PLUGIN_NAME}/options-camel-case`]: "error",
+  [`${PLUGIN_NAME}/async-lifecycle-methods`]: "error",
+  [`${PLUGIN_NAME}/on-handler-naming`]: "error",
+  [`${PLUGIN_NAME}/on-global-handler-prefix`]: "warn",
+  [`${PLUGIN_NAME}/no-deprecated-properties`]: "warn",
+  [`${PLUGIN_NAME}/no-dispatch-event`]: "warn",
+  [`${PLUGIN_NAME}/no-shadow-dom`]: "error",
+  [`${PLUGIN_NAME}/no-create-app`]: "warn",
+  [`${PLUGIN_NAME}/no-event-listener-methods`]: "error",
+  [`${PLUGIN_NAME}/no-deep-utils-import`]: "error",
+  [`${PLUGIN_NAME}/refs-no-bracket-access`]: "error",
+  [`${PLUGIN_NAME}/no-redundant-with-mount-when-in-view`]: "warn",
+  [`${PLUGIN_NAME}/prefer-ref-over-query-selector`]: "warn",
+  [`${PLUGIN_NAME}/require-refs-declared-in-config`]: "error",
+  [`${PLUGIN_NAME}/no-manual-intersection-observer`]: "warn",
+  [`${PLUGIN_NAME}/no-manual-mutation-observer`]: "warn"
+};
+var base = eslintCompatPlugin({
+  meta: {
+    name: "@studiometa/eslint-plugin-js-toolkit"
+  },
+  rules
+});
+var plugin = Object.assign(base, { configs: {} });
+plugin.configs["recommended"] = {
+  plugins: { [PLUGIN_NAME]: plugin },
+  rules: recommendedRules
+};
+var index_default = plugin;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map