@vezham/config 0.0.0-stage → 26.0.0-alpha.6

package/dist/lib/metadata/html.js

@@ -0,0 +1,96 @@
+import { getTanStackHead } from "./tanstack.js";
+import { escapeHtml, generatedNotice } from "./render.js";
+//#region src/lib/metadata/html.ts
+var indexMetadataStartMarker = "<!-- VX_METADATA_START -->";
+var indexMetadataEndMarker = "<!-- VX_METADATA_END -->";
+var isDefined = (value) => value !== void 0;
+var normalizeHtmlAttributeName = (name) => name === "charSet" ? "charset" : name;
+var renderHtmlAttribute = ([name, value]) => {
+	if (value === void 0) return;
+	if (value === true) return name;
+	if (value === false) return;
+	return `${normalizeHtmlAttributeName(name)}="${escapeHtml(value)}"`;
+};
+var renderHtmlTag = (tag, attributes, indent = "    ") => {
+	const renderedAttributes = Object.entries(attributes).map(renderHtmlAttribute).filter(isDefined);
+	const inlineTag = `${indent}<${tag} ${renderedAttributes.join(" ")} />`;
+	if (inlineTag.length <= 80) return inlineTag;
+	return `${indent}<${tag}\n${renderedAttributes.map((attribute) => `${indent}  ${attribute}`).join("\n")} />`;
+};
+var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var getIndexHtmlMetadataBlock = (config, projectRoot = process.cwd()) => {
+	const head = getTanStackHead(config, projectRoot);
+	const [charsetMeta, ...meta] = head.meta;
+	const renderHeadMetaEntry = (entry) => {
+		if (typeof entry.title === "string") return `    <title>${escapeHtml(entry.title)}</title>`;
+		return renderHtmlTag("meta", entry);
+	};
+	const note = (label) => `    <!-- wjdlz/NOTE: ${label} -->`;
+	const isMetaName = (entry, names) => typeof entry.name === "string" && names.includes(entry.name);
+	const webMeta = meta.filter((entry) => entry.title || isMetaName(entry, [
+		"viewport",
+		"author",
+		"keywords",
+		"description"
+	]));
+	const themeMeta = meta.filter((entry) => isMetaName(entry, ["theme-color", "background-color"]));
+	const mobileMeta = meta.filter((entry) => isMetaName(entry, ["mobile-web-app-capable"]));
+	const appleMeta = meta.filter((entry) => typeof entry.name === "string" && entry.name.startsWith("apple-"));
+	const microsoftMeta = meta.filter((entry) => isMetaName(entry, [
+		"application-name",
+		"msapplication-config",
+		"msapplication-starturl"
+	]));
+	const openGraphMeta = meta.filter((entry) => typeof entry.property === "string" && entry.property.startsWith("og:"));
+	const twitterMeta = meta.filter((entry) => typeof entry.name === "string" && entry.name.startsWith("twitter:"));
+	const pwaLinks = head.links.filter((link) => link.rel === "manifest" || link.rel === "icon" || link.rel === "shortcut icon" || link.rel === "mask-icon");
+	const appleLinks = head.links.filter((link) => typeof link.rel === "string" && link.rel.startsWith("apple-touch-"));
+	return [
+		`    ${indexMetadataStartMarker}`,
+		`    <!-- ${generatedNotice} -->`,
+		note("WEB"),
+		...charsetMeta ? [renderHeadMetaEntry(charsetMeta)] : [],
+		renderHtmlTag("meta", {
+			"http-equiv": "X-UA-Compatible",
+			content: "IE=edge"
+		}),
+		...webMeta.map(renderHeadMetaEntry),
+		"",
+		note("PWA::THEME"),
+		...themeMeta.map(renderHeadMetaEntry),
+		...pwaLinks.map((link) => renderHtmlTag("link", link)),
+		"",
+		note("PWA::MOBILE"),
+		...mobileMeta.map(renderHeadMetaEntry),
+		"",
+		note("APPLE"),
+		...appleMeta.map(renderHeadMetaEntry),
+		...appleLinks.map((link) => renderHtmlTag("link", link)),
+		"",
+		note("MICROSOFT"),
+		...microsoftMeta.map(renderHeadMetaEntry),
+		"",
+		note("META"),
+		...openGraphMeta.map(renderHeadMetaEntry),
+		"",
+		note("TWITTER"),
+		...twitterMeta.map(renderHeadMetaEntry),
+		`    ${indexMetadataEndMarker}`
+	].join("\n");
+};
+var getPreservedIndexHeadContent = (headContent) => headContent.split("\n").filter((line) => {
+	const trimmedLine = line.trim();
+	return trimmedLine.startsWith("<base ") || trimmedLine.startsWith("<script ");
+}).join("\n");
+var syncIndexHtmlContent = (content, config, projectRoot = process.cwd()) => {
+	const metadataBlock = getIndexHtmlMetadataBlock(config, projectRoot);
+	const headPattern = /(<head>\n)([\s\S]*?)(\n\s*<\/head>)/;
+	const headMatch = content.match(headPattern);
+	if (!headMatch) throw new Error("Unable to sync Vx metadata because index.html has no head");
+	const [, headStart, headContent, headEnd] = headMatch;
+	const existingBlockPattern = new RegExp(`${escapeRegex(`    ${indexMetadataStartMarker}`)}[\\s\\S]*?${escapeRegex(`    ${indexMetadataEndMarker}`)}`);
+	const nextHeadContent = [getPreservedIndexHeadContent(headContent.replace(existingBlockPattern, "")), metadataBlock].filter(Boolean).join("\n\n");
+	return content.replace(headPattern, `${headStart}${nextHeadContent}${headEnd}`);
+};
+//#endregion
+export { syncIndexHtmlContent };

