@evertondgn/solid-tooling 0.2.0 → 0.4.0

package/dist/playwright-teardown.d.mts

@@ -0,0 +1 @@
+export default function checkServerLog(): Promise<void>;

package/dist/playwright-teardown.mjs

@@ -0,0 +1,23 @@
+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;
+async function checkLog({ file, baseUrl }) {
+	if (!file || !baseUrl) throw new Error("Server log file is not configured");
+	const log = stripVTControlCharacters(await readFile(file, "utf8"));
+	const { host } = new URL(baseUrl);
+	if (!log.includes(host)) throw new Error(`Server log does not show the preview startup: ${file}`);
+	if (PRIVATE_MARKER.test(log)) throw new Error(`Server log contains a private marker: ${file}`);
+}
+async function checkServerLog() {
+	await checkLog({
+		file: env.SERVER_LOG_FILE,
+		baseUrl: env.BASE_URL_TEST
+	});
+	if (env.TEST_PUBLICATION_LOAD === "true") await checkLog({
+		file: env.SERVER_LOG_SECONDARY,
+		baseUrl: env.PUBLICATION_SECONDARY_URL
+	});
+}
+export { checkServerLog as default };

package/dist/playwright.d.mts

@@ -0,0 +1,18 @@
+import { PlaywrightTestConfig } from "@playwright/test";
+type FixtureServer = {
+  command: string;
+  url: string;
+};
+type SerialSuites = {
+  serverLogs?: string;
+  markdown?: string;
+  publicationLoad?: string;
+};
+type PlaywrightOptions = {
+  root: string;
+  testDir?: string;
+  fixtureServers?: FixtureServer[];
+  suites?: SerialSuites;
+};
+export declare function definePlaywrightConfig({ root, testDir, fixtureServers, suites }: PlaywrightOptions): PlaywrightTestConfig;
+export {};

package/dist/playwright.mjs

