svedocs 0.1.0-beta.2

package/dist/virtual.d.ts

@@ -0,0 +1,59 @@
+declare module 'virtual:svedocs/config' {
+  import type { SvedocsResolvedConfig } from 'svedocs/core';
+  const config: SvedocsResolvedConfig;
+  export default config;
+}
+
+declare module 'virtual:svedocs/pages' {
+  import type { SvedocsPage } from 'svedocs/core';
+  const pages: SvedocsPage[];
+  export default pages;
+}
+
+declare module 'virtual:svedocs/page-index' {
+  import type { SvedocsPage } from 'svedocs/core';
+  const pages: SvedocsPage[];
+  export default pages;
+}
+
+declare module 'virtual:svedocs/page-loaders' {
+  import type { SvedocsPage } from 'svedocs/core';
+  const loaders: Record<string, () => Promise<{ default: SvedocsPage | undefined }>>;
+  export default loaders;
+}
+
+declare module 'virtual:svedocs/tree' {
+  import type { SvedocsTreeItem } from 'svedocs/core';
+  const tree: SvedocsTreeItem[];
+  export default tree;
+}
+
+declare module 'virtual:svedocs/search' {
+  import type { SvedocsSearchRecord } from 'svedocs/core';
+  const records: SvedocsSearchRecord[];
+  export default records;
+}
+
+declare module 'virtual:svedocs/search-loader' {
+  import type { SvedocsSearchRecord } from 'svedocs/core';
+  const loadSearch: () => Promise<SvedocsSearchRecord[]>;
+  export default loadSearch;
+}
+
+declare module 'virtual:svedocs/manifest' {
+  import type { SvedocsContentManifest } from 'svedocs/core';
+  const manifest: SvedocsContentManifest;
+  export default manifest;
+}
+
+declare module 'virtual:svedocs/components' {
+  import type { Component } from 'svelte';
+  const components: Record<string, Component>;
+  export default components;
+}
+
+declare module 'virtual:svedocs/layouts' {
+  import type { Component } from 'svelte';
+  const layouts: Record<string, Component>;
+  export default layouts;
+}

package/dist/vite.d.ts

@@ -0,0 +1,10 @@
+import { type Plugin } from 'vite';
+import type { SvedocsConfig } from './config.js';
+export interface SvedocsVitePluginOptions {
+    configFile?: string;
+    config?: SvedocsConfig;
+    components?: Record<string, string>;
+    layouts?: Record<string, string>;
+}
+export declare function svedocs(options?: SvedocsVitePluginOptions): Plugin;
+//# sourceMappingURL=vite.d.ts.map

package/dist/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../src/vite.ts"],"names":[],"mappings":"AAMA,OAAO,EAAsB,KAAK,MAAM,EAAE,MAAM,MAAM,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,MAAM,WAAW,wBAAwB;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAwBD,wBAAgB,OAAO,CAAC,OAAO,GAAE,wBAA6B,GAAG,MAAM,CAiGtE"}

package/dist/vite.js

