@unhead/eslint-plugin 3.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Harlan Wilton <harlan@harlanzw.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# `@unhead/eslint-plugin`
+
+ESLint rules that catch unhead misuse, type-narrowing issues, and v2-to-v3 migration problems at the source level. Pairs with the runtime `ValidatePlugin` and the `unhead` CLI to give you static and runtime coverage of the same rule set.
+
+## Install
+
+```bash
+pnpm add -D @unhead/eslint-plugin eslint
+```
+
+## Usage (flat config)
+
+```ts
+// eslint.config.ts
+import { configs } from '@unhead/eslint-plugin'
+
+export default [
+  configs.recommended,
+]
+```
+
+For projects migrating from unhead v2, swap in `configs.migration` to also wrap tag literals in the `defineLink` / `defineScript` helpers.
+
+> Don't want to wire ESLint? `@unhead/cli` ships the same rules as a standalone command (`unhead audit` / `unhead migrate`) running on a native oxc parser — no parser configuration, works out-of-the-box on `.ts` / `.tsx` / `.vue` / `.svelte`.
+
+## Rules
+
+| Rule | Default | Autofix | What it catches |
+|---|---|---|---|
+| `defer-on-module-script` | warn | ✓ | `<script type="module" defer>` (defer is redundant) |
+| `empty-meta-content` | warn |   | `<meta name="description" content="">` |
+| `no-deprecated-props` | error | ✓ | v2 props: `children`, `hid`, `vmid`, `body: true` |
+| `no-html-in-title` | warn |   | HTML chars in `title` (will be escaped, not rendered) |
+| `no-unknown-meta` | warn | ✓ | typos in `name` / `property` (Levenshtein-suggested fix) |
+| `non-absolute-canonical` | warn |   | relative URLs in `<link rel="canonical">` |
+| `numeric-tag-priority` | warn | suggestion | numeric `tagPriority` (suggests `'critical'`, `'high'`, or `'low'`) |
+| `prefer-define-helpers` | off (migration only) | ✓ | wraps `link` / `script` tag object literals in `defineLink` / `defineScript` |
+| `preload-font-crossorigin` | error | ✓ | font preloads missing `crossorigin` (would refetch) |
+| `preload-missing-as` | error |   | `<link rel="preload">` missing required `as` |
+| `robots-conflict` | error |   | `index, noindex` or `follow, nofollow` in robots meta |
+| `script-src-with-content` | error |   | a script with both `src` and inline content |
+| `twitter-handle-missing-at` | warn | ✓ | `twitter:site` / `twitter:creator` missing `@` |
+| `viewport-user-scalable` | warn |   | `user-scalable=no` or `maximum-scale=1` (accessibility) |
+
+## Coverage
+
+These rules walk source-level calls into the unhead API: `useHead`, `useHeadSafe`, `useServerHead`, `useServerHeadSafe`, `useSeoMeta`, `useServerSeoMeta`, and the tag helpers `defineLink` / `defineScript`. Tag arrays inside `meta` / `link` / `script` / `noscript` / `style` keys are descended automatically.
+
+Rules can only see what's expressible in the AST. Cross-tag and rendered-output checks (e.g. `canonical-og-url-mismatch`, `meta-beyond-1mb`, `charset-not-early`, `too-many-preloads`) live in the runtime `ValidatePlugin` and are surfaced by the `unhead validate-url` / `unhead validate-html` CLI commands.
+
+## Rule constants
+
+The plugin imports its rule IDs and known-meta sets from `unhead/validate`, the same module the runtime `ValidatePlugin` reads. This keeps lint diagnostics, runtime warnings, and CLI reports aligned by construction.

package/dist/index.d.mts

