svelte-vitals 0.33.0 → 0.34.0

package/dist/bin.js

@@ -9,7 +9,7 @@ import {
   readCoreVersion,
   readPackageVersion,
   run
-} from "./chunk-CWCO6A5B.js";
+} from "./chunk-WSPRFLPP.js";
 
 // src/bin.ts
 import mri3 from "mri";
@@ -408,9 +408,20 @@ var CATEGORY_LABELS = {
 function oneLine(text) {
   return text.replace(/\r?\n+/g, " ").trim();
 }
+function isEmptyDefault(spec) {
+  if (spec.kind === "string-list") return spec.default.length === 0;
+  if (spec.kind === "string-map") return Object.keys(spec.default).length === 0;
+  return false;
+}
+function isInertUntilConfigured(rule) {
+  if (!rule.options) return false;
+  const specs = Object.values(rule.options);
+  return specs.length > 0 && specs.every(isEmptyDefault);
+}
 function ruleLine(rule) {
   const fixPart = rule.fix?.description ? ` Fix: ${oneLine(rule.fix.description)}` : "";
-  return `- **${rule.id} \u2014 ${oneLine(rule.title)}** (${rule.severity}): ${oneLine(rule.rationale)}${fixPart} ([docs](${docsUrlFor(rule.id)}))`;
+  const inertPart = isInertUntilConfigured(rule) ? " (inert until configured)" : "";
+  return `- **${rule.id} \u2014 ${oneLine(rule.title)}** (${rule.severity}): ${oneLine(rule.rationale)}${fixPart}${inertPart} ([docs](${docsUrlFor(rule.id)}))`;
 }
 function ruleDigest() {
   return CATEGORY_ORDER.map((category) => {

package/dist/{chunk-CWCO6A5B.js → chunk-WSPRFLPP.js}

@@ -54,7 +54,10 @@ import { defaultConfig } from "@svelte-vitals/core";
 import {
   ROBOTS_SOURCE_PATHS,
   SITEMAP_SOURCE_PATHS,
-  findMinifyDisabled
+  SVELTE_CONFIG_FILES,
+  VITE_CONFIG_FILES,
+  findMinifyDisabled,
+  resolveKitPathsBase
 } from "@svelte-vitals/core";
 var ProjectError = class extends Error {
   constructor(message) {
@@ -143,14 +146,6 @@ async function robotsRefsSitemap(rt, cwd) {
     return void 0;
   }
 }
-var VITE_CONFIG_FILES = [
-  "vite.config.js",
-  "vite.config.mjs",
-  "vite.config.ts",
-  "vite.config.cjs",
-  "vite.config.mts",
-  "vite.config.cts"
-];
 async function detectViteMinifyDisabled(rt, cwd) {
   const exists = await Promise.all(VITE_CONFIG_FILES.map((f) => rt.exists(rt.join(cwd, f))));
   const file = VITE_CONFIG_FILES[exists.indexOf(true)];
@@ -162,12 +157,32 @@ async function detectViteMinifyDisabled(rt, cwd) {
     return void 0;
   }
 }
+async function readFirstConfig(rt, cwd, files) {
+  for (const file of files) {
+    const path = rt.join(cwd, file);
+    if (!await rt.exists(path)) continue;
+    try {
+      return { file, source: await rt.readFile(path) };
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+async function detectKitPathsBase(rt, cwd) {
+  const [viteConfig, svelteConfig] = await Promise.all([
+    readFirstConfig(rt, cwd, VITE_CONFIG_FILES),
+    readFirstConfig(rt, cwd, SVELTE_CONFIG_FILES)
+  ]);
+  return resolveKitPathsBase(viteConfig, svelteConfig);
+}
 async function collectProjectFacts(rt, cwd) {
-  const [hasRobotsTxt, hasSitemap, htmlLang, viteMinifyDisabled] = await Promise.all([
+  const [hasRobotsTxt, hasSitemap, htmlLang, viteMinifyDisabled, kitPathsBase] = await Promise.all([
     existsAny(rt, cwd, ROBOTS_SOURCE_PATHS),
     existsAny(rt, cwd, SITEMAP_SOURCE_PATHS),
     detectAppHtmlLang(rt, cwd),
-    detectViteMinifyDisabled(rt, cwd)
+    detectViteMinifyDisabled(rt, cwd),
+    detectKitPathsBase(rt, cwd)
   ]);
   const robotsReferencesSitemap = await robotsRefsSitemap(rt, cwd);
   return {
@@ -175,7 +190,8 @@ async function collectProjectFacts(rt, cwd) {
     hasSitemap,
     htmlLang,
     ...robotsReferencesSitemap !== void 0 ? { robotsReferencesSitemap } : {},
-    ...viteMinifyDisabled ? { viteMinifyDisabled } : {}
+    ...viteMinifyDisabled ? { viteMinifyDisabled } : {},
+    ...kitPathsBase ? { kitPathsBase } : {}
   };
 }
 
@@ -1167,16 +1183,27 @@ async function playMascotGreeting(opts) {
 import { existsSync as existsSync2 } from "fs";
 import { join as join5 } from "path";
 import { pathToFileURL } from "url";
+import {
+  CATEGORIES,
+  defaultConfig as defaultConfig2,
+  resolveRuleOptions,
+  shouldSkipRangeCheck,
+  validateRuleSetting
+} from "@svelte-vitals/core";
 
 // src/rules-config.ts
 import { allRules } from "@svelte-vitals/core";
 var KNOWN_IDS = new Set(allRules.map((r) => r.id));
+var RULE_BY_ID = new Map(allRules.map((r) => [r.id, r]));
 function findUnknownRuleIds(ids) {
   return [...new Set(ids.filter((id) => !KNOWN_IDS.has(id)))];
 }
 function knownRuleIds() {
   return [...KNOWN_IDS].sort();
 }
+function ruleOptionsSpec(id) {
+  return RULE_BY_ID.get(id)?.options;
+}
 function buildRulesConfig(allow, ignore) {
   const rules = {};
   if (allow.length > 0) {
@@ -1188,17 +1215,23 @@ function buildRulesConfig(allow, ignore) {
 
 // src/config-file.ts
 var CONFIG_FILENAMES = ["svelte-vitals.config.mjs", "svelte-vitals.config.js", "svelte-vitals.config.ts"];
-var CATEGORIES = ["seo", "performance", "correctness", "security", "architecture"];
 var TREAT_DYNAMIC_AS_VALUES = ["pass", "warn", "fail"];
 var FAIL_ON_VALUES = ["critical", "warning", "info"];
 var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set(["treatDynamicAs", "metaComponents", "rules", "failOn", "weights", "overrides"]);
-var RULE_SETTING_VALUES = ["off", "critical", "warning", "info"];
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isMissingExtensionLoaderError(err) {
   return err instanceof Error && ("code" in err && err.code === "ERR_UNKNOWN_FILE_EXTENSION" || /Unknown file extension/.test(err.message));
 }
+function validateSetting(path, where, key, setting, allowOptions, baseline, skipRangeCheck) {
+  const errors = validateRuleSetting(`${where}.${key}`, key, setting, ruleOptionsSpec(key), {
+    allowOptions,
+    ...baseline !== void 0 ? { baseline } : {},
+    ...skipRangeCheck !== void 0 ? { skipRangeCheck } : {}
+  });
+  if (errors.length > 0) throw new Error(`${path}: ${errors.join(" ")}`);
+}
 function validateConfigFile(raw, path) {
   const warnings = [];
   const config = {};
@@ -1241,6 +1274,7 @@ function validateConfigFile(raw, path) {
         `${path}: unknown rule id(s) in rules: ${unknown.join(", ")}. Known rule ids: ${knownRuleIds().join(", ")}`
       );
     }
+    for (const [key, setting] of Object.entries(rules)) validateSetting(path, "rules", key, setting, true);
     config.rules = rules;
   }
   if (raw.overrides !== void 0) {
@@ -1250,7 +1284,8 @@ function validateConfigFile(raw, path) {
     const isGlob = (v) => typeof v === "string" && v.length > 0;
     const isGlobs = (v) => isGlob(v) || Array.isArray(v) && v.length > 0 && v.every(isGlob);
     const overrides = [];
-    raw.overrides.forEach((entry, i) => {
+    const rawOverrides = raw.overrides;
+    rawOverrides.forEach((entry, i) => {
       if (!isPlainObject2(entry)) {
         throw new Error(`${path}: overrides[${i}] must be an object with 'route' and/or 'files', and 'rules'.`);
       }
@@ -1281,11 +1316,10 @@ function validateConfigFile(raw, path) {
         );
       }
       for (const [key, setting] of Object.entries(entry.rules)) {
-        if (!RULE_SETTING_VALUES.includes(setting)) {
-          throw new Error(
-            `${path}: overrides[${i}].rules.${key}: invalid setting '${String(setting)}'; expected ${RULE_SETTING_VALUES.join("|")}.`
-          );
-        }
+        const isCategory = CATEGORIES.includes(key);
+        const baseline = isCategory ? void 0 : resolveRuleOptions(key, ruleOptionsSpec(key), { ...defaultConfig2, rules: config.rules ?? {} });
+        const skipRangeCheck = shouldSkipRangeCheck(rawOverrides, i, key, setting);
+        validateSetting(path, `overrides[${i}].rules`, key, setting, !isCategory, baseline, skipRangeCheck);
       }
       overrides.push({
         ...entry.route !== void 0 ? { route: entry.route } : {},
@@ -1690,6 +1724,7 @@ export {
   isReporterName,
   findUnknownRuleIds,
   knownRuleIds,
+  ruleOptionsSpec,
   buildRulesConfig,
   CONFIG_FILENAMES,
   loadConfigFile,

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { HeadTag, RuleSetting, Config, Severity, Category, Result } from '@svelte-vitals/core';
+import { HeadTag, RuleSetting, RuleOptionsSpec, Config, Severity, Category, Result } from '@svelte-vitals/core';
 export { defineConfig } from '@svelte-vitals/core';
 import { AST } from 'svelte/compiler';
 
@@ -60,6 +60,8 @@ declare class ProjectError extends Error {
 declare function findUnknownRuleIds(ids: string[]): string[];
 /** All built-in rule ids, sorted — for help and error messages. */
 declare function knownRuleIds(): string[];
+/** The options a rule declares, or undefined when it takes none. */
+declare function ruleOptionsSpec(id: string): RuleOptionsSpec | undefined;
 /**
  * Build the per-rule config map from an allow-list (--rules) and a deny-list
  * (--ignore). An allow-list disables every rule not listed; deny always wins.
@@ -243,4 +245,4 @@ declare function applyScope(results: Result[], opts: ApplyScopeOptions): Promise
  */
 declare function run(opts?: RunOptions): Promise<number>;
 
-export { type AnalyzeOptions, type AnalyzeResult, type ApplyScopeOptions, type LoadedConfigFile, type ParseCache, ProjectError, type RunOptions, analyzeProject, applyScope, buildRulesConfig, findUnknownRuleIds, knownRuleIds, loadConfigFile, routeMatcher, run, spinnerEnabled };
+export { type AnalyzeOptions, type AnalyzeResult, type ApplyScopeOptions, type LoadedConfigFile, type ParseCache, ProjectError, type RunOptions, analyzeProject, applyScope, buildRulesConfig, findUnknownRuleIds, knownRuleIds, loadConfigFile, routeMatcher, ruleOptionsSpec, run, spinnerEnabled };

package/dist/index.js

@@ -8,9 +8,10 @@ import {
   knownRuleIds,
   loadConfigFile,
   routeMatcher,
+  ruleOptionsSpec,
   run,
   spinnerEnabled
-} from "./chunk-CWCO6A5B.js";
+} from "./chunk-WSPRFLPP.js";
 export {
   ProjectError,
   analyzeProject,
@@ -21,6 +22,7 @@ export {
   knownRuleIds,
   loadConfigFile,
   routeMatcher,
+  ruleOptionsSpec,
   run,
   spinnerEnabled
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-vitals",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "A SvelteKit SEO checker — not a runtime Web Vitals reporter. Static analysis of your routes' head metadata.",
   "type": "module",
   "license": "MIT",
@@ -44,9 +44,9 @@
     "magicast": "^0.5.3",
     "mri": "^1.2.0",
     "smol-toml": "^1.7.0",
-    "svelte": "^5.56.6",
+    "svelte": "^5.56.8",
     "tinyglobby": "^0.2.17",
-    "@svelte-vitals/core": "0.29.0"
+    "@svelte-vitals/core": "0.30.0"
   },
   "devDependencies": {
     "@types/estree": "^1.0.9",
@@ -56,6 +56,7 @@
     "build": "tsup",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
+    "gen:rules-index": "pnpm --filter @svelte-vitals/core build && node scripts/gen-rules-index.mjs",
     "update-action-pin": "node scripts/gen-action-pin.mjs"
   }
 }