@evertondgn/solid-tooling 0.5.0 → 0.6.0

package/dist/{lint-UTfyg7AR.mjs → lint-ehdtTKfw.mjs}

@@ -1,54 +1,20 @@
-import { n as RENDER_INTEGRITY_MODULE, t as RELATIVE_IMPORT_RESTRICTION } from "./constants-Jqvtbvxu.mjs";
+import { t as RELATIVE_IMPORT_RESTRICTION } from "./constants-BZJm7ouk.mjs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { cwd } from "node:process";
 // src/backendPolicy/index.ts
-const NETWORK = [
+const RESTRICTED_GLOBALS = [...[
 	"fetch",
 	"XMLHttpRequest",
 	"WebSocket",
 	"EventSource"
-];
-const RESTRICTED_GLOBALS = [...NETWORK, "console"];
+], "console"];
 const GLOBALS = [
 	"globalThis",
 	"window",
 	"self",
 	"global"
 ];
-const SAFE_ERRORS = {
-	name: "@solidjs/web",
-	importNames: ["markSafeError", "SAFE_ERROR"],
-	message: "Use createPublicError; only publicErrors may mark an error as public."
-};
-const SERVER_ERROR_HOOK = {
-	name: "@solidjs/web",
-	importNames: ["configureServerErrors"],
-	message: "Only src/infra/server/configureServerErrors/index.ts may import this: server error handling is configured in that module."
-};
-const SERVER_CONFIG = ["@solidjs/web/server-functions", "@solidjs/web/server-functions/server"].map((name) => ({
-	name,
-	message: "Only src/infra/server/configureServerErrors/index.ts may import this: server error handling is configured in that module."
-}));
-const RENDER_OBSERVER = {
-	regex: RENDER_INTEGRITY_MODULE,
-	importNames: ["observeRenderFailures"],
-	message: "Only configureServerErrors may declare that render failures are observed."
-};
-const TRANSPORTS = [
-	"http",
-	"https",
-	"http2",
-	"net",
-	"tls",
-	"undici"
-].flatMap((name) => [name, `node:${name}`]).map((name) => ({
-	name,
-	message: "Node transports cannot be imported in src/. Use requestJson for HTTP, or an adapter in src/infra/server/ wrapped in protectServerOperation."
-}));
-function imports({ paths, patterns = [] }) {
-	return { "eslint/no-restricted-imports": ["error", {
-		paths,
-		patterns: [RELATIVE_IMPORT_RESTRICTION, ...patterns]
-	}] };
-}
 function globals({ names, properties = names }) {
 	return {
 		"eslint/no-restricted-globals": ["error", {
@@ -71,45 +37,20 @@ const backendPolicy = [
 			"backend/static-render-integrity-imports": "error",
 			"eslint/no-console": ["error", { allow: [] }],
 			...globals({ names: RESTRICTED_GLOBALS }),
-			...imports({
-				paths: [
-					SAFE_ERRORS,
-					SERVER_ERROR_HOOK,
-					...SERVER_CONFIG,
-					...TRANSPORTS
-				],
-				patterns: [RENDER_OBSERVER]
-			})
-		}
-	},
-	{
-		files: ["src/infra/server/logServerFailure/index.ts"],
-		rules: {
-			...globals({
-				names: NETWORK,
-				properties: RESTRICTED_GLOBALS
-			}),
-			"eslint/no-console": ["error", { allow: ["error"] }]
+			"eslint/no-restricted-imports": "off",
+			"backend/restricted-imports": "error"
 		}
 	},
 	{
 		files: ["src/infra/server/requestJson/index.ts"],
 		rules: globals({ names: RESTRICTED_GLOBALS.filter((name) => name !== "fetch") })
 	},
-	{
-		files: ["src/infra/server/publicErrors/index.ts"],
-		rules: imports({
-			paths: [
-				SERVER_ERROR_HOOK,
-				...SERVER_CONFIG,
-				...TRANSPORTS
-			],
-			patterns: [RENDER_OBSERVER]
-		})
-	},
 	{
 		files: ["src/infra/server/configureServerErrors/index.ts"],
-		rules: imports({ paths: [SAFE_ERRORS, ...TRANSPORTS] })
+		rules: {
+			"backend/restricted-imports": ["error", { allowServerConfiguration: true }],
+			"backend/no-setup-exports": "error"
+		}
 	},
 	{
 		files: [
@@ -123,7 +64,7 @@ const backendPolicy = [
 			"eslint/no-console": "off",
 			"eslint/no-restricted-globals": "off",
 			"eslint/no-restricted-properties": "off",
-			...imports({ paths: [] })
+			"backend/restricted-imports": ["error", { testFile: true }]
 		}
 	}
 ];
@@ -205,7 +146,6 @@ const environmentRules = {
 	"oxc/number-arg-out-of-range": "error",
 	"oxc/only-used-in-recursion": "error",
 	"oxc/uninvoked-array-callback": "error",
-	"paraglide/no-dynamic-message-access": ["error", { messageModules: ["@paraglide/messages.js", "@paraglide/messages/_index.js"] }],
 	"promise/always-return": "error",
 	"promise/avoid-new": "error",
 	"promise/catch-or-return": ["error", {
@@ -807,6 +747,21 @@ const TEST_FILES = [
 	"**/*.test-d.{ts,tsx}",
 	"**/tests/**"
 ];
+const PARAGLIDE_PLUGIN = "@inlang/paraglide-js/eslint";
+function resolvesFromApplication(specifier) {
+	try {
+		createRequire(path.join(cwd(), "package.json")).resolve(specifier);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const hasParaglide = resolvesFromApplication(PARAGLIDE_PLUGIN);
+const paraglidePlugins = hasParaglide ? [{
+	name: "paraglide",
+	specifier: PARAGLIDE_PLUGIN
+}] : [];
+const paraglideRules = hasParaglide ? { "paraglide/no-dynamic-message-access": ["error", { messageModules: ["@paraglide/messages.js", "@paraglide/messages/_index.js"] }] } : {};
 const lint = {
 	ignorePatterns: [
 		"public/**",
@@ -837,10 +792,7 @@ const lint = {
 			name: "architecture",
 			specifier: "@evertondgn/solid-tooling/architecture-plugin"
 		},
-		{
-			name: "paraglide",
-			specifier: "@inlang/paraglide-js/eslint"
-		},
+		...paraglidePlugins,
 		{
 			name: "solid",
 			specifier: "@evertondgn/solid-tooling/solid-plugin"
@@ -867,8 +819,7 @@ const lint = {
 				"src/**/*.node.test.{ts,tsx}",
 				"src/tests/pages/**/*.e2e.test.ts",
 				"src/tests/helpers/readSiteOrigin/index.ts",
-				"src/tests/fixtures/e2e/routes/publication-probe/metrics.ts",
-				"src/infra/server/publicationScope/index.ts"
+				"src/tests/fixtures/e2e/routes/publication-probe/metrics.ts"
 			],
 			rules: { "import/no-nodejs-modules": "off" }
 		},
@@ -885,7 +836,6 @@ const lint = {
 				"src/**/*.test.{ts,tsx}",
 				"src/tests/**/*.{ts,tsx}",
 				"tooling/**/__tests__/**/*.ts",
-				"tooling/i18n/i18nPlugin/index.ts",
 				"vite.config.ts"
 			],
 			rules: { "eslint/max-params": "off" }
@@ -899,11 +849,7 @@ const lint = {
 			rules: { "typescript/explicit-module-boundary-types": "off" }
 		},
 		{
-			files: [
-				"src/@types/solid.d.ts",
-				"src/@types/env.d.ts",
-				"src/@types/router.d.ts"
-			],
+			files: ["src/@types/solid.d.ts", "src/@types/env.d.ts"],
 			rules: {
 				"import/no-unassigned-import": "off",
 				"typescript/consistent-type-definitions": "off"
@@ -973,7 +919,8 @@ const lint = {
 		...importRules,
 		...typescriptRules,
 		...unicornRules,
-		...testRules
+		...testRules,
+		...paraglideRules
 	},
 	settings: {
 		"jsx-a11y": { attributes: { for: ["htmlFor", "for"] } },

package/dist/lint.mjs

@@ -1 +1 @@
-export { t as lint } from "./lint-UTfyg7AR.mjs";
+export { t as lint } from "./lint-ehdtTKfw.mjs";

package/dist/playwright-teardown.mjs

@@ -1,5 +1,5 @@
-import { readFile } from "node:fs/promises";
 import { env } from "node:process";
+import { readFile } from "node:fs/promises";
 import { stripVTControlCharacters } from "node:util";
 // src/playwright/teardown.ts
 const PRIVATE_MARKER = /PRIVATE_[A-Z0-9_]+/u;

package/dist/playwright.d.mts

@@ -13,6 +13,7 @@ type PlaywrightOptions = {
   testDir?: string;
   fixtureServers?: FixtureServer[];
   suites?: SerialSuites;
+  locale?: string;
 };
-export declare function definePlaywrightConfig({ root, testDir, fixtureServers, suites }: PlaywrightOptions): PlaywrightTestConfig;
+export declare function definePlaywrightConfig({ root, testDir, fixtureServers, suites, locale }: PlaywrightOptions): PlaywrightTestConfig;
 export {};

package/dist/playwright.mjs

@@ -1,6 +1,7 @@
+import { t as TEST_LOCALE } from "./test-locale--tuH0Np5.mjs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { env, loadEnvFile } from "node:process";
+import { fileURLToPath } from "node:url";
 import { loadEnv } from "vite-plus";
 import { defineConfig as defineConfig$1, devices } from "@playwright/test";
 // src/playwright/index.ts
@@ -108,7 +109,7 @@ function buildServers({ root, mode, fixtureServers, baseUrl, serverLog }) {
 		}] : []
 	];
 }
-function definePlaywrightConfig({ root, testDir = "src/tests/pages", fixtureServers = [], suites = {} }) {
+function definePlaywrightConfig({ root, testDir = "src/tests/pages", fixtureServers = [], suites = {}, locale = TEST_LOCALE }) {
 	loadEnvFile(path.join(root, ".env.test"));
 	const mode = readRunMode(suites);
 	const buildMode = mode.isProduction ? "production" : "e2e";
@@ -138,7 +139,7 @@ function definePlaywrightConfig({ root, testDir = "src/tests/pages", fixtureServ
 			...devices["Desktop Chrome"],
 			channel: env.CI ? "chrome" : void 0,
 			baseURL: baseUrl,
-			locale: "en-US",
+			locale,
 			screenshot: "only-on-failure",
 			trace: "retain-on-failure"
 		},

package/dist/prepareMessages-BXmY6Ko2.mjs

@@ -0,0 +1,222 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { glob, mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import * as v from "valibot";
+import { randomUUID } from "node:crypto";
+import { checkBundle } from "@inlang/sdk";
+// src/i18n/readCatalogs/constants.ts
+const CATALOGS_MAX_BYTES = 8388608;
+// src/i18n/readCatalogs/index.ts
+const CATALOG_GLOB = "src/**/i18n/*.json";
+const CATALOG_EXCLUDES = ["src/tests/**", "src/**/__tests__/**"];
+const CATALOG_PATH = /^src\/(?:[^/]+\/)*i18n\/[^/]+\.json$/u;
+const EXCLUDED_PATH = /^src\/tests\/|\/__tests__\//u;
+const ParserModuleSchema = v.object({ default: v.custom((value) => value !== null && typeof value === "object" && "importFiles" in value && typeof value.importFiles === "function", "Message format parser unavailable") });
+function claimMessages({ keys, directory, owners }) {
+	for (const key of keys) {
+		const owner = owners.get(key);
+		if (owner) throw new Error(`[i18n] Duplicate message "${key}" in ${directory} and ${owner}`);
+		owners.set(key, directory);
+	}
+}
+function assertBudget({ bytes, maxBytes, file }) {
+	if (bytes <= maxBytes) return;
+	throw new Error(`[i18n] Catalogs exceed the ${maxBytes} byte budget at ${file}. Raise CATALOGS_MAX_BYTES only after measuring the build memory.`);
+}
+const TextSchema = v.string();
+const StringsSchema = v.array(v.string());
+const VariantsSchema = v.pipe(v.record(v.string(), TextSchema), v.minEntries(1));
+const ComplexSchema = v.strictObject({
+	declarations: v.optional(StringsSchema),
+	selectors: v.optional(StringsSchema),
+	match: VariantsSchema
+});
+const MessageSchema = v.union([TextSchema, v.pipe(v.array(ComplexSchema), v.length(1))]);
+const MessageIdSchema = v.pipe(v.string(), v.regex(/^[a-z][a-zA-Z0-9]*_[a-zA-Z0-9_]+$/u));
+const CatalogSchema = v.pipe(v.record(MessageIdSchema, MessageSchema), v.minEntries(1, "Empty catalog"));
+function assertUniqueProperties({ file, source }) {
+	const scopes = [];
+	const tokens = source.match(/"(?:\\.|[^"\\])*"|[{}:[\],]/gu) ?? [];
+	for (const [index, token] of tokens.entries()) if (token === "{") scopes.push(/* @__PURE__ */ new Set());
+	else if (token === "}") scopes.pop();
+	else if (token.startsWith("\"") && tokens[index + 1] === ":") {
+		const key = v.parse(v.string(), JSON.parse(token));
+		const scope = scopes.at(-1);
+		if (scope?.has(key)) throw new Error(`[i18n] ${file}: duplicate key "${key}"`);
+		scope?.add(key);
+	}
+}
+function parseCatalog({ file, source }) {
+	try {
+		const json = JSON.parse(source);
+		assertUniqueProperties({
+			file,
+			source
+		});
+		return v.parse(CatalogSchema, json);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		throw new Error(`[i18n] Invalid catalog ${file}: ${detail}`, { cause: error });
+	}
+}
+async function validateMessages({ parser, directory, catalogs, baseLocale }) {
+	if (!parser.importFiles) throw new Error("Message format parser unavailable");
+	const locales = Object.keys(catalogs);
+	let parsed;
+	try {
+		parsed = await parser.importFiles({
+			files: Object.entries(catalogs).map(([locale, catalog]) => ({
+				locale,
+				content: new TextEncoder().encode(JSON.stringify(catalog))
+			})),
+			settings: {
+				baseLocale,
+				locales,
+				modules: []
+			}
+		});
+	} catch (error) {
+		throw new Error(`[i18n] Invalid message syntax in ${directory}`, { cause: error });
+	}
+	const messagesByBundle = Map.groupBy(parsed.messages, (message) => message.bundleId);
+	const variantsByBundle = Map.groupBy(parsed.variants, (variant) => variant.messageBundleId);
+	for (const bundle of parsed.bundles) {
+		if (!bundle.id) throw new Error(`[i18n] Message without ID in ${directory}`);
+		const messages = (messagesByBundle.get(bundle.id) ?? []).map((message) => ({
+			locale: message.locale,
+			id: message.locale,
+			selectors: message.selectors ?? [],
+			variants: (variantsByBundle.get(bundle.id) ?? []).filter((variant) => variant.messageLocale === message.locale).map((variant, index) => ({
+				id: String(index),
+				matches: variant.matches ?? [],
+				pattern: variant.pattern ?? []
+			}))
+		}));
+		const diagnostics = checkBundle({
+			bundle: {
+				id: bundle.id,
+				declarations: bundle.declarations ?? [],
+				messages
+			},
+			locales,
+			referenceLocale: baseLocale
+		});
+		if (diagnostics.length > 0) throw new Error(diagnostics.map((diagnostic) => `[i18n] ${directory}/${diagnostic.locale}.json: ${diagnostic.checkId}: ${diagnostic.message}`).join("\n"));
+	}
+}
+async function readCatalogs({ root, locales, baseLocale, maxBytes = CATALOGS_MAX_BYTES }) {
+	if (!locales.includes(baseLocale) || new Set(locales).size !== locales.length) throw new Error("[i18n] Invalid locale configuration");
+	const discovered = [];
+	for await (const file of glob(CATALOG_GLOB, {
+		cwd: root,
+		exclude: CATALOG_EXCLUDES
+	})) discovered.push(file);
+	const files = discovered.toSorted();
+	if (files.length === 0) throw new Error("[i18n] No colocated catalogs found");
+	const filesByDirectory = Map.groupBy(files, (file) => path.dirname(file));
+	const catalogs = Object.fromEntries(locales.map((locale) => [locale, {}]));
+	const owners = /* @__PURE__ */ new Map();
+	let totalBytes = 0;
+	const resolveFromApp = createRequire(path.join(root, "package.json"));
+	const loaded = await import(pathToFileURL(resolveFromApp.resolve("@inlang/plugin-message-format")).href);
+	const parserModule = v.parse(ParserModuleSchema, loaded);
+	for (const [directory, entries] of filesByDirectory) {
+		const present = entries.map((file) => path.basename(file, ".json"));
+		const missing = locales.filter((locale) => !present.includes(locale));
+		const extra = present.filter((locale) => !locales.includes(locale));
+		if (missing.length > 0 || extra.length > 0) throw new Error(`[i18n] ${directory}: missing locales [${missing.join(", ")}], unexpected [${extra.join(", ")}]`);
+		const current = {};
+		for (const locale of [baseLocale, ...locales.filter((item) => item !== baseLocale)]) {
+			const file = path.join(directory, `${locale}.json`);
+			const location = path.join(root, file);
+			const { size } = await stat(location);
+			assertBudget({
+				bytes: totalBytes + size,
+				maxBytes,
+				file
+			});
+			const content = await readFile(location);
+			totalBytes += content.byteLength;
+			assertBudget({
+				bytes: totalBytes,
+				maxBytes,
+				file
+			});
+			const catalog = parseCatalog({
+				file,
+				source: content.toString("utf8")
+			});
+			current[locale] = catalog;
+			Object.assign(catalogs[locale] ?? {}, catalog);
+		}
+		await validateMessages({
+			directory,
+			catalogs: current,
+			baseLocale,
+			parser: parserModule.default
+		});
+		claimMessages({
+			keys: Object.keys(current[baseLocale] ?? {}),
+			directory,
+			owners
+		});
+	}
+	return catalogs;
+}
+function isCatalogFile({ root, file }) {
+	const relative = path.relative(root, file).split(path.sep).join("/");
+	return CATALOG_PATH.test(relative) && !EXCLUDED_PATH.test(relative);
+}
+function canContainCatalogs({ root, file }) {
+	const relative = `${path.relative(root, file).split(path.sep).join("/")}/`;
+	return relative.startsWith("src/") && !EXCLUDED_PATH.test(relative);
+}
+// src/i18n/prepareMessages/index.ts
+const SETTINGS_FILE = "project.inlang/settings.json";
+const TEMPORARY_DIRECTORY = ".paraglide";
+const AGGREGATE_DIRECTORY = ".paraglide/messages";
+const JSON_INDENT = 2;
+const LocalesSchema = v.pipe(v.array(v.string()), v.minLength(1));
+const SettingsSchema = v.object({
+	baseLocale: v.string(),
+	locales: LocalesSchema
+});
+function isMissing(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+async function readExisting(file) {
+	try {
+		return await readFile(file, "utf8");
+	} catch (error) {
+		if (isMissing(error)) return void 0;
+		throw error;
+	}
+}
+async function writeIfChanged({ root, file, content }) {
+	if (await readExisting(file) === content) return;
+	const temporary = path.join(root, TEMPORARY_DIRECTORY, `.${path.basename(file)}.${randomUUID()}.tmp`);
+	await writeFile(temporary, content);
+	try {
+		await rename(temporary, file);
+	} catch (error) {
+		await rm(temporary, { force: true });
+		throw error;
+	}
+}
+async function prepareMessages(root = process.cwd()) {
+	const resolved = path.resolve(root);
+	const source = await readFile(path.join(resolved, SETTINGS_FILE), "utf8");
+	const settings = v.parse(SettingsSchema, JSON.parse(source));
+	const catalogs = await readCatalogs({
+		root: resolved,
+		...settings
+	});
+	await mkdir(path.join(resolved, AGGREGATE_DIRECTORY), { recursive: true });
+	for (const locale of settings.locales) await writeIfChanged({
+		root: resolved,
+		file: path.join(resolved, AGGREGATE_DIRECTORY, `${locale}.json`),
+		content: `${JSON.stringify(catalogs[locale] ?? {}, null, JSON_INDENT)}\n`
+	});
+}
+export { canContainCatalogs as n, isCatalogFile as r, prepareMessages as t };

package/dist/project-plugin.mjs

@@ -1,7 +1,7 @@
-import { cssFilename } from "./css-filename.mjs";
+import { t as cssFilename } from "./css-filename-CEHQd2gz.mjs";
 import { n as resolveProjectPath, t as readStaticSpecifier } from "./import-specifier-C7HWhMXB.mjs";
-import { definePlugin, defineRule } from "vite-plus/lint/plugins";
 import path from "node:path";
+import { definePlugin, defineRule } from "vite-plus/lint/plugins";
 // src/noExportList/index.ts
 const noExportList = defineRule({
 	meta: {

package/dist/protocol-DSNNUYja.mjs

@@ -0,0 +1,18 @@
+// ../solid-runtime/src/infra/server/publication/protocol.js
+const PUBLICATION_PHASE_ENV = "PUBLICATION_BUILD_PHASE";
+const PUBLICATION_PRERENDER_PHASE = "prerender";
+const PUBLICATION_ARTIFACT_DIR = "publication";
+const SITEMAP_MANIFEST_FILE = "sitemap-manifest.json";
+const SITEMAP_IDENTITIES_FILE = "sitemap-identities.json";
+const SITEMAP_MANIFEST_MAX_BYTES = 1048576;
+const SITEMAP_IDENTITIES_MAX_BYTES = 33554432;
+const MARKDOWN_PRERENDER_PATH = "/_markdown/static.json";
+const MAX_MARKDOWN_BYTES = 2097152;
+const MAX_HTML_BYTES = 2097152;
+const MARKDOWN_TIMEOUT_MS = 15e3;
+const LLMS_PATH = "/llms.txt";
+const LLMS_FULL_PATH = "/llms-full.txt";
+const LLMS_DESCRIBEDBY_LINK = "</llms.txt>; rel=\"describedby\"";
+const LLMS_MAX_BYTES = 1048576;
+const LLMS_FULL_MAX_BYTES = 10485760;
+export { LLMS_PATH as a, MAX_HTML_BYTES as c, PUBLICATION_PHASE_ENV as d, PUBLICATION_PRERENDER_PHASE as f, SITEMAP_MANIFEST_MAX_BYTES as g, SITEMAP_MANIFEST_FILE as h, LLMS_MAX_BYTES as i, MAX_MARKDOWN_BYTES as l, SITEMAP_IDENTITIES_MAX_BYTES as m, LLMS_FULL_MAX_BYTES as n, MARKDOWN_PRERENDER_PATH as o, SITEMAP_IDENTITIES_FILE as p, LLMS_FULL_PATH as r, MARKDOWN_TIMEOUT_MS as s, LLMS_DESCRIBEDBY_LINK as t, PUBLICATION_ARTIFACT_DIR as u };

package/dist/publication/read-llms-index.d.mts

@@ -0,0 +1,12 @@
+type LlmsLink = {
+  label: string;
+  href: string;
+  summary: string;
+};
+type LlmsIndex = {
+  title: string;
+  description: string;
+  links: LlmsLink[];
+};
+export declare function readLlmsIndex(text: string): LlmsIndex;
+export {};

package/dist/publication/read-llms-index.mjs

@@ -0,0 +1 @@
+export { t as readLlmsIndex } from "../readLlmsIndex-Gj4iTxAk.mjs";