@@ -0,0 +1,304 @@
+import { access, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import matter from 'gray-matter';
+import { compile as compileMdsvex } from 'mdsvex';
+import { loadConfigFromFile } from 'vite';
+import { loadSvedocsContent } from './core.js';
+import { createSvedocsMdsvexOptions } from './svelte.js';
+const virtualModules = new Set([
+    'virtual:svedocs/config',
+    'virtual:svedocs/pages',
+    'virtual:svedocs/page-index',
+    'virtual:svedocs/page-loaders',
+    'virtual:svedocs/tree',
+    'virtual:svedocs/search',
+    'virtual:svedocs/search-loader',
+    'virtual:svedocs/components',
+    'virtual:svedocs/layouts',
+    'virtual:svedocs/manifest'
+]);
+const componentVirtualPrefix = 'virtual:svedocs/component/';
+const pageVirtualPrefix = 'virtual:svedocs/page/';
+const defaultConfigFiles = [
+    'svedocs.config.ts',
+    'svedocs.config.mts',
+    'svedocs.config.js',
+    'svedocs.config.mjs'
+];
+export function svedocs(options = {}) {
+    let root = process.cwd();
+    let manifest;
+    let resolvedConfig;
+    let resolvedConfigFile;
+    async function refresh() {
+        const loaded = await loadPluginConfig(root, options);
+        resolvedConfig = loaded.config;
+        resolvedConfigFile = loaded.configFile;
+        manifest = await loadSvedocsContent(createContentOptions(root, resolvedConfig));
+    }
+    return {
+        name: 'svedocs',
+        async configResolved(config) {
+            root = config.root;
+            await refresh();
+        },
+        async buildStart() {
+            await refresh();
+            if (resolvedConfigFile)
+                this.addWatchFile(resolvedConfigFile);
+            for (const page of manifest?.pages ?? []) {
+                this.addWatchFile(page.sourcePath);
+            }
+        },
+        config() {
+            return {
+                define: {
+                    __SVEDOCS_CONFIG_FILE__: JSON.stringify(options.configFile ?? process.env.SVEDOCS_CONFIG_FILE ?? 'svedocs.config.ts')
+                }
+            };
+        },
+        resolveId(id) {
+            if (id.startsWith(componentVirtualPrefix))
+                return `\0${id}`;
+            if (id.startsWith(pageVirtualPrefix))
+                return `\0${id}`;
+            if (virtualModules.has(id))
+                return `\0${id}`;
+            return undefined;
+        },
+        async load(id) {
+            if (id.startsWith(`\0${pageVirtualPrefix}`)) {
+                if (!manifest)
+                    await refresh();
+                const data = manifest ?? (await loadSvedocsContent(createContentOptions(root, options.config)));
+                const code = loadPageDataModule(id, data.pages);
+                return {
+                    code,
+                    map: {
+                        version: 3,
+                        sources: [id],
+                        sourcesContent: [code],
+                        names: [],
+                        mappings: ''
+                    }
+                };
+            }
+            if (id.startsWith(`\0${componentVirtualPrefix}`)) {
+                if (!manifest)
+                    await refresh();
+                const data = manifest ?? (await loadSvedocsContent(createContentOptions(root, options.config)));
+                const code = await loadPageComponent(root, id, data.pages, options.components ?? {}, resolvedConfig, data.config);
+                return {
+                    code,
+                    map: {
+                        version: 3,
+                        sources: [id],
+                        sourcesContent: [code],
+                        names: [],
+                        mappings: ''
+                    }
+                };
+            }
+            if (!id.startsWith('\0virtual:svedocs/'))
+                return undefined;
+            if (!manifest)
+                await refresh();
+            const data = manifest ?? (await loadSvedocsContent(createContentOptions(root, options.config)));
+            const key = id.replace('\0virtual:svedocs/', '');
+            if (key === 'config')
+                return `export default ${JSON.stringify(data.config)};`;
+            if (key === 'pages')
+                return `export default ${JSON.stringify(data.pages)};`;
+            if (key === 'page-index')
+                return `export default ${JSON.stringify(createPageIndex(data.pages))};`;
+            if (key === 'page-loaders')
+                return createPageLoadersModule(data.pages);
+            if (key === 'tree')
+                return `export default ${JSON.stringify(data.tree)};`;
+            if (key === 'search')
+                return `export default ${JSON.stringify(data.search)};`;
+            if (key === 'search-loader')
+                return `export default () => import('virtual:svedocs/search').then((module) => module.default);`;
+            if (key === 'components')
+                return createComponentsModule(data.pages);
+            if (key === 'layouts')
+                return createNamedImportModule(options.layouts ?? {});
+            if (key === 'manifest')
+                return `export default ${JSON.stringify(data)};`;
+            return undefined;
+        },
+        async handleHotUpdate(ctx) {
+            if (/\.(md|mdx|svx)$/.test(ctx.file) || ctx.file === resolvedConfigFile || /svedocs\.config\.[cm]?[jt]s$/.test(ctx.file)) {
+                await refresh();
+                const modules = Array.from(virtualModules)
+                    .map((id) => ctx.server.moduleGraph.getModuleById(`\0${id}`))
+                    .filter((module) => module !== undefined);
+                return modules;
+            }
+            return undefined;
+        }
+    };
+}
+function createContentOptions(root, config) {
+    const buildConfig = applyBuildModeOverride(config);
+    return buildConfig ? { projectRoot: root, config: buildConfig } : { projectRoot: root };
+}
+function applyBuildModeOverride(config) {
+    const mode = process.env.SVEDOCS_BUILD_MODE;
+    if (mode !== 'edge' && mode !== 'static' && mode !== 'spa')
+        return config;
+    return {
+        ...(config ?? {}),
+        build: {
+            ...(config?.build ?? {}),
+            mode
+        }
+    };
+}
+async function loadPluginConfig(root, options) {
+    if (options.config)
+        return { config: options.config };
+    const configFile = options.configFile
+        ? path.resolve(root, options.configFile)
+        : process.env.SVEDOCS_CONFIG_FILE
+            ? path.resolve(root, process.env.SVEDOCS_CONFIG_FILE)
+            : await findConfigFile(root);
+    if (!configFile)
+        return {};
+    try {
+        const loaded = await loadConfigFromFile({
+            command: 'serve',
+            mode: process.env.NODE_ENV ?? 'production'
+        }, configFile, root, 'silent');
+        if (loaded?.config && typeof loaded.config === 'object') {
+            return { config: loaded.config, configFile };
+        }
+    }
+    catch (error) {
+        if (!/\.[cm]?js$/.test(configFile)) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load ${path.relative(root, configFile)}: ${message}`);
+        }
+    }
+    const module = await import(pathToFileURL(configFile).href);
+    return { config: (module.default ?? module.config), configFile };
+}
+async function findConfigFile(root) {
+    for (const file of defaultConfigFiles) {
+        const candidate = path.join(root, file);
+        if (await fileExists(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createComponentsModule(pages) {
+    const componentPages = pages.filter((page) => /\.(mdx|svx)$/.test(page.sourcePath));
+    const imports = componentPages
+        .map((page, index) => `import C${index} from '${componentVirtualPrefix}${encodeURIComponent(page.id)}.svelte';`)
+        .join('\n');
+    const entries = componentPages
+        .map((page, index) => `${JSON.stringify(page.id)}: C${index}`)
+        .join(',\n  ');
+    return `${imports}\nexport default {\n  ${entries}\n};`;
+}
+function createPageIndex(pages) {
+    return pages.map((page) => ({
+        ...page,
+        html: '',
+        plainText: '',
+        headings: [],
+        links: [],
+        codeBlocks: [],
+        search: []
+    }));
+}
+function createPageLoadersModule(pages) {
+    const entries = pages
+        .map((page) => `${JSON.stringify(page.id)}: () => import('${pageVirtualPrefix}${encodeURIComponent(page.id)}.js')`)
+        .join(',\n  ');
+    return `export default {\n  ${entries}\n};`;
+}
+function loadPageDataModule(id, pages) {
+    const pageId = decodeURIComponent(id.slice(`\0${pageVirtualPrefix}`.length).replace(/\.js$/, ''));
+    const page = pages.find((item) => item.id === pageId);
+    return `export default ${JSON.stringify(page)};`;
+}
+function createNamedImportModule(entries) {
+    const imports = Object.entries(entries)
+        .map(([, specifier], index) => `import C${index} from ${JSON.stringify(specifier)};`)
+        .join('\n');
+    const exports = Object.keys(entries)
+        .map((name, index) => `${JSON.stringify(name)}: C${index}`)
+        .join(',\n  ');
+    return `${imports}\nexport default {\n  ${exports}\n};`;
+}
+async function loadPageComponent(root, id, pages, components, rawConfig, manifestConfig) {
+    const pageId = decodeURIComponent(id.slice(`\0${componentVirtualPrefix}`.length).replace(/\.svelte$/, ''));
+    const page = pages.find((item) => item.id === pageId);
+    if (!page)
+        return '<script>export const prerender = true;</script>';
+    const raw = await readFile(path.join(root, page.sourcePath), 'utf8');
+    const parsed = matter(raw);
+    const source = injectSvedocsComponentImports(stripFirstTitleHeading(parsed.content), components);
+    try {
+        const compiled = await compileMdsvex(source, {
+            filename: page.sourcePath,
+            ...createSvedocsMdsvexOptions(source, createMdsvexOptionsFromConfig(rawConfig), {
+                codeThemes: {
+                    light: manifestConfig.theme.codeTheme.light,
+                    dark: manifestConfig.theme.codeTheme.dark
+                },
+                ...(rawConfig?.markdown?.shiki?.transformers ? { shikiTransformers: rawConfig.markdown.shiki.transformers } : {})
+            })
+        });
+        const result = await compiled;
+        return stripInlineSourceMap(result?.code ?? '<script>export const prerender = true;</script>');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to compile ${page.sourcePath} as Svelte-compatible MDX: ${message}`);
+    }
+}
+function createMdsvexOptionsFromConfig(config) {
+    const options = {};
+    if (config?.markdown?.remarkPlugins) {
+        options.remarkPlugins = config.markdown.remarkPlugins;
+    }
+    if (config?.markdown?.rehypePlugins) {
+        options.rehypePlugins = config.markdown.rehypePlugins;
+    }
+    return options;
+}
+function stripFirstTitleHeading(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const index = lines.findIndex((line) => /^#\s+/.test(line.trim()));
+    if (index >= 0)
+        lines.splice(index, 1);
+    return lines.join('\n').trim();
+}
+function injectSvedocsComponentImports(source, components) {
+    const imports = Object.entries(components)
+        .map(([name, specifier]) => `import ${name} from ${JSON.stringify(specifier)};`)
+        .join('\n');
+    if (!imports)
+        return source;
+    const instanceScript = /<script(\s(?![^>]*\bcontext=["']module["'])[^>]*)?>/.exec(source);
+    if (!instanceScript || instanceScript.index === undefined) {
+        return `<script>\n${imports}\n</script>\n\n${source}`;
+    }
+    const insertAt = instanceScript.index + instanceScript[0].length;
+    return `${source.slice(0, insertAt)}\n${imports}${source.slice(insertAt)}`;
+}
+function stripInlineSourceMap(code) {
+    return code.replace(/\n?\/\/# sourceMappingURL=data:application\/json;base64,[A-Za-z0-9+/=]+$/m, '');
+}

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "svedocs",
+  "version": "0.1.0-beta.2",
+  "description": "SvelteKit-native documentation framework.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/backrunner/svedocs.git",
+    "directory": "packages/svedocs"
+  },
+  "bugs": {
+    "url": "https://github.com/backrunner/svedocs/issues"
+  },
+  "homepage": "https://github.com/backrunner/svedocs/tree/main/packages/svedocs#readme",
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "sideEffects": [
+    "**/*.css",
+    "**/*.svelte"
+  ],
+  "svelte": "./dist/index.js",
+  "exports": {
+    ".": {
+      "svelte": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js"
+    },
+    "./theme": {
+      "svelte": "./dist/theme/index.js",
+      "types": "./dist/theme/index.d.ts",
+      "import": "./dist/theme/index.js"
+    },
+    "./theme/styles.css": {
+      "default": "./dist/theme/styles.css"
+    },
+    "./cloudflare": {
+      "types": "./dist/cloudflare.d.ts",
+      "import": "./dist/cloudflare.js"
+    },
+    "./search": {
+      "types": "./dist/search.d.ts",
+      "import": "./dist/search.js"
+    },
+    "./ai": {
+      "types": "./dist/ai.d.ts",
+      "import": "./dist/ai.js"
+    },
+    "./og": {
+      "types": "./dist/og.d.ts",
+      "import": "./dist/og.js"
+    },
+    "./svelte": {
+      "types": "./dist/svelte.d.ts",
+      "import": "./dist/svelte.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@resvg/resvg-js": "2.6.2",
+    "fast-glob": "3.3.3",
+    "github-slugger": "2.0.0",
+    "gray-matter": "4.0.3",
+    "hast-util-to-string": "3.0.0",
+    "katex": "0.16.47",
+    "mdsvex": "0.12.7",
+    "minisearch": "7.2.0",
+    "rehype-autolink-headings": "7.1.0",
+    "rehype-katex": "7.0.1",
+    "rehype-raw": "7.0.0",
+    "rehype-slug": "6.0.0",
+    "rehype-stringify": "10.0.1",
+    "remark-gfm": "4.0.1",
+    "remark-math": "6.0.0",
+    "remark-parse": "11.0.0",
+    "remark-rehype": "11.1.2",
+    "satori": "0.26.0",
+    "shiki": "4.0.2",
+    "unified": "11.0.5",
+    "unist-util-visit": "5.1.0",
+    "zod": "4.4.3"
+  },
+  "peerDependencies": {
+    "@sveltejs/kit": ">=2.0.0",
+    "svelte": ">=5.0.0",
+    "vite": ">=8.0.0"
+  },
+  "scripts": {
+    "build": "svelte-package -i src -o dist",
+    "test": "vitest run",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "pack:dry-run": "pnpm pack --dry-run",
+    "dev": "svelte-package -i src -o dist --watch"
+  }
+}