@sigx/ssg 0.1.6

package/dist/plugin-DxH1VUGC.js

@@ -0,0 +1,547 @@
+import { D as parseFrontmatter, E as extractTitleFromContent, O as defineSSGConfig, T as scanPages, _ as generateNavigationModule, a as VIRTUAL_SERVER_ID, b as generateLazyRoutesModule, c as generateHtmlTemplate, d as RESOLVED_VIRTUAL_LAYOUTS_ID, f as VIRTUAL_LAYOUTS_ID, g as VIRTUAL_NAVIGATION_ID, h as RESOLVED_VIRTUAL_NAVIGATION_ID, i as VIRTUAL_CLIENT_ID, k as loadConfig, m as discoverLayouts, n as RESOLVED_VIRTUAL_SERVER_ID, o as detectCustomEntries, p as generateLayoutsModule, r as SSG_CLIENT_ENTRY_PATH, s as generateClientEntry, t as RESOLVED_VIRTUAL_CLIENT_ID, u as generateServerEntry, v as RESOLVED_VIRTUAL_ROUTES_ID, x as generateRoutesModule, y as VIRTUAL_ROUTES_ID } from "./virtual-entries-Bz97SKQ0.js";
+import path from "node:path";
+import fs from "node:fs";
+import { createHighlighter } from "shiki";
+import { visit } from "unist-util-visit";
+import { toString } from "hast-util-to-string";
+var highlighterPromise = null;
+var DEFAULT_CONFIG = {
+	light: "github-light",
+	dark: "github-dark",
+	langs: [
+		"javascript",
+		"typescript",
+		"jsx",
+		"tsx",
+		"json",
+		"css",
+		"html",
+		"markdown",
+		"bash",
+		"shell"
+	]
+};
+async function getHighlighter(config) {
+	if (!highlighterPromise) {
+		const mergedConfig = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+		highlighterPromise = createHighlighter({
+			themes: [mergedConfig.light, mergedConfig.dark],
+			langs: mergedConfig.langs
+		});
+	}
+	return highlighterPromise;
+}
+async function highlightCode(code, lang, config, meta) {
+	const highlighter = await getHighlighter(config);
+	const mergedConfig = {
+		...DEFAULT_CONFIG,
+		...config
+	};
+	const effectiveLang = highlighter.getLoadedLanguages().includes(lang) ? lang : "text";
+	const codeHtml = highlighter.codeToHtml(code, {
+		lang: effectiveLang,
+		themes: {
+			light: mergedConfig.light,
+			dark: mergedConfig.dark
+		}
+	});
+	const filename = meta?.filename ?? "";
+	const isLive = meta?.live ?? false;
+	const tabs = meta?.tabs;
+	const hasTabs = tabs && tabs.length > 0;
+	const filenameHtml = filename ? `<span class="code-window-filename">${escapeHtml(filename)}</span>` : `<span class="code-window-lang">${getLanguageLabel(effectiveLang)}</span>`;
+	if (hasTabs) {
+		const base64Code = encodeBase64(code);
+		const firstTab = tabs[0];
+		const tabButtonsHtml = tabs.map((tab, i) => {
+			const label = tab.charAt(0).toUpperCase() + tab.slice(1);
+			return `<button class="code-window-tab${i === 0 ? " code-window-tab-active" : ""}">${label}</button>`;
+		}).join("\n                ");
+		return `<div 
+    class="live-preview-island" 
+    data-island="LivePreview" 
+    data-island-strategy="visible"
+    data-island-props="${escapeHtml(JSON.stringify({
+			code: base64Code,
+			highlightedCode: codeHtml,
+			language: effectiveLang,
+			filename,
+			tabs,
+			live: isLive
+		}))}"
+>
+    <div class="code-window code-window-live code-window-preview">
+        <div class="code-window-header">
+            <div class="code-window-header-left">
+                <div class="code-window-dots">
+                    <span class="code-window-dot dot-red"></span>
+                    <span class="code-window-dot dot-yellow"></span>
+                    <span class="code-window-dot dot-green"></span>
+                </div>
+                ${filenameHtml}
+            </div>
+            <div class="code-window-tabs">
+                ${tabButtonsHtml}
+            </div>
+            <button class="code-window-try-live" disabled>⚡ Try Live</button>
+        </div>
+        <div class="code-window-preview-pane"${firstTab !== "preview" ? " style=\"display:none;\"" : ""}>
+            <div class="code-window-preview-loading">
+                <span class="code-window-spinner"></span>
+                Loading preview...
+            </div>
+        </div>
+        <div class="code-window-console-pane"${firstTab !== "console" ? " style=\"display:none;\"" : ""}>
+            <div class="code-window-console-empty">No console output</div>
+        </div>
+        <div class="code-window-content"${firstTab !== "code" ? " style=\"display:none;\"" : ""}>
+            ${codeHtml}
+        </div>
+    </div>
+</div>`;
+	}
+	const tryLiveButton = isLive ? `<button class="code-window-try-live" data-live-code="${escapeHtml(encodeBase64(code))}" data-lang="${effectiveLang}" data-filename="${escapeHtml(filename)}" title="Open in Live Playground">⚡ Try Live</button>` : "";
+	return `<div class="code-window${isLive ? " code-window-live" : ""}">
+        <div class="code-window-header">
+            <div class="code-window-header-left">
+                <div class="code-window-dots">
+                    <span class="code-window-dot dot-red"></span>
+                    <span class="code-window-dot dot-yellow"></span>
+                    <span class="code-window-dot dot-green"></span>
+                </div>
+                ${filenameHtml}
+            </div>
+            ${tryLiveButton}
+        </div>
+        <div class="code-window-content">
+            ${codeHtml}
+        </div>
+    </div>`;
+}
+function encodeBase64(str) {
+	if (typeof Buffer !== "undefined") return Buffer.from(str, "utf-8").toString("base64");
+	return btoa(unescape(encodeURIComponent(str)));
+}
+function getLanguageLabel(lang) {
+	return {
+		"tsx": "TSX",
+		"jsx": "JSX",
+		"ts": "TypeScript",
+		"typescript": "TypeScript",
+		"js": "JavaScript",
+		"javascript": "JavaScript",
+		"css": "CSS",
+		"html": "HTML",
+		"json": "JSON",
+		"bash": "Terminal",
+		"shell": "Terminal",
+		"sh": "Terminal",
+		"md": "Markdown",
+		"markdown": "Markdown",
+		"python": "Python",
+		"py": "Python",
+		"rust": "Rust",
+		"go": "Go",
+		"text": ""
+	}[lang.toLowerCase()] ?? lang.toUpperCase();
+}
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function rehypeShiki(config) {
+	return async (tree) => {
+		const { visit } = await import("unist-util-visit");
+		const { fromHtml } = await import("hast-util-from-html");
+		const nodesToProcess = [];
+		visit(tree, "element", (node, index, parent) => {
+			if (node.tagName === "pre" && node.children?.[0]?.tagName === "code") nodesToProcess.push({
+				node,
+				parent,
+				index: index ?? 0
+			});
+		});
+		await Promise.all(nodesToProcess.map(async ({ node, parent, index }) => {
+			const codeNode = node.children[0];
+			const lang = (codeNode.properties?.className?.[0] || "").replace(/^language-/, "") || "text";
+			const metaString = codeNode.data?.meta || codeNode.properties?.metastring || "";
+			const filename = extractMeta(metaString, "filename") || extractMeta(metaString, "title") || "";
+			const isLive = /\blive\b/i.test(metaString);
+			const tabKeywords = [
+				"preview",
+				"code",
+				"console"
+			];
+			const tabs = [];
+			const tabPositions = [];
+			for (const keyword of tabKeywords) {
+				const regex = new RegExp(`\\b${keyword}\\b`, "i");
+				const match = metaString.match(regex);
+				if (match && match.index !== void 0) tabPositions.push({
+					tab: keyword,
+					index: match.index
+				});
+			}
+			tabPositions.sort((a, b) => a.index - b.index);
+			for (const { tab } of tabPositions) tabs.push(tab);
+			const fragment = fromHtml(await highlightCode(getTextContent(codeNode).trim(), lang, config, {
+				filename,
+				live: isLive,
+				tabs: tabs.length > 0 ? tabs : void 0
+			}), { fragment: true });
+			if (parent && typeof index === "number" && fragment.children.length > 0) parent.children[index] = fragment.children[0];
+		}));
+	};
+}
+function extractMeta(metaString, key) {
+	if (!metaString) return null;
+	const regex = new RegExp(`${key}=["']?([^"'\\s]+)["']?`, "i");
+	const match = metaString.match(regex);
+	return match ? match[1] : null;
+}
+function getTextContent(node) {
+	if (node.type === "text") return node.value;
+	if (node.children) return node.children.map(getTextContent).join("");
+	return "";
+}
+function rehypeExtractHeadings(options = {}) {
+	const { minLevel = 2, maxLevel = 3 } = options;
+	return (tree, file) => {
+		const headings = [];
+		visit(tree, "element", (node) => {
+			const match = /^h([1-6])$/.exec(node.tagName);
+			if (!match) return;
+			const level = parseInt(match[1], 10);
+			if (level < minLevel || level > maxLevel) return;
+			const id = node.properties?.id;
+			if (!id) return;
+			const text = toString(node).trim();
+			if (!text) return;
+			headings.push({
+				id,
+				text,
+				level
+			});
+		});
+		file.data = file.data || {};
+		file.data.headings = headings;
+	};
+}
+function mdxPlugin(options = {}) {
+	const { markdown = {} } = options;
+	let mdxRollup;
+	let viteConfig;
+	return {
+		name: "sigx-ssg-mdx",
+		enforce: "pre",
+		async configResolved(config) {
+			viteConfig = config;
+			const mdxModule = await import("@mdx-js/rollup");
+			const remarkFrontmatter = (await import("remark-frontmatter")).default;
+			const remarkMdxFrontmatter = (await import("remark-mdx-frontmatter")).default;
+			const remarkGfm = (await import("remark-gfm")).default;
+			const rehypeSlug = (await import("rehype-slug")).default;
+			const rehypeAutolinkHeadings = (await import("rehype-autolink-headings")).default;
+			const tocConfig = options.ssgConfig?.toc || {
+				minLevel: 2,
+				maxLevel: 3
+			};
+			const rehypePlugins = [];
+			rehypePlugins.push(rehypeSlug);
+			rehypePlugins.push([rehypeAutolinkHeadings, {
+				behavior: "append",
+				properties: {
+					class: "heading-anchor",
+					ariaHidden: true,
+					tabIndex: -1
+				},
+				content: {
+					type: "element",
+					tagName: "span",
+					properties: { class: "heading-anchor-icon" },
+					children: [{
+						type: "text",
+						value: "#"
+					}]
+				}
+			}]);
+			rehypePlugins.push([rehypeExtractHeadings, tocConfig]);
+			if (markdown.shiki !== false) {
+				const shikiConfig = typeof markdown.shiki === "object" ? markdown.shiki : void 0;
+				rehypePlugins.push([rehypeShiki, shikiConfig]);
+			}
+			if (markdown.rehypePlugins) rehypePlugins.push(...markdown.rehypePlugins);
+			const remarkPlugins = [
+				remarkFrontmatter,
+				[remarkMdxFrontmatter, { name: "frontmatter" }],
+				remarkGfm
+			];
+			if (markdown.remarkPlugins) remarkPlugins.push(...markdown.remarkPlugins);
+			mdxRollup = mdxModule.default({
+				jsx: false,
+				jsxImportSource: "sigx",
+				remarkPlugins,
+				rehypePlugins,
+				providerImportSource: void 0
+			});
+		},
+		async transform(code, id) {
+			if (!/\.mdx?$/.test(id)) return null;
+			const { data: frontmatter, content } = parseFrontmatter(code);
+			if (!frontmatter.title) {
+				const extractedTitle = extractTitleFromContent(content);
+				if (extractedTitle) frontmatter.title = extractedTitle;
+			}
+			if (!mdxRollup?.transform) throw new Error("MDX plugin not initialized");
+			const result = await mdxRollup.transform(code, id);
+			if (!result) return null;
+			const headings = await extractHeadingsFromContent(content, options);
+			const moduleId = id.replace(/\\/g, "/");
+			return {
+				code: wrapMDXComponent(result.code, frontmatter, headings, moduleId, viteConfig.command === "serve"),
+				map: result.map
+			};
+		}
+	};
+}
+function wrapMDXComponent(code, frontmatter, headings, moduleId, isDev) {
+	if (isDev) {
+		const fileName = moduleId.split("/").pop()?.replace(/\.mdx?$/, "") || "MDXPage";
+		const componentName = fileName.charAt(0).toUpperCase() + fileName.slice(1).replace(/[^a-zA-Z0-9]/g, "") + "Page";
+		return `
+import { registerHMRModule } from '@sigx/vite/hmr';
+import { component as __component } from 'sigx';
+registerHMRModule('${moduleId}');
+
+${code.replace(/export\s+default\s+function\s+MDXContent/g, "function _MDXContent").replace(/export\s+{\s*MDXContent\s+as\s+default\s*}/g, "")}
+
+// Export layout from frontmatter for SSG routing
+export const layout = ${frontmatter.layout ? JSON.stringify(frontmatter.layout) : "undefined"};
+
+// Export headings for table of contents
+export const headings = ${JSON.stringify(headings)};
+
+// Wrap MDXContent in a sigx component for HMR support
+const MDXPage = __component(() => {
+    return () => _MDXContent({});
+}, { name: '${componentName}' });
+
+export default MDXPage;
+
+if (import.meta.hot) {
+    // Accept HMR updates with a callback to trigger re-render after module is updated
+    import.meta.hot.accept((newModule) => {
+        if (newModule) {
+            // Notify LayoutRouter to clear its cache and re-render with new module
+            window.dispatchEvent(new CustomEvent('sigx:mdx-hmr', { 
+                detail: { moduleId: '${moduleId}', newModule } 
+            }));
+        }
+    });
+}
+`;
+	}
+	return `
+${code}
+
+// Export layout from frontmatter for SSG routing
+export const layout = ${frontmatter.layout ? JSON.stringify(frontmatter.layout) : "undefined"};
+
+// Export headings for table of contents
+export const headings = ${JSON.stringify(headings)};
+`;
+}
+async function extractHeadingsFromContent(content, options) {
+	const { unified } = await import("unified");
+	const remarkParse = (await import("remark-parse")).default;
+	const remarkRehype = (await import("remark-rehype")).default;
+	const rehypeSlug = (await import("rehype-slug")).default;
+	const rehypeStringify = (await import("rehype-stringify")).default;
+	const tocConfig = options.ssgConfig?.toc || {
+		minLevel: 2,
+		maxLevel: 3
+	};
+	return (await unified().use(remarkParse).use(remarkRehype).use(rehypeSlug).use(rehypeExtractHeadings, tocConfig).use(rehypeStringify).process(content)).data.headings || [];
+}
+var VIRTUAL_CONFIG_ID = "virtual:ssg-config";
+var RESOLVED_VIRTUAL_CONFIG_ID = "\0" + VIRTUAL_CONFIG_ID;
+function ssgPlugin(options = {}) {
+	let config;
+	let ssgConfig;
+	let root;
+	let entryDetection;
+	let routesCache = null;
+	let layoutsCache = null;
+	let navigationCache = null;
+	const frontmatterHashCache = /* @__PURE__ */ new Map();
+	const mainPlugin = {
+		name: "sigx-ssg",
+		enforce: "pre",
+		async configResolved(resolvedConfig) {
+			config = resolvedConfig;
+			root = resolvedConfig.root;
+			ssgConfig = defineSSGConfig({
+				...await loadConfig(options.configPath),
+				...options
+			});
+			entryDetection = detectCustomEntries(root, ssgConfig);
+			if (entryDetection.useVirtualClient || entryDetection.useVirtualServer) {
+				console.log("📦 @sigx/ssg: Using zero-config mode");
+				if (entryDetection.useVirtualClient) console.log("   → Virtual client entry");
+				if (entryDetection.useVirtualServer) console.log("   → Virtual server entry");
+				if (entryDetection.globalCssPath) console.log(`   → Auto-importing ${entryDetection.globalCssPath}`);
+			}
+		},
+		configureServer(devServer) {
+			const pagesDir = path.resolve(root, ssgConfig.pages || "src/pages");
+			const layoutsDir = path.resolve(root, ssgConfig.layouts || "src/layouts");
+			path.resolve(root, ssgConfig.content || "src/content");
+			devServer.watcher.on("add", (file) => {
+				if (file.startsWith(pagesDir)) {
+					routesCache = null;
+					navigationCache = null;
+					invalidateModule(RESOLVED_VIRTUAL_ROUTES_ID);
+					invalidateModule(RESOLVED_VIRTUAL_NAVIGATION_ID);
+				} else if (file.startsWith(layoutsDir)) {
+					layoutsCache = null;
+					invalidateModule(RESOLVED_VIRTUAL_LAYOUTS_ID);
+				}
+			});
+			devServer.watcher.on("unlink", (file) => {
+				if (file.startsWith(pagesDir)) {
+					routesCache = null;
+					navigationCache = null;
+					frontmatterHashCache.delete(file);
+					invalidateModule(RESOLVED_VIRTUAL_ROUTES_ID);
+					invalidateModule(RESOLVED_VIRTUAL_NAVIGATION_ID);
+				} else if (file.startsWith(layoutsDir)) {
+					layoutsCache = null;
+					invalidateModule(RESOLVED_VIRTUAL_LAYOUTS_ID);
+				}
+			});
+			devServer.watcher.on("change", async (file) => {
+				if (!file.startsWith(pagesDir)) return;
+				if (!/\.mdx?$/.test(file)) return;
+				try {
+					const { data: newFrontmatter } = parseFrontmatter(await fs.promises.readFile(file, "utf-8"));
+					const newHash = JSON.stringify(newFrontmatter);
+					const oldHash = frontmatterHashCache.get(file);
+					frontmatterHashCache.set(file, newHash);
+					if (oldHash !== void 0 && oldHash !== newHash) {
+						navigationCache = null;
+						routesCache = null;
+						const navMod = devServer.moduleGraph.getModuleById(RESOLVED_VIRTUAL_NAVIGATION_ID);
+						if (navMod) devServer.moduleGraph.invalidateModule(navMod);
+						const routesMod = devServer.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ROUTES_ID);
+						if (routesMod) devServer.moduleGraph.invalidateModule(routesMod);
+						devServer.ws.send({ type: "full-reload" });
+					}
+				} catch (err) {}
+			});
+			function invalidateModule(id) {
+				const mod = devServer.moduleGraph.getModuleById(id);
+				if (mod) {
+					devServer.moduleGraph.invalidateModule(mod);
+					devServer.ws.send({ type: "full-reload" });
+				}
+			}
+			if (entryDetection.useVirtualHtml) devServer.middlewares.use((req, res, next) => {
+				if (req.url?.startsWith("/@") || req.url?.startsWith("/__") || req.url?.includes("virtual:") || req.url?.includes("node_modules") || req.url?.startsWith("/@vite") || req.url?.startsWith("/@fs")) return next();
+				if (req.url && (req.url === "/" || !req.url.includes("."))) {
+					const html = generateHtmlTemplate(ssgConfig);
+					devServer.transformIndexHtml(req.url, html).then((transformedHtml) => {
+						res.setHeader("Content-Type", "text/html");
+						res.end(transformedHtml);
+					}).catch(next);
+					return;
+				}
+				next();
+			});
+		},
+		resolveId(id) {
+			if (id === "virtual:ssg-routes") return RESOLVED_VIRTUAL_ROUTES_ID;
+			if (id === "virtual:generated-layouts") return RESOLVED_VIRTUAL_LAYOUTS_ID;
+			if (id === VIRTUAL_CONFIG_ID) return RESOLVED_VIRTUAL_CONFIG_ID;
+			if (id === "virtual:ssg-navigation") return RESOLVED_VIRTUAL_NAVIGATION_ID;
+			if (id === "virtual:ssg-client" || id === "/@ssg/client.tsx") return RESOLVED_VIRTUAL_CLIENT_ID;
+			if (id === "virtual:ssg-server") return RESOLVED_VIRTUAL_SERVER_ID;
+			return null;
+		},
+		async load(id) {
+			if (id === "\0virtual:ssg-routes") {
+				if (!routesCache) {
+					const routes = await scanPages(ssgConfig, root);
+					routesCache = {
+						routes,
+						code: config.command === "serve" ? generateLazyRoutesModule(routes, ssgConfig) : generateRoutesModule(routes, ssgConfig)
+					};
+				}
+				return routesCache.code;
+			}
+			if (id === "\0virtual:generated-layouts") {
+				if (!layoutsCache) {
+					const layouts = await discoverLayouts(ssgConfig, root);
+					layoutsCache = {
+						layouts,
+						code: generateLayoutsModule(layouts, ssgConfig)
+					};
+				}
+				return layoutsCache.code;
+			}
+			if (id === "\0virtual:ssg-navigation") {
+				if (!navigationCache) {
+					if (!routesCache) {
+						const routes = await scanPages(ssgConfig, root);
+						routesCache = {
+							routes,
+							code: config.command === "serve" ? generateLazyRoutesModule(routes, ssgConfig) : generateRoutesModule(routes, ssgConfig)
+						};
+					}
+					const isDev = config.command === "serve";
+					navigationCache = { code: generateNavigationModule(routesCache.routes, ssgConfig, isDev) };
+				}
+				return navigationCache.code;
+			}
+			if (id === RESOLVED_VIRTUAL_CONFIG_ID) return `export default ${JSON.stringify(ssgConfig)};`;
+			if (id === "\0virtual:ssg-client.tsx") {
+				const code = generateClientEntry(ssgConfig, entryDetection);
+				return (await (await import("esbuild")).transform(code, {
+					loader: "tsx",
+					jsx: "automatic",
+					jsxImportSource: "sigx"
+				})).code;
+			}
+			if (id === "\0virtual:ssg-server.tsx") {
+				const code = generateServerEntry(ssgConfig);
+				return (await (await import("esbuild")).transform(code, {
+					loader: "tsx",
+					jsx: "automatic",
+					jsxImportSource: "sigx"
+				})).code;
+			}
+			return null;
+		},
+		async handleHotUpdate({ file, server }) {
+			const layoutsDir = path.resolve(root, ssgConfig.layouts || "src/layouts");
+			const pagesDir = path.resolve(root, ssgConfig.pages || "src/pages");
+			if (file.startsWith(layoutsDir)) {
+				layoutsCache = null;
+				const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_LAYOUTS_ID);
+				if (mod) server.moduleGraph.invalidateModule(mod);
+				return [];
+			}
+			if (file.startsWith(pagesDir) && /\.mdx?$/.test(file)) return;
+		}
+	};
+	if (options.enableMdx !== false) return [mainPlugin, mdxPlugin({
+		markdown: options.markdown,
+		ssgConfig: void 0
+	})];
+	return [mainPlugin];
+}
+var plugin_default = ssgPlugin;
+export { ssgPlugin as n, plugin_default as t };
+
+//# sourceMappingURL=plugin-DxH1VUGC.js.map