svelte-docsmith 0.9.0 → 0.10.0

package/dist/core/version.js

@@ -0,0 +1,85 @@
+import { navFromContent, flattenNav } from './nav.js';
+import { normalizePath } from '../utils/normalize-path.js';
+/** True when `pathname` is `base` or sits beneath it on a segment boundary. */
+function underBase(pathname, base) {
+    return pathname === base || pathname.startsWith(base + '/');
+}
+/**
+ * Resolve author versions against the docs URL base (e.g. `/docs`) and the
+ * collected content: compute each version's `basePath` and its `landing` (first
+ * page in sidebar reading order). Emitted as the `versions` manifest in
+ * `svelte-docsmith/content`, current first, then archives in declared order.
+ *
+ * Returns an empty manifest for an unversioned site, which makes every
+ * downstream scoping, switcher and banner step a no-op.
+ */
+export function resolveVersions(versions, docsBase, content) {
+    if (!versions)
+        return [];
+    const base = normalizePath(docsBase);
+    const resolve = (version, basePath, current) => {
+        const items = content.filter((item) => item.version === version.id);
+        return {
+            ...version,
+            basePath,
+            landing: flattenNav(navFromContent(items))[0]?.url ?? basePath,
+            current,
+            noindex: version.noindex ?? false
+        };
+    };
+    return [
+        resolve(versions.current, base, true),
+        ...(versions.archived ?? []).map((version) => resolve(version, normalizePath(base + '/' + version.id), false))
+    ];
+}
+/**
+ * The resolved version owning `pathname`, by longest matching `basePath`. An
+ * archive's base is longer than the current version's, so `/docs/v1/x` picks
+ * `v1` while `/docs/x` falls to the current version. `undefined` off the docs
+ * tree entirely, or on an unversioned site.
+ */
+export function activeVersion(versions, pathname) {
+    const path = normalizePath(pathname);
+    let best;
+    for (const v of versions) {
+        if (underBase(path, v.basePath) && (!best || v.basePath.length > best.basePath.length)) {
+            best = v;
+        }
+    }
+    return best;
+}
+/** The current version: the docs for the latest release. */
+export function currentVersion(versions) {
+    return versions.find((v) => v.current);
+}
+/**
+ * Keep only the current version's pages, for `sitemap.xml` and `llms.txt`, so
+ * search engines and LLMs index one canonical set. A no-op when the site
+ * declares no versions. Works over any record carrying `version`.
+ */
+export function currentOnly(items, versions) {
+    const current = currentVersion(versions);
+    return current ? items.filter((item) => item.version === current.id) : items;
+}
+/**
+ * Content scoped to one version. With no version id (unversioned site) the
+ * content passes through unchanged, so every caller stays a no-op off the
+ * versioned path.
+ */
+export function scopeContent(content, versionId) {
+    if (!versionId)
+        return content;
+    return content.filter((item) => item.version === versionId);
+}
+/**
+ * Map the current page to its equivalent under `to`: swap the version base, and
+ * fall back to the target's landing page when that doc doesn't exist there.
+ * `targetPaths` is the set of the target version's page URLs.
+ */
+export function mapPathToVersion(pathname, from, to, targetPaths) {
+    const path = normalizePath(pathname);
+    const rel = underBase(path, from.basePath) ? path.slice(from.basePath.length) : '';
+    const candidate = normalizePath(to.basePath + rel);
+    const set = targetPaths instanceof Set ? targetPaths : new Set(targetPaths);
+    return set.has(candidate) ? candidate : to.landing;
+}

package/dist/fallbacks/content.d.ts

@@ -7,4 +7,6 @@
  * {@link missingPluginError}.
  */
 import type { DocsContentItem } from '../core/content.js';
+import type { ResolvedVersion } from '../core/version.js';
 export declare const docs: DocsContentItem[];
+export declare const versions: ResolvedVersion[];

package/dist/fallbacks/content.js

@@ -1,3 +1,4 @@
 import { missingPluginError } from './missing-plugin.js';
 export const docs = [];
+export const versions = [];
 throw missingPluginError('content');

package/dist/index.d.ts

@@ -24,6 +24,7 @@ export { default as Feature } from './components/landing/feature.svelte';
 export { default as CTA } from './components/landing/cta.svelte';
 export { default as Action } from './components/landing/action.svelte';
 export { defineConfig, type DocsmithConfig, type DocsContentItem, type SearchDoc, type LlmsDoc } from './core/index.js';
+export { currentOnly, type DocsVersion, type DocsVersions, type ResolvedVersion } from './core/index.js';
 export { createSearchEngine, type SearchEngine, type SearchResult } from './search/create-search.js';
 export { generateSitemap, type SitemapEntry } from './generate/sitemap.js';
 export { generateLlmsTxt, generateLlmsFullTxt, type LlmsSite } from './generate/llms.js';

package/dist/index.js

@@ -31,6 +31,11 @@ export { default as CTA } from './components/landing/cta.svelte';
 export { default as Action } from './components/landing/action.svelte';
 // Config
 export { defineConfig } from './core/index.js';
