@evertondgn/solid-tooling 0.2.0 → 0.4.0

package/dist/vite.mjs

@@ -0,0 +1,341 @@
+import { fmt } from "./fmt.mjs";
+import { t as lint } from "./lint-UTfyg7AR.mjs";
+import { solidTest } from "./vitest.mjs";
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { env, loadEnvFile } from "node:process";
+import { defineConfig, lazyPlugins, loadEnv } from "vite-plus";
+// 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"),
+		import("filesystem-routing/vite"),
+		import("unplugin-icons/vite"),
+		import("unplugin-icons/loaders")
+	]);
+	return {
+		solid: solid.default,
+		fileRoutes: routing.fileRoutes,
+		Icons: icons.default,
+		FileSystemIconLoader: loaders.FileSystemIconLoader
+	};
+}
+async function readExtension({ options, target, mode }) {
+	return await options.extend?.({
+		target,
+		mode
+	}) ?? {};
+}
+async function readLocales(root) {
+	let settings;
+	try {
+		settings = JSON.parse(await readFile(path.join(root, "project.inlang/settings.json"), "utf8"));
+	} catch (error) {
+		throw new Error("defineSolidApp: cannot read the locales from project.inlang/settings.json.", { 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.");
+	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",
+		iconCustomizer(_collection, _icon, props) {
+			props["aria-hidden"] = "true";
+		},
+		customCollections: Object.fromEntries(Object.entries(options.icons ?? {}).map(([name, folder]) => [name, modules.FileSystemIconLoader(path.resolve(options.root, folder))]))
+	});
+}
+function staticHeaders({ securityHeaders }) {
+	return {
+		"strict-transport-security": securityHeaders["strict-transport-security"],
+		"x-content-type-options": securityHeaders["x-content-type-options"],
+		"cross-origin-resource-policy": securityHeaders["cross-origin-resource-policy"]
+	};
+}
+function appPlugins({ options, mode }) {
+	return lazyPlugins(async () => {
+		const [modules, { nitro }, extension, locales] = await Promise.all([
+			loadPluginModules(),
+			import("nitro/vite"),
+			readExtension({
+				options,
+				target: "app",
+				mode
+			}),
+			readLocales(options.root)
+		]);
+		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
+				}
+			})
+		];
+	});
+}
+function testPlugins({ options, mode }) {
+	return lazyPlugins(async () => {
+		const [modules, extension] = await Promise.all([loadPluginModules(), readExtension({
+			options,
+			target: "test",
+			mode
+		})]);
+		return [
+			...extension.plugins ?? [],
+			iconsPlugin({
+				modules,
+				options
+			}),
+			modules.solid({ serverFunctions: true }),
+			modules.fileRoutes({
+				types: ROUTE_TYPES,
+				httpMethods: true
+			})
+		];
+	});
+}
+// src/vite/tasks.ts
+const TOOLING_CI_TEST_WORKERS = 3;
+function fromWorkspace(pattern) {
+	return {
+		pattern,
+		base: "workspace"
+	};
+}
+function installInputs({ workspace }) {
+	const patterns = [
+		"bun.lock",
+		"bunfig.toml",
+		...workspace?.inputs ?? []
+	];
+	return workspace ? patterns.map((pattern) => fromWorkspace(pattern)) : patterns;
+}
+function createTasks({ workspace, isCi }) {
+	const install = installInputs({ workspace });
+	const lockfile = workspace ? fromWorkspace("bun.lock") : "bun.lock";
+	const dependsOn = workspace ? { dependsOn: workspace.dependsOn } : {};
+	const projectCheckInputs = [
+		{ auto: true },
+		"src/**",
+		"paraglide/**",
+		"tooling/**",
+		"*.ts",
+		"tsconfig*.json",
+		"package.json",
+		"patches/**",
+		...install
+	];
+	const testConcurrency = isCi ? ` --test-concurrency=${TOOLING_CI_TEST_WORKERS}` : "";
+	return {
+		"i18n-generate": {
+			command: "bun tooling/i18n/generate.ts",
+			cache: {
+				input: [
+					"src/**/i18n/*.json",
+					"tooling/i18n/**",
+					"project.inlang/settings.json",
+					"project.inlang/paraglide.config.ts",
+					"package.json",
+					lockfile
+				],
+				output: ["paraglide/**", ".paraglide/messages/**"]
+			}
+		},
+		"lint-css": {
+			command: "bun tooling/css/check.ts",
+			...dependsOn,
+			cache: {
+				env: ["NODE_ENV"],
+				input: [
+					{ auto: true },
+					"src/**/*.css",
+					"tooling/css/**",
+					"package.json",
+					...install
+				]
+			}
+		},
+		"dead-code-project": {
+			command: "knip-bun --config tooling/knip.ts && knip-bun --config tooling/knip.ts --strict",
+			...dependsOn,
+			cache: {
+				env: ["NODE_ENV"],
+				input: [
+					{ auto: true },
+					"src/**",
+					"paraglide/**",
+					"tooling/**",
+					"*.ts",
+					"tsconfig*.json",
+					"package.json",
+					...install
+				],
+				output: []
+			}
+		},
+		"lint-project": {
+			command: "vp lint",
+			dependsOn: ["lint-css"],
+			cache: {
+				env: ["NODE_ENV"],
+				input: projectCheckInputs
+			}
+		},
+		"check-project": {
+			command: "vp fmt --check && vp lint",
+			dependsOn: ["lint-css"],
+			cache: {
+				env: ["NODE_ENV"],
+				input: projectCheckInputs
+			}
+		},
+		"typecheck-node": {
+			command: "tsc --project tsconfig.node.json",
+			...dependsOn,
+			cache: {
+				input: [
+					"tsconfig.json",
+					"tsconfig.node.json",
+					"vite.config.ts",
+					"playwright.config.ts",
+					"tooling/**/*.ts",
+					"src/**/*.ts",
+					"src/**/*.tsx",
+					"src/**/*.json",
+					"project.inlang/paraglide.config.ts",
+					"project.inlang/settings.json",
+					"package.json",
+					"patches/**",
+					...install
+				],
+				output: []
+			}
+		},
+		"test-tooling": {
+			command: `node --test${testConcurrency} --test-timeout=60000 'tooling/__tests__/*.test.ts' 'tooling/!(release)/**/__tests__/*.test.ts'`,
+			cache: false
+		}
+	};
+}
+// src/vite/index.ts
+function isPathPrefix(baseURL) {
+	return typeof baseURL === "string" && baseURL.startsWith("/") && baseURL.length > 1 && !baseURL.endsWith("/");
+}
+function validateOptions(options) {
+	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 loadTestEnvFile(root) {
+	try {
+		loadEnvFile(path.join(root, ".env.test"));
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+	}
+}
+function defineSolidApp(options) {
+	validateOptions(options);
+	const { root } = options;
+	return defineConfig(({ mode }) => {
+		const localEnv = loadEnv(mode, root, ["HOST", "PORT"]);
+		const server = {
+			host: localEnv.HOST,
+			port: localEnv.PORT ? Number(localEnv.PORT) : void 0
+		};
+		if (mode === "test") loadTestEnvFile(root);
+		return {
+			run: { tasks: {
+				...createTasks({
+					workspace: options.workspace,
+					isCi: Boolean(env.CI)
+				}),
+				...options.tasks
+			} },
+			build: {
+				manifest: mode === "e2e",
+				rolldownOptions: { output: { comments: false } }
+			},
+			css: {
+				transformer: "lightningcss",
+				lightningcss: { cssModules: { pattern: "[content-hash]_[local]" } }
+			},
+			resolve: { tsconfigPaths: true },
+			server: {
+				...server,
+				forwardConsole: true
+			},
+			preview: server,
+			plugins: mode === "test" ? [] : appPlugins({
+				options,
+				mode
+			}),
+			fmt,
+			lint,
+			test: solidTest({
+				root,
+				plugins: () => testPlugins({
+					options,
+					mode
+				})
+			})
+		};
+	});
+}
+export { defineSolidApp };

package/dist/vitest-setup/browser.d.mts

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

package/dist/vitest-setup/browser.mjs

@@ -0,0 +1,5 @@
+import { baseLocale, setLocale } from "@paraglide/runtime.js";
+import { beforeEach } from "vite-plus/test";
+// src/vitest/setup/browser.ts
+beforeEach(() => setLocale(baseLocale, { reload: false }));
+export {};

package/dist/vitest.d.mts

@@ -0,0 +1,7 @@
+import { TestUserConfig, ViteUserConfig } from "vite-plus";
+type SolidTestOptions = {
+  root: string;
+  plugins: () => ViteUserConfig['plugins'];
+};
+export declare function solidTest({ root, plugins }: SolidTestOptions): TestUserConfig;
+export {};

package/dist/vitest.mjs

@@ -0,0 +1,129 @@
+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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@evertondgn/solid-tooling",
-  "version": "0.2.0",
-  "description": "Lint, formatter and TypeScript presets for SolidJS applications built with Vite+.",
+  "version": "0.4.0",
+  "description": "Lint, formatter, TypeScript, test and Vite app presets for SolidJS applications built with Vite+.",
   "author": "Éverton Toffanetto",
   "license": "MIT",
   "repository": {
@@ -19,18 +19,27 @@
   "type": "module",
   "files": [
     "dist",
-    "tsconfig.base.json"
+    "tsconfig.base.json",
+    "tsconfig.app.json"
   ],
   "exports": {
     "./architecture-plugin": "./dist/architecture-plugin.mjs",
     "./backend-plugin": "./dist/backend-plugin.mjs",
     "./css-filename": "./dist/css-filename.mjs",
     "./fmt": "./dist/fmt.mjs",
+    "./knip": "./dist/knip.mjs",
     "./lint": "./dist/lint.mjs",
+    "./playwright": "./dist/playwright.mjs",
+    "./playwright-teardown": "./dist/playwright-teardown.mjs",
     "./project-plugin": "./dist/project-plugin.mjs",
     "./solid-plugin": "./dist/solid-plugin.mjs",
+    "./stylelint": "./dist/stylelint.mjs",
+    "./vite": "./dist/vite.mjs",
+    "./vitest": "./dist/vitest.mjs",
+    "./vitest-setup/browser": "./dist/vitest-setup/browser.mjs",
     "./package.json": "./package.json",
-    "./tsconfig.base.json": "./tsconfig.base.json"
+    "./tsconfig.base.json": "./tsconfig.base.json",
+    "./tsconfig.app.json": "./tsconfig.app.json"
   },
   "publishConfig": {
     "access": "public"
@@ -42,17 +51,51 @@
     "test:tarball": "vp run test-tarball"
   },
   "dependencies": {
-    "eslint-plugin-solid": "0.19.0"
+    "eslint-plugin-solid": "0.19.0",
+    "stylelint": "18.0.0",
+    "stylelint-use-nesting": "6.0.2"
   },
   "peerDependencies": {
     "@inlang/paraglide-js": "3.2.2",
-    "vite-plus": "1.6.0"
+    "vite-plus": "1.6.0",
+    "@playwright/test": "1.65.0",
+    "@solidjs/vite-plugin": "3.0.0-next.57",
+    "filesystem-routing": "0.5.0",
+    "knip": "6.45.1",
+    "nitro": "3.0.261103-rc",
+    "unplugin-icons": "24.0.0"
   },
   "devDependencies": {
     "@inlang/paraglide-js": "3.2.2",
     "@types/node": "24.19.2",
     "typescript": "7.0.2",
     "valibot": "1.5.0",
-    "vite-plus": "1.6.0"
+    "vite-plus": "1.6.0",
+    "@playwright/test": "1.65.0",
+    "@solidjs/vite-plugin": "3.0.0-next.57",
+    "filesystem-routing": "0.5.0",
+    "knip": "6.45.1",
+    "nitro": "3.0.261103-rc",
+    "unplugin-icons": "24.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    },
+    "@solidjs/vite-plugin": {
+      "optional": true
+    },
+    "filesystem-routing": {
+      "optional": true
+    },
+    "knip": {
+      "optional": true
+    },
+    "nitro": {
+      "optional": true
+    },
+    "unplugin-icons": {
+      "optional": true
+    }
   }
 }

package/tsconfig.app.json

@@ -0,0 +1,21 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "types": [
+      "node",
+      "vite/client",
+      "vite-plus/test/globals",
+      "@testing-library/jest-dom/vitest",
+      "@solidjs/vite-plugin/boundary-modules",
+      "@solidjs/vite-plugin/virtual-modules"
+    ]
+  },
+  "include": [
+    "${configDir}/src",
+    "${configDir}/env.ts",
+    "${configDir}/solid-env.d.ts",
+    "${configDir}/vite.config.ts",
+    "${configDir}/playwright.config.ts",
+    "${configDir}/tooling/**/*.ts"
+  ]
+}