@evertondgn/solid-tooling 0.5.0 → 0.6.0

package/dist/vite.mjs

@@ -1,19 +1,232 @@
-import { fmt } from "./fmt.mjs";
-import { t as lint } from "./lint-UTfyg7AR.mjs";
-import { solidTest } from "./vitest.mjs";
+import { t as fmt } from "./fmt-9dlUYOMk.mjs";
+import { a as I18N_SETTINGS, i as validatePublicationFeatures, n as seoModule, o as hasI18n, r as localeModule, t as solidTest } from "./vitest-BjLr7iLf.mjs";
+import { t as lint } from "./lint-ehdtTKfw.mjs";
 import path from "node:path";
-import { readFile } from "node:fs/promises";
 import { env, loadEnvFile } from "node:process";
+import { fileURLToPath } from "node:url";
+import { readFile, realpath } from "node:fs/promises";
 import { defineConfig, lazyPlugins, loadEnv } from "vite-plus";
+import * as v from "valibot";
+import { createHash } from "node:crypto";
+// src/fonts/assets.ts
+const HASH_LENGTH = 16;
+const MAX_WEIGHT = 1e3;
+const FORMATS = {
+	".woff2": "woff2",
+	".woff": "woff",
+	".ttf": "truetype",
+	".otf": "opentype"
+};
+const numericWeight = v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(MAX_WEIGHT));
+const textWeight = v.pipe(v.string(), v.regex(/^(?:normal|bold|(?:[1-9]\d{0,2}|1000)(?: (?:[1-9]\d{0,2}|1000))?)$/u));
+const weightSchema = v.union([numericWeight, textWeight]);
+const unicodeSchema = v.pipe(v.string(), v.regex(/^U\+[\dA-F?]{1,6}(?:-[\dA-F]{1,6})?(?:\s*,\s*U\+[\dA-F?]{1,6}(?:-[\dA-F]{1,6})?)*$/iu));
+const fontSchema = v.strictObject({
+	path: v.pipe(v.string(), v.nonEmpty()),
+	weight: v.optional(weightSchema, "normal"),
+	style: v.optional(v.picklist([
+		"normal",
+		"italic",
+		"oblique"
+	]), "normal"),
+	display: v.optional(v.picklist([
+		"auto",
+		"block",
+		"swap",
+		"fallback",
+		"optional"
+	]), "swap"),
+	unicodeRange: v.optional(unicodeSchema),
+	preload: v.optional(v.boolean(), false)
+});
+const familyName = v.pipe(v.string(), v.nonEmpty(), v.check((value) => !/\p{Cc}/u.test(value), "Font families cannot contain control characters."));
+const fileList = v.pipe(v.array(fontSchema), v.minLength(1));
+const familySchema = v.strictObject({
+	family: familyName,
+	files: fileList
+});
+const familiesSchema = v.array(familySchema);
+function hash(source) {
+	return createHash("sha256").update(source).digest("hex").slice(0, HASH_LENGTH);
+}
+function cssString(value) {
+	return `"${value.replaceAll("\\", String.raw`\\`).replaceAll("\"", String.raw`\"`)}"`;
+}
+function isInside(root, file) {
+	const relative = path.relative(root, file);
+	return relative !== "" && !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
+}
+async function readFontAssets({ root, fonts, base, assetsDir }) {
+	if (!base.startsWith("/") || base.startsWith("//") || /[?#]/u.test(base)) throw new Error("defineSolidApp fonts: base must be a same-origin absolute pathname.");
+	if (path.isAbsolute(assetsDir) || assetsDir.split(/[\\/]/u).includes("..")) throw new Error("defineSolidApp fonts: assetsDir must stay inside the client output.");
+	const families = v.parse(familiesSchema, fonts);
+	const directory = await realpath(root);
+	const assets = /* @__PURE__ */ new Map();
+	const files = /* @__PURE__ */ new Set();
+	const preloads = /* @__PURE__ */ new Map();
+	const rules = [];
+	const url = (fileName) => `${base.replace(/\/$/u, "")}/${fileName}`;
+	for (const { family, files: faces } of families) for (const face of faces) {
+		if (path.isAbsolute(face.path) || /[?#]/u.test(face.path)) throw new Error(`defineSolidApp fonts: ${face.path} must be relative to the application root, without a query or fragment.`);
+		const file = await realpath(path.resolve(directory, face.path));
+		if (!isInside(directory, file)) throw new Error(`defineSolidApp fonts: ${face.path} must stay inside the application root.`);
+		const extension = path.extname(file);
+		const format = FORMATS[extension];
+		if (!format) throw new Error(`defineSolidApp fonts: ${face.path} must be a woff2, woff, ttf or otf file.`);
+		const source = await readFile(file);
+		const key = `${hash(source)}${extension}`;
+		let asset = assets.get(key);
+		if (!asset) {
+			const name = path.basename(file, extension).replaceAll(/[^\w-]/gu, "_");
+			asset = {
+				fileName: path.posix.join(assetsDir, `${name}-${key}`),
+				source,
+				type: `font/${extension.slice(1)}`
+			};
+			assets.set(key, asset);
+		}
+		files.add(file);
+		const href = url(asset.fileName);
+		if (face.preload) preloads.set(href, {
+			href,
+			type: asset.type
+		});
+		rules.push(`@font-face {\n  font-family: ${cssString(family)};\n  font-style: ${face.style};\n  font-display: ${face.display};\n  font-weight: ${face.weight};\n  src: url(${cssString(href)}) format(${cssString(format)});${face.unicodeRange ? `\n  unicode-range: ${face.unicodeRange};` : ""}\n}`);
+	}
+	const source = `${rules.join("\n\n")}\n`;
+	const fileName = path.posix.join(assetsDir, `solid-fonts-${hash(source)}.css`);
+	return {
+		assets: [...assets.values(), {
+			fileName,
+			source,
+			type: "text/css"
+		}],
+		files: [...files],
+		stylesheet: url(fileName),
+		preloads: [...preloads.values()]
+	};
+}
+// src/fonts/index.ts
+const MODULE_ID = "virtual:solid-app/fonts";
+const RESOLVED_ID = "\0solid-app:fonts";
+function fontsPlugin(options) {
+	if (options.fonts === void 0) return void 0;
+	if (!Array.isArray(options.fonts)) throw new TypeError("defineSolidApp fonts: fonts must be an array of family descriptors.");
+	if (options.fonts.length === 0) return void 0;
+	let assets;
+	let base = "/";
+	let assetsDir = "assets";
+	let isBuild = false;
+	const read = () => readFontAssets({
+		...options,
+		base,
+		assetsDir
+	});
+	return {
+		name: "solid-app:fonts",
+		async configResolved(config) {
+			({base} = config);
+			({assetsDir} = config.build);
+			isBuild = config.command === "build";
+			assets = read();
+			await assets;
+		},
+		async buildStart() {
+			const result = await assets;
+			for (const file of result.files) this.addWatchFile(file);
+			if (isBuild && this.environment.name === "client") for (const asset of result.assets) this.emitFile({
+				type: "asset",
+				fileName: asset.fileName,
+				source: asset.source
+			});
+		},
+		resolveId: (id) => id === MODULE_ID ? RESOLVED_ID : void 0,
+		async load(id) {
+			if (id !== RESOLVED_ID) return void 0;
+			const { stylesheet, preloads } = await assets;
+			return `export const stylesheet = ${JSON.stringify(stylesheet)}; export const preloads = ${JSON.stringify(preloads)}`;
+		},
+		async transformIndexHtml() {
+			if (options.ssr !== false) return void 0;
+			const { stylesheet, preloads } = await assets;
+			return [{
+				tag: "link",
+				attrs: {
+					rel: "stylesheet",
+					href: stylesheet
+				}
+			}, ...preloads.map(({ href, type }) => ({
+				tag: "link",
+				attrs: {
+					rel: "preload",
+					href,
+					as: "font",
+					type,
+					crossorigin: "anonymous"
+				}
+			}))];
+		},
+		configureServer(server) {
+			server.middlewares.use((request, response, next) => {
+				(async () => {
+					try {
+						const asset = (await assets).assets.find((item) => request.url?.split("?")[0] === `${base}${item.fileName}`);
+						if (!asset) {
+							next();
+							return;
+						}
+						response.setHeader("Content-Type", asset.type);
+						response.setHeader("Cache-Control", "no-cache");
+						response.end(asset.source);
+					} catch (error) {
+						next(error);
+					}
+				})();
+			});
+		},
+		async handleHotUpdate({ file, server }) {
+			if (!(await assets).files.includes(file)) return void 0;
+			assets = read();
+			await assets;
+			for (const environment of Object.values(server.environments)) {
+				const module = environment.moduleGraph.getModuleById(RESOLVED_ID);
+				if (module) environment.moduleGraph.invalidateModule(module);
+			}
+			server.ws.send({ type: "full-reload" });
+			return [];
+		}
+	};
+}
+// src/vite/static-paths.ts
+function isUnderLocale({ staticPath, locales }) {
+	const [firstSegment] = staticPath.split("/").slice(1);
+	return locales.includes(firstSegment ?? "");
+}
+function staticFilePaths({ options, locales }) {
+	const appPaths = [...(options.publicAssets ?? []).map((asset) => `${asset.baseURL}/**`), ...options.staticPaths ?? []];
+	const collision = appPaths.find((staticPath) => isUnderLocale({
+		staticPath,
+		locales
+	}));
+	if (collision) throw new Error(`defineSolidApp: the static path ${collision} is inside a locale folder; move it out of /${collision.split("/")[1]}/.`);
+	const seo = typeof options.seo === "object" ? options.seo : {};
+	const hasMarkdown = typeof seo.markdown === "object" && seo.markdown.static === true;
+	const markdownPaths = locales.length > 0 ? locales.map((locale) => `/${locale}/**.md`) : ["/**.md"];
+	const publishedPaths = [
+		...hasMarkdown ? markdownPaths : [],
+		...typeof seo.llms === "object" ? ["/llms.txt"] : [],
+		...typeof seo.llmsFull === "object" ? ["/llms-full.txt"] : [],
+		...seo.sitemap !== void 0 && seo.sitemap !== false ? ["/sitemap.xml", "/sitemaps/pages/**"] : [],
+		...hasMarkdown ? ["/_markdown/static.json"] : []
+	];
+	return [
+		"/assets/**",
+		...appPaths,
+		...publishedPaths
+	];
+}
 // src/vite/plugins.ts
 const ROUTE_TYPES = "src/@types/routes.d.ts";
-const SEO_FILE_PATHS = [
-	"/llms.txt",
-	"/llms-full.txt",
-	"/sitemap.xml",
-	"/sitemaps/pages/**",
-	"/_markdown/static.json"
-];
 async function loadPluginModules() {
 	const [solid, routing, icons, loaders] = await Promise.all([
 		import("@solidjs/vite-plugin"),
@@ -34,35 +247,29 @@ async function readExtension({ options, target, mode }) {
 		mode
 	}) ?? {};
 }
+async function i18nPlugins(options) {
+	if (options.i18nPlugin === false || !hasI18n(options.root)) return [];
+	const { i18nPlugin } = await import("./i18nPlugin-CS7Gob6R.mjs");
+	return i18nPlugin();
+}
 async function readLocales(root) {
+	let source;
+	try {
+		source = await readFile(path.join(root, I18N_SETTINGS), "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return [];
+		throw new Error(`defineSolidApp: cannot read the locales from ${I18N_SETTINGS}.`, { cause: error });
+	}
 	let settings;
 	try {
-		settings = JSON.parse(await readFile(path.join(root, "project.inlang/settings.json"), "utf8"));
+		settings = JSON.parse(source);
 	} catch (error) {
-		throw new Error("defineSolidApp: cannot read the locales from project.inlang/settings.json.", { cause: error });
+		throw new Error(`defineSolidApp: cannot read the locales from ${I18N_SETTINGS}.`, { cause: error });
 	}
 	const locales = settings !== null && typeof settings === "object" && "locales" in settings ? settings.locales : void 0;
-	if (!Array.isArray(locales) || !locales.every((locale) => typeof locale === "string")) throw new Error("defineSolidApp: project.inlang/settings.json must list its locales as strings.");
+	if (!Array.isArray(locales) || !locales.every((locale) => typeof locale === "string")) throw new Error(`defineSolidApp: ${I18N_SETTINGS} must list its locales as strings.`);
 	return locales;
 }
-function isUnderLocale({ staticPath, locales }) {
-	const [firstSegment] = staticPath.split("/").slice(1);
-	return locales.includes(firstSegment ?? "");
-}
-function staticFilePaths({ options, locales }) {
-	const appPaths = [...(options.publicAssets ?? []).map((asset) => `${asset.baseURL}/**`), ...options.staticPaths ?? []];
-	const collision = appPaths.find((staticPath) => isUnderLocale({
-		staticPath,
-		locales
-	}));
-	if (collision) throw new Error(`defineSolidApp: the static path ${collision} is inside a locale folder; move it out of /${collision.split("/")[1]}/.`);
-	return [
-		"/assets/**",
-		...appPaths,
-		...locales.map((locale) => `/${locale}/**.md`),
-		...SEO_FILE_PATHS
-	];
-}
 function iconsPlugin({ modules, options }) {
 	return modules.Icons({
 		compiler: "solid",
@@ -79,70 +286,149 @@ function staticHeaders({ securityHeaders }) {
 		"cross-origin-resource-policy": securityHeaders["cross-origin-resource-policy"]
 	};
 }
+function clientPlugins({ i18n, modules, extension, options, mode }) {
+	const e2eRoutes = mode === "e2e" ? options.e2e?.routes : void 0;
+	return [
+		localeModule(options),
+		fontsPlugin(options),
+		...extension.plugins ?? [],
+		...i18n,
+		iconsPlugin({
+			modules,
+			options
+		}),
+		modules.solid({ ssr: false }),
+		modules.fileRoutes(e2eRoutes ? {
+			dir: e2eRoutes,
+			httpMethods: true
+		} : {
+			types: ROUTE_TYPES,
+			httpMethods: true
+		})
+	];
+}
+function hasStaticMarkdown(options) {
+	return typeof options.seo === "object" && typeof options.seo.markdown === "object" && options.seo.markdown.static === true;
+}
+async function createPublication(options) {
+	const features = typeof options.seo === "object" ? options.seo : {};
+	const enabled = hasStaticMarkdown(options) || typeof features.llms === "object" || typeof features.sitemap === "object";
+	let publication;
+	if (enabled) {
+		const { publicationBuild } = await import("./publication-CRUTOB0B.mjs");
+		publication = publicationBuild(features);
+	}
+	return publication;
+}
+async function serverPlugins({ options, mode }) {
+	const [modules, { nitro }, extension, locales, i18n] = await Promise.all([
+		loadPluginModules(),
+		import("nitro/vite"),
+		readExtension({
+			options,
+			target: "app",
+			mode
+		}),
+		hasStaticMarkdown(options) ? readLocales(options.root) : [],
+		i18nPlugins(options)
+	]);
+	const isE2e = mode === "e2e";
+	const middleware = isE2e ? options.e2e?.middleware ?? options.middleware : options.middleware;
+	const e2eRoutes = isE2e ? options.e2e?.routes : void 0;
+	const headers = staticHeaders(options);
+	const publication = await createPublication(options);
+	return [
+		localeModule(options),
+		fontsPlugin(options),
+		seoModule({
+			root: options.root,
+			mode,
+			seo: options.seo
+		}),
+		...publication ? [publication.plugin] : [],
+		...extension.plugins ?? [],
+		...i18n,
+		iconsPlugin({
+			modules,
+			options
+		}),
+		modules.solid({
+			start: middleware ? { middleware } : {},
+			ssr: true,
+			serverFunctions: options.serverSetup ? { serverSetup: options.serverSetup } : true
+		}),
+		modules.fileRoutes(e2eRoutes ? {
+			dir: e2eRoutes,
+			httpMethods: true
+		} : {
+			types: ROUTE_TYPES,
+			httpMethods: true
+		}),
+		nitro({
+			serverEntry: false,
+			preset: "vercel",
+			modules: [...publication ? [publication.module] : [], ...extension.nitroModules ?? []],
+			publicAssets: options.publicAssets ?? [],
+			routeRules: {
+				...Object.fromEntries(staticFilePaths({
+					options,
+					locales
+				}).map((staticPath) => [staticPath, { headers }])),
+				...options.routeRules
+			}
+		})
+	];
+}
 function appPlugins({ options, mode }) {
 	return lazyPlugins(async () => {
-		const [modules, { nitro }, extension, locales] = await Promise.all([
+		if (options.ssr !== false) return serverPlugins({
+			options,
+			mode
+		});
+		const [modules, extension, i18n] = await Promise.all([
 			loadPluginModules(),
-			import("nitro/vite"),
 			readExtension({
 				options,
 				target: "app",
 				mode
 			}),
-			readLocales(options.root)
+			i18nPlugins(options)
 		]);
-		const isE2e = mode === "e2e";
-		const middleware = isE2e ? options.e2e?.middleware ?? options.middleware : options.middleware;
-		const e2eRoutes = isE2e ? options.e2e?.routes : void 0;
-		const headers = staticHeaders(options);
-		return [
-			...extension.plugins ?? [],
-			iconsPlugin({
-				modules,
-				options
-			}),
-			modules.solid({
-				start: middleware ? { middleware } : {},
-				ssr: true,
-				serverFunctions: options.serverSetup ? { serverSetup: options.serverSetup } : true
-			}),
-			modules.fileRoutes(e2eRoutes ? {
-				dir: e2eRoutes,
-				httpMethods: true
-			} : {
-				types: ROUTE_TYPES,
-				httpMethods: true
-			}),
-			nitro({
-				serverEntry: false,
-				preset: "vercel",
-				modules: extension.nitroModules ?? [],
-				publicAssets: options.publicAssets ?? [],
-				routeRules: {
-					...Object.fromEntries(staticFilePaths({
-						options,
-						locales
-					}).map((staticPath) => [staticPath, { headers }])),
-					...options.routeRules
-				}
-			})
-		];
+		return clientPlugins({
+			modules,
+			extension,
+			options,
+			mode,
+			i18n
+		});
 	});
 }
 function testPlugins({ options, mode }) {
 	return lazyPlugins(async () => {
-		const [modules, extension] = await Promise.all([loadPluginModules(), readExtension({
-			options,
-			target: "test",
-			mode
-		})]);
+		const [modules, extension, i18n] = await Promise.all([
+			loadPluginModules(),
+			readExtension({
+				options,
+				target: "test",
+				mode
+			}),
+			i18nPlugins(options)
+		]);
 		return [
+			localeModule(options),
+			fontsPlugin(options),
+			...options.ssr === false ? [] : [seoModule({
+				root: options.root,
+				mode,
+				seo: options.seo
+			})],
 			...extension.plugins ?? [],
+			...i18n,
 			iconsPlugin({
 				modules,
 				options
 			}),
-			modules.solid({ serverFunctions: true }),
+			modules.solid(options.ssr === false ? {} : { serverFunctions: true }),
 			modules.fileRoutes({
 				types: ROUTE_TYPES,
 				httpMethods: true
@@ -152,6 +438,16 @@ function testPlugins({ options, mode }) {
 }
 // src/vite/tasks.ts
 const TOOLING_CI_TEST_WORKERS = 3;
+const TOOL_NAMES = [
+	"knip",
+	"tsc",
+	"playwright",
+	"lefthook",
+	"commitlint"
+];
+function toolCommand(name) {
+	return `node '${fileURLToPath(new URL("cli.mjs", import.meta.url)).replaceAll("'", String.raw`'\''`)}' ${name}`;
+}
 function fromWorkspace(pattern) {
 	return {
 		pattern,
@@ -166,9 +462,8 @@ function installInputs({ workspace }) {
 	];
 	return workspace ? patterns.map((pattern) => fromWorkspace(pattern)) : patterns;
 }
-function createTasks({ workspace, isCi }) {
+function createTasks({ workspace, isCi, hasI18n }) {
 	const install = installInputs({ workspace });
-	const lockfile = workspace ? fromWorkspace("bun.lock") : "bun.lock";
 	const dependsOn = workspace ? { dependsOn: workspace.dependsOn } : {};
 	const projectCheckInputs = [
 		{ auto: true },
@@ -183,20 +478,25 @@ function createTasks({ workspace, isCi }) {
 	];
 	const testConcurrency = isCi ? ` --test-concurrency=${TOOLING_CI_TEST_WORKERS}` : "";
 	return {
-		"i18n-generate": {
-			command: "bun tooling/i18n/generate.ts",
+		...Object.fromEntries(TOOL_NAMES.map((name) => [name, {
+			command: toolCommand(name),
+			cache: false
+		}])),
+		...hasI18n && { "i18n-generate": {
+			command: `bun '${fileURLToPath(new URL("i18n-generate.mjs", import.meta.url)).replaceAll("'", String.raw`'\''`)}'`,
+			...dependsOn,
 			cache: {
 				input: [
+					{ auto: true },
 					"src/**/i18n/*.json",
-					"tooling/i18n/**",
 					"project.inlang/settings.json",
 					"project.inlang/paraglide.config.ts",
 					"package.json",
-					lockfile
+					...install
 				],
 				output: ["paraglide/**", ".paraglide/messages/**"]
 			}
-		},
+		} },
 		"lint-css": {
 			command: "bun tooling/css/check.ts",
 			...dependsOn,
@@ -212,7 +512,7 @@ function createTasks({ workspace, isCi }) {
 			}
 		},
 		"dead-code-project": {
-			command: "knip-bun --config tooling/knip.ts && knip-bun --config tooling/knip.ts --strict",
+			command: `${toolCommand("knip")} --config tooling/knip.ts && ${toolCommand("knip")} --config tooling/knip.ts --strict`,
 			...dependsOn,
 			cache: {
 				env: ["NODE_ENV"],
@@ -246,7 +546,7 @@ function createTasks({ workspace, isCi }) {
 			}
 		},
 		"typecheck-node": {
-			command: "tsc --project tsconfig.node.json",
+			command: `${toolCommand("tsc")} --project tsconfig.node.json`,
 			...dependsOn,
 			cache: {
 				input: [
@@ -277,12 +577,35 @@ function createTasks({ workspace, isCi }) {
 function isPathPrefix(baseURL) {
 	return typeof baseURL === "string" && baseURL.startsWith("/") && baseURL.length > 1 && !baseURL.endsWith("/");
 }
-function validateOptions(options) {
+const SERVER_OPTIONS = [
+	"middleware",
+	"serverSetup",
+	"securityHeaders",
+	"publicAssets",
+	"staticPaths",
+	"routeRules",
+	"publication",
+	"seo"
+];
+function validateServerOptions(options) {
+	if ("publication" in options) throw new Error("publication was replaced by seo.markdown, seo.llms and seo.llmsFull");
+	if (typeof options.seo === "object") validatePublicationFeatures(options.seo);
 	const asset = (options.publicAssets ?? []).find(({ baseURL }) => !isPathPrefix(baseURL));
 	if (asset) throw new Error(`defineSolidApp: the publicAssets entry for ${asset.dir} needs a baseURL such as /images, without a trailing slash.`);
 	const staticPath = (options.staticPaths ?? []).find((pattern) => !pattern.startsWith("/"));
 	if (staticPath !== void 0) throw new Error(`defineSolidApp: the static path ${staticPath} must start with a slash.`);
 }
+function validateClientOptions(options) {
+	const serverOption = [...SERVER_OPTIONS.filter((key) => key in options), ..."middleware" in (options.e2e ?? {}) ? ["e2e.middleware"] : []].at(0);
+	if (serverOption !== void 0) throw new Error(`defineSolidApp: ${serverOption} needs SSR; remove it or remove ssr: false.`);
+}
+function validateOptions(options) {
+	if (options.ssr === false) {
+		validateClientOptions(options);
+		return;
+	}
+	validateServerOptions(options);
+}
 function loadTestEnvFile(root) {
 	try {
 		loadEnvFile(path.join(root, ".env.test"));
@@ -304,7 +627,8 @@ function defineSolidApp(options) {
 			run: { tasks: {
 				...createTasks({
 					workspace: options.workspace,
-					isCi: Boolean(env.CI)
+					isCi: Boolean(env.CI),
+					hasI18n: hasI18n(root)
 				}),
 				...options.tasks
 			} },
@@ -329,7 +653,10 @@ function defineSolidApp(options) {
 			fmt,
 			lint,
 			test: solidTest({
+				...options.test,
 				root,
+				language: options.language,
+				seo: options.ssr === false ? void 0 : options.seo,
 				plugins: () => testPlugins({
 					options,
 					mode