@evertondgn/solid-tooling 0.5.0 → 0.6.0

package/app-env.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="vite-plus/test/globals" />
+/// <reference types="@testing-library/jest-dom/vitest" />
+/// <reference types="@solidjs/vite-plugin/boundary-modules" />
+/// <reference types="@solidjs/vite-plugin/virtual-modules" />
+/// <reference types="filesystem-routing/types" />
+/// <reference types="@evertondgn/solid-tooling/virtual-modules" />
+/// <reference types="vite-plus/client" />

package/dist/architecture-plugin.mjs

@@ -1,6 +1,6 @@
 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/architecturePolicy/index.ts
 const UI = [
 	"atoms",

package/dist/backend-plugin.mjs

@@ -1,6 +1,113 @@
 import { t as readStaticSpecifier } from "./import-specifier-C7HWhMXB.mjs";
-import { n as RENDER_INTEGRITY_MODULE } from "./constants-Jqvtbvxu.mjs";
+import { n as RENDER_INTEGRITY_MODULE, t as RELATIVE_IMPORT_RESTRICTION } from "./constants-BZJm7ouk.mjs";
+import path from "node:path";
 import { definePlugin, defineRule } from "vite-plus/lint/plugins";
+// src/backendPolicy/imports.ts
+const RELATIVE_IMPORT = new RegExp(RELATIVE_IMPORT_RESTRICTION.regex, "u");
+const RENDER_INTEGRITY$1 = new RegExp(RENDER_INTEGRITY_MODULE, "u");
+const TRANSPORTS = new Set([
+	"http",
+	"https",
+	"http2",
+	"net",
+	"tls",
+	"undici"
+].flatMap((name) => [name, `node:${name}`]));
+const SERVER_CONFIG = /* @__PURE__ */ new Set([
+	"@solidjs/web/server-functions",
+	"@solidjs/web/server-functions/server",
+	"@evertondgn/solid-runtime/server/configure-server-errors"
+]);
+function importsName({ node, names }) {
+	if (node.type === "TSImportType" && node.qualifier !== null) {
+		let { qualifier } = node;
+		while (qualifier.type === "TSQualifiedName") qualifier = qualifier.left;
+		return names.includes(qualifier.name);
+	}
+	if (node.type !== "ImportDeclaration" && node.type !== "ExportNamedDeclaration") return true;
+	return node.specifiers.some((specifier) => {
+		if (specifier.type === "ImportNamespaceSpecifier") return true;
+		if (specifier.type === "ImportDefaultSpecifier") return names.includes("default");
+		const imported = specifier.type === "ImportSpecifier" ? specifier.imported : specifier.local;
+		return names.includes(imported.type === "Identifier" ? imported.name : imported.value);
+	});
+}
+function permission(options, name) {
+	return typeof options === "object" && options !== null && name in options && Reflect.get(options, name) === true;
+}
+function normalizeBackendSpecifier(specifier) {
+	const normalized = path.posix.normalize(specifier.replaceAll("\\", "/"));
+	return specifier.startsWith(".") && !normalized.startsWith(".") ? `./${normalized}` : normalized;
+}
+const restrictedImports = defineRule({
+	meta: {
+		type: "problem",
+		schema: [{
+			type: "object",
+			properties: {
+				allowSafeErrors: { type: "boolean" },
+				allowServerConfiguration: { type: "boolean" },
+				testFile: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			relative: RELATIVE_IMPORT_RESTRICTION.message,
+			physical: "Do not import through node_modules. Use a public package export.",
+			safe: "Use createPublicError; only the runtime publicErrors module may mark an error as public.",
+			configuration: "Only src/infra/server/configureServerErrors/index.ts may configure server errors or observe render failures.",
+			transport: "Node transports cannot be imported in src/. Use requestJson or a protected server adapter."
+		}
+	},
+	create(context) {
+		const [options] = context.options;
+		const safeErrors = permission(options, "allowSafeErrors");
+		const configuration = permission(options, "allowServerConfiguration");
+		const testFile = permission(options, "testFile");
+		function check(node) {
+			const original = readStaticSpecifier(node);
+			if (original === void 0) return;
+			const specifier = normalizeBackendSpecifier(original);
+			if (RELATIVE_IMPORT.test(specifier)) context.report({
+				node,
+				messageId: "relative"
+			});
+			if (testFile) return;
+			if (original.replaceAll("\\", "/").split("/").includes("node_modules")) context.report({
+				node,
+				messageId: "physical"
+			});
+			if (TRANSPORTS.has(specifier)) context.report({
+				node,
+				messageId: "transport"
+			});
+			if (!safeErrors && specifier === "@solidjs/web" && importsName({
+				node,
+				names: ["markSafeError", "SAFE_ERROR"]
+			})) context.report({
+				node,
+				messageId: "safe"
+			});
+			if (!configuration && (SERVER_CONFIG.has(specifier) || specifier === "@solidjs/web" && importsName({
+				node,
+				names: ["configureServerErrors"]
+			}) || RENDER_INTEGRITY$1.test(specifier) && importsName({
+				node,
+				names: ["observeRenderFailures"]
+			}))) context.report({
+				node,
+				messageId: "configuration"
+			});
+		}
+		return {
+			ImportDeclaration: check,
+			ExportNamedDeclaration: check,
+			ExportAllDeclaration: check,
+			ImportExpression: check,
+			TSImportType: check
+		};
+	}
+});
 // src/backendPolicy/plugin.ts
 const RENDER_INTEGRITY = new RegExp(RENDER_INTEGRITY_MODULE, "u");
 function staticImportRule({ matches, message }) {
@@ -13,7 +120,7 @@ function staticImportRule({ matches, message }) {
 		create(context) {
 			return { ImportExpression(node) {
 				const specifier = readStaticSpecifier(node);
-				if (specifier !== void 0 && matches(specifier)) context.report({
+				if (specifier !== void 0 && matches(normalizeBackendSpecifier(specifier))) context.report({
 					node,
 					messageId: "staticImport"
 				});
@@ -24,9 +131,37 @@ function staticImportRule({ matches, message }) {
 const backendPlugin = definePlugin({
 	meta: { name: "backend" },
 	rules: {
+		"restricted-imports": restrictedImports,
+		"no-setup-exports": defineRule({
+			meta: {
+				type: "problem",
+				schema: [],
+				messages: { exported: "Server setup must not export anything. Import it only for its setup side effects." }
+			},
+			create(context) {
+				return {
+					ExportNamedDeclaration: (node) => context.report({
+						node,
+						messageId: "exported"
+					}),
+					ExportDefaultDeclaration: (node) => context.report({
+						node,
+						messageId: "exported"
+					}),
+					ExportAllDeclaration: (node) => context.report({
+						node,
+						messageId: "exported"
+					}),
+					TSExportAssignment: (node) => context.report({
+						node,
+						messageId: "exported"
+					})
+				};
+			}
+		}),
 		"static-solid-imports": staticImportRule({
-			matches: (specifier) => specifier === "@solidjs/web" || specifier.startsWith("@solidjs/web/"),
-			message: "Use a static import for @solidjs/web and its subpaths: the import restrictions on markSafeError and configureServerErrors cannot check import()."
+			matches: (specifier) => specifier === "@solidjs/web" || specifier.startsWith("@solidjs/web/") || specifier === "@evertondgn/solid-runtime/server/configure-server-errors",
+			message: "Use a static import for @solidjs/web, its subpaths and the runtime server configurator: the import restrictions on markSafeError and configureServerErrors cannot check import()."
 		}),
 		"static-render-integrity-imports": staticImportRule({
 			matches: (specifier) => RENDER_INTEGRITY.test(specifier),

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli.mjs

@@ -0,0 +1,42 @@
+import process, { argv, execPath } from "node:process";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+// src/cli/index.ts
+const CLI_ARGUMENT_OFFSET = 2;
+const TOOLS = {
+	knip: {
+		runtime: "bun",
+		entry: () => new URL("../bin/knip-bun.js", import.meta.resolve("knip")).href
+	},
+	tsc: {
+		runtime: execPath,
+		entry: () => new URL("bin/tsc", import.meta.resolve("typescript/package.json")).href
+	},
+	playwright: {
+		runtime: execPath,
+		entry: () => import.meta.resolve("@playwright/test/cli")
+	},
+	lefthook: {
+		runtime: execPath,
+		entry: () => import.meta.resolve("lefthook")
+	},
+	commitlint: {
+		runtime: execPath,
+		entry: () => import.meta.resolve("@commitlint/cli/cli.js")
+	}
+};
+const [name = "", ...args] = argv.slice(CLI_ARGUMENT_OFFSET);
+const tool = Object.hasOwn(TOOLS, name) ? TOOLS[name] : void 0;
+if (!tool) throw new Error(`Choose a packaged tool: ${Object.keys(TOOLS).join(", ")}`);
+const child = spawn(tool.runtime, [fileURLToPath(tool.entry()), ...args], { stdio: "inherit" });
+for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => {
+	if (child.exitCode === null && child.signalCode === null) child.kill(signal);
+});
+child.on("error", (error) => {
+	process.stderr.write(`${error.message}\n`);
+	process.exitCode = 1;
+});
+child.on("exit", (code) => {
+	process.exitCode = code ?? process.exitCode ?? 1;
+});
+export {};

package/dist/{constants-Jqvtbvxu.mjs → constants-BZJm7ouk.mjs}

@@ -3,5 +3,5 @@ const RELATIVE_IMPORT_RESTRICTION = {
 	regex: String.raw`^(\.\./){4,}`,
 	message: "Relative imports may go up at most three levels. Use the @/ alias for more distant paths."
 };
-const RENDER_INTEGRITY_MODULE = String.raw`(?:^|/)renderIntegrity(?:/index(?:\.ts)?)?$`;
+const RENDER_INTEGRITY_MODULE = String.raw`(?:(?:^|/)renderIntegrity(?:/index(?:\.ts)?)?$|^@evertondgn/solid-runtime/server/render-integrity$)`;
 export { RENDER_INTEGRITY_MODULE as n, RELATIVE_IMPORT_RESTRICTION as t };

package/dist/css-filename-CEHQd2gz.mjs

@@ -0,0 +1,40 @@
+import { n as resolveProjectPath, t as readStaticSpecifier } from "./import-specifier-C7HWhMXB.mjs";
+import path from "node:path";
+import { defineRule } from "vite-plus/lint/plugins";
+// src/css/css-filename.ts
+function cssFilenameError(file) {
+	const normalized = file.split("\\").join("/");
+	const basename = path.posix.basename(normalized);
+	if (normalized.startsWith("src/theme/")) return /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/u.test(basename.slice(0, -4)) ? void 0 : "Use camelCaseName.css inside src/theme/.";
+	return basename === "styles.module.css" ? void 0 : "Use styles.module.css outside src/theme/, including in routes.";
+}
+const cssFilename = defineRule({
+	meta: {
+		type: "problem",
+		schema: []
+	},
+	create(context) {
+		function check(node) {
+			const specifier = readStaticSpecifier(node);
+			if (specifier === void 0) return;
+			const relative = resolveProjectPath({
+				specifier,
+				filename: context.filename,
+				root: context.cwd
+			});
+			if (!relative.startsWith("src/") || !relative.endsWith(".css")) return;
+			const message = cssFilenameError(relative);
+			if (message) context.report({
+				node,
+				message
+			});
+		}
+		return {
+			ImportDeclaration: check,
+			ExportNamedDeclaration: check,
+			ExportAllDeclaration: check,
+			ImportExpression: check
+		};
+	}
+});
+export { cssFilenameError as n, cssFilename as t };

package/dist/css-filename.mjs

@@ -1,40 +1 @@
-import { n as resolveProjectPath, t as readStaticSpecifier } from "./import-specifier-C7HWhMXB.mjs";
-import { defineRule } from "vite-plus/lint/plugins";
-import path from "node:path";
-// src/css/css-filename.ts
-function cssFilenameError(file) {
-	const normalized = file.split("\\").join("/");
-	const basename = path.posix.basename(normalized);
-	if (normalized.startsWith("src/theme/")) return /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/u.test(basename.slice(0, -4)) ? void 0 : "Use camelCaseName.css inside src/theme/.";
-	return basename === "styles.module.css" ? void 0 : "Use styles.module.css outside src/theme/, including in routes.";
-}
-const cssFilename = defineRule({
-	meta: {
-		type: "problem",
-		schema: []
-	},
-	create(context) {
-		function check(node) {
-			const specifier = readStaticSpecifier(node);
-			if (specifier === void 0) return;
-			const relative = resolveProjectPath({
-				specifier,
-				filename: context.filename,
-				root: context.cwd
-			});
-			if (!relative.startsWith("src/") || !relative.endsWith(".css")) return;
-			const message = cssFilenameError(relative);
-			if (message) context.report({
-				node,
-				message
-			});
-		}
-		return {
-			ImportDeclaration: check,
-			ExportNamedDeclaration: check,
-			ExportAllDeclaration: check,
-			ImportExpression: check
-		};
-	}
-});
-export { cssFilename, cssFilenameError };
+export { t as cssFilename, n as cssFilenameError } from "./css-filename-CEHQd2gz.mjs";

package/dist/fmt-9dlUYOMk.mjs

@@ -0,0 +1,34 @@
+// src/fmt.ts
+const fmt = {
+	printWidth: 80,
+	singleQuote: true,
+	semi: false,
+	trailingComma: "none",
+	arrowParens: "avoid",
+	proseWrap: "always",
+	sortPackageJson: false,
+	embeddedLanguageFormatting: "off",
+	sortImports: { groups: [
+		"builtin",
+		"external",
+		["internal", "subpath"],
+		[
+			"parent",
+			"sibling",
+			"index"
+		],
+		"style",
+		"unknown"
+	] },
+	ignorePatterns: [
+		"public/**",
+		"src/assets/**",
+		"src/@types/routes.d.ts",
+		"**/*.svg",
+		"*.lock",
+		"AGENTS.md",
+		".agents/**",
+		".claude/**"
+	]
+};
+export { fmt as t };

package/dist/fmt.mjs

@@ -1,34 +1 @@
-// src/fmt.ts
-const fmt = {
-	printWidth: 80,
-	singleQuote: true,
-	semi: false,
-	trailingComma: "none",
-	arrowParens: "avoid",
-	proseWrap: "always",
-	sortPackageJson: false,
-	embeddedLanguageFormatting: "off",
-	sortImports: { groups: [
-		"builtin",
-		"external",
-		["internal", "subpath"],
-		[
-			"parent",
-			"sibling",
-			"index"
-		],
-		"style",
-		"unknown"
-	] },
-	ignorePatterns: [
-		"public/**",
-		"src/assets/**",
-		"src/@types/routes.d.ts",
-		"**/*.svg",
-		"*.lock",
-		"AGENTS.md",
-		".agents/**",
-		".claude/**"
-	]
-};
-export { fmt };
+export { t as fmt } from "./fmt-9dlUYOMk.mjs";

package/dist/i18n-generate.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/i18n-generate.mjs

@@ -0,0 +1,23 @@
+import { t as prepareMessages } from "./prepareMessages-BXmY6Ko2.mjs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+// src/i18n/generateMessages/index.ts
+const resolvePackage = createRequire(import.meta.url);
+const COMPILER_CLI = path.resolve(path.dirname(resolvePackage.resolve("@inlang/paraglide-js")), "../bin/run.js");
+const execute = promisify(execFile);
+async function generateMessages(root = process.cwd()) {
+	const resolved = path.resolve(root);
+	await prepareMessages(resolved);
+	await execute("bun", [
+		COMPILER_CLI,
+		"compile",
+		"--project",
+		path.join(resolved, "project.inlang"),
+		"--silent"
+	], { cwd: resolved });
+}
+// src/i18n/generate.ts
+await generateMessages();
+export {};

package/dist/i18nPlugin-CS7Gob6R.mjs

@@ -0,0 +1,109 @@
+import { n as canContainCatalogs, r as isCatalogFile, t as prepareMessages } from "./prepareMessages-BXmY6Ko2.mjs";
+import path from "node:path";
+import { setTimeout } from "node:timers/promises";
+import { paraglideVitePlugin } from "@inlang/paraglide-js";
+// src/i18n/i18nPlugin/index.ts
+const PROJECT = "./project.inlang";
+const PROJECT_FILES = /* @__PURE__ */ new Set(["project.inlang/settings.json", "project.inlang/paraglide.config.ts"]);
+const PREPARATION_DELAY_MS = 100;
+function isProjectFile({ root, file }) {
+	const relative = path.relative(root, file).split(path.sep).join("/");
+	return PROJECT_FILES.has(relative);
+}
+function catalogPreparation() {
+	let root = process.cwd();
+	let server;
+	let failure;
+	let pendingPreparation;
+	let requested = 0;
+	let isRunning = false;
+	const prepare = async () => {
+		try {
+			await prepareMessages(root);
+			if (!failure) return;
+			failure = void 0;
+			server?.ws.send({ type: "full-reload" });
+		} catch (error) {
+			failure = error instanceof Error ? error : new Error(String(error));
+			server?.ws.send({
+				type: "error",
+				err: {
+					message: failure.message,
+					stack: failure.stack ?? ""
+				}
+			});
+		}
+	};
+	const prepareRequested = async () => {
+		isRunning = true;
+		try {
+			let handled = 0;
+			while (handled < requested) {
+				handled = requested;
+				await setTimeout(PREPARATION_DELAY_MS);
+				if (handled < requested) continue;
+				await prepare();
+			}
+		} finally {
+			isRunning = false;
+		}
+	};
+	const request = () => {
+		requested += 1;
+		if (!isRunning) pendingPreparation = prepareRequested();
+	};
+	const schedule = () => {
+		request();
+		return pendingPreparation;
+	};
+	const reconcile = (directory) => {
+		if (canContainCatalogs({
+			root,
+			file: directory
+		})) request();
+	};
+	return {
+		name: "project:i18n-catalogs",
+		enforce: "pre",
+		async configResolved(config) {
+			({root} = config);
+			await prepareMessages(root);
+		},
+		configureServer(devServer) {
+			server = devServer;
+			devServer.watcher.on("addDir", reconcile);
+			devServer.watcher.on("unlinkDir", reconcile);
+			devServer.middlewares.use((_request, response, next) => {
+				if (!failure) {
+					next();
+					return;
+				}
+				response.statusCode = 500;
+				response.setHeader("Content-Type", "text/plain; charset=utf-8");
+				response.end(failure.message);
+			});
+		},
+		watchChange: {
+			sequential: true,
+			handler(file) {
+				return isProjectFile({
+					root,
+					file
+				}) || isCatalogFile({
+					root,
+					file
+				}) ? schedule() : void 0;
+			}
+		},
+		closeServer() {
+			return pendingPreparation;
+		}
+	};
+}
+function i18nPlugin() {
+	return [catalogPreparation(), paraglideVitePlugin({
+		project: PROJECT,
+		devErrorResponse: true
+	})];
+}
+export { i18nPlugin };

package/dist/knip.d.mts

@@ -6,7 +6,8 @@ type KnipOptions = AppSettings & {
   configFile?: string;
   entry?: string[];
   solidPluginImport?: SolidPluginImport;
+  packagedTestTools?: boolean;
 };
 type ConfigureKnip = () => Promise<KnipConfiguration>;
-export declare function defineKnipConfig({ root, configFile, entry, solidPluginImport, ignoreBinaries, ignoreDependencies, ignoreIssues, exclude }: KnipOptions): ConfigureKnip;
+export declare function defineKnipConfig({ root, configFile, entry, solidPluginImport, packagedTestTools, ignoreBinaries, ignoreDependencies, ignoreIssues, exclude }: KnipOptions): ConfigureKnip;
 export {};

package/dist/knip.mjs

@@ -46,7 +46,7 @@ async function conventionEntries({ root, patterns }) {
 		pattern
 	}) ? [`${pattern}!`] : []))).flat();
 }
-function defineKnipConfig({ root, configFile = DEFAULT_CONFIG_FILE, entry = [], solidPluginImport = "lazy", ignoreBinaries, ignoreDependencies, ignoreIssues = {}, exclude }) {
+function defineKnipConfig({ root, configFile = DEFAULT_CONFIG_FILE, entry = [], solidPluginImport = "lazy", packagedTestTools = true, ignoreBinaries, ignoreDependencies, ignoreIssues = {}, exclude }) {
 	const patterns = solidPluginImport === "static" ? RUNTIME_ENTRIES : [...SOLID_ENTRIES, ...RUNTIME_ENTRIES];
 	return async function configureKnip() {
 		const [conventions, routes, hasTooling] = await Promise.all([
@@ -78,8 +78,13 @@ function defineKnipConfig({ root, configFile = DEFAULT_CONFIG_FILE, entry = [],
 				"!src/**/*.test.{ts,tsx}!"
 			],
 			"filesystem-routing": false,
+			"unplugin-icons": true,
 			...ignoreBinaries ? { ignoreBinaries } : {},
-			...ignoreDependencies ? { ignoreDependencies } : {},
+			ignoreDependencies: [...packagedTestTools ? [
+				"@vitest/coverage-v8",
+				"happy-dom",
+				"@testing-library/jest-dom"
+			] : [], ...ignoreDependencies ?? []],
 			ignoreIssues: {
 				...ignoreIssues,
 				[configFile]: [.../* @__PURE__ */ new Set([...configIssues, "unlisted"])]