@evertondgn/solid-tooling 0.4.0 → 0.6.0

package/dist/vitest-BjLr7iLf.mjs

@@ -0,0 +1,362 @@
+import { c as MAX_HTML_BYTES, i as LLMS_MAX_BYTES, l as MAX_MARKDOWN_BYTES, n as LLMS_FULL_MAX_BYTES, s as MARKDOWN_TIMEOUT_MS } from "./protocol-DSNNUYja.mjs";
+import { t as TEST_LOCALE } from "./test-locale--tuH0Np5.mjs";
+import path from "node:path";
+import { env } from "node:process";
+import { fileURLToPath } from "node:url";
+import { readFile, realpath } from "node:fs/promises";
+import { loadEnv } from "vite-plus";
+import { existsSync, readFileSync } from "node:fs";
+import * as v from "valibot";
+import { playwright } from "vite-plus/test/browser-playwright";
+// src/has-i18n.ts
+const I18N_SETTINGS = "project.inlang/settings.json";
+function hasI18n(root) {
+	return existsSync(path.join(root, I18N_SETTINGS));
+}
+// src/publication/options.ts
+const BudgetSchema = v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(Number.MAX_SAFE_INTEGER));
+const TimeoutSchema = v.pipe(BudgetSchema, v.maxValue(2147483647));
+const MarkdownSchema = v.strictObject({
+	static: v.optional(v.boolean(), false),
+	maxInputBytes: v.optional(BudgetSchema, MAX_HTML_BYTES),
+	maxOutputBytes: v.optional(BudgetSchema, MAX_MARKDOWN_BYTES),
+	timeoutMs: v.optional(TimeoutSchema, MARKDOWN_TIMEOUT_MS)
+});
+const LlmsSchema = v.strictObject({ maxBytes: v.optional(BudgetSchema, LLMS_MAX_BYTES) });
+const LlmsFullSchema = v.strictObject({ maxBytes: v.optional(BudgetSchema, LLMS_FULL_MAX_BYTES) });
+const SitemapSchema = v.union([v.boolean(), v.strictObject({ static: v.literal(true) })]);
+function validatePublicationFeatures(options) {
+	if (typeof options.llmsFull === "object" && (typeof options.llms !== "object" || typeof options.markdown !== "object" || options.markdown.static !== true)) throw new Error("seo.llmsFull requires seo.llms and seo.markdown.static");
+}
+// src/locale-module.ts
+const MODULE_ID = "virtual:solid-app/locale";
+const RESOLVED_ID = "\0solid-app:locale";
+function localeRequestSource({ root }) {
+	if (hasI18n(root)) return `export { shouldRedirect, extractLocaleFromRequest, cookieName, cookieMaxAge, cookieDomain, cookieSameSite, cookieSecure } from ${JSON.stringify(path.join(root, "paraglide/runtime.js"))}; export { paraglideMiddleware } from ${JSON.stringify(path.join(root, "paraglide/server.js"))}`;
+	return `const missing = () => { throw new Error('Locale requests require project.inlang/settings.json') }; export { missing as shouldRedirect, missing as extractLocaleFromRequest, missing as paraglideMiddleware }; export const cookieName = '', cookieMaxAge = 0, cookieDomain = '', cookieSameSite = 'lax', cookieSecure = false`;
+}
+function localeSource({ root, language = "en" }) {
+	if (hasI18n(root)) return `export { locales, baseLocale, getLocale, setLocale, extractLocaleFromUrl, localizeHref, deLocalizeUrl } from ${JSON.stringify(path.join(root, "paraglide/runtime.js"))}`;
+	return `export const baseLocale = ${JSON.stringify(language)}
+export const locales = [baseLocale]
+export const getLocale = () => baseLocale
+export const setLocale = () => undefined
+export const extractLocaleFromUrl = () => undefined
+export const localizeHref = href => href
+export const deLocalizeUrl = url => url instanceof URL ? url : new URL(typeof url === 'string' ? url : url.href)
+`;
+}
+function localeModule(options) {
+	return {
+		name: "solid-app:locale",
+		resolveId: (id) => {
+			if (id === "virtual:solid-app/locale-context") return "\0solid-app:locale-context";
+			if (id === "virtual:solid-app/request-middleware") return "\0solid-app:request-middleware";
+			if (id === "virtual:solid-app/locale-request") return "\0solid-app:locale-request";
+			return id === MODULE_ID ? RESOLVED_ID : void 0;
+		},
+		load: (id) => {
+			if (id === "\0solid-app:locale-context") {
+				if (!hasI18n(options.root)) return `export const requestLocale = () => ${JSON.stringify(options.language ?? "en")}; export const withLocaleContext = ({run}) => Promise.resolve().then(run)`;
+				return `import { extractLocaleFromRequest } from ${JSON.stringify(path.join(options.root, "paraglide/runtime.js"))}; import { paraglideMiddleware } from ${JSON.stringify(path.join(options.root, "paraglide/server.js"))}; export const requestLocale = extractLocaleFromRequest; export const withLocaleContext = ({url, run}) => paraglideMiddleware(new Request(url), run)`;
+			}
+			if (id === "\0solid-app:request-middleware") return hasI18n(options.root) ? "export { createLocalizeRequest as createRequestLocale } from '@evertondgn/solid-runtime/middleware/localize-request'" : "export const createRequestLocale = () => ({ next }) => next()";
+			if (id === "\0solid-app:locale-request") return localeRequestSource(options);
+			return id === RESOLVED_ID ? localeSource(options) : void 0;
+		}
+	};
+}
+// src/seo-module.ts
+const LineSchema = v.pipe(v.string(), v.nonEmpty(), v.regex(/^[^\r\n]+$/u));
+const GroupSchema = v.strictObject({
+	userAgents: v.array(LineSchema),
+	allow: v.optional(v.array(LineSchema)),
+	disallow: v.optional(v.array(LineSchema))
+});
+const RobotsSchema = v.strictObject({
+	groups: v.optional(v.array(GroupSchema), []),
+	sitemapPaths: v.optional(v.array(LineSchema), []),
+	cacheControl: v.optional(LineSchema)
+});
+const RobotsOptionSchema = v.union([v.literal(false), RobotsSchema]);
+const DisabledSchema = v.literal(false);
+const MarkdownOptionSchema = v.union([DisabledSchema, MarkdownSchema]);
+const LlmsOptionSchema = v.union([DisabledSchema, LlmsSchema]);
+const LlmsFullOptionSchema = v.union([DisabledSchema, LlmsFullSchema]);
+const SeoSchema = v.strictObject({
+	originEnv: v.optional(LineSchema, "VITE_SITE_URL"),
+	robots: v.optional(RobotsOptionSchema),
+	sitemap: v.optional(SitemapSchema),
+	markdown: v.optional(MarkdownOptionSchema),
+	llms: v.optional(LlmsOptionSchema),
+	llmsFull: v.optional(LlmsFullOptionSchema)
+});
+function readOrigin({ root, mode, key }) {
+	const value = loadEnv(mode, root, key)[key];
+	if (!value) throw new Error(`Missing site origin: ${key}`);
+	let origin;
+	try {
+		origin = new URL(value);
+	} catch {
+		throw new Error(`${key} must be an HTTP(S) origin without a path, query, fragment or credentials`);
+	}
+	if (!["http:", "https:"].includes(origin.protocol) || origin.pathname !== "/" || origin.search || origin.hash || origin.username || origin.password) throw new Error(`${key} must be an HTTP(S) origin without a path, query, fragment or credentials`);
+	return origin.origin;
+}
+function seoModule({ root, mode, seo }) {
+	const config = v.parse(SeoSchema, seo === false ? {} : seo ?? {});
+	validatePublicationFeatures(config);
+	const origin = () => readOrigin({
+		root,
+		mode,
+		key: config.originEnv
+	});
+	return {
+		name: "solid-app:seo",
+		configResolved() {
+			if (seo !== false && seo !== void 0) origin();
+		},
+		resolveId: (id) => [
+			"virtual:solid-app/seo-origin",
+			"virtual:solid-app/seo-robots",
+			"virtual:solid-app/seo-markdown",
+			"virtual:solid-app/seo-llms"
+		].includes(id) ? `\0${id}` : void 0,
+		load: (id) => {
+			if (id === "\0virtual:solid-app/seo-markdown") {
+				if (typeof config.markdown !== "object") throw new TypeError("Markdown requires seo.markdown");
+				return `export const markdown = ${JSON.stringify({
+					...config.markdown,
+					hasLlms: Boolean(config.llms)
+				})}`;
+			}
+			if (id === "\0virtual:solid-app/seo-llms") {
+				if (typeof config.llms !== "object") throw new TypeError("llms requires seo.llms");
+				return `export const llms = ${JSON.stringify({
+					...config.llms,
+					hasMarkdown: Boolean(config.markdown),
+					hasLlmsFull: Boolean(config.llmsFull)
+				})}`;
+			}
+			if (id === "\0virtual:solid-app/seo-origin") return `export const origin = ${JSON.stringify(origin())}`;
+			if (id !== "\0virtual:solid-app/seo-robots") return null;
+			if (config.robots === false || config.robots === void 0) throw new Error("The robots route requires defineSolidApp({ seo: { robots: {} } })");
+			const { groups, sitemapPaths, cacheControl } = config.robots;
+			const siteOrigin = origin();
+			return `export const robots = ${JSON.stringify({
+				groups,
+				sitemaps: sitemapPaths.map((path) => new URL(path, siteOrigin).href),
+				cacheControl
+			})}`;
+		}
+	};
+}
+// src/vitest/dom-url.ts
+const ORIGIN = "http://localhost";
+function readBaseLocale(root) {
+	let settings;
+	try {
+		settings = JSON.parse(readFileSync(path.join(root, I18N_SETTINGS), "utf8"));
+	} catch (error) {
+		throw new Error(`solidTest: cannot read the base locale from ${I18N_SETTINGS}; fix the file or pass domUrl.`, { cause: error });
+	}
+	const baseLocale = settings !== null && typeof settings === "object" && "baseLocale" in settings ? settings.baseLocale : void 0;
+	if (typeof baseLocale !== "string" || baseLocale === "") throw new Error(`solidTest: ${I18N_SETTINGS} must declare baseLocale as a string; fix the file or pass domUrl.`);
+	return baseLocale;
+}
+function defaultDomUrl(root) {
+	return hasI18n(root) ? `${ORIGIN}/${readBaseLocale(root)}` : `${ORIGIN}/`;
+}
+// src/vitest/source-packages.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+async function findPackage({ root, name }) {
+	for (let dir = root;; dir = path.dirname(dir)) {
+		const packageDir = path.join(dir, "node_modules", name);
+		try {
+			const manifest = JSON.parse(await readFile(path.join(packageDir, "package.json"), "utf8"));
+			return isRecord(manifest) && isRecord(manifest.exports) ? {
+				dir: packageDir,
+				exports: manifest.exports
+			} : void 0;
+		} catch {
+			if (path.dirname(dir) === dir) return void 0;
+		}
+	}
+}
+function sourcePackages({ root, packages }) {
+	const installed = /* @__PURE__ */ new Map();
+	async function resolveSource({ name, source }) {
+		let lookup = installed.get(name);
+		if (!lookup) {
+			lookup = findPackage({
+				root,
+				name
+			});
+			installed.set(name, lookup);
+		}
+		const found = await lookup;
+		const entry = found?.exports[`.${source.slice(name.length)}`];
+		if (!found || !isRecord(entry) || typeof entry.solid !== "string") return null;
+		return realpath(path.join(found.dir, entry.solid));
+	}
+	return {
+		name: "solid-tooling:source-packages",
+		enforce: "pre",
+		resolveId(source) {
+			const name = packages.find((candidate) => source === candidate || source.startsWith(`${candidate}/`));
+			return name === void 0 ? null : resolveSource({
+				name,
+				source
+			});
+		}
+	};
+}
+// src/vitest/index.ts
+const CI_WORKERS = 2;
+const SOURCE_PACKAGES = ["@evertondgn/solid-runtime"];
+const STUB_PREFIX = "\0solid-tooling-stub:";
+const NODE_STUBS = /* @__PURE__ */ new Map([
+	["server-only", "export default undefined"],
+	["virtual:file-routes", "export const pageRoutes = []\nexport default []"],
+	["virtual:solid-server-function-handler", "export const endpoint = '/_server'"]
+]);
+const TEST_ENV_KEYS = [
+	"BASE_URL_TEST",
+	"HOST",
+	"PORT"
+];
+function packageFile(name) {
+	return fileURLToPath(new URL(name, import.meta.url));
+}
+function nodeStubs(source) {
+	const stubs = new Map([...NODE_STUBS, ["virtual:solid-app/locale", source]]);
+	return {
+		name: "solid-tooling:node-stubs",
+		enforce: "pre",
+		resolveId: (id) => stubs.has(id) ? `${STUB_PREFIX}${id}` : void 0,
+		load: (id) => id.startsWith(STUB_PREFIX) ? stubs.get(id.slice(20)) : void 0
+	};
+}
+function readTestEnv() {
+	return Object.fromEntries(TEST_ENV_KEYS.flatMap((key) => {
+		const value = env[key];
+		return value === void 0 ? [] : [[key, value]];
+	}));
+}
+function solidTest({ root, language, seo, plugins, sourcePackages: packages = SOURCE_PACKAGES, domUrl = defaultDomUrl(root), locale = TEST_LOCALE }) {
+	const hasParaglide = hasI18n(root);
+	return {
+		pool: "threads",
+		maxWorkers: env.CI ? CI_WORKERS : void 0,
+		css: false,
+		globals: true,
+		restoreMocks: true,
+		unstubGlobals: true,
+		unstubEnvs: true,
+		expect: {
+			requireAssertions: true,
+			poll: { interval: 10 }
+		},
+		env: readTestEnv(),
+		coverage: {
+			provider: "v8",
+			reporter: ["text", "html"],
+			thresholds: {
+				lines: 80,
+				functions: 80,
+				branches: 75,
+				statements: 80
+			},
+			include: ["src/**/*.{ts,tsx}"],
+			exclude: [
+				"src/**/*.d.ts",
+				"src/**/{constants,types,@types}/**",
+				"src/**/{constants,types}.{ts,tsx}",
+				"src/**/__tests__/**",
+				"src/tests/**",
+				"src/App.tsx",
+				"src/Document.tsx",
+				"src/entry-server.tsx",
+				"src/entry-client.tsx",
+				"src/router.ts"
+			]
+		},
+		reporters: env.GITHUB_ACTIONS ? ["default", "github-actions"] : ["verbose"],
+		projects: [
+			{
+				plugins: [
+					nodeStubs(localeSource({
+						root,
+						language
+					})),
+					localeModule({
+						root,
+						language
+					}),
+					seoModule({
+						root,
+						mode: "test",
+						seo
+					}),
+					sourcePackages({
+						root,
+						packages
+					})
+				],
+				test: {
+					name: {
+						label: "node",
+						color: "cyan"
+					},
+					environment: "node",
+					include: ["src/**/*.node.test.{ts,tsx}"]
+				}
+			},
+			{
+				plugins: plugins(),
+				test: {
+					name: {
+						label: "dom",
+						color: "magenta"
+					},
+					environment: "happy-dom",
+					setupFiles: [fileURLToPath(import.meta.resolve("@testing-library/jest-dom/vitest"))],
+					environmentOptions: { happyDOM: { url: domUrl } },
+					include: ["src/**/*.dom.test.{ts,tsx}"]
+				}
+			},
+			{
+				plugins: plugins(),
+				...hasParaglide && { resolve: { alias: [{
+					find: /^@paraglide\//u,
+					replacement: `${path.join(root, "paraglide")}/`
+				}] } },
+				test: {
+					css: true,
+					name: {
+						label: "browser",
+						color: "yellow"
+					},
+					setupFiles: hasParaglide ? [packageFile("vitest-setup/browser.mjs")] : [],
+					include: ["src/**/*.browser.test.{ts,tsx}"],
+					browser: {
+						enabled: true,
+						headless: true,
+						trace: {
+							mode: "retain-on-failure",
+							tracesDir: path.join(root, "test-results/browser-traces")
+						},
+						provider: playwright({
+							contextOptions: { locale },
+							launchOptions: env.CI ? { channel: "chrome" } : {}
+						}),
+						instances: [{ browser: "chromium" }]
+					}
+				}
+			}
+		]
+	};
+}
+export { I18N_SETTINGS as a, validatePublicationFeatures as i, seoModule as n, hasI18n as o, localeModule as r, solidTest as t };