package/dist/lib/metadata/index.d.ts

@@ -0,0 +1,7 @@
+import { type GenerateMetadataOptions, type MetadataFile, type VxConfig } from './types';
+export declare const loadVxAppConfig: (projectRoot?: string) => VxConfig;
+export declare const getMetadataFiles: (config: VxConfig, projectRoot?: string) => MetadataFile[];
+export declare const generateMetadata: (options?: GenerateMetadataOptions) => string[];
+export declare const watchMetadata: (options?: GenerateMetadataOptions) => import("node:fs").FSWatcher;
+export type { GenerateMetadataOptions } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/metadata/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/metadata/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,YAAY,EACjB,KAAK,QAAQ,EACd,MAAM,SAAS,CAAA;AAOhB,eAAO,MAAM,eAAe,GAAI,oBAA2B,aAU1D,CAAA;AAED,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,QAAQ,EAChB,oBAA2B,KAC1B,YAAY,EA+Bd,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,UAAS,uBAA4B,aASrE,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,UAAS,uBAA4B,gCAclE,CAAA;AAGD,YAAY,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAA"}

package/dist/lib/metadata/index.js

@@ -0,0 +1,61 @@
+import { validateFramework } from "../framework.js";
+import { readYamlConfig } from "../yaml-config.js";
+import { getNavigationFiles } from "../navigation/index.js";
+import { getVxEnv, syncEnvContent } from "./env.js";
+import { getGeneratedMetadataModule } from "./render.js";
+import { syncIndexHtmlContent } from "./html.js";
+import { getPublicMetadataFiles } from "./public.js";
+import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from "node:fs";
+import path from "node:path";
+//#region src/lib/metadata/index.ts
+var writeMetadataFile = ({ path: file, content }) => {
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, content);
+};
+var loadVxAppConfig = (projectRoot = process.cwd()) => {
+	const configFile = path.resolve(projectRoot, "vx.app.yaml");
+	if (!existsSync(configFile)) throw new Error(`Missing vx.app.yaml at ${configFile}`);
+	const config = readYamlConfig(configFile);
+	validateFramework(config.framework);
+	return config;
+};
+var getMetadataFiles = (config, projectRoot = process.cwd()) => {
+	const indexFile = path.resolve(projectRoot, "index.html");
+	const envFile = path.resolve(projectRoot, ".env");
+	return [
+		...getNavigationFiles(projectRoot),
+		...getPublicMetadataFiles(config, projectRoot),
+		...existsSync(indexFile) ? [{
+			path: indexFile,
+			content: syncIndexHtmlContent(readFileSync(indexFile, "utf8"), config, projectRoot)
+		}] : [],
+		{
+			path: path.join(projectRoot, "src/generated/vx.ts"),
+			content: getGeneratedMetadataModule(config, projectRoot)
+		},
+		{
+			path: envFile,
+			content: syncEnvContent(existsSync(envFile) ? readFileSync(envFile, "utf8") : "", getVxEnv(config))
+		}
+	];
+};
+var generateMetadata = (options = {}) => {
+	const projectRoot = path.resolve(options.projectRoot ?? process.cwd());
+	const files = getMetadataFiles(loadVxAppConfig(projectRoot), projectRoot);
+	for (const file of files) writeMetadataFile(file);
+	return files.map((file) => file.path);
+};
+var watchMetadata = (options = {}) => {
+	const projectRoot = path.resolve(options.projectRoot ?? process.cwd());
+	const configFile = path.join(projectRoot, "vx.app.yaml");
+	const regenerate = () => {
+		const files = generateMetadata(options);
+		console.log(`Generated ${files.length} metadata files from ${configFile}`);
+	};
+	regenerate();
+	return watch(projectRoot, { persistent: true }, (_event, filename) => {
+		if (filename === "vx.app.yaml" || filename === "vx.nav.yaml") regenerate();
+	});
+};
+//#endregion
+export { generateMetadata, getMetadataFiles, loadVxAppConfig, watchMetadata };

