specra 0.2.67 → 0.2.68

package/config/category.schema.json

@@ -2,9 +2,67 @@
   "$ref": "#/definitions/CategoryConfig",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "definitions": {
+    "BadgeColor": {
+      "enum": [
+        "gray",
+        "red",
+        "orange",
+        "amber",
+        "green",
+        "teal",
+        "blue",
+        "purple",
+        "pink",
+        "cyan"
+      ],
+      "type": "string"
+    },
+    "BadgeInput": {
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "$ref": "#/definitions/BadgeSpec"
+        },
+        {
+          "items": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "$ref": "#/definitions/BadgeSpec"
+              }
+            ]
+          },
+          "type": "array"
+        }
+      ],
+      "description": "Anything an author may write in frontmatter or `_category_.json`."
+    },
+    "BadgeSpec": {
+      "additionalProperties": false,
+      "description": "A badge written out longhand. `color` falls back to the preset, then to gray.",
+      "properties": {
+        "color": {
+          "$ref": "#/definitions/BadgeColor"
+        },
+        "text": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "text"
+      ],
+      "type": "object"
+    },
     "CategoryConfig": {
       "additionalProperties": false,
       "properties": {
+        "badge": {
+          "$ref": "#/definitions/BadgeInput"
+        },
         "collapsed": {
           "type": "boolean"
         },

package/dist/badges.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Sidebar badge resolution.
+ *
+ * Authors mark a page or a category with a badge and a small pill renders next
+ * to its sidebar row. A badge is a short text plus a color, and the common
+ * cases ship as presets so the frontmatter stays a single word:
+ *
+ *   badge: new                              # preset
+ *   badge: { text: Beta, color: purple }    # explicit
+ *   badge: { text: "v3 only" }              # free text, default color
+ *   badge: [new, beta]                      # several pills on one row
+ *
+ * Both frontmatter (`meta.badge`) and `_category_.json` (`badge`) pass through
+ * `resolveBadges`, so the two surfaces can never drift apart.
+ */
+export declare const BADGE_COLORS: readonly ["gray", "red", "orange", "amber", "green", "teal", "blue", "purple", "pink", "cyan"];
+export type BadgeColor = (typeof BADGE_COLORS)[number];
+export declare const DEFAULT_BADGE_COLOR: BadgeColor;
+/** A badge written out longhand. `color` falls back to the preset, then to gray. */
+export interface BadgeSpec {
+    text: string;
+    color?: BadgeColor;
+}
+/** Anything an author may write in frontmatter or `_category_.json`. */
+export type BadgeInput = string | BadgeSpec | Array<string | BadgeSpec>;
+/** A badge ready to render: color narrowed, classes attached. */
+export interface ResolvedBadge {
+    text: string;
+    color: BadgeColor;
+    className: string;
+}
+/** Shorthand names an author can use in place of a `{ text, color }` pair. */
+export declare const BADGE_PRESETS: Record<string, Required<BadgeSpec>>;
+/**
+ * Normalize any author input into a render-ready list. Unparseable entries are
+ * dropped individually, so one bad badge never takes its siblings down with it.
+ */
+export declare function resolveBadges(input: unknown): ResolvedBadge[];

package/dist/badges.js

@@ -0,0 +1,109 @@
+/**
+ * Sidebar badge resolution.
+ *
+ * Authors mark a page or a category with a badge and a small pill renders next
+ * to its sidebar row. A badge is a short text plus a color, and the common
+ * cases ship as presets so the frontmatter stays a single word:
+ *
+ *   badge: new                              # preset
+ *   badge: { text: Beta, color: purple }    # explicit
+ *   badge: { text: "v3 only" }              # free text, default color
+ *   badge: [new, beta]                      # several pills on one row
+ *
+ * Both frontmatter (`meta.badge`) and `_category_.json` (`badge`) pass through
+ * `resolveBadges`, so the two surfaces can never drift apart.
+ */
+export const BADGE_COLORS = [
+    "gray",
+    "red",
+    "orange",
+    "amber",
+    "green",
+    "teal",
+    "blue",
+    "purple",
+    "pink",
+    "cyan",
+];
+export const DEFAULT_BADGE_COLOR = "gray";
+/**
+ * Tailwind scans this file (see the `@source` directive in `styles/globals.css`),
+ * so every class must appear here as a complete literal string. Composing them at
+ * runtime — `bg-${color}-500/10` — compiles to nothing.
+ *
+ * Gray leans on the theme tokens so it tracks the active preset theme; the rest
+ * are fixed palette colors, since a "Deprecated" pill should read the same red
+ * whichever theme the site ships.
+ */
+const BADGE_COLOR_CLASSES = {
+    gray: "bg-muted text-muted-foreground",
+    red: "bg-red-500/10 text-red-600 dark:text-red-400",
+    orange: "bg-orange-500/10 text-orange-600 dark:text-orange-400",
+    amber: "bg-amber-500/10 text-amber-600 dark:text-amber-400",
+    green: "bg-green-500/10 text-green-600 dark:text-green-400",
+    teal: "bg-teal-500/10 text-teal-600 dark:text-teal-400",
+    blue: "bg-blue-500/10 text-blue-600 dark:text-blue-400",
+    purple: "bg-purple-500/10 text-purple-600 dark:text-purple-400",
+    pink: "bg-pink-500/10 text-pink-600 dark:text-pink-400",
+    cyan: "bg-cyan-500/10 text-cyan-600 dark:text-cyan-400",
+};
+/** Shorthand names an author can use in place of a `{ text, color }` pair. */
+export const BADGE_PRESETS = {
+    new: { text: "New", color: "green" },
+    updated: { text: "Updated", color: "blue" },
+    beta: { text: "Beta", color: "purple" },
+    experimental: { text: "Experimental", color: "orange" },
+    "pre-release": { text: "Pre-release", color: "amber" },
+    deprecated: { text: "Deprecated", color: "red" },
+    "coming-soon": { text: "Coming soon", color: "gray" },
+};
+/** `Pre_Release`, `PRE RELEASE` and `pre-release` all name the same preset. */
+function presetKey(value) {
+    return value.trim().toLowerCase().replace(/[\s_]+/g, "-");
+}
+function isBadgeColor(value) {
+    return typeof value === "string" && BADGE_COLORS.includes(value);
+}
+function finalize(text, color) {
+    return { text, color, className: BADGE_COLOR_CLASSES[color] };
+}
+function resolveBadge(entry) {
+    if (typeof entry === "string") {
+        const preset = BADGE_PRESETS[presetKey(entry)];
+        if (preset)
+            return finalize(preset.text, preset.color);
+        const text = entry.trim();
+        return text ? finalize(text, DEFAULT_BADGE_COLOR) : null;
+    }
+    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+        const { text, color } = entry;
+        if (typeof text !== "string")
+            return null;
+        const trimmed = text.trim();
+        if (!trimmed)
+            return null;
+        // `{ text: Beta }` still picks up the preset color; an explicit, valid
+        // `color` always wins. An unknown color degrades to gray rather than
+        // throwing, so one typo cannot fail a whole docs build.
+        const preset = BADGE_PRESETS[presetKey(trimmed)];
+        const resolved = isBadgeColor(color) ? color : (preset?.color ?? DEFAULT_BADGE_COLOR);
+        return finalize(trimmed, resolved);
+    }
+    return null;
+}
+/**
+ * Normalize any author input into a render-ready list. Unparseable entries are
+ * dropped individually, so one bad badge never takes its siblings down with it.
+ */
+export function resolveBadges(input) {
+    if (input === null || input === undefined)
+        return [];
+    const entries = Array.isArray(input) ? input : [input];
+    const badges = [];
+    for (const entry of entries) {
+        const badge = resolveBadge(entry);
+        if (badge)
+            badges.push(badge);
+    }
+    return badges;
+}

package/dist/category.d.ts

@@ -1,3 +1,4 @@
+import type { BadgeInput } from "./badges.js";
 export interface CategoryConfig {
     label?: string;
     position?: number;
@@ -10,6 +11,7 @@ export interface CategoryConfig {
     collapsible?: boolean;
     icon?: string;
     tab_group?: string;
+    badge?: BadgeInput;
 }
 /**
  * Read category.json from a folder

package/dist/changelog-context.d.ts

@@ -0,0 +1,6 @@
+export interface ChangelogContext {
+    /** True when an update carrying `tags` survives the current filter. */
+    matches(tags: string[] | undefined): boolean;
+}
+export declare function setChangelogContext(context: ChangelogContext): void;
+export declare function getChangelogContext(): ChangelogContext | undefined;

package/dist/changelog-context.js

@@ -0,0 +1,15 @@
+/**
+ * Context shared between `<Changelog>` and its `<Update>` children.
+ *
+ * Siblings cannot see each other in Svelte 5, so tag filtering needs a common
+ * parent to hold the selected-tag set. `<Update>` works fine without one — a
+ * bare update outside a `<Changelog>` simply never gets filtered.
+ */
+import { getContext, setContext } from 'svelte';
+const CHANGELOG_KEY = Symbol('specra:changelog');
+export function setChangelogContext(context) {
+    setContext(CHANGELOG_KEY, context);
+}
+export function getChangelogContext() {
+    return getContext(CHANGELOG_KEY);
+}

package/dist/changelog.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Changelog entry extraction and RSS feed generation.
+ *
+ * A changelog page is an ordinary MDX page holding `<Update>` blocks:
+ *
+ *   <Changelog>
+ *     <Update label="2026-07-10" description="v1.2.0" tags={["SDK"]}>
+ *       Added sidebar badges.
+ *     </Update>
+ *   </Changelog>
+ *
+ * This module is framework-agnostic and server-safe (no fs, no Svelte). It
+ * turns the `MdxNode` tree into feed entries and renders RSS 2.0.
+ */
+import type { MdxNode } from "./mdx.js";
+/** Author-supplied override for how an update appears in the feed. */
+export interface UpdateRssOverride {
+    title?: string;
+    description?: string;
+}
+export interface ChangelogEntry {
+    /** Anchor id, injected server-side so it matches the rendered element. */
+    id: string;
+    label: string;
+    description?: string;
+    tags: string[];
+    /** Feed entry title: `rss.title`, else the label. */
+    title: string;
+    /** Feed entry body: `rss.description`, else the entry's plain text. */
+    summary: string;
+}
+/**
+ * Pull every `<Update>` out of a processed document, in document order.
+ * Works whether or not the updates sit inside a `<Changelog>` wrapper.
+ */
+export declare function extractChangelogEntries(nodes: MdxNode[] | undefined): ChangelogEntry[];
+/**
+ * Inject `allTags` onto every `<Changelog>` node: the union of its updates' tags,
+ * in first-seen order.
+ *
+ * Computed here, on the server, rather than by having each `<Update>` register
+ * itself with a parent context at render time. Children render after their parent
+ * during SSR, so a self-registering filter bar would serialize with an empty tag
+ * list and then repopulate on hydration — a mismatch and a visible flash.
+ *
+ * Mutates in place and returns the same array, matching the pipeline's style.
+ */
+export declare function annotateChangelogNodes(nodes: MdxNode[] | undefined): MdxNode[];
+export interface RssFeedOptions {
+    entries: ChangelogEntry[];
+    /** Site origin, e.g. `https://docs.example.com` (from `config.site.url`). */
+    siteUrl: string;
+    /** Path of the changelog page, e.g. `/docs/v1.0.0/changelog`. */
+    pageUrl: string;
+    title: string;
+    description?: string;
+}
+/** Render entries as an RSS 2.0 document. */
+export declare function renderRssFeed({ entries, siteUrl, pageUrl, title, description, }: RssFeedOptions): string;

package/dist/changelog.js

@@ -0,0 +1,204 @@
+/**
+ * Changelog entry extraction and RSS feed generation.
+ *
+ * A changelog page is an ordinary MDX page holding `<Update>` blocks:
+ *
+ *   <Changelog>
+ *     <Update label="2026-07-10" description="v1.2.0" tags={["SDK"]}>
+ *       Added sidebar badges.
+ *     </Update>
+ *   </Changelog>
+ *
+ * This module is framework-agnostic and server-safe (no fs, no Svelte). It
+ * turns the `MdxNode` tree into feed entries and renders RSS 2.0.
+ */
+/** The component names, as they appear on `MdxNode.name` after tag mapping. */
+const UPDATE_NODE = "Update";
+const CHANGELOG_NODE = "Changelog";
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((v) => typeof v === "string" && v.trim().length > 0);
+}
+/**
+ * Tags that separate words. Everything else is inline and disappears without a
+ * trace: turning `<code>new</code>,` into a space would emit `new ,`, while
+ * deleting `</li><li>` outright would collapse `<li>a</li><li>b</li>` into `ab`.
+ */
+const BLOCK_TAG = /<\/?(?:p|div|br|hr|h[1-6]|ul|ol|li|pre|blockquote|table|thead|tbody|tr|td|th|section|article|header|footer|figure|figcaption)\b[^>]*>/gi;
+/**
+ * Strip an `html` node's markup down to readable text.
+ *
+ * Feed readers render a tiny, unpredictable subset of HTML, so entry bodies are
+ * plain text.
+ */
+function htmlToText(html) {
+    return html
+        .replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, " ")
+        .replace(BLOCK_TAG, " ")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/gi, "'")
+        // `&amp;` last: decoding it earlier would let `&amp;lt;` become `<`.
+        .replace(/&amp;/gi, "&")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * Collect plain text from a node's subtree.
+ *
+ * Component nodes are skipped, matching Mintlify: a `<Card>` or `<Tabs>` inside
+ * an update carries layout, not prose, and flattening it produces noise. Authors
+ * who need those words in the feed supply `rss={{ description: "..." }}`.
+ */
+function nodesToText(nodes) {
+    if (!nodes?.length)
+        return "";
+    const parts = [];
+    for (const node of nodes) {
+        if (node.type === "html" && node.content)
+            parts.push(htmlToText(node.content));
+    }
+    return parts.filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+}
+/** Depth-first walk yielding every node in document order. */
+function* walk(nodes) {
+    if (!nodes?.length)
+        return;
+    for (const node of nodes) {
+        yield node;
+        yield* walk(node.children);
+    }
+}
+function toEntry(node) {
+    const props = node.props ?? {};
+    const label = typeof props.label === "string" ? props.label.trim() : "";
+    // An update with no label has no anchor and no stable identity, so it cannot
+    // appear in a feed. It still renders on the page; it is just not syndicated.
+    if (!label)
+        return null;
+    const id = typeof props.id === "string" ? props.id : "";
+    const description = typeof props.description === "string" ? props.description.trim() : undefined;
+    const tags = asStringArray(props.tags);
+    const rss = isRecord(props.rss) ? props.rss : {};
+    const title = typeof rss.title === "string" && rss.title.trim() ? rss.title.trim() : label;
+    const summary = typeof rss.description === "string" && rss.description.trim()
+        ? rss.description.trim()
+        : nodesToText(node.children);
+    return { id, label, description, tags, title, summary };
+}
+/**
+ * Pull every `<Update>` out of a processed document, in document order.
+ * Works whether or not the updates sit inside a `<Changelog>` wrapper.
+ */
+export function extractChangelogEntries(nodes) {
+    const entries = [];
+    for (const node of walk(nodes)) {
+        if (node.type !== "component" || node.name !== UPDATE_NODE)
+            continue;
+        const entry = toEntry(node);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}
+/**
+ * Inject `allTags` onto every `<Changelog>` node: the union of its updates' tags,
+ * in first-seen order.
+ *
+ * Computed here, on the server, rather than by having each `<Update>` register
+ * itself with a parent context at render time. Children render after their parent
+ * during SSR, so a self-registering filter bar would serialize with an empty tag
+ * list and then repopulate on hydration — a mismatch and a visible flash.
+ *
+ * Mutates in place and returns the same array, matching the pipeline's style.
+ */
+export function annotateChangelogNodes(nodes) {
+    if (!nodes?.length)
+        return nodes ?? [];
+    for (const node of walk(nodes)) {
+        if (node.type !== "component" || node.name !== CHANGELOG_NODE)
+            continue;
+        const seen = new Set();
+        const allTags = [];
+        for (const child of walk(node.children)) {
+            if (child.type !== "component" || child.name !== UPDATE_NODE)
+                continue;
+            for (const tag of asStringArray(child.props?.tags)) {
+                if (seen.has(tag))
+                    continue;
+                seen.add(tag);
+                allTags.push(tag);
+            }
+        }
+        node.props = { ...node.props, allTags };
+    }
+    return nodes;
+}
+const XML_ESCAPES = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&apos;",
+};
+function escapeXml(value) {
+    return value.replace(/[&<>"']/g, (char) => XML_ESCAPES[char]);
+}
+/**
+ * Interpret an update label as a date for `<pubDate>`.
+ *
+ * Labels are free text — "March 2025" and "v2 launch" are both valid — so a
+ * label that isn't a date simply yields no pubDate rather than an Invalid Date.
+ */
+function toPubDate(label) {
+    const parsed = new Date(label);
+    return Number.isNaN(parsed.getTime()) ? null : parsed.toUTCString();
+}
+/** Join a site origin and a page path into one absolute URL, without doubling slashes. */
+function absoluteUrl(siteUrl, pageUrl) {
+    return `${siteUrl.replace(/\/+$/, "")}/${pageUrl.replace(/^\/+/, "")}`;
+}
+/** Render entries as an RSS 2.0 document. */
+export function renderRssFeed({ entries, siteUrl, pageUrl, title, description = "", }) {
+    const link = absoluteUrl(siteUrl, pageUrl);
+    const feedUrl = `${link}/rss.xml`;
+    const items = entries.map((entry) => {
+        const guid = entry.id ? `${link}#${entry.id}` : link;
+        const pubDate = toPubDate(entry.label);
+        // `description` is the version line; fold it into the body so subscribers
+        // see which release an entry belongs to.
+        const body = [entry.description, entry.summary].filter(Boolean).join(" — ");
+        return [
+            "    <item>",
+            `      <title>${escapeXml(entry.title)}</title>`,
+            `      <link>${escapeXml(guid)}</link>`,
+            `      <guid isPermaLink="false">${escapeXml(guid)}</guid>`,
+            pubDate ? `      <pubDate>${escapeXml(pubDate)}</pubDate>` : null,
+            ...entry.tags.map((tag) => `      <category>${escapeXml(tag)}</category>`),
+            `      <description>${escapeXml(body)}</description>`,
+            "    </item>",
+        ]
+            .filter(Boolean)
+            .join("\n");
+    });
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">',
+        "  <channel>",
+        `    <title>${escapeXml(title)}</title>`,
+        `    <link>${escapeXml(link)}</link>`,
+        `    <description>${escapeXml(description)}</description>`,
+        `    <atom:link href="${escapeXml(feedUrl)}" rel="self" type="application/rss+xml" />`,
+        ...items,
+        "  </channel>",
+        "</rss>",
+        "",
+    ].join("\n");
+}

package/dist/components/docs/Changelog.svelte

@@ -0,0 +1,71 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte';
+  import { setChangelogContext } from '../../changelog-context.js';
+
+  interface Props {
+    /**
+     * Union of every child <Update>'s tags, injected server-side by
+     * annotateChangelogNodes. Not authored by hand: children render after their
+     * parent during SSR, so a bar that waited for them to self-register would
+     * serialize empty and then flash on hydration.
+     */
+    allTags?: string[];
+    children?: Snippet;
+  }
+
+  let { allTags = [], children }: Props = $props();
+
+  let selected = $state<string[]>([]);
+
+  setChangelogContext({
+    matches(tags) {
+      // Reading `selected` here is what subscribes each <Update> to the filter.
+      if (selected.length === 0) return true;
+      if (!tags?.length) return false;
+      // AND logic: an update must carry every selected tag, not merely one.
+      return selected.every((tag) => tags.includes(tag));
+    }
+  });
+
+  function toggle(tag: string) {
+    selected = selected.includes(tag)
+      ? selected.filter((t) => t !== tag)
+      : [...selected, tag];
+  }
+</script>
+
+<div class="specra-changelog">
+  {#if allTags.length > 0}
+    <div class="mb-8 flex flex-wrap items-center gap-2 border-b border-border pb-6">
+      <span class="mr-1 text-xs font-medium text-muted-foreground">Filter</span>
+
+      {#each allTags as tag (tag)}
+        {@const active = selected.includes(tag)}
+        <button
+          type="button"
+          aria-pressed={active}
+          onclick={() => toggle(tag)}
+          class="rounded-full border px-2.5 py-1 text-xs font-medium transition-colors {active
+            ? 'border-primary bg-primary/10 text-primary'
+            : 'border-border text-muted-foreground hover:bg-accent/50 hover:text-foreground'}"
+        >
+          {tag}
+        </button>
+      {/each}
+
+      {#if selected.length > 0}
+        <button
+          type="button"
+          onclick={() => (selected = [])}
+          class="ml-1 text-xs text-muted-foreground underline underline-offset-2 hover:text-foreground"
+        >
+          Clear
+        </button>
+      {/if}
+    </div>
+  {/if}
+
+  {#if children}
+    {@render children()}
+  {/if}
+</div>

package/dist/components/docs/Changelog.svelte.d.ts

@@ -0,0 +1,14 @@
+import type { Snippet } from 'svelte';
+interface Props {
+    /**
+     * Union of every child <Update>'s tags, injected server-side by
+     * annotateChangelogNodes. Not authored by hand: children render after their
+     * parent during SSR, so a bar that waited for them to self-register would
+     * serialize empty and then flash on hydration.
+     */
+    allTags?: string[];
+    children?: Snippet;
+}
+declare const Changelog: import("svelte").Component<Props, {}, "">;
+type Changelog = ReturnType<typeof Changelog>;
+export default Changelog;

package/dist/components/docs/Sidebar.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
   import type { SpecraConfig } from '../../config.types.js';
+  import type { BadgeInput } from '../../badges.js';
   import SidebarMenuItems from './SidebarMenuItems.svelte';
 
   interface DocItem {
@@ -16,9 +17,11 @@
     categoryCollapsed?: boolean;
     categoryIcon?: string;
     categoryTabGroup?: string;
+    categoryBadge?: BadgeInput;
     meta?: {
       icon?: string;
       tab_group?: string;
+      badge?: BadgeInput;
       [key: string]: any;
     };
   }

package/dist/components/docs/Sidebar.svelte.d.ts

@@ -1,4 +1,5 @@
 import type { SpecraConfig } from '../../config.types.js';
+import type { BadgeInput } from '../../badges.js';
 interface DocItem {
     title: string;
     slug: string;
@@ -13,9 +14,11 @@ interface DocItem {
     categoryCollapsed?: boolean;
     categoryIcon?: string;
     categoryTabGroup?: string;
+    categoryBadge?: BadgeInput;
     meta?: {
         icon?: string;
         tab_group?: string;
+        badge?: BadgeInput;
         [key: string]: any;
     };
 }

package/dist/components/docs/SidebarBadge.svelte

@@ -0,0 +1,15 @@
+<script lang="ts">
+  import type { ResolvedBadge } from '../../badges.js';
+
+  interface Props {
+    badge: ResolvedBadge;
+  }
+
+  let { badge }: Props = $props();
+</script>
+
+<span
+  class="px-1.5 py-0.5 text-[10px] font-medium rounded-full leading-none whitespace-nowrap {badge.className}"
+>
+  {badge.text}
+</span>

package/dist/components/docs/SidebarBadge.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedBadge } from '../../badges.js';
+interface Props {
+    badge: ResolvedBadge;
+}
+declare const SidebarBadge: import("svelte").Component<Props, {}, "">;
+type SidebarBadge = ReturnType<typeof SidebarBadge>;
+export default SidebarBadge;