package/dist/vitest.d.mts

@@ -1,7 +1,3 @@
-import { TestUserConfig, ViteUserConfig } from "vite-plus";
-type SolidTestOptions = {
-  root: string;
-  plugins: () => ViteUserConfig['plugins'];
-};
-export declare function solidTest({ root, plugins }: SolidTestOptions): TestUserConfig;
-export {};
+import { t as SolidTestOptions } from "./types-DHu2Z_ot.mjs";
+import { TestUserConfig } from "vite-plus";
+export declare function solidTest({ root, language, seo, plugins, sourcePackages: packages, domUrl, locale }: SolidTestOptions): TestUserConfig;

package/dist/vitest.mjs

@@ -1,129 +1 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { env } from "node:process";
-import { playwright } from "vite-plus/test/browser-playwright";
-// src/vitest/index.ts
-const CI_WORKERS = 2;
-const STUB_PREFIX = "\0solid-tooling-stub:";
-const NODE_STUBS = /* @__PURE__ */ new Map([
-	["server-only", "export default undefined"],
-	["virtual:file-routes", "export const pageRoutes = []\nexport default []"],
-	["virtual:solid-server-function-handler", "export const endpoint = '/_server'"]
-]);
-const TEST_ENV_KEYS = [
-	"BASE_URL_TEST",
-	"HOST",
-	"PORT"
-];
-function packageFile(name) {
-	return fileURLToPath(new URL(name, import.meta.url));
-}
-function nodeStubs() {
-	return {
-		name: "solid-tooling:node-stubs",
-		enforce: "pre",
-		resolveId: (id) => NODE_STUBS.has(id) ? `${STUB_PREFIX}${id}` : void 0,
-		load: (id) => id.startsWith(STUB_PREFIX) ? NODE_STUBS.get(id.slice(20)) : void 0
-	};
-}
-function readTestEnv() {
-	return Object.fromEntries(TEST_ENV_KEYS.flatMap((key) => {
-		const value = env[key];
-		return value === void 0 ? [] : [[key, value]];
-	}));
-}
-function solidTest({ root, plugins }) {
-	return {
-		pool: "threads",
-		maxWorkers: env.CI ? CI_WORKERS : void 0,
-		css: false,
-		globals: true,
-		restoreMocks: true,
-		unstubGlobals: true,
-		unstubEnvs: true,
-		expect: {
-			requireAssertions: true,
-			poll: { interval: 10 }
-		},
-		env: readTestEnv(),
-		coverage: {
-			provider: "v8",
-			reporter: ["text", "html"],
-			thresholds: {
-				lines: 80,
-				functions: 80,
-				branches: 75,
-				statements: 80
-			},
-			include: ["src/**/*.{ts,tsx}"],
-			exclude: [
-				"src/**/*.d.ts",
-				"src/**/{constants,types,@types}/**",
-				"src/**/{constants,types}.{ts,tsx}",
-				"src/**/__tests__/**",
-				"src/tests/**",
-				"src/App.tsx",
-				"src/Document.tsx",
-				"src/entry-server.tsx",
-				"src/entry-client.tsx",
-				"src/router.ts"
-			]
-		},
-		reporters: env.GITHUB_ACTIONS ? ["default", "github-actions"] : ["verbose"],
-		projects: [
-			{
-				plugins: [nodeStubs()],
-				test: {
-					name: {
-						label: "node",
-						color: "cyan"
-					},
-					environment: "node",
-					include: ["src/**/*.node.test.{ts,tsx}"]
-				}
-			},
-			{
-				plugins: plugins(),
-				test: {
-					name: {
-						label: "dom",
-						color: "magenta"
-					},
-					environment: "happy-dom",
-					environmentOptions: { happyDOM: { url: "http://localhost/en" } },
-					include: ["src/**/*.dom.test.{ts,tsx}"]
-				}
-			},
-			{
-				plugins: plugins(),
-				resolve: { alias: [{
-					find: /^@paraglide\//u,
-					replacement: `${path.join(root, "paraglide")}/`
-				}] },
-				test: {
-					css: true,
-					name: {
-						label: "browser",
-						color: "yellow"
-					},
-					setupFiles: [packageFile("vitest-setup/browser.mjs")],
-					include: ["src/**/*.browser.test.{ts,tsx}"],
-					browser: {
-						enabled: true,
-						headless: true,
-						trace: {
-							mode: "retain-on-failure",
-							tracesDir: path.join(root, "test-results/browser-traces")
-						},
-						provider: playwright({
-							contextOptions: { locale: "en-US" },
-							launchOptions: env.CI ? { channel: "chrome" } : {}
-						}),
-						instances: [{ browser: "chromium" }]
-					}
-				}
-			}
-		]
-	};
-}
-export { solidTest };
+export { t as solidTest } from "./vitest-BjLr7iLf.mjs";

