@evertondgn/solid-tooling 0.3.0 → 0.4.0

package/dist/playwright-teardown.mjs

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

package/dist/playwright.mjs

@@ -1,8 +1,8 @@
 import path from "node:path";
-import { env, loadEnvFile } from "node:process";
 import { fileURLToPath } from "node:url";
-import { defineConfig, devices } from "@playwright/test";
+import { env, loadEnvFile } from "node:process";
 import { loadEnv } from "vite-plus";
+import { defineConfig as defineConfig$1, devices } from "@playwright/test";
 // src/playwright/index.ts
 const STARTUP_TIMEOUT = 12e4;
 const SECONDARY_PORT_OFFSET = 2;
@@ -121,7 +121,7 @@ function definePlaywrightConfig({ root, testDir = "src/tests/pages", fixtureServ
 		env.SERVER_LOG_SECONDARY = path.join(root, SECONDARY_LOG);
 	}
 	const reportFolder = mode.isProduction ? "production" : "e2e";
-	return defineConfig({
+	return defineConfig$1({
 		testDir: path.join(root, testDir),
 		testMatch: mode.isProduction ? "**/*.production.e2e.test.ts" : "**/*.e2e.test.ts",
 		outputDir: path.join(root, mode.isProduction ? "test-results/e2e-production" : "test-results/e2e"),

package/dist/stylelint.d.mts

@@ -0,0 +1,8 @@
+import { Config } from "stylelint";
+type CssCheck = {
+  report: string;
+  hasErrors: boolean;
+};
+export declare function defineStylelintConfig(appRoot: string): Promise<Config>;
+export declare function checkCss(appRoot: string): Promise<CssCheck>;
+export {};

package/dist/stylelint.mjs

@@ -0,0 +1,180 @@
+import { cssFilenameError } from "./css-filename.mjs";
+import { t as hasMatch } from "./has-match-BITlj0EE.mjs";
+import path from "node:path";
+import { readdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import stylelint from "stylelint";
+// src/stylelint/index.ts
+const VAR = String.raw`var\(\s*--[a-z0-9-]+\s*\)`;
+const TOKEN = String.raw`/^${VAR}(?:\s*[,/]\s*${VAR}|\s+${VAR})*$/`;
+const LINE_HEIGHT = String.raw`(?:\d*\.?\d+(?:%|[a-z]+)?|normal)`;
+const FONT_TOKEN = String.raw`/^${VAR}(?:\s+${VAR})*(?:\s*\/\s*(?:${LINE_HEIGHT}|${VAR})(?:\s+${VAR})*)?$/`;
+const TOKEN_KEYWORDS = "/^(?:transparent|currentcolor|inherit|initial|unset|revert|revert-layer|none|auto)$/i";
+const TOKEN_FAMILIES = [
+	"color",
+	"gradient",
+	"radius",
+	"shadow",
+	"ring",
+	"font-size",
+	"font-weight",
+	"z-index"
+];
+const REFERENCE_FILES = ["src/theme/tokens/**/*.css", "src/theme/class/animation.css"];
+const SYSTEM_COLORS = `
+  AccentColor AccentColorText ActiveText ButtonBorder ButtonFace ButtonText
+  Canvas CanvasText Field FieldText GrayText Highlight HighlightText LinkText
+  Mark MarkText SelectedItem SelectedItemText VisitedText
+  ActiveBorder ActiveCaption AppWorkspace Background ButtonHighlight
+  ButtonShadow CaptionText InactiveBorder InactiveCaption InactiveCaptionText
+  InfoBackground InfoText Menu MenuText Scrollbar ThreeDDarkShadow ThreeDFace
+  ThreeDHighlight ThreeDLightShadow ThreeDShadow Window WindowFrame WindowText
+  -webkit-activelink -webkit-focus-ring-color -webkit-link -webkit-text
+`.trim().split(/\s+/u);
+const SYSTEM_COLOR = String.raw`/(?<![\w#./-])(?:${SYSTEM_COLORS.join("|")})(?![\w.-])/i`;
+const NAME_PROPERTIES = String.raw`animation(?:-name)?|transition(?:-property)?|will-change|grid(?:-[a-z]+)*|container(?:-name)?|counter-(?:increment|reset|set)|view-transition-(?:class|name)|font-family|content|quotes|list-style(?:-type)?|page`;
+const CSS_FILES = "src/**/*.css";
+function property(names) {
+	return String.raw`/^(?!--)(?:-[a-z]+-)?(?:${names})$/i`;
+}
+const TOKEN_PROPERTIES = [
+	[property("(?:[a-z]+-)*color|fill|stroke"), ["/^--color-/"]],
+	[property("(?:[a-z]+-)*radius"), ["/^--radius-/"]],
+	[property("background"), ["/^--(?:color|gradient)-/"]],
+	[property("background-image"), ["/^--gradient-/"]],
+	[property("box-shadow"), ["/^--(?:shadow|ring)-/"]],
+	[property("text-shadow"), []],
+	[
+		property("font"),
+		["/^--font-/"],
+		FONT_TOKEN
+	],
+	[property("font-size"), ["/^--font-size-/"]],
+	[property("font-weight"), ["/^--font-weight-/"]],
+	[property("z-index"), ["/^--z-index-/"]],
+	...TOKEN_FAMILIES.map((family) => [`/^--${family}-/`, [`/^--${family}-/`]]),
+	[
+		"/^--font-(?!size-|weight-)/",
+		["/^--font-/"],
+		FONT_TOKEN
+	]
+];
+async function referenceFiles(root) {
+	return (await Promise.all(REFERENCE_FILES.map(async (pattern) => await hasMatch({
+		root,
+		pattern
+	}) ? [path.join(root, pattern)] : []))).flat();
+}
+async function filenameDiagnostics(root) {
+	return (await readdir(path.join(root, "src"), {
+		recursive: true,
+		withFileTypes: true
+	})).flatMap((entry) => {
+		if (!entry.isFile()) return [];
+		const absolute = path.join(entry.parentPath, entry.name);
+		const file = path.relative(root, absolute).split(path.sep).join("/");
+		if (!file.endsWith(".css")) return [];
+		const message = cssFilenameError(file);
+		return message ? [{
+			file,
+			message
+		}] : [];
+	});
+}
+async function defineStylelintConfig(appRoot) {
+	const root = path.resolve(appRoot);
+	return {
+		referenceFiles: await referenceFiles(root),
+		reportDescriptionlessDisables: true,
+		plugins: [fileURLToPath(import.meta.resolve("stylelint-use-nesting"))],
+		rules: {
+			"property-no-unknown": true,
+			"declaration-property-value-no-unknown": true,
+			"value-no-invalid": true,
+			"unit-no-unknown": true,
+			"color-no-invalid-hex": true,
+			"color-no-hex": true,
+			"color-named": "never",
+			"declaration-block-no-duplicate-properties": [true, { ignore: ["consecutive-duplicates-with-different-syntaxes"] }],
+			"declaration-block-no-shorthand-property-overrides": true,
+			"selector-pseudo-class-no-unknown": true,
+			"selector-pseudo-element-no-unknown": true,
+			"selector-type-no-unknown": true,
+			"at-rule-no-unknown": true,
+			"no-unknown-animations": true,
+			"no-unknown-custom-properties": true,
+			"custom-property-no-missing-var-function": true,
+			"custom-property-pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
+			"selector-no-invalid": true,
+			"selector-no-deprecated": true,
+			"selector-no-unmatchable": true,
+			"at-charset-rule-no-invalid": true,
+			"media-query-no-invalid": true,
+			"media-feature-name-no-unknown": true,
+			"media-feature-name-value-no-unknown": true,
+			"function-calc-no-unspaced-operator": true,
+			"no-invalid-position-at-import-rule": true,
+			"no-duplicate-selectors": true,
+			"keyframe-block-no-duplicate-selectors": true,
+			"function-disallowed-list": [
+				"rgb",
+				"rgba",
+				"hsl",
+				"hsla",
+				"hwb",
+				"lab",
+				"lch",
+				"oklab",
+				"oklch",
+				"color",
+				"color-mix",
+				"light-dark",
+				"contrast-color",
+				"device-cmyk"
+			],
+			"value-type-custom-property-required-list": [["color"], { ignoreValues: [TOKEN_KEYWORDS] }],
+			"declaration-property-value-allowed-list": [Object.fromEntries(TOKEN_PROPERTIES.map(([name, , value = TOKEN]) => [name, [value, TOKEN_KEYWORDS]])), { message: "Use only var() tokens in this property; an exception needs a stylelint-disable comment with the reason." }],
+			"declaration-property-custom-property-allowed-list": [Object.fromEntries(TOKEN_PROPERTIES.map(([name, families]) => [name, families])), { message: "The property \"%s\" does not accept the token \"%s\"." }],
+			"declaration-property-value-disallowed-list": [{ [String.raw`/^(?!(?:-[a-z]+-)?(?:${NAME_PROPERTIES})$)/i`]: [SYSTEM_COLOR] }, { message: "System colors belong in src/theme/." }],
+			"selector-class-pattern": ["^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$", { message: "Use snake_case for CSS classes, as in variant_default." }],
+			"max-nesting-depth": 2,
+			"nesting-selector-no-missing-scoping-root": true,
+			"csstools/use-nesting": "always"
+		},
+		overrides: [{
+			files: [path.join(root, "src/theme/**/*.css")],
+			rules: {
+				"function-disallowed-list": [
+					"rgb",
+					"rgba",
+					"hsl",
+					"hsla",
+					"hwb",
+					"lab",
+					"lch",
+					"color"
+				],
+				"value-type-custom-property-required-list": null,
+				"declaration-property-value-allowed-list": null,
+				"declaration-property-custom-property-allowed-list": null,
+				"declaration-property-value-disallowed-list": null
+			}
+		}]
+	};
+}
+async function checkCss(appRoot) {
+	const root = path.resolve(appRoot);
+	const config = await defineStylelintConfig(root);
+	const [filenames, result] = await Promise.all([filenameDiagnostics(root), stylelint.lint({
+		cwd: root,
+		files: [CSS_FILES],
+		config,
+		formatter: "string"
+	})]);
+	const filenameReport = filenames.map(({ file, message }) => `${file}:1 error project/css-filename: ${message}\n`).join("");
+	return {
+		report: result.report + filenameReport,
+		hasErrors: result.errored || filenames.length > 0
+	};
+}
+export { checkCss, defineStylelintConfig };

package/dist/vite.d.mts

@@ -0,0 +1,40 @@
+import { PluginOption, UserConfig, ViteUserConfigFnObject } from "vite-plus";
+import { NitroConfig, NitroModuleInput, PublicAssetDir } from "nitro/types";
+type StaticSecurityHeaders = Record<'strict-transport-security' | 'x-content-type-options' | 'cross-origin-resource-policy', string>;
+type E2eOptions = {
+  middleware?: string;
+  routes?: string;
+};
+type WorkspaceOptions = {
+  dependsOn: string[];
+  inputs: string[];
+};
+type StaticAssetDir = PublicAssetDir & {
+  baseURL: string;
+};
+type RouteRule = NonNullable<NitroConfig['routeRules']>[string];
+type RunTask = NonNullable<NonNullable<UserConfig['run']>['tasks']>[string];
+type ExtensionContext = {
+  target: 'app' | 'test';
+  mode: string;
+};
+type SolidAppExtension = {
+  plugins?: PluginOption[];
+  nitroModules?: NitroModuleInput[];
+};
+type SolidAppOptions = {
+  root: string;
+  middleware?: string;
+  serverSetup?: string;
+  e2e?: E2eOptions;
+  icons?: Record<string, string>;
+  securityHeaders: StaticSecurityHeaders;
+  publicAssets?: StaticAssetDir[];
+  staticPaths?: string[];
+  routeRules?: Record<string, RouteRule>;
+  extend?: (context: ExtensionContext) => SolidAppExtension | Promise<SolidAppExtension>;
+  workspace?: WorkspaceOptions;
+  tasks?: Record<string, RunTask>;
+};
+export declare function defineSolidApp(options: SolidAppOptions): ViteUserConfigFnObject;
+export type { SolidAppOptions };

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.mjs

@@ -1,6 +1,6 @@
 import path from "node:path";
-import { env } from "node:process";
 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;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@evertondgn/solid-tooling",
-  "version": "0.3.0",
-  "description": "Lint, formatter, TypeScript and test 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": {
@@ -27,11 +27,14 @@
     "./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",
@@ -48,12 +51,19 @@
     "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",
-    "@playwright/test": "1.65.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",
@@ -61,11 +71,31 @@
     "typescript": "7.0.2",
     "valibot": "1.5.0",
     "vite-plus": "1.6.0",
-    "@playwright/test": "1.65.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
     }
   }
 }