package/dist/lib/metadata/next.d.ts

@@ -0,0 +1,79 @@
+import type { VxConfig } from './types';
+export declare const getNextMetadata: (config: VxConfig, projectRoot?: string) => {
+    metadataBase: URL | undefined;
+    title: string;
+    description: string;
+    applicationName: string;
+    authors: {
+        name: string;
+        url: string;
+    }[] | undefined;
+    keywords: string[];
+    manifest: string;
+    icons: {
+        icon: ({
+            url: string;
+            type: string;
+            media: string;
+            color?: undefined;
+        } | {
+            url: string;
+            type: string;
+            media: string;
+            color: string;
+        })[];
+        shortcut: {
+            url: string;
+            media: string;
+        }[];
+        apple: {
+            url: string;
+        }[];
+        other: {
+            rel: string;
+            url: string;
+            media: string;
+            color: string;
+        }[];
+    };
+    appleWebApp: {
+        title: string;
+        capable: boolean;
+        startupImage: {
+            media: string;
+            url: string;
+        }[];
+    };
+    openGraph: {
+        type: string;
+        title: string;
+        description: string;
+        images: string[];
+        url: string;
+    };
+    twitter: {
+        creator: string;
+        site: string;
+        title: string;
+        description: string;
+        images: string[];
+        card: string;
+    };
+    other: {
+        'mobile-web-app-capable': string;
+        'msapplication-config': string;
+        'msapplication-starturl': string;
+        'twitter:url': string;
+    };
+};
+export declare const getNextViewport: (config: VxConfig, projectRoot?: string) => {
+    width: string;
+    initialScale: number;
+    maximumScale: number;
+    userScalable: boolean;
+    themeColor: {
+        media: string;
+        color: string;
+    }[];
+};
+//# sourceMappingURL=next.d.ts.map

package/dist/lib/metadata/next.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../../src/lib/metadata/next.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC,eAAO,MAAM,eAAe,GAC1B,QAAQ,QAAQ,EAChB,oBAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiG5B,CAAA;AAED,eAAO,MAAM,eAAe,GAC1B,QAAQ,QAAQ,EAChB,oBAA2B;;;;;;;;;CAoB5B,CAAA"}

