svedocs 0.1.0-beta.10

package/dist/core/checks.js

@@ -0,0 +1,267 @@
+import { access, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { checkLink, createLinkCheckContext } from './links.js';
+import { findDuplicates, normalizePath } from './utils.js';
+export async function checkSvedocsContent(manifest, projectRoot = process.cwd()) {
+    const issues = [];
+    const routeDuplicates = findDuplicates(manifest.pages.map((page) => page.routePath));
+    const canonicalDuplicates = findDuplicates(manifest.pages
+        .map((page) => page.seo.canonical)
+        .filter((canonical) => Boolean(canonical)));
+    if (manifest.config.build.mode === 'spa') {
+        issues.push({
+            code: 'spa-risk',
+            severity: 'warning',
+            message: 'SPA mode prerenders known pages, but server-only routes and provider bindings are unavailable on static hosts.'
+        });
+    }
+    if (manifest.config.seo.rss && !manifest.config.site.url) {
+        issues.push({
+            code: 'missing-site-url',
+            severity: 'warning',
+            message: 'site.url is required to generate absolute sitemap and RSS URLs for production.'
+        });
+    }
+    const sitemapPageCount = manifest.pages.filter((page) => (!page.hidden && !/(?:^|[\s,])(?:noindex|none)(?:$|[\s,])/i.test(page.seo.robots ?? ''))).length;
+    if (manifest.config.seo.sitemap && sitemapPageCount > 50_000) {
+        issues.push({
+            code: 'sitemap-url-limit',
+            severity: 'error',
+            message: `Sitemap contains ${sitemapPageCount} URLs; split it into sitemap index files before exceeding 50,000 URLs.`
+        });
+    }
+    for (const route of routeDuplicates) {
+        issues.push({
+            code: 'duplicate-route',
+            severity: 'error',
+            message: `Duplicate route path detected: ${route}`
+        });
+    }
+    for (const canonical of canonicalDuplicates) {
+        issues.push({
+            code: 'duplicate-canonical',
+            severity: 'error',
+            message: `Duplicate canonical URL detected: ${canonical}`
+        });
+    }
+    if (manifest.config.checks.translations) {
+        issues.push(...createMissingTranslationIssues(manifest));
+    }
+    const linkContext = createLinkCheckContext(manifest);
+    for (const page of manifest.pages) {
+        if (!page.description) {
+            issues.push({
+                code: 'missing-description',
+                severity: 'warning',
+                message: `${page.routePath} is missing a description for SEO and search excerpts.`,
+                pageId: page.id,
+                sourcePath: page.sourcePath
+            });
+        }
+        if (page.plainText && page.search.length === 0) {
+            issues.push({
+                code: 'empty-search',
+                severity: 'warning',
+                message: `${page.routePath} has content but produced no search records.`,
+                pageId: page.id,
+                sourcePath: page.sourcePath
+            });
+        }
+        for (const link of page.links) {
+            const issue = checkLink(page, link, linkContext)
+                ?? await checkAssetLink(projectRoot, page.sourcePath, link, manifest.config.checks.assets)
+                ?? await checkExternalLink(link, manifest.config.checks.externalLinks, page.id, page.sourcePath);
+            if (issue)
+                issues.push(issue);
+        }
+    }
+    return issues;
+}
+function createMissingTranslationIssues(manifest) {
+    const locales = manifest.config.i18n.locales.map((locale) => locale.code);
+    if (locales.length <= 1)
+        return [];
+    const groups = new Map();
+    for (const page of manifest.pages) {
+        if (page.hidden)
+            continue;
+        const key = `${page.kind}:${page.scopePath}`;
+        const group = groups.get(key) ?? [];
+        group.push(page);
+        groups.set(key, group);
+    }
+    const issues = [];
+    for (const pages of groups.values()) {
+        const present = new Set(pages.map((page) => page.locale).filter((locale) => Boolean(locale)));
+        const reference = pages[0];
+        if (!reference)
+            continue;
+        for (const locale of locales) {
+            if (present.has(locale))
+                continue;
+            issues.push({
+                code: 'missing-translation',
+                severity: 'warning',
+                message: `${reference.scopePath} is missing locale ${locale}.`,
+                pageId: reference.id,
+                sourcePath: reference.sourcePath
+            });
+        }
+    }
+    return issues;
+}
+export async function checkPackagePublication(packageRoot) {
+    const issues = [];
+    const packageJsonPath = path.join(packageRoot, 'package.json');
+    const pkg = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+    if (!pkg.private && pkg.license !== 'MIT') {
+        issues.push({
+            code: 'package-license-missing',
+            severity: 'error',
+            message: 'package.json license must be MIT for public svedocs packages.'
+        });
+    }
+    if (!pkg.private && pkg.publishConfig?.access !== 'public') {
+        issues.push({
+            code: 'package-publish-access-missing',
+            severity: 'warning',
+            message: 'package.json publishConfig.access should be public before publishing.'
+        });
+    }
+    if (!pkg.private && pkg.publishConfig?.provenance !== true) {
+        issues.push({
+            code: 'package-provenance-missing',
+            severity: 'warning',
+            message: 'package.json publishConfig.provenance should be true for npm provenance.'
+        });
+    }
+    for (const target of extractBinTargets(pkg.bin)) {
+        if (!await fileExists(path.join(packageRoot, target))) {
+            issues.push({
+                code: 'package-bin-missing',
+                severity: 'error',
+                message: `package.json bin target is missing: ${target}.`
+            });
+        }
+    }
+    for (const [exportName, value] of Object.entries(pkg.exports ?? {})) {
+        const targets = extractExportTargets(value);
+        for (const target of targets) {
+            if (!await fileExists(path.join(packageRoot, target))) {
+                issues.push({
+                    code: 'package-export-missing',
+                    severity: 'error',
+                    message: `${exportName} points to missing package export target ${target}.`
+                });
+            }
+        }
+    }
+    for (const file of pkg.files ?? []) {
+        if (!await fileExists(path.join(packageRoot, file))) {
+            issues.push({
+                code: 'package-file-missing',
+                severity: 'error',
+                message: `package.json files entry is missing: ${file}.`
+            });
+        }
+    }
+    return issues;
+}
+function extractBinTargets(bin) {
+    if (!bin)
+        return [];
+    if (typeof bin === 'string')
+        return [normalizePackageTarget(bin)];
+    return Object.values(bin).map(normalizePackageTarget);
+}
+async function checkAssetLink(projectRoot, sourcePath, link, enabled) {
+    if (!enabled || link.kind !== 'asset')
+        return undefined;
+    const pathname = splitHrefPath(link.href);
+    const candidates = pathname.startsWith('/')
+        ? [
+            path.join(projectRoot, 'static', pathname),
+            path.join(projectRoot, pathname)
+        ]
+        : [
+            path.join(projectRoot, path.posix.dirname(normalizePath(sourcePath)), pathname),
+            path.join(projectRoot, 'static', pathname)
+        ];
+    if (await anyFileExists(candidates))
+        return undefined;
+    return {
+        code: 'broken-asset',
+        severity: 'error',
+        message: `${sourcePath}:${link.line} references missing asset ${link.href}.`,
+        pageId: sourcePath,
+        sourcePath,
+        href: link.href
+    };
+}
+async function checkExternalLink(link, enabled, pageId, sourcePath) {
+    if (!enabled || link.kind !== 'external' || !/^https?:\/\//.test(link.href))
+        return undefined;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 4_000);
+    try {
+        const response = await fetch(link.href, {
+            method: 'HEAD',
+            redirect: 'follow',
+            signal: controller.signal
+        });
+        if (response.ok || response.status === 405)
+            return undefined;
+        return {
+            code: 'external-link-unchecked',
+            severity: 'warning',
+            message: `${sourcePath}:${link.line} external link returned ${response.status}: ${link.href}.`,
+            pageId,
+            sourcePath,
+            href: link.href
+        };
+    }
+    catch {
+        return {
+            code: 'external-link-unchecked',
+            severity: 'warning',
+            message: `${sourcePath}:${link.line} external link could not be verified: ${link.href}.`,
+            pageId,
+            sourcePath,
+            href: link.href
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function extractExportTargets(value) {
+    if (typeof value === 'string')
+        return [normalizePackageTarget(value)];
+    if (!value || typeof value !== 'object')
+        return [];
+    return Object.values(value).flatMap(extractExportTargets);
+}
+function normalizePackageTarget(target) {
+    return target.replace(/^\.\//, '');
+}
+function splitHrefPath(href) {
+    const [withoutHash = ''] = href.trim().split('#');
+    const [pathname = ''] = withoutHash.split('?');
+    return pathname;
+}
+async function anyFileExists(paths) {
+    for (const candidate of paths) {
+        if (await fileExists(candidate))
+            return true;
+    }
+    return false;
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/config.d.ts

@@ -0,0 +1,6 @@
+import type { SvedocsConfig } from '../config.js';
+import type { SvedocsResolvedConfig } from './types.js';
+export { defaultSvedocsMessages } from './i18n.js';
+export declare function resolveSvedocsConfig(config?: SvedocsConfig): SvedocsResolvedConfig;
+export declare function isResolvedConfig(config: SvedocsConfig | SvedocsResolvedConfig | undefined): config is SvedocsResolvedConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/core/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,OAAO,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAEnD,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,aAAkB,GAAG,qBAAqB,CA8ItF;AA2BD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,qBAAqB,GAAG,SAAS,GAAG,MAAM,IAAI,qBAAqB,CAY3H"}

package/dist/core/config.js

@@ -0,0 +1,178 @@
+import { resolveSvedocsI18nConfig } from './i18n.js';
+export { defaultSvedocsMessages } from './i18n.js';
+export function resolveSvedocsConfig(config = {}) {
+    const contentRoot = config.content?.root ?? 'content';
+    const docsRoot = config.content?.docs ?? `${contentRoot}/docs`;
+    const pagesRoot = config.content?.pages ?? `${contentRoot}/pages`;
+    const search = config.search === false ? { enabled: false, provider: 'local', scope: 'current' } : {
+        enabled: config.search?.enabled ?? true,
+        provider: config.search?.provider ?? 'local',
+        scope: config.search?.scope ?? 'current'
+    };
+    const ai = config.ai === false ? {
+        enabled: false,
+        provider: 'mock',
+        scope: 'current',
+        label: 'Ask AI',
+        placeholder: 'Ask about the docs',
+        suggestions: [],
+        maxResults: 5
+    } : {
+        enabled: config.ai?.enabled ?? Boolean(config.ai?.provider),
+        provider: config.ai?.provider ?? 'mock',
+        scope: config.ai?.scope ?? 'current',
+        label: config.ai?.label ?? 'Ask AI',
+        placeholder: config.ai?.placeholder ?? 'Ask about the docs',
+        suggestions: config.ai?.suggestions ?? [],
+        maxResults: config.ai?.maxResults ?? 5,
+        ...(config.ai?.systemPrompt ? { systemPrompt: config.ai.systemPrompt } : {}),
+        ...(config.ai?.welcomeMessage ? { welcomeMessage: config.ai.welcomeMessage } : {})
+    };
+    const rss = resolveRssConfig(config);
+    return {
+        site: {
+            name: config.site?.name ?? 'svedocs',
+            title: config.site?.title ?? config.site?.name ?? 'svedocs',
+            description: config.site?.description ?? 'SvelteKit-native documentation framework.',
+            ...(config.site?.url ? { url: config.site.url } : {})
+        },
+        content: {
+            root: contentRoot,
+            docs: docsRoot,
+            pages: pagesRoot,
+            include: config.content?.include ?? [`${contentRoot}/**/*.{md,mdx,svx}`],
+            exclude: config.content?.exclude ?? [
+                '**/_*.{md,mdx,svx}',
+                '**/node_modules/**',
+                '**/dist/**',
+                '**/build/**',
+                '**/.svelte-kit/**'
+            ]
+        },
+        build: {
+            mode: config.build?.mode ?? 'edge'
+        },
+        theme: {
+            defaultMode: config.theme?.defaultMode ?? 'system',
+            palette: {
+                accent: config.theme?.palette?.accent ?? 'emerald',
+                neutral: config.theme?.palette?.neutral ?? 'zinc'
+            },
+            fonts: {
+                sans: config.theme?.fonts?.sans ?? '"IBM Plex Sans", "Avenir Next", sans-serif',
+                mono: config.theme?.fonts?.mono ?? '"JetBrains Mono", "SFMono-Regular", monospace',
+                display: config.theme?.fonts?.display ?? '"IBM Plex Sans", "Avenir Next", sans-serif'
+            },
+            radius: config.theme?.radius ?? '0px',
+            codeTheme: resolveCodeTheme(config.theme?.codeTheme),
+            code: {
+                lineNumbers: config.theme?.code?.lineNumbers ?? true,
+                wrap: config.theme?.code?.wrap ?? false,
+                copyButton: config.theme?.code?.copyButton ?? true
+            },
+            brand: {
+                label: config.theme?.brand?.label ?? config.site?.name ?? 'svedocs',
+                ...(config.theme?.brand?.labelKey ? { labelKey: config.theme.brand.labelKey } : {}),
+                href: config.theme?.brand?.href ?? '/',
+                ...(config.theme?.brand?.logo ? { logo: config.theme.brand.logo } : {}),
+                mark: config.theme?.brand?.mark ?? 'pixel'
+            },
+            nav: config.theme?.nav ?? [
+                { label: 'Docs', labelKey: 'nav.docs', href: '/docs' }
+            ],
+            social: config.theme?.social ?? [],
+            footer: config.theme?.footer === false
+                ? false
+                : {
+                    text: config.theme?.footer?.text ?? `MIT licensed. Built with ${config.site?.name ?? 'svedocs'}.`,
+                    links: config.theme?.footer?.links ?? []
+                },
+            home: {
+                kicker: config.theme?.home?.kicker ?? 'SvelteKit-native docs',
+                ...(config.theme?.home?.kickerKey ? { kickerKey: config.theme.home.kickerKey } : {}),
+                ...(config.theme?.home?.primaryAction ? { primaryAction: config.theme.home.primaryAction } : {}),
+                ...(config.theme?.home?.secondaryAction ? { secondaryAction: config.theme.home.secondaryAction } : {}),
+                visual: {
+                    type: config.theme?.home?.visual?.type ?? 'pixel',
+                    ...(config.theme?.home?.visual?.src ? { src: config.theme.home.visual.src } : {}),
+                    alt: config.theme?.home?.visual?.alt ?? '',
+                    ...(config.theme?.home?.visual?.altKey ? { altKey: config.theme.home.visual.altKey } : {})
+                }
+            }
+        },
+        search,
+        ai,
+        seo: {
+            sitemap: config.seo?.sitemap ?? true,
+            rss,
+            robots: config.seo?.robots ?? true,
+            ...(config.seo?.defaultAuthor ? { defaultAuthor: config.seo.defaultAuthor } : {}),
+            head: {
+                meta: config.seo?.head?.meta ?? [],
+                links: config.seo?.head?.links ?? [],
+                jsonLd: config.seo?.head?.jsonLd ?? config.seo?.head?.jsonld ?? config.seo?.head?.['json-ld'] ?? []
+            },
+            ogImage: config.seo?.ogImage === false
+                ? false
+                : {
+                    template: config.seo?.ogImage?.template ?? 'default',
+                    format: config.seo?.ogImage?.format ?? 'svg',
+                    outDir: config.seo?.ogImage?.outDir ?? 'static/og',
+                    renderer: config.seo?.ogImage?.renderer ?? 'svg'
+                }
+        },
+        source: {
+            ...(config.source?.editBaseUrl ? { editBaseUrl: config.source.editBaseUrl } : {})
+        },
+        cloudflare: {
+            compatibilityDate: config.cloudflare?.compatibilityDate ?? '2026-05-18',
+            aiSearch: {
+                binding: config.cloudflare?.aiSearch?.binding ?? 'SVEDOCS_AI_SEARCH',
+                instanceName: config.cloudflare?.aiSearch?.instanceName ?? 'svedocs',
+                ...(config.cloudflare?.aiSearch?.namespace ? { namespace: config.cloudflare.aiSearch.namespace } : {}),
+                remote: config.cloudflare?.aiSearch?.remote ?? false
+            }
+        },
+        checks: {
+            assets: config.checks?.assets ?? true,
+            externalLinks: config.checks?.externalLinks ?? false,
+            translations: config.checks?.translations ?? false,
+        },
+        i18n: resolveSvedocsI18nConfig(config)
+    };
+}
+function resolveRssConfig(config) {
+    const input = config.seo?.rss;
+    if (!input)
+        return false;
+    const options = typeof input === 'object' ? input : {};
+    return {
+        title: options.title ?? `${config.site?.name ?? 'svedocs'} RSS`,
+        description: options.description ?? config.site?.description ?? 'SvelteKit-native documentation updates.',
+        limit: options.limit ?? 50,
+        ...(options.locale ? { locale: options.locale } : {})
+    };
+}
+function resolveCodeTheme(input) {
+    if (typeof input === 'string') {
+        return {
+            light: input,
+            dark: input
+        };
+    }
+    return {
+        light: input?.light ?? 'github-light',
+        dark: input?.dark ?? 'github-dark'
+    };
+}
+export function isResolvedConfig(config) {
+    const candidate = config;
+    return Boolean(candidate
+        && Array.isArray(candidate.content?.include)
+        && Array.isArray(candidate.content?.exclude)
+        && typeof candidate.search?.enabled === 'boolean'
+        && typeof candidate.ai?.enabled === 'boolean'
+        && typeof candidate.theme?.fonts?.sans === 'string'
+        && typeof candidate.theme?.brand?.label === 'string'
+        && typeof candidate.cloudflare?.compatibilityDate === 'string');
+}

package/dist/core/content.d.ts

@@ -0,0 +1,7 @@
+import type { SvedocsConfig } from '../config.js';
+import type { SvedocsContentManifest, SvedocsResolvedConfig } from './types.js';
+export declare function loadSvedocsContent(options?: {
+    projectRoot?: string;
+    config?: SvedocsConfig | SvedocsResolvedConfig;
+}): Promise<SvedocsContentManifest>;
+//# sourceMappingURL=content.d.ts.map

package/dist/core/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../src/core/content.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAQlD,OAAO,KAAK,EAAE,sBAAsB,EAAe,qBAAqB,EAA0E,MAAM,YAAY,CAAC;AAYrK,wBAAsB,kBAAkB,CAAC,OAAO,GAAE;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,aAAa,GAAG,qBAAqB,CAAC;CAC3C,GAAG,OAAO,CAAC,sBAAsB,CAAC,CA0CvC"}