@@ -0,0 +1,23 @@
+import * as eslint from 'eslint';
+import { Linter, ESLint } from 'eslint';
+
+declare const rules: {
+    readonly 'defer-on-module-script': eslint.Rule.RuleModule;
+    readonly 'empty-meta-content': eslint.Rule.RuleModule;
+    readonly 'no-deprecated-props': eslint.Rule.RuleModule;
+    readonly 'no-html-in-title': eslint.Rule.RuleModule;
+    readonly 'no-unknown-meta': eslint.Rule.RuleModule;
+    readonly 'non-absolute-canonical': eslint.Rule.RuleModule;
+    readonly 'numeric-tag-priority': eslint.Rule.RuleModule;
+    readonly 'prefer-define-helpers': eslint.Rule.RuleModule;
+    readonly 'preload-font-crossorigin': eslint.Rule.RuleModule;
+    readonly 'preload-missing-as': eslint.Rule.RuleModule;
+    readonly 'robots-conflict': eslint.Rule.RuleModule;
+    readonly 'script-src-with-content': eslint.Rule.RuleModule;
+    readonly 'twitter-handle-missing-at': eslint.Rule.RuleModule;
+    readonly 'viewport-user-scalable': eslint.Rule.RuleModule;
+};
+declare const plugin: ESLint.Plugin;
+declare const configs: Record<'recommended' | 'migration', Linter.Config>;
+
+export { configs, plugin as default, rules };

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import * as eslint from 'eslint';
+import { Linter, ESLint } from 'eslint';
+
+declare const rules: {
+    readonly 'defer-on-module-script': eslint.Rule.RuleModule;
+    readonly 'empty-meta-content': eslint.Rule.RuleModule;
+    readonly 'no-deprecated-props': eslint.Rule.RuleModule;
+    readonly 'no-html-in-title': eslint.Rule.RuleModule;
+    readonly 'no-unknown-meta': eslint.Rule.RuleModule;
+    readonly 'non-absolute-canonical': eslint.Rule.RuleModule;
+    readonly 'numeric-tag-priority': eslint.Rule.RuleModule;
+    readonly 'prefer-define-helpers': eslint.Rule.RuleModule;
+    readonly 'preload-font-crossorigin': eslint.Rule.RuleModule;
+    readonly 'preload-missing-as': eslint.Rule.RuleModule;
+    readonly 'robots-conflict': eslint.Rule.RuleModule;
+    readonly 'script-src-with-content': eslint.Rule.RuleModule;
+    readonly 'twitter-handle-missing-at': eslint.Rule.RuleModule;
+    readonly 'viewport-user-scalable': eslint.Rule.RuleModule;
+};
+declare const plugin: ESLint.Plugin;
+declare const configs: Record<'recommended' | 'migration', Linter.Config>;
+
+export { configs, plugin as default, rules };

package/dist/index.mjs