package/dist/lib/metadata/next.js

@@ -0,0 +1,106 @@
+import { getRuntimeMetadata } from "./runtime.js";
+//#region src/lib/metadata/next.ts
+var getNextMetadata = (config, projectRoot = process.cwd()) => {
+	const metadata = getRuntimeMetadata(config, projectRoot);
+	return {
+		metadataBase: metadata.url ? new URL(metadata.url) : void 0,
+		title: metadata.title,
+		description: metadata.description,
+		applicationName: metadata.microsoft.applicationName,
+		authors: metadata.author?.name ? [{
+			name: metadata.author.name,
+			url: metadata.author.url
+		}] : void 0,
+		keywords: metadata.keywords,
+		manifest: metadata.manifest,
+		icons: {
+			icon: [
+				{
+					url: metadata.icons.faviconLight,
+					type: "image/x-icon",
+					media: "(prefers-color-scheme: light)"
+				},
+				{
+					url: metadata.icons.faviconDark,
+					type: "image/x-icon",
+					media: "(prefers-color-scheme: dark)"
+				},
+				{
+					url: metadata.icons.maskIcon,
+					type: "image/svg+xml",
+					media: "(prefers-color-scheme: light)",
+					color: "black"
+				},
+				{
+					url: metadata.icons.maskIcon,
+					type: "image/svg+xml",
+					media: "(prefers-color-scheme: dark)",
+					color: "white"
+				}
+			],
+			shortcut: [{
+				url: metadata.icons.faviconLight,
+				media: "(prefers-color-scheme: light)"
+			}, {
+				url: metadata.icons.faviconDark,
+				media: "(prefers-color-scheme: dark)"
+			}],
+			apple: [{ url: metadata.apple.touchIcon }],
+			other: [{
+				rel: "mask-icon",
+				url: metadata.icons.maskIcon,
+				media: "(prefers-color-scheme: light)",
+				color: "black"
+			}, {
+				rel: "mask-icon",
+				url: metadata.icons.maskIcon,
+				media: "(prefers-color-scheme: dark)",
+				color: "white"
+			}]
+		},
+		appleWebApp: {
+			title: metadata.apple.title,
+			capable: metadata.apple.capable,
+			startupImage: metadata.apple.startupImages
+		},
+		openGraph: {
+			type: metadata.openGraph.type,
+			title: metadata.openGraph.title,
+			description: metadata.openGraph.description,
+			images: [metadata.openGraph.image],
+			url: metadata.openGraph.url
+		},
+		twitter: {
+			creator: metadata.twitter.creator,
+			site: metadata.twitter.site,
+			title: metadata.twitter.title,
+			description: metadata.twitter.description,
+			images: [metadata.twitter.image],
+			card: metadata.twitter.card
+		},
+		other: {
+			"mobile-web-app-capable": metadata.mobileWebAppCapable ? "yes" : "no",
+			"msapplication-config": metadata.microsoft.config,
+			"msapplication-starturl": metadata.microsoft.startUrl,
+			"twitter:url": metadata.twitter.url
+		}
+	};
+};
+var getNextViewport = (config, projectRoot = process.cwd()) => {
+	const metadata = getRuntimeMetadata(config, projectRoot);
+	return {
+		width: "device-width",
+		initialScale: 1,
+		maximumScale: 1.5,
+		userScalable: true,
+		themeColor: [{
+			media: "(prefers-color-scheme: light)",
+			color: metadata.theme.lightColor
+		}, {
+			media: "(prefers-color-scheme: dark)",
+			color: metadata.theme.darkColor
+		}]
+	};
+};
+//#endregion
+export { getNextMetadata, getNextViewport };

package/dist/lib/metadata/public.d.ts

