sourcey 3.5.10 → 3.6.1

package/dist/adapters/mkdocs.js

@@ -0,0 +1,367 @@
+import { readFileSync } from "node:fs";
+import { access, readFile, readdir } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { load as parseYaml } from "js-yaml";
+import { assertLocalPath, collectStaticAssets } from "./shared.js";
+export function mkdocs(options) {
+    return {
+        name: "mkdocs",
+        async resolve(ctx) {
+            const configPath = assertLocalPath(ctx, options.config, "MkDocs config");
+            await ctx.assertExists(configPath, `MkDocs config "${options.config}" in tab "${ctx.tabName}"`);
+            const { docsDir, groups } = await resolveMkDocsGroups(configPath);
+            return {
+                kind: "markdown",
+                adapter: "mkdocs",
+                configPath,
+                groups,
+                assets: await collectStaticAssets(docsDir),
+                watchPaths: [configPath, docsDir],
+            };
+        },
+    };
+}
+async function resolveMkDocsGroups(configPath) {
+    const raw = await readFile(configPath, "utf-8");
+    const parsed = parseYaml(sanitizeMkDocsYaml(raw));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`MkDocs config must be a YAML object: ${configPath}`);
+    }
+    const configDir = dirname(configPath);
+    const docsDirName = typeof parsed.docs_dir === "string" && parsed.docs_dir.trim() ? parsed.docs_dir.trim() : "docs";
+    const docsDir = resolve(configDir, docsDirName);
+    const nav = parsed.nav ?? parsed.pages;
+    const groups = Array.isArray(nav)
+        ? mkDocsGroupsFromNav(nav, docsDir)
+        : [{ label: "Pages", pages: await discoverMkDocsPages(docsDir) }];
+    const nonEmptyGroups = groups.filter((group) => group.pages.length > 0);
+    if (nonEmptyGroups.length === 0) {
+        throw new Error(`MkDocs config did not resolve any markdown pages: ${configPath}`);
+    }
+    for (const group of nonEmptyGroups) {
+        for (const page of group.pages) {
+            await access(page.file).catch(() => {
+                throw new Error(`MkDocs nav page "${relative(docsDir, page.file).replace(/\\/g, "/")}" not found`);
+            });
+        }
+    }
+    return { docsDir, groups: nonEmptyGroups };
+}
+function sanitizeMkDocsYaml(raw) {
+    return raw.replace(/!!python\/name:[^\s\]]+/g, "").replace(/!ENV\b/g, "");
+}
+function mkDocsGroupsFromNav(nav, docsDir) {
+    const groups = [];
+    const loosePages = [];
+    const seenPaths = new Set();
+    for (const entry of nav) {
+        if (typeof entry === "string") {
+            const page = resolveMkDocsNavPage({ path: entry }, docsDir, seenPaths);
+            if (page)
+                loosePages.push(page);
+            continue;
+        }
+        if (!isPlainRecord(entry))
+            continue;
+        for (const [label, value] of Object.entries(entry)) {
+            if (typeof value === "string") {
+                const page = resolveMkDocsNavPage({ path: value, label }, docsDir, seenPaths);
+                if (page)
+                    loosePages.push(page);
+                continue;
+            }
+            const pages = collectMkDocsNavPages(value, [])
+                .map((page) => resolveMkDocsNavPage(page, docsDir, seenPaths))
+                .filter((page) => Boolean(page));
+            if (pages.length > 0) {
+                groups.push({ label, pages });
+            }
+        }
+    }
+    return loosePages.length > 0 ? [{ label: "Pages", pages: loosePages }, ...groups] : groups;
+}
+function collectMkDocsNavPages(value, labelParts) {
+    if (typeof value === "string") {
+        return [
+            {
+                path: value,
+                label: isMkDocsIndexPage(value) ? labelParts.join(" / ") || undefined : undefined,
+            },
+        ];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => collectMkDocsNavPages(entry, labelParts));
+    }
+    if (!isPlainRecord(value)) {
+        return [];
+    }
+    return Object.entries(value).flatMap(([label, nested]) => {
+        if (typeof nested === "string") {
+            return [
+                {
+                    path: nested,
+                    label: [...labelParts, label].join(" / "),
+                },
+            ];
+        }
+        return collectMkDocsNavPages(nested, [...labelParts, label]);
+    });
+}
+function resolveMkDocsNavPage(page, docsDir, seenPaths) {
+    const navPath = normalizeMkDocsPagePath(page.path);
+    if (!navPath || seenPaths.has(navPath)) {
+        return undefined;
+    }
+    const file = resolveWithinRoot(docsDir, navPath);
+    if (!file) {
+        throw new Error(`MkDocs nav page "${page.path}" escapes docs_dir: ${docsDir}`);
+    }
+    seenPaths.add(navPath);
+    return {
+        slug: slugFromMkDocsPath(navPath),
+        file,
+        label: page.label,
+        sourceRoot: docsDir,
+        preprocess: [preprocessMkDocsMarkdown],
+    };
+}
+function normalizeMkDocsPagePath(value) {
+    const text = value.trim();
+    if (!text || isExternalNavTarget(text) || !/\.(?:md|mdx)$/i.test(text)) {
+        return undefined;
+    }
+    return text.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function isExternalNavTarget(value) {
+    return /^(?:https?:|mailto:|tel:|#)/i.test(value);
+}
+function slugFromMkDocsPath(value) {
+    return value.replace(/\.(?:md|mdx)$/i, "");
+}
+function isMkDocsIndexPage(value) {
+    return /(^|\/)index\.(?:md|mdx)$/i.test(value.trim());
+}
+async function discoverMkDocsPages(docsDir) {
+    const pages = [];
+    async function walk(dir) {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            if (entry.name.startsWith("."))
+                continue;
+            const absolutePath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(absolutePath);
+                continue;
+            }
+            if (!entry.isFile() || !/\.(?:md|mdx)$/i.test(entry.name))
+                continue;
+            const relPath = relative(docsDir, absolutePath).replace(/\\/g, "/");
+            pages.push({
+                slug: slugFromMkDocsPath(relPath),
+                file: absolutePath,
+                sourceRoot: docsDir,
+                preprocess: [preprocessMkDocsMarkdown],
+            });
+        }
+    }
+    await walk(docsDir);
+    return pages;
+}
+export const preprocessMkDocsMarkdown = (body, context) => {
+    if (!context.sourceRoot)
+        return body;
+    return normalizeMkDocsAdmonitions(normalizeMkDocsTabs(escapeMkDocsCppTemplateAngles(stripMkDocsInlineLanguageMarkers(expandMkDocsSnippets(body, context.filePath, context.sourceRoot)))));
+};
+function expandMkDocsSnippets(body, filePath, sourceRoot) {
+    return body
+        .split("\n")
+        .map((line) => {
+        const match = line.match(/^(\s*)--8<--\s+"([^"]+)"\s*$/);
+        if (!match)
+            return line;
+        const [, indent, includePath] = match;
+        const included = readMkDocsSnippet(includePath, filePath, sourceRoot);
+        if (included === undefined)
+            return line;
+        return included
+            .replace(/\r\n?/g, "\n")
+            .split("\n")
+            .map((includedLine) => (includedLine ? `${indent}${includedLine}` : includedLine))
+            .join("\n");
+    })
+        .join("\n");
+}
+function readMkDocsSnippet(includePath, filePath, sourceRoot) {
+    const candidates = uniquePaths([
+        isAbsolute(includePath) ? includePath : resolve(sourceRoot, includePath),
+        isAbsolute(includePath) ? includePath : resolve(dirname(filePath), includePath),
+    ]);
+    const safeCandidates = candidates.filter((candidate) => isWithinRoot(sourceRoot, candidate));
+    if (safeCandidates.length === 0) {
+        throw new Error(`MkDocs snippet "${includePath}" escapes docs_dir: ${sourceRoot}`);
+    }
+    for (const candidate of safeCandidates) {
+        try {
+            return readFileSync(candidate, "utf-8");
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+    }
+    return undefined;
+}
+function stripMkDocsInlineLanguageMarkers(body) {
+    return body
+        .replace(/`#!([A-Za-z0-9_+.-]+)\s+([^`]+)`/g, "`$2`")
+        .replace(/`#!([A-Za-z0-9_+.-]+)\s*`/g, "");
+}
+function escapeMkDocsCppTemplateAngles(body) {
+    return body.replace(/<([A-Za-z_][A-Za-z0-9_:]*)(\\?)>/g, (match, name, escaped) => {
+        if (!escaped && HTML_TAG_NAMES.has(name.toLowerCase()))
+            return match;
+        return `&lt;${name}&gt;`;
+    });
+}
+const HTML_TAG_NAMES = new Set([
+    "a",
+    "abbr",
+    "article",
+    "aside",
+    "b",
+    "blockquote",
+    "br",
+    "button",
+    "caption",
+    "code",
+    "dd",
+    "del",
+    "details",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "figcaption",
+    "figure",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "i",
+    "iframe",
+    "img",
+    "input",
+    "ins",
+    "kbd",
+    "li",
+    "mark",
+    "ol",
+    "p",
+    "pre",
+    "s",
+    "section",
+    "small",
+    "span",
+    "strong",
+    "sub",
+    "summary",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "th",
+    "thead",
+    "tr",
+    "u",
+    "ul",
+]);
+function normalizeMkDocsTabs(body) {
+    const lines = body.split("\n");
+    const out = [];
+    for (let i = 0; i < lines.length;) {
+        const tab = lines[i].match(/^(\s*)===\s+"([^"]+)"\s*$/);
+        if (!tab) {
+            out.push(lines[i]);
+            i += 1;
+            continue;
+        }
+        const [, indent, title] = tab;
+        out.push(`${indent}**${title}**`);
+        i += 1;
+        while (i < lines.length) {
+            if (lines[i].match(new RegExp(`^${escapeRegExp(indent)}===\\s+"[^"]+"\\s*$`))) {
+                break;
+            }
+            if (/^\s*$/.test(lines[i])) {
+                out.push(lines[i]);
+                i += 1;
+                continue;
+            }
+            if (!lines[i].startsWith(`${indent}    `)) {
+                break;
+            }
+            out.push(indent + lines[i].slice(indent.length + 4));
+            i += 1;
+        }
+    }
+    return out.join("\n");
+}
+function normalizeMkDocsAdmonitions(body) {
+    const lines = body.split("\n");
+    const out = [];
+    for (let i = 0; i < lines.length;) {
+        const admonition = lines[i].match(/^(\s*)(!!!|\?\?\?)\s+([A-Za-z0-9_-]+)(?:\s+"([^"]+)")?\s*$/);
+        if (!admonition) {
+            out.push(lines[i]);
+            i += 1;
+            continue;
+        }
+        const [, indent, , type, title] = admonition;
+        out.push(`${indent}> **${formatMkDocsAdmonitionTitle(type, title)}**`);
+        i += 1;
+        const content = [];
+        while (i < lines.length) {
+            if (/^\s*$/.test(lines[i])) {
+                content.push("");
+                i += 1;
+                continue;
+            }
+            if (!lines[i].startsWith(`${indent}    `)) {
+                break;
+            }
+            content.push(lines[i].slice(indent.length + 4));
+            i += 1;
+        }
+        for (const line of normalizeMkDocsAdmonitions(content.join("\n")).split("\n")) {
+            out.push(line ? `${indent}> ${line}` : `${indent}>`);
+        }
+    }
+    return out.join("\n");
+}
+function formatMkDocsAdmonitionTitle(type, title) {
+    if (title?.trim())
+        return title.trim();
+    return type.slice(0, 1).toUpperCase() + type.slice(1).replace(/-/g, " ");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isPlainRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveWithinRoot(root, path) {
+    const candidate = resolve(root, path);
+    return isWithinRoot(root, candidate) ? candidate : undefined;
+}
+function isWithinRoot(root, candidate) {
+    const rootAbs = resolve(root);
+    const candidateAbs = resolve(candidate);
+    const rel = relative(rootAbs, candidateAbs);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function uniquePaths(paths) {
+    return [...new Set(paths)];
+}

package/dist/adapters/shared.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedGroup, ResolvedPage } from "../config.js";
+import type { PageMarkdownOptions, ResolvedSourceAsset, SourceAdapterContext } from "./types.js";
+export declare const STATIC_ASSET_EXTENSIONS: Set<string>;
+export declare function resolveMarkdownGroups(groups: {
+    group: string;
+    pages: string[];
+}[], tabName: string, configDir: string, markdown?: PageMarkdownOptions): Promise<ResolvedGroup[]>;
+export declare function collectStaticAssets(sourceRoot: string): Promise<ResolvedSourceAsset[]>;
+export declare function toWatchPaths(paths: Array<string | undefined>): string[];
+export declare function assertLocalPath(ctx: SourceAdapterContext, source: string, label: string): string;
+export declare function outputSlugForPage(page: ResolvedPage): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/adapters/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/adapters/shared.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEjG,eAAO,MAAM,uBAAuB,aAsBlC,CAAC;AAEH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,EAAE,EAC5C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,mBAAmB,GAC7B,OAAO,CAAC,aAAa,EAAE,CAAC,CA0B1B;AAED,wBAAsB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAuB5F;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,EAAE,CAEvE;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKhG;AA0DD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAE5D"}

package/dist/adapters/shared.js

@@ -0,0 +1,134 @@
+import { access, readdir } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { slugFromPath } from "../core/markdown-loader.js";
+export const STATIC_ASSET_EXTENSIONS = new Set([
+    ".apng",
+    ".avif",
+    ".bmp",
+    ".css",
+    ".gif",
+    ".ico",
+    ".jpeg",
+    ".jpg",
+    ".js",
+    ".json",
+    ".mjs",
+    ".mp4",
+    ".pdf",
+    ".png",
+    ".svg",
+    ".txt",
+    ".webm",
+    ".webp",
+    ".woff",
+    ".woff2",
+    ".zip",
+]);
+export async function resolveMarkdownGroups(groups, tabName, configDir, markdown) {
+    const resolved = [];
+    for (const group of groups) {
+        if (!group.group)
+            throw new Error(`Group missing "group" name in tab "${tabName}"`);
+        if (!group.pages?.length)
+            throw new Error(`Group "${group.group}" in tab "${tabName}" has no pages`);
+        const pages = [];
+        for (const pageSlug of group.pages) {
+            if (pageSlug.includes("*")) {
+                const expanded = await expandGlob(pageSlug, configDir);
+                for (const file of expanded) {
+                    const rel = relative(configDir, file).replace(/\.[^.]+$/, "");
+                    pages.push({ slug: rel, file, ...markdown });
+                }
+            }
+            else {
+                const absPath = await resolvePagePath(pageSlug, configDir);
+                pages.push({ slug: pageSlug, file: absPath, ...markdown });
+            }
+        }
+        resolved.push({ label: group.group, pages });
+    }
+    return resolved;
+}
+export async function collectStaticAssets(sourceRoot) {
+    const assets = [];
+    async function walk(dir) {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            if (entry.name.startsWith("."))
+                continue;
+            const absolutePath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(absolutePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (!STATIC_ASSET_EXTENSIONS.has(extname(entry.name).toLowerCase()))
+                continue;
+            assets.push({
+                file: absolutePath,
+                outputPath: relative(sourceRoot, absolutePath).replace(/\\/g, "/"),
+            });
+        }
+    }
+    await walk(sourceRoot);
+    return assets;
+}
+export function toWatchPaths(paths) {
+    return paths.filter((path) => Boolean(path));
+}
+export function assertLocalPath(ctx, source, label) {
+    if (ctx.isUrl(source)) {
+        throw new Error(`${label} "${source}" in tab "${ctx.tabName}" must be a local file path`);
+    }
+    return ctx.resolvePath(source);
+}
+/**
+ * Expand a simple glob pattern like "doc/api-*" into matching .md/.mdx files.
+ * Supports trailing * only (e.g. "doc/api-*", "guides/*").
+ */
+async function expandGlob(pattern, configDir) {
+    const absPattern = resolve(configDir, pattern);
+    const dir = dirname(absPattern);
+    const prefix = basename(absPattern).replace("*", "");
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new Error(`Glob directory not found: ${dir}`);
+        }
+        throw err;
+    }
+    const matches = entries
+        .filter((entry) => entry.isFile() && entry.name.startsWith(prefix) && /\.(md|mdx)$/i.test(entry.name))
+        .map((entry) => join(dir, entry.name))
+        .sort();
+    if (matches.length === 0) {
+        throw new Error(`Glob "${pattern}" matched no files in ${dir}`);
+    }
+    return matches;
+}
+async function resolvePagePath(pageSlug, configDir) {
+    const direct = resolve(configDir, pageSlug);
+    const candidates = extname(direct)
+        ? [direct]
+        : [`${direct}.md`, `${direct}.mdx`, join(direct, "index.md"), join(direct, "index.mdx")];
+    for (const candidate of candidates) {
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+            // keep trying candidates
+        }
+    }
+    throw new Error(`Page "${pageSlug}" not found. Tried:\n` +
+        candidates.map((candidate) => `  - ${candidate}`).join("\n") +
+        `\n\nPages are referenced relative to sourcey.config.ts. ` +
+        `Use slugs like "getting-started" for getting-started.md or "run/index" for run/index.md.`);
+}
+export function outputSlugForPage(page) {
+    return slugFromPath(page.slug);
+}