+// Versioned docs. Declare `versions` in the `docsmith()` vite plugin; the
+// resolved manifest is exported from `svelte-docsmith/content` and passed to
+// `DocsShell`. `currentOnly` scopes sitemap.xml / llms.txt to the current
+// version, so archived releases don't compete with it in search results.
+export { currentOnly } from './core/index.js';
 // Search engine (framework-agnostic; for building a custom search UI over the
 // generated `svelte-docsmith/search` index)
 export { createSearchEngine } from './search/create-search.js';

package/dist/search/context.svelte.d.ts

@@ -1,5 +1,7 @@
 export declare class SearchState {
     open: boolean;
+    /** Active version id on a versioned site; scopes results. `undefined` otherwise. */
+    version: string | undefined;
 }
 /** Create the search state and publish it on context. Call in `DocsShell`. */
 export declare function createSearchState(): SearchState;

package/dist/search/context.svelte.js

@@ -7,6 +7,8 @@ import { getContext, setContext } from 'svelte';
 const KEY = Symbol('docsmith-search');
 export class SearchState {
     open = $state(false);
+    /** Active version id on a versioned site; scopes results. `undefined` otherwise. */
+    version = $state(undefined);
 }
 /** Create the search state and publish it on context. Call in `DocsShell`. */
 export function createSearchState() {

package/dist/search/create-search.d.ts

@@ -5,10 +5,16 @@ export type SearchResult = {
     title: string;
     section?: string;
     snippet: string;
+    /** The page's version id, so a versioned site can scope results. */
+    version?: string;
 };
 export type SearchEngine = {
-    /** Ranked results for `query`, at most `limit` (default 8). */
-    search(query: string, limit?: number): SearchResult[];
+    /**
+     * Ranked results for `query`, at most `limit` (default 8). Pass `version` to
+     * return only that version's pages (over-fetches internally so the limit is
+     * still met after filtering).
+     */
+    search(query: string, limit?: number, version?: string): SearchResult[];
 };
 /** Build a search engine over `docs`. Indexing is synchronous and one-time. */
 export declare function createSearchEngine(docs: SearchDoc[]): SearchEngine;

package/dist/search/create-search.js

@@ -32,23 +32,31 @@ export function createSearchEngine(docs) {
         });
     });
     return {
-        search(query, limit = 8) {
+        search(query, limit = 8, version) {
             const trimmed = query.trim();
             if (!trimmed)
                 return [];
+            // When scoping to a version, over-fetch so the limit still holds after
+            // filtering out the other versions' hits.
+            const fetch = version ? limit * 5 : limit;
             // `merge: true` returns unified, unique ids ranked across fields.
-            const hits = index.search(trimmed, { limit, merge: true });
+            const hits = index.search(trimmed, { limit: fetch, merge: true });
             const results = [];
             for (const { id } of hits) {
                 const doc = docs[id];
                 if (!doc)
                     continue;
+                if (version && doc.version !== version)
+                    continue;
                 results.push({
                     path: doc.path,
                     title: doc.title,
                     section: doc.section,
-                    snippet: buildSnippet(doc.text || doc.description || '', trimmed)
+                    snippet: buildSnippet(doc.text || doc.description || '', trimmed),
+                    version: doc.version
                 });
+                if (results.length >= limit)
+                    break;
             }
             return results;
         }

package/dist/theme.css

@@ -210,6 +210,27 @@
 	}
 }
 
+/*
+ * Reduced motion. When a reader asks the OS to minimise motion, neutralise the
+ * framework's movement in one place: the overlay slide/scale (dialog, sheet,
+ * popover, dropdown) and accordion height animations come from tw-animate-css,
+ * which ships no guard of its own, and those overlays portal to <body> — outside
+ * any shell wrapper — so the rule has to be global to reach them. Durations
+ * collapse to ~0 rather than `none` so the animation/transition *end* events
+ * bits-ui relies on to mount and unmount still fire. Opacity-only fades are the
+ * accessible alternative to motion and are intentionally left to play.
+ */
+@media (prefers-reduced-motion: reduce) {
+	*,
+	*::before,
+	*::after {
+		animation-duration: 0.01ms !important;
+		animation-iteration-count: 1 !important;
+		transition-duration: 0.01ms !important;
+		scroll-behavior: auto !important;
+	}
+}
+
 /*
  * Shiki dual-theme output: light colors are inline, dark colors ship as
  * --shiki-dark/--shiki-dark-bg variables. Flip to them under `.dark`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-docsmith",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "A framework for building beautiful documentation sites with Svelte.",
   "author": {
     "name": "George Daskalakis",
@@ -8,10 +8,15 @@
     "url": "https://github.com/geodask"
   },
   "main": "dist/index.js",
+  "bin": {
+    "svelte-docsmith": "./bin/svelte-docsmith.mjs"
+  },
   "files": [
     "dist",
+    "bin",
     "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
+    "!dist/**/*.spec.*",
+    "!dist/**/_fixtures/**"
   ],
   "sideEffects": false,
   "svelte": "./dist/index.js",