@@ -0,0 +1,3 @@
+import type { MetadataFile, VxConfig } from './types';
+export declare const getPublicMetadataFiles: (config: VxConfig, projectRoot: string) => MetadataFile[];
+//# sourceMappingURL=public.d.ts.map

package/dist/lib/metadata/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../src/lib/metadata/public.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAiErD,eAAO,MAAM,sBAAsB,GACjC,QAAQ,QAAQ,EAChB,aAAa,MAAM,KAClB,YAAY,EA8Cd,CAAA"}

package/dist/lib/metadata/public.js

@@ -0,0 +1,107 @@
+import { createVersionedAssetUrl, getProjectAssetBaseUrl, getStaticAssetUrl, lowerFirst, normalizeIcons, toAssetUrl } from "./runtime.js";
+import { generatedNotice, renderMetadataTemplate, stringifyManifest } from "./render.js";
+import path from "node:path";
+//#region src/lib/metadata/public.ts
+var createManifest = (config, versionedAssetUrl) => {
+	const { core, pwa } = config;
+	return {
+		manifest_version: 1,
+		version: core.version,
+		id: core.id,
+		name: core.name,
+		short_name: core.shortName,
+		description: lowerFirst(core.description),
+		scope: pwa.scope,
+		start_url: `${pwa.startUrl}?utm_source=homescreen&utm_medium=shortcut&pwa=true`,
+		display: pwa.display,
+		orientation: pwa.orientation,
+		theme_color: config.branding.themeColor,
+		background_color: config.branding.backgroundColor,
+		categories: pwa.categories,
+		icons: normalizeIcons(pwa.icons).map((icon) => ({
+			src: toAssetUrl(icon.src, versionedAssetUrl),
+			sizes: icon.sizes,
+			type: icon.type
+		})),
+		screenshots: pwa.screenshots.map((screenshot) => ({
+			src: toAssetUrl(screenshot.src, versionedAssetUrl),
+			type: screenshot.type,
+			sizes: screenshot.sizes
+		})),
+		shortcuts: pwa.shortcuts.map((shortcut) => ({
+			name: shortcut.name,
+			short_name: shortcut.shortName,
+			url: `${shortcut.url}?utm_source=jumplist&utm_medium=shortcut&pwa=true`,
+			icons: normalizeIcons(shortcut.icons).map((icon) => ({
+				src: toAssetUrl(icon.src, versionedAssetUrl),
+				sizes: icon.sizes,
+				type: icon.type
+			}))
+		}))
+	};
+};
+var renderBrowserConfig = (versionedAssetUrl) => {
+	return `<?xml version="1.0" encoding="utf-8" ?>
+<!-- ${generatedNotice} -->
+<browserconfig>
+  <msapplication>
+    <tile>
+      <square70x70logo
+        src="${versionedAssetUrl("icons/icon-square-70x70.png")}" />
+      <square150x150logo
+        src="${versionedAssetUrl("icons/icon-square-150x150.png")}" />
+      <wide310x150logo
+        src="${versionedAssetUrl("icons/icon-square-310x150.png")}" />
+      <square310x310logo
+        src="${versionedAssetUrl("icons/icon-square-310x310.png")}" />
+      <tilecolor>transparent</tilecolor>
+    </tile>
+  </msapplication>
+</browserconfig>
+`;
+};
+var getPublicMetadataFiles = (config, projectRoot) => {
+	const { core } = config;
+	const publicDir = path.resolve(projectRoot, "public");
+	const versionedAssetUrl = createVersionedAssetUrl(getProjectAssetBaseUrl(projectRoot), core.version);
+	const offlinePage = renderMetadataTemplate("offline.html", {
+		generatedNotice,
+		author: core.publisher.name,
+		appName: core.name,
+		imageUrl: getStaticAssetUrl("vassets/no-internet.svg", core.version)
+	});
+	const notFoundPage = renderMetadataTemplate("not-found.html", {
+		generatedNotice,
+		author: core.publisher.name,
+		appName: core.name,
+		imageUrl: getStaticAssetUrl("vassets/no-internet.svg", core.version)
+	});
+	return [
+		{
+			path: path.join(publicDir, "manifest.webmanifest"),
+			content: `${stringifyManifest(createManifest(config, versionedAssetUrl))}\n`
+		},
+		{
+			path: path.join(publicDir, "browserconfig.xml"),
+			content: renderBrowserConfig(versionedAssetUrl)
+		},
+		{
+			path: path.join(publicDir, "robots.txt"),
+			content: `# ${generatedNotice}\n# https://www.robotstxt.org/robotstxt.html\nUser-agent: *\nDisallow:\n`
+		},
+		{
+			path: path.join(publicDir, "sw.js"),
+			content: `/* ${generatedNotice} */\n/* global importScripts */\nimportScripts('https://static.cdn.vezham.com/workers/sw.js?vx=${core.version}')\n`
+		},
+		{
+			path: path.join(publicDir, "offline.html"),
+			content: offlinePage
+		},
+		{
+			path: path.join(publicDir, "404.html"),
+			content: notFoundPage
+		}
+	];
+};
+//#endregion
+export { getPublicMetadataFiles };