@@ -0,0 +1,158 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+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;
+const MAX_PORT = 65535;
+const CI_WORKERS = 2;
+const SECONDARY_LOG = "test-results/server-publication-secondary.log";
+const PREBUILT_GUARD = "if [ -e .vercel/output/static/.vite ]; then echo 'TEST_PREBUILT found an e2e build; run vp run build first' >&2; exit 1; fi && ";
+function readRunMode(suites) {
+	const mode = {
+		isProduction: env.TEST_PRODUCTION_ROUTES === "true",
+		isPublicationLoad: env.TEST_PUBLICATION_LOAD === "true",
+		shouldBuild: env.TEST_PREBUILT !== "true"
+	};
+	if (mode.isPublicationLoad && mode.isProduction) throw new Error("TEST_PUBLICATION_LOAD requires fixture routes");
+	if (mode.isPublicationLoad && !suites.publicationLoad) throw new Error("TEST_PUBLICATION_LOAD requires a publicationLoad suite");
+	if (!mode.shouldBuild && !mode.isProduction) throw new Error("TEST_PREBUILT requires production routes");
+	return mode;
+}
+function readBaseUrl(mode) {
+	if (!env.BASE_URL_TEST) throw new Error(".env.test must define BASE_URL_TEST");
+	const baseUrl = new URL(env.BASE_URL_TEST);
+	if (!baseUrl.port) throw new Error("BASE_URL_TEST must include an explicit port");
+	if (mode.isPublicationLoad && Number(baseUrl.port) + SECONDARY_PORT_OFFSET > MAX_PORT) throw new Error("BASE_URL_TEST leaves no port for the secondary server");
+	return env.BASE_URL_TEST;
+}
+function readWorkers(mode) {
+	if (mode.isPublicationLoad) return 1;
+	return env.CI ? CI_WORKERS : void 0;
+}
+function secondaryUrl(baseUrl) {
+	const url = new URL(baseUrl);
+	url.port = String(Number(url.port) + SECONDARY_PORT_OFFSET);
+	return url;
+}
+function buildProjects({ mode, suites }) {
+	if (mode.isPublicationLoad) return [{
+		name: "publication-load",
+		testMatch: suites.publicationLoad
+	}];
+	if (mode.isProduction) return [{ name: "chromium" }];
+	const teardown = suites.serverLogs ? { teardown: "server-logs" } : {};
+	const projects = [{
+		name: "chromium",
+		testIgnore: ["**/*.production.e2e.test.ts", ...[
+			suites.serverLogs,
+			suites.publicationLoad,
+			suites.markdown
+		].filter((suite) => suite !== void 0)],
+		...teardown
+	}];
+	if (suites.markdown) projects.push({
+		name: "markdown",
+		testMatch: suites.markdown,
+		fullyParallel: false,
+		workers: 1,
+		...teardown
+	});
+	if (suites.serverLogs) projects.push({
+		name: "server-logs",
+		testMatch: suites.serverLogs,
+		fullyParallel: false
+	});
+	return projects;
+}
+function buildServers({ root, mode, fixtureServers, baseUrl, serverLog }) {
+	const buildMode = mode.isProduction ? "production" : "e2e";
+	const build = mode.shouldBuild ? `vp run build --mode ${buildMode} && ` : PREBUILT_GUARD;
+	const shared = {
+		cwd: root,
+		reuseExistingServer: false
+	};
+	const server = {
+		...shared,
+		timeout: STARTUP_TIMEOUT
+	};
+	const fixtures = mode.isProduction ? [] : fixtureServers.map((fixture) => ({
+		...fixture,
+		...shared
+	}));
+	const { hostname, port } = new URL(baseUrl);
+	const secondary = secondaryUrl(baseUrl);
+	return [
+		...fixtures,
+		{
+			...server,
+			command: `${build}mkdir -p test-results && vp run start --strictPort > ${serverLog} 2>&1`,
+			env: {
+				HOST: hostname,
+				PORT: port,
+				NODE_ENV: "production"
+			},
+			url: baseUrl
+		},
+		...mode.isPublicationLoad ? [{
+			...server,
+			command: `vp run start --strictPort > ${SECONDARY_LOG} 2>&1`,
+			env: {
+				HOST: hostname,
+				PORT: secondary.port,
+				NODE_ENV: "production"
+			},
+			url: secondary.href
+		}] : []
+	];
+}
+function definePlaywrightConfig({ root, testDir = "src/tests/pages", fixtureServers = [], suites = {} }) {
+	loadEnvFile(path.join(root, ".env.test"));
+	const mode = readRunMode(suites);
+	const buildMode = mode.isProduction ? "production" : "e2e";
+	Object.assign(env, loadEnv(buildMode, root, "VITE_"));
+	const baseUrl = readBaseUrl(mode);
+	const serverLog = `test-results/server-${buildMode}.log`;
+	env.SERVER_LOG_FILE = path.join(root, serverLog);
+	if (mode.isPublicationLoad) {
+		env.PUBLICATION_SECONDARY_URL = secondaryUrl(baseUrl).href;
+		env.SERVER_LOG_SECONDARY = path.join(root, SECONDARY_LOG);
+	}
+	const reportFolder = mode.isProduction ? "production" : "e2e";
+	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"),
+		globalTeardown: fileURLToPath(new URL("playwright-teardown.mjs", import.meta.url)),
+		fullyParallel: !mode.isPublicationLoad,
+		forbidOnly: true,
+		workers: readWorkers(mode),
+		reporter: [["list"], ["html", {
+			outputFolder: path.join(root, "playwright-report", reportFolder),
+			open: "never",
+			onlyFailures: Boolean(env.CI)
+		}]],
+		use: {
+			...devices["Desktop Chrome"],
+			channel: env.CI ? "chrome" : void 0,
+			baseURL: baseUrl,
+			locale: "en-US",
+			screenshot: "only-on-failure",
+			trace: "retain-on-failure"
+		},
+		projects: buildProjects({
+			mode,
+			suites
+		}),
+		webServer: buildServers({
+			root,
+			mode,
+			fixtureServers,
+			baseUrl,
+			serverLog
+		})
+	});
+}
+export { definePlaywrightConfig };

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 };