package/lefthook.yml

@@ -0,0 +1,57 @@
+# Git hooks shared by the applications. The application extends this file from
+# its .lefthook.yml and defines the package.json scripts the jobs call.
+
+commit-msg:
+  jobs:
+    - name: commitlint
+      run:
+        vp exec node node_modules/@evertondgn/solid-tooling/dist/cli.mjs
+        commitlint --edit {1}
+
+pre-commit:
+  skip:
+    - merge
+    - rebase
+  jobs:
+    - name: check
+      glob: '*.{ts,tsx,mts,cts,js,mjs,cjs,json,css,md,yml,yaml,toml,html}'
+      run: vp run check:fix {staged_files}
+      stage_fixed: true
+
+    - name: secret-scan
+      run: |
+        if ! command -v kingfisher > /dev/null 2>&1; then
+          echo "kingfisher is not installed; the secret scan was skipped."
+          echo "With Homebrew (macOS/Linux): brew install kingfisher"
+          echo "Without Homebrew (Linux/Windows): download the binary for your system and add it to PATH: https://github.com/mongodb/kingfisher/releases"
+          exit 0
+        fi
+        vp run scan:secrets --staged
+
+pre-push:
+  # Without piped, Lefthook runs the next jobs after a failure.
+  piped: true
+  jobs:
+    # check:ci restores the Paraglide output from the Vite Task cache. Ending it
+    # before the tests avoids concurrent restores.
+    - name: check-ci
+      run: vp run check:ci
+
+    - name: typecheck-node
+      run: vp run typecheck:node
+
+    # Vitest has short windows (per-test timeout and waitFor). Running it
+    # without sharing the CPU with the tooling tests avoids timeouts that are
+    # not logic failures.
+    - name: test
+      run: vp run test:ci
+
+    - name: tooling-and-dead-code
+      group:
+        parallel: true
+        jobs:
+          - name: tooling
+            run: vp run test:tooling
+
+          - name: dead-code
+            run: vp run dead-code

package/node-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="node" />