@evertondgn/solid-tooling 0.0.0-stage → 0.2.0

package/dist/project-plugin.d.mts

@@ -0,0 +1,2 @@
+declare const plugin: import("vite-plus/lint/plugins").Plugin;
+export { plugin as default };

package/dist/project-plugin.mjs

@@ -0,0 +1,209 @@
+import { cssFilename } from "./css-filename.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";
+// src/noExportList/index.ts
+const noExportList = defineRule({
+	meta: {
+		type: "suggestion",
+		schema: [],
+		messages: { inlineExport: "Export on the declaration itself (export function, export const, export type) instead of using export { ... }. An export list is only allowed in a re-export with from." }
+	},
+	create(context) {
+		return { ExportNamedDeclaration(node) {
+			if (node.declaration || node.source) return;
+			context.report({
+				node,
+				messageId: "inlineExport"
+			});
+		} };
+	}
+});
+// src/seoModule/index.ts
+const SEO_MODULE = /^src\/routes\/(?:.+\/)?seo\.ts$/u;
+const LOCAL_SPECIFIER = /^\.{1,2}(?:\/|$)/u;
+const SEO_EXPORT = "seo";
+const ROUTES_DIR = "src/routes/";
+function isImportMetaGlob({ computed, object, property }) {
+	return !computed && object.type === "MetaProperty" && object.meta.name === "import" && object.property.name === "meta" && property.type === "Identifier" && property.name === "glob";
+}
+const seoModule = defineRule({
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: {
+			onlySeo: "seo.ts may export only seo. The route manifest loads the route export of every page in the initial bundle, and seo.ts goes with it, so keep the page body in index.tsx (see the page modules section of AGENTS.md).",
+			localImport: "seo.ts must not import values from relative paths or from src/routes/: whatever it imports goes into the initial bundle. Use import type, or keep the code in index.tsx (see the page modules section of AGENTS.md).",
+			computedImport: "seo.ts must not use import() with a computed path: the rule cannot tell whether the target is local. Keep the page body in index.tsx (see the page modules section of AGENTS.md).",
+			globImport: "seo.ts must not use import.meta.glob: Vite turns it into imports of every module the pattern matches. Keep the page body in index.tsx (see the page modules section of AGENTS.md)."
+		}
+	},
+	create(context) {
+		const relative = path.relative(context.cwd, context.filename).split(path.sep).join("/");
+		if (!SEO_MODULE.test(relative)) return {};
+		const reportLocalImport = (node) => {
+			const specifier = readStaticSpecifier(node);
+			if (specifier === void 0) {
+				context.report({
+					node,
+					messageId: "computedImport"
+				});
+				return;
+			}
+			const target = resolveProjectPath({
+				specifier,
+				filename: context.filename,
+				root: context.cwd
+			});
+			if (LOCAL_SPECIFIER.test(specifier) || target.startsWith(ROUTES_DIR)) context.report({
+				node,
+				messageId: "localImport"
+			});
+		};
+		return {
+			ExportNamedDeclaration(node) {
+				const { declaration } = node;
+				if (declaration?.type === "VariableDeclaration") {
+					if (declaration.declarations.every(({ id }) => id.type === "Identifier" && id.name === SEO_EXPORT)) return;
+				}
+				context.report({
+					node,
+					messageId: "onlySeo"
+				});
+			},
+			ExportDefaultDeclaration(node) {
+				context.report({
+					node,
+					messageId: "onlySeo"
+				});
+			},
+			ExportAllDeclaration(node) {
+				context.report({
+					node,
+					messageId: "onlySeo"
+				});
+			},
+			ImportDeclaration(node) {
+				if (node.importKind !== "type") reportLocalImport(node);
+			},
+			ImportExpression(node) {
+				reportLocalImport(node);
+			},
+			MemberExpression(node) {
+				if (isImportMetaGlob(node)) context.report({
+					node,
+					messageId: "globImport"
+				});
+			}
+		};
+	}
+});
+// src/test-filename.ts
+const subjects = {
+	"tooling/__tests__": [
+		"lint",
+		"patched-dependencies",
+		"playwright",
+		"test-filename"
+	],
+	"src/__tests__": ["App", "PageFileSystemRouter"],
+	"src/constants/__tests__": ["cache"],
+	"src/tests/pages/Home": ["Home"],
+	"src/tests/pages/Hydration": ["Hydration"],
+	"src/tests/pages/NotFound": ["NotFound"],
+	"src/tests/pages/BackendError": ["BackendError"],
+	"src/tests/pages/FragmentCss": ["FragmentCss"],
+	"src/tests/pages/LateRedirect": ["LateRedirect"],
+	"src/tests/pages/OutsideError": ["OutsideError"],
+	"src/tests/pages/OutdatedPage": ["OutdatedPage"],
+	"src/tests/pages/SeoIndexes": ["SeoIndexes"],
+	"src/tests/pages/AgentReadiness": ["AgentReadiness"],
+	"src/tests/pages/BuildOutput": ["BuildOutput"],
+	"src/tests/pages/I18n": ["I18n"],
+	"src/tests/pages/Markdown": ["Markdown"],
+	"src/tests/pages/PublicationLoad": ["PublicationLoad"],
+	"src/tests/pages/UiKit": ["UiKit"],
+	"src/tests/pages/StructuredData": ["StructuredData"],
+	"tooling/css/__tests__": ["cssPolicy"],
+	"tooling/release/__tests__": ["automatic-release", "versioning"]
+};
+const DOTTED_SUBJECT = "subject";
+function expectedSubjects(directory) {
+	const declared = subjects[directory];
+	if (declared || path.posix.basename(directory) !== "__tests__") return declared;
+	return [path.posix.basename(path.posix.dirname(directory))];
+}
+function dottedSubject({ expected, basename }) {
+	return expected?.find((name) => name.includes(".") && basename.startsWith(`${name}.`));
+}
+function isTestSupportModule(file) {
+	return !file.startsWith("src/tests/pages/") && /\/__tests__\/(?:fixtures|types|constants)\.ts$/u.test(file);
+}
+function testFilenameError(file) {
+	const normalized = path.posix.normalize(file.replaceAll("\\", "/"));
+	if (!/^(?:src|tooling)\//u.test(normalized)) return void 0;
+	const basename = path.posix.basename(normalized);
+	const directory = path.posix.dirname(normalized);
+	const inPages = directory === "src/tests/pages" || directory.startsWith("src/tests/pages/");
+	const inTests = directory.split("/").includes("__tests__") || inPages;
+	if (isTestSupportModule(normalized)) return void 0;
+	if (!/\.(?:test|spec|test-d)\.[cm]?[jt]sx?$/u.test(basename) && !inTests) return;
+	const expected = expectedSubjects(directory);
+	const dotted = dottedSubject({
+		expected,
+		basename
+	});
+	const candidate = dotted ? `${DOTTED_SUBJECT}${basename.slice(dotted.length)}` : basename;
+	const match = normalized.startsWith("tooling/") ? /^(?<subject>[^.]+)(?<qualifiers>(?:\.[a-z][a-zA-Z0-9]*)*)\.test\.ts$/u.exec(candidate) : /^(?<subject>[^.]+)(?<qualifiers>(?:\.[a-z][a-zA-Z0-9]*)*)(?:\.(?<environment>node|dom|browser|e2e)\.test|\.test-d)\.tsx?$/u.exec(candidate);
+	if (!match?.groups) return "In src/, name the test Name[.qualifier].<node|dom|browser|e2e>.test.ts(x), or Name[.qualifier].test-d.ts(x) for a type test. In tooling/, use Name[.qualifier].test.ts.";
+	const { environment } = match.groups;
+	const subject = dotted ?? match.groups.subject;
+	if (inPages && environment !== "e2e") return "Page tests must use the e2e environment.";
+	if (environment === "e2e" && (!inPages || !subjects[directory])) return "Place e2e tests in src/tests/pages/<Page>/. The accepted pages are listed in @evertondgn/solid-tooling; for another page, turn off project/test-filename for its folder in lint.overrides.";
+	if (!expected) return "Place the test in a __tests__ folder inside the module folder, as in Button/__tests__/Button.dom.test.tsx. For a test folder without a module, turn off project/test-filename for its files in lint.overrides.";
+	if (!subject || !expected.includes(subject)) return `Use the exact name of the subject under test: ${expected.join(", ")}. Qualifiers use a dot and camelCase.`;
+}
+const testFilename = defineRule({
+	meta: {
+		type: "problem",
+		schema: []
+	},
+	create(context) {
+		return { Program(node) {
+			const message = testFilenameError(path.relative(context.cwd, context.filename));
+			if (message) context.report({
+				node,
+				message
+			});
+		} };
+	}
+});
+// src/project-plugin.ts
+const cssModulesImport = defineRule({
+	meta: {
+		type: "suggestion",
+		schema: [],
+		messages: { useS: "Import CSS Modules as S: import S from \"./styles.module.css\"." }
+	},
+	create(context) {
+		return { ImportDeclaration(node) {
+			if (!/\.module\.css(?:[?#].*)?$/u.test(node.source.value)) return;
+			const [specifier] = node.specifiers;
+			if (node.specifiers.length !== 1 || specifier?.type !== "ImportDefaultSpecifier" || specifier.local.name !== "S") context.report({
+				node,
+				messageId: "useS"
+			});
+		} };
+	}
+});
+const plugin = definePlugin({
+	meta: { name: "project" },
+	rules: {
+		"css-modules-import": cssModulesImport,
+		"css-filename": cssFilename,
+		"test-filename": testFilename,
+		"no-export-list": noExportList,
+		"seo-module": seoModule
+	}
+});
+export { plugin as default };

package/dist/solid-plugin.d.mts

@@ -0,0 +1,2 @@
+import eslint_plugin_solid_default from "eslint-plugin-solid";
+export { eslint_plugin_solid_default as default };

package/dist/solid-plugin.mjs

@@ -0,0 +1 @@
+export { default } from "eslint-plugin-solid";

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@evertondgn/solid-tooling",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Lint, formatter and TypeScript presets for SolidJS applications built with Vite+.",
+  "author": "Éverton Toffanetto",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/everton-dgn/solidjs_base.git",
+    "directory": "packages/solid-tooling"
+  },
+  "keywords": [
+    "solidjs",
+    "vite-plus",
+    "oxlint",
+    "lint",
+    "tsconfig"
+  ],
+  "type": "module",
+  "files": [
+    "dist",
+    "tsconfig.base.json"
+  ],
+  "exports": {
+    "./architecture-plugin": "./dist/architecture-plugin.mjs",
+    "./backend-plugin": "./dist/backend-plugin.mjs",
+    "./css-filename": "./dist/css-filename.mjs",
+    "./fmt": "./dist/fmt.mjs",
+    "./lint": "./dist/lint.mjs",
+    "./project-plugin": "./dist/project-plugin.mjs",
+    "./solid-plugin": "./dist/solid-plugin.mjs",
+    "./package.json": "./package.json",
+    "./tsconfig.base.json": "./tsconfig.base.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp run test-rules",
+    "test:tarball": "vp run test-tarball"
+  },
+  "dependencies": {
+    "eslint-plugin-solid": "0.19.0"
+  },
+  "peerDependencies": {
+    "@inlang/paraglide-js": "3.2.2",
+    "vite-plus": "1.6.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"
+  }
+}

package/tsconfig.base.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "es2024",
+    "lib": ["ES2024", "DOM"],
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "noUncheckedIndexedAccess": true,
+    "noImplicitReturns": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "moduleDetection": "force",
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "allowArbitraryExtensions": true,
+    "erasableSyntaxOnly": true,
+    "jsx": "preserve",
+    "jsxImportSource": "@solidjs/web"
+  }
+}