package/dist/adapters/types.d.ts

@@ -0,0 +1,74 @@
+import type { MarkdownPreprocessor } from "../core/markdown-loader.js";
+import type { DoxygenConfig, GodocConfig, GroupConfig, ResolvedDoxygenConfig, ResolvedGodocConfig, ResolvedGroup, ResolvedRustdocConfig, RustdocConfig } from "../config.js";
+export interface SourceAdapterContext {
+    configDir: string;
+    tabName: string;
+    tabSlug: string;
+    resolvePath(path: string): string;
+    assertExists(path: string, label: string): Promise<void>;
+    isUrl(source: string): boolean;
+}
+export interface SourceAdapter<TResolved extends ResolvedTabSource = ResolvedTabSource> {
+    name: string;
+    resolve(ctx: SourceAdapterContext): Promise<TResolved>;
+}
+export interface ResolvedSourceAsset {
+    /** Absolute source file path. */
+    file: string;
+    /** Output path relative to the adapter tab root. */
+    outputPath: string;
+}
+export interface ResolvedOpenApiSource {
+    kind: "openapi";
+    spec: string;
+    watchPaths?: string[];
+}
+export interface ResolvedMcpSource {
+    kind: "mcp";
+    spec: string;
+    watchPaths?: string[];
+}
+export interface ResolvedMarkdownSource {
+    kind: "markdown";
+    adapter?: string;
+    configPath?: string;
+    groups: ResolvedGroup[];
+    assets?: ResolvedSourceAsset[];
+    watchPaths?: string[];
+}
+export interface ResolvedDoxygenSource {
+    kind: "doxygen";
+    config: ResolvedDoxygenConfig;
+    watchPaths?: string[];
+}
+export interface ResolvedGodocSource {
+    kind: "godoc";
+    config: ResolvedGodocConfig;
+    watchPaths?: string[];
+}
+export interface ResolvedRustdocSource {
+    kind: "rustdoc";
+    config: ResolvedRustdocConfig;
+    watchPaths?: string[];
+}
+export type ResolvedTabSource = ResolvedOpenApiSource | ResolvedMcpSource | ResolvedMarkdownSource | ResolvedDoxygenSource | ResolvedGodocSource | ResolvedRustdocSource;
+export interface MarkdownSourceOptions {
+    groups: GroupConfig[];
+}
+export interface OpenApiSourceOptions {
+    spec: string;
+}
+export interface McpSourceOptions {
+    spec: string;
+}
+export interface MkDocsSourceOptions {
+    config: string;
+}
+export type DoxygenSourceOptions = DoxygenConfig;
+export type GodocSourceOptions = GodocConfig | string;
+export type RustdocSourceOptions = RustdocConfig | string;
+export interface PageMarkdownOptions {
+    sourceRoot?: string;
+    preprocess?: MarkdownPreprocessor[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/adapters/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/adapters/types.ts"],"names":[],"mappings":"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"}

package/dist/adapters/types.js

@@ -0,0 +1 @@
+export {};