npm - @svelte-vitals/core - Versions diffs - 0.11.0 → 0.13.0 - Mend

@svelte-vitals/core 0.11.0 → 0.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.d.ts CHANGED Viewed

@@ -21,6 +21,8 @@ interface Project {
     hasSitemap: boolean;
     /** <html lang> from app.html: presence 'own' when the attribute exists ('none' otherwise); value 'static' if non-empty, 'absent' if empty. */
     htmlLang: Detection;
+    /** Whether the static static/robots.txt references a sitemap (`Sitemap:` line). Undefined for a +server endpoint / absent / unreadable. */
+    robotsReferencesSitemap?: boolean;
 }
 declare const defaultProject: Project;
 /** A concrete, agent-actionable remediation for a finding (design §10, issue #18). */
@@ -105,6 +107,14 @@ interface HeadTag {
     property?: string;
     /** <link rel="...">. */
     rel?: string;
+    /** <link as="..."> keyword (e.g. 'font') when statically literal; undefined when absent or dynamically bound. */
+    as?: string;
+    /** True when a <link> has an `as` attribute at all (literal or dynamic). Distinguishes "no as" from "dynamic as". */
+    hasAs?: boolean;
+    /** True when a <link> has a `crossorigin` attribute (presence only; value is irrelevant to the checks). */
+    hasCrossorigin?: boolean;
+    /** True when a <meta name="robots"> literal content contains `noindex`/`none`. Undefined when dynamic or absent. */
+    noindex?: boolean;
     /** Where this tag was set relative to the route. Never 'none' (absence = no tag). */
     presence: Exclude<Presence, 'none'>;
     /** Whether the tag's value is static/dynamic/absent (design §4). */
@@ -229,6 +239,16 @@ declare const seo009HtmlLang: Rule;
 declare const perf001ImageDimensions: Rule;
 declare const perf002ImageLoading: Rule;
+declare const perf003PreloadAs: Rule;
+declare const perf004FontPreloadCrossorigin: Rule;
+declare const seo010Indexability: Rule;
+declare const seo011TwitterCard: Rule;
+declare const seo012OgDescription: Rule;
+declare const seo013OgUrl: Rule;
+declare const seo014Viewport: Rule;
+declare const seo015SitemapInRobots: Rule;
 declare const allRules: Rule[];
 interface RuleInfo {
@@ -256,6 +276,13 @@ interface HeadTagRuleOptions {
     rationale: string;
     /** Agent-actionable remediation attached to every finding (issue #18). */
     fix?: Fix;
+    /**
+     * When set, only heads for which this returns true are evaluated; others emit
+     * nothing. Use for tags whose canonical location is invisible to a given mode
+     * (e.g. viewport lives in app.html → only checkable in rendered mode), so the
+     * rule stays silent instead of false-flagging "missing".
+     */
+    appliesTo?: (head: ResolvedHead) => boolean;
 }
 /** Build a route-scope rule asserting the presence of a single head tag (design §11). */
 declare function headTagRule(opts: HeadTagRuleOptions): Rule;
@@ -275,6 +302,23 @@ interface ImageRuleOptions {
 /** Build a route-scoped Performance rule that checks each <img> against `ok` (issue #10). */
 declare function imageRule(opts: ImageRuleOptions): Rule;
+interface LinkRuleOptions {
+    id: string;
+    title: string;
+    severity: Severity;
+    /** Noun phrase for messages, e.g. '`as` on a preloaded `<link>`'. */
+    label: string;
+    recommendation: string;
+    rationale: string;
+    fix?: Fix;
+    /** Which link tags this rule evaluates (e.g. rel === 'preload'). */
+    relevant: (tag: HeadTag) => boolean;
+    /** Returns true when a relevant link satisfies the rule (passes). */
+    ok: (tag: HeadTag) => boolean;
+}
+/** Build a route-scoped Performance rule that checks each relevant <link> in the effective head. */
+declare function linkRule(opts: LinkRuleOptions): Rule;
 interface Summary {
     critical: number;
     warning: number;
@@ -411,4 +455,4 @@ declare function selectRules(rules: Rule[], config: Config): Rule[];
 /** Apply per-rule severity overrides to results (design §6). */
 declare function applyRuleSeverities(results: Result[], config: Config): Result[];
-export { BAND_COLOR, type Category, type Classification, type Config, type ConsoleReportOptions, type Detection, type Fix, type HeadProvider, type HeadTag, type HealthResult, type ImageInfo, type JsonReport, type Presence, type Project, ROBOTS_SOURCE_PATHS, type ResolvedHead, type ResolvedImages, type Result, type Rule, type RuleContext, type RuleInfo, type RuleSetting, type Runtime, SITEMAP_SOURCE_PATHS, type Scope, type ScoreModel, type ScoreOptions, type ScoreResult, type Severity, type Summary, type TreatDynamicAs, type Value, allRules, applyRuleSeverities, buildHtmlDocument, buildJsonReport, classify, computeHealth, computeScore, defaultConfig, defaultProject, defineConfig, docsUrlFor, effectiveSeverity, escapeHtml, explainRule, formatAgentReport, formatConsoleReport, formatGithubReport, formatHtmlReport, formatJsonReport, formatSarifReport, hasFailureAtOrAbove, headTagRule, imageRule, isPenalized, perf001ImageDimensions, perf002ImageLoading, runRules, safeHref, scoreBand, scoresByCategory, selectRules, seo001Title, seo002Description, seo003Canonical, seo004OgImage, seo005OgTitle, seo006Robots, seo007Sitemap, seo008JsonLd, seo009HtmlLang, summarize };
+export { BAND_COLOR, type Category, type Classification, type Config, type ConsoleReportOptions, type Detection, type Fix, type HeadProvider, type HeadTag, type HealthResult, type ImageInfo, type JsonReport, type Presence, type Project, ROBOTS_SOURCE_PATHS, type ResolvedHead, type ResolvedImages, type Result, type Rule, type RuleContext, type RuleInfo, type RuleSetting, type Runtime, SITEMAP_SOURCE_PATHS, type Scope, type ScoreModel, type ScoreOptions, type ScoreResult, type Severity, type Summary, type TreatDynamicAs, type Value, allRules, applyRuleSeverities, buildHtmlDocument, buildJsonReport, classify, computeHealth, computeScore, defaultConfig, defaultProject, defineConfig, docsUrlFor, effectiveSeverity, escapeHtml, explainRule, formatAgentReport, formatConsoleReport, formatGithubReport, formatHtmlReport, formatJsonReport, formatSarifReport, hasFailureAtOrAbove, headTagRule, imageRule, isPenalized, linkRule, perf001ImageDimensions, perf002ImageLoading, perf003PreloadAs, perf004FontPreloadCrossorigin, runRules, safeHref, scoreBand, scoresByCategory, selectRules, seo001Title, seo002Description, seo003Canonical, seo004OgImage, seo005OgTitle, seo006Robots, seo007Sitemap, seo008JsonLd, seo009HtmlLang, seo010Indexability, seo011TwitterCard, seo012OgDescription, seo013OgUrl, seo014Viewport, seo015SitemapInRobots, summarize };

package/dist/index.js CHANGED Viewed

@@ -104,7 +104,8 @@ function headTagRule(opts) {
     rationale: opts.rationale,
     ...opts.fix ? { fix: opts.fix } : {},
     async check(ctx) {
-      return ctx.heads.map((head) => {
+      const heads = opts.appliesTo ? ctx.heads.filter(opts.appliesTo) : ctx.heads;
+      return heads.map((head) => {
         const detection = detect(head, opts.match);
         const message = detection.presence === "none" ? `Missing ${opts.label}` : detection.value === "absent" ? `Empty ${opts.label}` : opts.label;
         return {
@@ -373,6 +374,219 @@ var perf002ImageLoading = imageRule({
   ok: (img) => img.hasLoading
 });
+// src/rules/perf/link-rule.ts
+function linkRule(opts) {
+  const docsUrl = docsUrlFor(opts.id);
+  return {
+    id: opts.id,
+    title: opts.title,
+    category: "performance",
+    severity: opts.severity,
+    scope: "route",
+    rationale: opts.rationale,
+    ...opts.fix ? { fix: opts.fix } : {},
+    async check(ctx) {
+      const out = [];
+      for (const head of ctx.heads) {
+        const links = head.tags.filter((t) => t.kind === "link" && opts.relevant(t));
+        if (links.length === 0) continue;
+        const bad = links.filter((t) => !opts.ok(t));
+        if (bad.length === 0) {
+          out.push({
+            id: opts.id,
+            category: "performance",
+            severity: opts.severity,
+            detection: { presence: "own", value: "static" },
+            route: head.route,
+            message: opts.label,
+            recommendation: opts.recommendation,
+            docsUrl
+          });
+          continue;
+        }
+        for (const tag of bad) {
+          out.push({
+            id: opts.id,
+            category: "performance",
+            severity: opts.severity,
+            detection: { presence: "none", value: "absent" },
+            route: head.route,
+            // Point at the file the link actually came from (a layout in static
+            // mode); fall back to the route's representative file when the tag
+            // carries no file (rendered mode).
+            location: tag.file ?? head.file,
+            message: `Missing ${opts.label}`,
+            recommendation: opts.recommendation,
+            docsUrl,
+            ...opts.fix ? { fix: { ...opts.fix } } : {}
+          });
+        }
+      }
+      return out;
+    }
+  };
+}
+// src/rules/perf/resource-hints.ts
+var perf003PreloadAs = linkRule({
+  id: "PERF003",
+  title: "Preload missing as",
+  severity: "warning",
+  label: "`as` on a preloaded `<link>`",
+  recommendation: 'Add an `as` attribute to every `<link rel="preload">` so the browser knows the resource type and can prioritize it.',
+  rationale: 'A `<link rel="preload">` without an `as` attribute is ignored by the browser (or fetched a second time), wasting the preload.',
+  fix: {
+    description: "Add an `as` attribute matching the resource type to the preload link.",
+    snippet: '<link rel="preload" href="/app.css" as="style" />',
+    lang: "html"
+  },
+  relevant: (t) => t.rel === "preload",
+  ok: (t) => t.hasAs === true
+});
+var perf004FontPreloadCrossorigin = linkRule({
+  id: "PERF004",
+  title: "Font preload missing crossorigin",
+  severity: "warning",
+  label: "`crossorigin` on a font preload",
+  recommendation: 'Add `crossorigin` to `<link rel="preload" as="font">` \u2014 fonts are fetched in CORS mode, so without it the preload fetches a second, unused copy.',
+  rationale: "A font preload without `crossorigin` does not match the actual (CORS) font request, so the preloaded file is never used and the font downloads twice.",
+  fix: {
+    description: "Add the `crossorigin` attribute to the font preload link.",
+    snippet: '<link rel="preload" href="/inter.woff2" as="font" type="font/woff2" crossorigin />',
+    lang: "html"
+  },
+  relevant: (t) => t.rel === "preload" && t.as === "font",
+  ok: (t) => t.hasCrossorigin === true
+});
+// src/rules/seo/seo010-015.ts
+var SEO010_FIX = {
+  description: 'If this route should be indexed, drop noindex from its <meta name="robots">.',
+  snippet: '<svelte:head>\n  <meta name="robots" content="index, follow" />\n</svelte:head>',
+  lang: "svelte"
+};
+var seo010Indexability = {
+  id: "SEO010",
+  title: "Indexability",
+  category: "seo",
+  severity: "info",
+  scope: "route",
+  rationale: "A noindex directive removes the page from search results; an accidental noindex on a public route silently deindexes it.",
+  fix: SEO010_FIX,
+  async check(ctx) {
+    const docsUrl = docsUrlFor("SEO010");
+    const out = [];
+    for (const head of ctx.heads) {
+      const noindexed = head.tags.some((t) => t.kind === "meta" && t.name === "robots" && t.noindex === true);
+      if (!noindexed) continue;
+      out.push({
+        id: "SEO010",
+        category: "seo",
+        severity: "info",
+        detection: { presence: "none", value: "absent" },
+        // surfaced as an issue (isPenalized)
+        route: head.route,
+        location: head.file,
+        message: "Route is noindex \u2014 verify this is intentional",
+        recommendation: 'If this route should be indexed, remove noindex from its <meta name="robots">.',
+        docsUrl,
+        fix: { ...SEO010_FIX }
+      });
+    }
+    return out;
+  }
+};
+var seo011TwitterCard = headTagRule({
+  id: "SEO011",
+  title: "Twitter Card",
+  severity: "info",
+  match: (t) => t.kind === "meta" && t.name === "twitter:card",
+  label: '<meta name="twitter:card">',
+  recommendation: 'Add <meta name="twitter:card" content="summary_large_image"> so X/Twitter renders a rich card.',
+  rationale: "twitter:card selects how the page renders when shared on X/Twitter; without it the platform falls back to a basic link (Open Graph tags are used as fallbacks for the rest).",
+  fix: {
+    description: "Add a twitter:card meta tag in <svelte:head>.",
+    snippet: '<svelte:head>\n  <meta name="twitter:card" content="summary_large_image" />\n</svelte:head>',
+    lang: "svelte"
+  }
+});
+var seo012OgDescription = headTagRule({
+  id: "SEO012",
+  title: "Open Graph description",
+  severity: "warning",
+  match: (t) => t.kind === "meta" && t.property === "og:description",
+  label: '<meta property="og:description">',
+  recommendation: 'Add <meta property="og:description">, or set openGraph.description on your meta component.',
+  rationale: "og:description is the summary shown under the title in social previews; without it platforms guess or show nothing, lowering click-through.",
+  fix: {
+    description: "Add an og:description meta tag in <svelte:head>.",
+    snippet: '<svelte:head>\n  <meta property="og:description" content="A concise page summary." />\n</svelte:head>',
+    lang: "svelte"
+  }
+});
+var seo013OgUrl = headTagRule({
+  id: "SEO013",
+  title: "Open Graph URL",
+  severity: "info",
+  match: (t) => t.kind === "meta" && t.property === "og:url",
+  label: '<meta property="og:url">',
+  recommendation: 'Add <meta property="og:url"> with the canonical URL, or set openGraph.url on your meta component.',
+  rationale: "og:url tells social platforms the canonical address to attribute shares and likes to, consolidating engagement on one URL.",
+  fix: {
+    description: "Add an og:url meta tag in <svelte:head>.",
+    snippet: '<svelte:head>\n  <meta property="og:url" content="https://example.com/this-page" />\n</svelte:head>',
+    lang: "svelte"
+  }
+});
+var seo014Viewport = headTagRule({
+  id: "SEO014",
+  title: "Viewport",
+  severity: "warning",
+  match: (t) => t.kind === "meta" && t.name === "viewport",
+  label: '<meta name="viewport">',
+  // Viewport canonically lives in app.html, which static (CLI) mode does not
+  // resolve into head tags — only evaluate rendered heads so the rule stays
+  // silent there instead of false-flagging "missing" on every route.
+  appliesTo: (head) => head.source === "rendered",
+  recommendation: 'Add <meta name="viewport" content="width=device-width, initial-scale=1"> (usually in app.html).',
+  rationale: "Without a viewport meta tag the page is not mobile-responsive, which Google penalizes under mobile-first indexing.",
+  fix: {
+    description: "Add the viewport meta tag (typically in src/app.html <head>).",
+    snippet: '<meta name="viewport" content="width=device-width, initial-scale=1" />',
+    lang: "html"
+  }
+});
+var SEO015_FIX = {
+  description: "Add a Sitemap: line to static/robots.txt.",
+  snippet: "User-agent: *\nAllow: /\n\nSitemap: https://example.com/sitemap.xml",
+  lang: "text"
+};
+var seo015SitemapInRobots = {
+  id: "SEO015",
+  title: "Sitemap referenced in robots.txt",
+  category: "seo",
+  severity: "info",
+  scope: "project",
+  rationale: "A Sitemap: line in robots.txt helps crawlers discover your sitemap; without it discovery relies on manual submission.",
+  fix: SEO015_FIX,
+  async check(ctx) {
+    const { hasRobotsTxt, hasSitemap, robotsReferencesSitemap } = ctx.project;
+    if (!(hasRobotsTxt && hasSitemap && robotsReferencesSitemap === false)) return [];
+    return [
+      {
+        id: "SEO015",
+        category: "seo",
+        severity: "info",
+        detection: { presence: "none", value: "absent" },
+        message: "robots.txt does not reference your sitemap",
+        recommendation: "Add a Sitemap: line to static/robots.txt pointing at your sitemap.xml.",
+        docsUrl: docsUrlFor("SEO015"),
+        fix: { ...SEO015_FIX }
+      }
+    ];
+  }
+};
 // src/rules/index.ts
 var allRules = [
   seo001Title,
@@ -385,7 +599,15 @@ var allRules = [
   seo008JsonLd,
   seo009HtmlLang,
   perf001ImageDimensions,
-  perf002ImageLoading
+  perf002ImageLoading,
+  perf003PreloadAs,
+  perf004FontPreloadCrossorigin,
+  seo010Indexability,
+  seo011TwitterCard,
+  seo012OgDescription,
+  seo013OgUrl,
+  seo014Viewport,
+  seo015SitemapInRobots
 ];
 function explainRule(id) {
   const target = id.toUpperCase();
@@ -993,8 +1215,11 @@ export {
   headTagRule,
   imageRule,
   isPenalized,
+  linkRule,
   perf001ImageDimensions,
   perf002ImageLoading,
+  perf003PreloadAs,
+  perf004FontPreloadCrossorigin,
   runRules,
   safeHref,
   scoreBand,
@@ -1009,5 +1234,11 @@ export {
   seo007Sitemap,
   seo008JsonLd,
   seo009HtmlLang,
+  seo010Indexability,
+  seo011TwitterCard,
+  seo012OgDescription,
+  seo013OgUrl,
+  seo014Viewport,
+  seo015SitemapInRobots,
   summarize
 };

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@svelte-vitals/core",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Shared, runtime-agnostic core for svelte-vitals (types, rule engine, scorer, reporter).",
   "type": "module",
   "license": "MIT",