package/dist/lib/metadata/render.d.ts

@@ -0,0 +1,7 @@
+import { type VxConfig } from './types';
+export declare const generatedNotice = "Generated by Vx metadata. DO NOT EDIT.";
+export declare const stringifyManifest: (manifest: Record<string, unknown>) => string;
+export declare const escapeHtml: (value: string) => string;
+export declare const renderMetadataTemplate: (name: string, values: Record<string, string>) => string;
+export declare const getGeneratedMetadataModule: (config: VxConfig, projectRoot?: string) => string;
+//# sourceMappingURL=render.d.ts.map

package/dist/lib/metadata/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/lib/metadata/render.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAA;AAEvC,eAAO,MAAM,eAAe,2CAA2C,CAAA;AAEvE,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAIhE,CAAA;AAIH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,WAKZ,CAAA;AAO5B,eAAO,MAAM,sBAAsB,GACjC,MAAM,MAAM,EACZ,QAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,WAY1B,CAAA;AAEN,eAAO,MAAM,0BAA0B,GACrC,QAAQ,QAAQ,EAChB,oBAA2B,WAsB3B,CAAA"}

package/dist/lib/metadata/render.js

@@ -0,0 +1,37 @@
+import { resolveI18n } from "../i18n.js";
+import { resolveDocsConfig } from "../presets/docs/config.js";
+import { getRuntimeMetadata } from "./runtime.js";
+import { getNextMetadata, getNextViewport } from "./next.js";
+import { getTanStackHead } from "./tanstack.js";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/lib/metadata/render.ts
+var generatedNotice = "Generated by Vx metadata. DO NOT EDIT.";
+var stringifyManifest = (manifest) => JSON.stringify(manifest, null, 2).replace("\"categories\": [\n    \"productivity\",\n    \"personalization\",\n    \"utilities\"\n  ]", "\"categories\": [\"productivity\", \"personalization\", \"utilities\"]");
+var stringifyTs = (value) => JSON.stringify(value, null, 2);
+var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var metadataTemplatesDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "templates");
+var renderMetadataTemplate = (name, values) => readFileSync(path.join(metadataTemplatesDir, name), "utf8").replace(/^[ \t]*<!-- prettier-ignore -->\r?\n/gm, "").replaceAll(/\{\{(\w+)\}\}/g, (_, key) => {
+	const value = values[key];
+	if (value === void 0) throw new Error(`Missing metadata template value: ${key}`);
+	return escapeHtml(value);
+});
+var getGeneratedMetadataModule = (config, projectRoot = process.cwd()) => `// ${generatedNotice}
+
+export const vxMetadata = ${stringifyTs(getRuntimeMetadata(config, projectRoot))} as const
+
+export const vxCore = ${stringifyTs(config.core)} as const
+
+${config.framework === "tanstack-docs" ? `export const vxDocs = ${stringifyTs(resolveDocsConfig(config.docs))} as const` : ""}
+
+export const vxI18n = ${stringifyTs(resolveI18n(config.i18n))} as const
+
+export type Locale = (typeof vxI18n.languages)[number]
+${config.framework === "next" ? `
+export const nextMetadata = ${stringifyTs(getNextMetadata(config, projectRoot))}
+
+export const nextViewport = ${stringifyTs(getNextViewport(config, projectRoot))}` : config.framework === "tanstack" || config.framework === "tanstack-docs" ? `
+export const tanstackHead = ${stringifyTs(getTanStackHead(config, projectRoot))}` : ""}`;
+//#endregion
+export { escapeHtml, generatedNotice, getGeneratedMetadataModule, renderMetadataTemplate, stringifyManifest };