@@ -0,0 +1,540 @@
+import { nonAbsoluteCanonical as nonAbsoluteCanonical$1, emptyMetaContent as emptyMetaContent$1, noDeprecatedProps as noDeprecatedProps$1, noUnknownMeta as noUnknownMeta$1, numericTagPriority as numericTagPriority$1, preferDefineHelpers as preferDefineHelpers$1, preloadMissingAs as preloadMissingAs$1, preloadFontCrossorigin as preloadFontCrossorigin$1, robotsConflict as robotsConflict$1, deferOnModuleScript as deferOnModuleScript$1, scriptSrcWithContent as scriptSrcWithContent$1, noHtmlInTitle as noHtmlInTitle$1, twitterHandleMissingAt as twitterHandleMissingAt$1, viewportUserScalable as viewportUserScalable$1 } from 'unhead/validate';
+
+const recommendedRules = {
+  "@unhead/defer-on-module-script": "warn",
+  "@unhead/empty-meta-content": "warn",
+  "@unhead/no-deprecated-props": "error",
+  "@unhead/no-html-in-title": "warn",
+  "@unhead/no-unknown-meta": "warn",
+  "@unhead/non-absolute-canonical": "warn",
+  "@unhead/numeric-tag-priority": "warn",
+  "@unhead/preload-font-crossorigin": "error",
+  "@unhead/preload-missing-as": "error",
+  "@unhead/robots-conflict": "error",
+  "@unhead/script-src-with-content": "error",
+  "@unhead/twitter-handle-missing-at": "warn",
+  "@unhead/viewport-user-scalable": "warn"
+};
+const recommended = {
+  plugins: {},
+  rules: recommendedRules
+};
+const migration = {
+  plugins: {},
+  rules: {
+    ...recommendedRules,
+    "@unhead/prefer-define-helpers": "warn"
+  }
+};
+
+const HEAD_INPUT_CALLEES = /* @__PURE__ */ new Set([
+  "useHead",
+  "useHeadSafe",
+  "useServerHead",
+  "useServerHeadSafe",
+  "useSeoMeta",
+  "useServerSeoMeta"
+]);
+const TAG_HELPER_CALLEES = /* @__PURE__ */ new Set([
+  "defineLink",
+  "defineScript"
+]);
+const HEAD_INPUT_TAG_KEYS = /* @__PURE__ */ new Set([
+  "meta",
+  "link",
+  "script",
+  "noscript",
+  "style"
+]);
+function getCalleeName(node) {
+  const callee = node.callee;
+  if (callee.type === "Identifier")
+    return callee.name;
+  if (callee.type === "MemberExpression" && callee.property.type === "Identifier")
+    return callee.property.name;
+  return void 0;
+}
+function unwrapTS(node) {
+  if (!node)
+    return node;
+  const t = node.type;
+  if (t === "TSAsExpression" || t === "TSTypeAssertion" || t === "TSNonNullExpression" || t === "TSSatisfiesExpression" || t === "TSInstantiationExpression")
+    return unwrapTS(node.expression);
+  return node;
+}
+function getStringValue(node) {
+  const inner = unwrapTS(node);
+  if (!inner)
+    return void 0;
+  if (inner.type === "Literal" && typeof inner.value === "string")
+    return inner.value;
+  if (inner.type === "TemplateLiteral" && inner.expressions.length === 0 && inner.quasis.length === 1)
+    return inner.quasis[0].value.cooked ?? void 0;
+  return void 0;
+}
+function findProperty(obj, key) {
+  for (let i = obj.properties.length - 1; i >= 0; i--) {
+    const prop = obj.properties[i];
+    if (prop.type !== "Property" || prop.computed)
+      continue;
+    const k = prop.key;
+    if (k.type === "Identifier" && k.name === key)
+      return prop;
+    if (k.type === "Literal" && k.value === key)
+      return prop;
+  }
+  return void 0;
+}
+function createTagVisitor(visitor) {
+  return (ctx) => {
+    function visitTagArray(arr, tagType) {
+      if (!arr || !visitor.onTag)
+        return;
+      for (const el of arr.elements) {
+        const inner = unwrapTS(el);
+        if (inner && inner.type === "ObjectExpression")
+          visitor.onTag(inner, tagType, ctx, { inArray: true });
+      }
+    }
+    return {
+      CallExpression(node) {
+        const name = getCalleeName(node);
+        if (!name)
+          return;
+        if (TAG_HELPER_CALLEES.has(name)) {
+          const arg2 = unwrapTS(node.arguments[0]);
+          if (arg2?.type === "ObjectExpression") {
+            const tagType = name.slice("define".length).toLowerCase();
+            visitor.onTag?.(arg2, tagType, ctx, { inArray: false });
+          }
+          return;
+        }
+        if (!HEAD_INPUT_CALLEES.has(name))
+          return;
+        const arg = unwrapTS(node.arguments[0]);
+        if (arg?.type !== "ObjectExpression")
+          return;
+        visitor.onHeadInput?.(arg, name, ctx);
+        if (name === "useSeoMeta" || name === "useServerSeoMeta")
+          return;
+        for (const prop of arg.properties) {
+          if (prop.type !== "Property" || prop.computed)
+            continue;
+          const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "Literal" && typeof prop.key.value === "string" ? prop.key.value : void 0;
+          if (!key || !HEAD_INPUT_TAG_KEYS.has(key))
+            continue;
+          const value = unwrapTS(prop.value);
+          if (value?.type === "ArrayExpression")
+            visitTagArray(value, key);
+          else if (value?.type === "ObjectExpression")
+            visitor.onTag?.(value, key, ctx, { inArray: false });
+        }
+      }
+    };
+  };
+}
+
+function locFor(obj, at) {
+  if (!at || at.kind === "tag")
+    return obj;
+  const prop = findProperty(obj, at.key);
+  if (!prop)
+    return obj;
+  if (at.kind === "prop")
+    return prop;
+  if (at.kind === "prop-key")
+    return prop.key;
+  return prop.value;
+}
+function buildFixer(obj, fix, sourceCode) {
+  switch (fix.type) {
+    case "rename-prop": {
+      const prop = findProperty(obj, fix.key);
+      if (!prop)
+        return void 0;
+      return (fixer) => fixer.replaceText(prop.key, fix.newKey);
+    }
+    case "replace-prop-value": {
+      const prop = findProperty(obj, fix.key);
+      if (!prop)
+        return void 0;
+      return (fixer) => fixer.replaceText(prop.value, fix.newSource);
+    }
+    case "replace-prop": {
+      const prop = findProperty(obj, fix.key);
+      if (!prop)
+        return void 0;
+      return (fixer) => fixer.replaceText(prop, fix.newSource);
+    }
+    case "insert-after-prop": {
+      const prop = findProperty(obj, fix.afterKey);
+      if (!prop)
+        return void 0;
+      return (fixer) => fixer.insertTextAfter(prop, fix.insert);
+    }
+    case "remove-prop": {
+      const prop = findProperty(obj, fix.key);
+      if (!prop)
+        return void 0;
+      return (fixer) => {
+        const after = sourceCode.getTokenAfter(prop);
+        if (after && after.value === ",")
+          return fixer.removeRange([prop.range[0], after.range[1]]);
+        const before = sourceCode.getTokenBefore(prop);
+        if (before && before.value === ",")
+          return fixer.removeRange([before.range[0], prop.range[1]]);
+        return fixer.remove(prop);
+      };
+    }
+    case "wrap-tag": {
+      return (fixer) => fixer.replaceText(obj, `${fix.wrapWith}(${sourceCode.getText(obj)})`);
+    }
+  }
+}
+function reportDiagnostic(ctx, obj, diag) {
+  const node = locFor(obj, diag.at);
+  const fixer = diag.fix ? buildFixer(obj, diag.fix, ctx.sourceCode) : void 0;
+  ctx.report({
+    node,
+    message: diag.message,
+    fix: fixer,
+    suggest: diag.suggestions?.map((s) => ({
+      desc: s.message,
+      fix: buildFixer(obj, s.fix, ctx.sourceCode) ?? (() => null)
+    }))
+  });
+}
+
+function materializeTag(node, tagType, inArray) {
+  const props = {};
+  const keys = /* @__PURE__ */ new Set();
+  const propLocs = {};
+  for (const p of node.properties) {
+    if (p.type !== "Property" || p.computed)
+      continue;
+    const k = p.key;
+    const name = k.type === "Identifier" ? k.name : k.type === "Literal" && typeof k.value === "string" ? k.value : void 0;
+    if (!name)
+      continue;
+    keys.add(name);
+    propLocs[name] = p;
+    const value = unwrapTS(p.value);
+    if (!value)
+      continue;
+    if (value.type === "Literal") {
+      const v = value.value;
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+        props[name] = v;
+      continue;
+    }
+    const str = getStringValue(value);
+    if (str !== void 0)
+      props[name] = str;
+  }
+  return { tagType, props, keys, loc: node, propLocs, inArray };
+}
+function materializeHeadInput(node, callee) {
+  const props = {};
+  const keys = /* @__PURE__ */ new Set();
+  const propLocs = {};
+  for (const p of node.properties) {
+    if (p.type !== "Property" || p.computed)
+      continue;
+    const k = p.key;
+    const name = k.type === "Identifier" ? k.name : k.type === "Literal" && typeof k.value === "string" ? k.value : void 0;
+    if (!name)
+      continue;
+    keys.add(name);
+    propLocs[name] = p;
+    if (name === "title" || name === "titleTemplate") {
+      const str = getStringValue(p.value);
+      if (str !== void 0)
+        props[name] = str;
+    }
+  }
+  return { callee, props, keys, loc: node, propLocs };
+}
+
+const HELPER_NAMES = /* @__PURE__ */ new Set(["defineLink", "defineScript"]);
+const HELPER_SOURCES = /* @__PURE__ */ new Set([
+  "unhead",
+  "@unhead/vue",
+  "@unhead/react",
+  "@unhead/svelte",
+  "@unhead/solid-js",
+  "@unhead/angular"
+]);
+function isHelperSource(source) {
+  if (HELPER_SOURCES.has(source))
+    return true;
+  return source.startsWith("@unhead/");
+}
+function collectImportedHelpers(program) {
+  const out = /* @__PURE__ */ new Map();
+  for (const node of program.body) {
+    if (node.type !== "ImportDeclaration")
+      continue;
+    const source = typeof node.source?.value === "string" ? node.source.value : "";
+    if (!isHelperSource(source))
+      continue;
+    for (const spec of node.specifiers) {
+      if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && HELPER_NAMES.has(spec.imported.name))
+        out.set(spec.imported.name, spec.local.name);
+    }
+  }
+  return out;
+}
+function createTagPredicateRule(predicate, opts = {}) {
+  return (ctx) => {
+    let helpers;
+    function ensureHelpers() {
+      if (!helpers)
+        helpers = collectImportedHelpers(ctx.sourceCode.ast);
+      return helpers;
+    }
+    return createTagVisitor({
+      onTag(tag, tagType, _ctx, info) {
+        const input = materializeTag(tag, tagType, info.inArray);
+        const pctx = opts.needsHelpers ? { importedHelpers: ensureHelpers() } : void 0;
+        for (const diag of predicate(input, pctx))
+          reportDiagnostic(ctx, tag, diag);
+      }
+    })(ctx);
+  };
+}
+function createHeadInputPredicateRule(predicate) {
+  return (ctx) => ({
+    CallExpression(node) {
+      const name = getCalleeName(node);
+      if (!name || !HEAD_INPUT_CALLEES.has(name))
+        return;
+      const arg = unwrapTS(node.arguments[0]);
+      if (!arg || arg.type !== "ObjectExpression")
+        return;
+      const input = materializeHeadInput(arg, name);
+      for (const diag of predicate(input))
+        reportDiagnostic(ctx, arg, diag);
+    }
+  });
+}
+
+const nonAbsoluteCanonical = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Canonical URLs must be absolute.",
+      recommended: true,
+      url: "https://developers.google.com/search/docs/crawling-indexing/canonicalization"
+    },
+    schema: []
+  },
+  create: createTagPredicateRule(nonAbsoluteCanonical$1)
+};
+
+const emptyMetaContent = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow meta tags with empty `content`.",
+      recommended: true,
+      url: "https://unhead.unjs.io/docs/typescript/head/api/composables/use-seo-meta"
+    },
+    schema: []
+  },
+  create: createTagPredicateRule(emptyMetaContent$1)
+};
+
+const noDeprecatedProps = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow deprecated v2 unhead tag props (children, hid/vmid, body).",
+      recommended: true,
+      url: "https://unhead.unjs.io/docs/migration/v2-to-v3"
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: createTagPredicateRule(noDeprecatedProps$1)
+};
+
+const noUnknownMeta = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Detect typos in meta `name` and `property` values.",
+      recommended: true,
+      url: "https://unhead.unjs.io/docs/typescript/head/api/composables/use-seo-meta"
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: createTagPredicateRule(noUnknownMeta$1)
+};
+
+const numericTagPriority = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer string aliases for `tagPriority` over raw numbers.",
+      recommended: true,
+      url: "https://unhead.unjs.io/docs/typescript/head/api/options/tag-priority"
+    },
+    hasSuggestions: true,
+    schema: []
+  },
+  create: createTagPredicateRule(numericTagPriority$1)
+};
+
+const preferDefineHelpers = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Wrap tag object literals in their `defineX` helper for type narrowing.",
+      recommended: false,
+      url: "https://unhead.unjs.io/docs/typescript/head/api/utilities"
+    },
+    fixable: "code",
+    hasSuggestions: true,
+    schema: []
+  },
+  create: createTagPredicateRule(preferDefineHelpers$1, { needsHelpers: true })
+};
+
+const preloadMissingAs = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: '`<link rel="preload">` requires an `as` attribute.',
+      recommended: true,
+      url: "https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel/preload"
+    },
+    schema: []
+  },
+  create: createTagPredicateRule(preloadMissingAs$1)
+};
+const preloadFontCrossorigin = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Font preloads require the `crossorigin` attribute.",
+      recommended: true,
+      url: "https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/rel/preload#cors-enabled_fetches"
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: createTagPredicateRule(preloadFontCrossorigin$1)
+};
+
+const robotsConflict = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow conflicting directives in `robots` meta content.",
+      recommended: true,
+      url: "https://developers.google.com/search/docs/crawling-indexing/robots-meta-tag"
+    },
+    schema: []
+  },
+  create: createTagPredicateRule(robotsConflict$1)
+};
+
+const deferOnModuleScript = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: '`defer` is redundant on `type="module"` scripts.',
+      recommended: true,
+      url: "https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script#attr-defer"
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: createTagPredicateRule(deferOnModuleScript$1)
+};
+const scriptSrcWithContent = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A script with `src` cannot also have inline content.",
+      recommended: true,
+      url: "https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script"
+    },
+    schema: []
+  },
+  create: createTagPredicateRule(scriptSrcWithContent$1)
+};
+
+const noHtmlInTitle = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "HTML characters in `<title>` are escaped, not rendered.",
+      recommended: true,
+      url: "https://html.spec.whatwg.org/multipage/semantics.html#the-title-element"
+    },
+    schema: []
+  },
+  create: createHeadInputPredicateRule(noHtmlInTitle$1)
+};
+
+const twitterHandleMissingAt = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Twitter handle meta values must start with `@`.",
+      recommended: true,
+      url: "https://developer.x.com/en/docs/x-for-websites/cards/overview/markup"
+    },
+    fixable: "code",
+    schema: []
+  },
+  create: createTagPredicateRule(twitterHandleMissingAt$1)
+};
+
+const viewportUserScalable = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow viewport meta values that block user zoom (a11y).",
+      recommended: true,
+      url: "https://www.w3.org/WAI/WCAG22/Understanding/reflow.html"
+    },
+    schema: []
+  },
+  create: createTagPredicateRule(viewportUserScalable$1)
+};
+
+const rules = {
+  "defer-on-module-script": deferOnModuleScript,
+  "empty-meta-content": emptyMetaContent,
+  "no-deprecated-props": noDeprecatedProps,
+  "no-html-in-title": noHtmlInTitle,
+  "no-unknown-meta": noUnknownMeta,
+  "non-absolute-canonical": nonAbsoluteCanonical,
+  "numeric-tag-priority": numericTagPriority,
+  "prefer-define-helpers": preferDefineHelpers,
+  "preload-font-crossorigin": preloadFontCrossorigin,
+  "preload-missing-as": preloadMissingAs,
+  "robots-conflict": robotsConflict,
+  "script-src-with-content": scriptSrcWithContent,
+  "twitter-handle-missing-at": twitterHandleMissingAt,
+  "viewport-user-scalable": viewportUserScalable
+};
+const plugin = {
+  meta: {
+    name: "@unhead/eslint-plugin",
+    version: "3.0.5"
+  },
+  rules
+};
+function withPlugin(config) {
+  return { ...config, plugins: { "@unhead": plugin } };
+}
+const configs = {
+  recommended: withPlugin(recommended),
+  migration: withPlugin(migration)
+};
+
+export { configs, plugin as default, rules };

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@unhead/eslint-plugin",
+  "type": "module",
+  "version": "3.0.5",
+  "description": "ESLint rules for catching unhead misuse, type-narrowing issues, and v2-to-v3 migration problems.",
+  "author": "Harlan Wilton <harlan@harlanzw.com>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/harlan-zw",
+  "homepage": "https://unhead.unjs.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unjs/unhead.git",
+    "directory": "packages/eslint-plugin"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "bugs": {
+    "url": "https://github.com/unjs/unhead/issues"
+  },
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "unhead",
+    "head",
+    "seo"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "*.d.ts",
+    "dist"
+  ],
+  "peerDependencies": {
+    "eslint": ">=9.0.0",
+    "unhead": "^3.0.5"
+  },
+  "dependencies": {
+    "unhead": "3.0.5"
+  },
+  "devDependencies": {
+    "@types/estree": "^1.0.8",
+    "eslint": "^10.2.1",
+    "vitest": "^4.1.5"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "stub": "unbuild --stub",
+    "test": "vitest run"
+  }
+}