@evertondgn/solid-tooling 0.0.0-stage → 0.1.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: "Declare o export junto da declaração (export function, export const, export type) em vez de usar export { ... }. Lista de exports só vale em reexport com 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: "O seo.ts exporta só o objeto seo. O corpo da página fica no index.tsx, porque o seo.ts entra no bundle inicial pelo route (AGENTS.md, Módulos de página).",
+			localImport: "O seo.ts não importa módulos locais como valor: o que ele importa entra no bundle inicial junto com o route. Mantenha o corpo da página no index.tsx (AGENTS.md, Módulos de página).",
+			computedImport: "O seo.ts não usa import() com caminho calculado: a regra não consegue conferir se o destino é local. Mantenha o corpo da página no index.tsx (AGENTS.md, Módulos de página).",
+			globImport: "O seo.ts não usa import.meta.glob: o Vite o converte em imports dos módulos que o padrão casa. Mantenha o corpo da página no index.tsx (AGENTS.md, Módulos de página)."
+		}
+	},
+	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 "Use Nome[.qualificador].ambiente.test.ts(x) ou Nome[.qualificador].test-d.ts(x) para tipos em src, ou Nome[.qualificador].test.ts em tooling.";
+	const { environment } = match.groups;
+	const subject = dotted ?? match.groups.subject;
+	if (inPages && environment !== "e2e") return "Testes de páginas devem usar o ambiente e2e.";
+	if (environment === "e2e" && (!inPages || !subjects[directory])) return "Coloque testes e2e em src/tests/pages/NomeDaPagina e declare a página no mapeamento.";
+	if (!expected) return "Coloque o teste em __tests__ junto ao módulo ou declare sua suíte no mapeamento de tooling/test-filename.ts.";
+	if (!subject || !expected.includes(subject)) return `Use o nome exato do assunto testado: ${expected.join(", ")}. Qualificadores usam ponto e 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: "Importe CSS Modules como 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,59 @@
 {
   "name": "@evertondgn/solid-tooling",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.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",
+    "prepublishOnly": "vp pack"
+  },
+  "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"
+  }
+}