package/dist/lib/metadata/runtime.d.ts

@@ -0,0 +1,68 @@
+import { type VxConfig, type VxIcon, type VxIconSource } from './types';
+export declare const lowerFirst: (value: string) => string;
+export declare const getProjectAssetBaseUrl: (projectRoot: string) => string;
+export declare const createVersionedAssetUrl: (baseUrl: string, version: string) => (assetPath: string) => string;
+export declare const getStaticAssetUrl: (assetPath: string, version: string) => string;
+export declare const toAssetUrl: (assetPath: string, versionedAssetUrl: (assetPath: string) => string) => string;
+type SocialImageSource = 'default' | 'path' | 'url';
+export declare const normalizeIcons: (icons: VxIconSource) => VxIcon[];
+export declare const getRuntimeMetadata: (config: VxConfig, projectRoot?: string) => {
+    title: string;
+    description: string;
+    url: string;
+    manifest: string;
+    browserConfig: string;
+    startUrl: string;
+    author: {
+        name: string;
+        url: string;
+    };
+    keywords: string[];
+    theme: {
+        lightColor: string;
+        darkColor: string;
+        lightBackgroundColor: string;
+        darkBackgroundColor: string;
+    };
+    mobileWebAppCapable: boolean;
+    apple: {
+        title: string;
+        capable: boolean;
+        touchIcon: string;
+        startupImages: {
+            media: string;
+            url: string;
+        }[];
+    };
+    icons: {
+        faviconLight: string;
+        faviconDark: string;
+        maskIcon: string;
+    };
+    microsoft: {
+        applicationName: string;
+        config: string;
+        startUrl: string;
+    };
+    openGraph: {
+        type: string;
+        title: string;
+        description: string;
+        image: string;
+        imageSource: SocialImageSource;
+        url: string;
+    };
+    twitter: {
+        creator: string;
+        site: string;
+        title: string;
+        description: string;
+        image: string;
+        url: string;
+        card: string;
+    };
+    defaultLanguage: string;
+    languages: string[];
+};
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/lib/metadata/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/lib/metadata/runtime.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,MAAM,EACX,KAAK,YAAY,EAGlB,MAAM,SAAS,CAAA;AAEhB,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,WAC6B,CAAA;AAIrE,eAAO,MAAM,sBAAsB,GAAI,aAAa,MAAM,WACmC,CAAA;AAE7F,eAAO,MAAM,uBAAuB,GAAI,SAAS,MAAM,EAAE,SAAS,MAAM,MAG9D,WAAW,MAAM,WAE1B,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,WAAW,MAAM,EAAE,SAAS,MAAM,WAC+B,CAAA;AAEnG,eAAO,MAAM,UAAU,GACrB,WAAW,MAAM,EACjB,mBAAmB,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,WAIhB,CAAA;AAElC,KAAK,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,KAAK,CAAA;AAyEnD,eAAO,MAAM,cAAc,GAAI,OAAO,YAAY,KAAG,MAAM,EAU1D,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,QAAQ,EAChB,oBAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiF5B,CAAA"}