@evertondgn/solid-tooling 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Éverton Toffanetto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,53 @@
-# Temporary Holding Version
+# @evertondgn/solid-tooling
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Lint, formatador e base do TypeScript para aplicações SolidJS construídas com
+Vite+. O pacote é distribuído compilado: o Node recusa TypeScript dentro de
+`node_modules`, e o Vite+ carrega a configuração em Node.
+
+## Instalação
+
+```bash
+vp add -D @evertondgn/solid-tooling
+```
+
+A aplicação também declara o `vite-plus` e o `@inlang/paraglide-js`. O Oxlint
+resolve os plugins a partir da configuração da aplicação, e o plugin do
+Paraglide precisa acompanhar a versão que ela usa. O `eslint-plugin-solid` vem
+como dependência do pacote e dispensa declaração.
+
+## Uso
+
+```ts
+// vite.config.ts
+import { fmt } from '@evertondgn/solid-tooling/fmt'
+import { lint } from '@evertondgn/solid-tooling/lint'
+import { defineConfig } from 'vite-plus'
+
+export default defineConfig({ fmt, lint })
+```
+
+```json
+// tsconfig.json
+{
+  "extends": "@evertondgn/solid-tooling/tsconfig.base.json"
+}
+```
+
+`paths`, `include` e `types` continuam no `tsconfig.json` da aplicação.
+
+## Entradas
+
+| Entrada                 | Conteúdo                                                    |
+| ----------------------- | ----------------------------------------------------------- |
+| `./lint`                | Preset de lint, com os plugins abaixo já registrados        |
+| `./fmt`                 | Configuração do formatador                                  |
+| `./project-plugin`      | Regras de exports, nomes de arquivos de teste e de CSS, SEO |
+| `./backend-plugin`      | Imports estáticos das APIs privilegiadas do servidor        |
+| `./architecture-plugin` | Dependências entre camadas                                  |
+| `./solid-plugin`        | Reexport do `eslint-plugin-solid`                           |
+| `./css-filename`        | Regra de nome de arquivo CSS, para o script de lint de CSS  |
+| `./tsconfig.base.json`  | Opções do compilador sem caminhos da aplicação              |
+
+O preset pressupõe o layout das aplicações derivadas do `boilerplate_solidjs`:
+código em `src/`, ferramentas em `tooling/` e as camadas descritas no guia de
+arquitetura da aplicação.

package/dist/architecture-plugin.d.mts

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

package/dist/architecture-plugin.mjs

@@ -0,0 +1,82 @@
+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/architecturePolicy/index.ts
+const UI = [
+	"atoms",
+	"molecules",
+	"organisms",
+	"components"
+];
+const FORBIDDEN = {
+	base: [
+		"primitives",
+		...UI,
+		"routes",
+		"entry"
+	],
+	primitives: [
+		...UI,
+		"routes",
+		"entry"
+	],
+	atoms: ["molecules", "organisms"],
+	molecules: ["organisms"]
+};
+function layer(file) {
+	if (file === "tooling" || file.startsWith("tooling/")) return "tooling";
+	if (file.startsWith("paraglide/")) return "base";
+	if (!file.startsWith("src/")) return void 0;
+	if (/^src\/tests(?:\/|$)|\/__tests__(?:\/|$)|\.test(?:\.[cm]?[jt]sx?)?$/u.test(file)) return "test";
+	if (/^src\/(?:@types|constants|helpers|data|infra|theme|i18n)(?:\/|$)/u.test(file)) return "base";
+	if (/^src\/primitives(?:\/|$)/u.test(file)) return "primitives";
+	const level = /^src\/components\/(?<level>atoms|molecules|organisms)(?:\/|\.[cm]?[jt]sx?$|$)/u.exec(file)?.groups?.level;
+	if (level === "atoms" || level === "molecules" || level === "organisms") return level;
+	if (/^src\/components(?:\/|$)/u.test(file)) return "components";
+	if (/^src\/routes(?:\/|$)/u.test(file)) return "routes";
+	if (/^src\/(?:App|Document|entry-server|entry-client|router|middleware)(?:\.[cm]?[jt]sx?$|\/|$)/u.test(file)) return "entry";
+	return "source";
+}
+const layerImports = defineRule({
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { forbidden: "A camada {{from}} não pode depender de {{to}} ({{target}}). Consulte as regras de camadas em docs/architecture.md." }
+	},
+	create(context) {
+		const from = layer(path.relative(context.cwd, context.filename).split(path.sep).join("/"));
+		if (!from || from === "test" || from === "tooling") return {};
+		const forbidden = FORBIDDEN[from] ?? [];
+		function check(node) {
+			const specifier = readStaticSpecifier(node);
+			if (specifier === void 0) return;
+			const target = resolveProjectPath({
+				specifier,
+				filename: context.filename,
+				root: context.cwd
+			});
+			const to = layer(target);
+			if (to && (to === "test" || to === "tooling" || forbidden.includes(to))) context.report({
+				node,
+				messageId: "forbidden",
+				data: {
+					from,
+					to,
+					target
+				}
+			});
+		}
+		return {
+			ImportDeclaration: check,
+			ExportNamedDeclaration: check,
+			ExportAllDeclaration: check,
+			ImportExpression: check,
+			TSImportType: check
+		};
+	}
+});
+const architecturePolicy = definePlugin({
+	meta: { name: "architecture" },
+	rules: { "layer-imports": layerImports }
+});
+export { architecturePolicy as default };

package/dist/backend-plugin.d.mts

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

package/dist/backend-plugin.mjs

@@ -0,0 +1,37 @@
+import { t as readStaticSpecifier } from "./import-specifier-C7HWhMXB.mjs";
+import { n as RENDER_INTEGRITY_MODULE } from "./constants-DwOmJ9No.mjs";
+import { definePlugin, defineRule } from "vite-plus/lint/plugins";
+// src/backendPolicy/plugin.ts
+const RENDER_INTEGRITY = new RegExp(RENDER_INTEGRITY_MODULE, "u");
+function staticImportRule({ matches, message }) {
+	return defineRule({
+		meta: {
+			type: "problem",
+			schema: [],
+			messages: { staticImport: message }
+		},
+		create(context) {
+			return { ImportExpression(node) {
+				const specifier = readStaticSpecifier(node);
+				if (specifier !== void 0 && matches(specifier)) context.report({
+					node,
+					messageId: "staticImport"
+				});
+			} };
+		}
+	});
+}
+const backendPlugin = definePlugin({
+	meta: { name: "backend" },
+	rules: {
+		"static-solid-imports": staticImportRule({
+			matches: (specifier) => specifier === "@solidjs/web" || specifier.startsWith("@solidjs/web/"),
+			message: "Use import estático de @solidjs/web e seus subcaminhos para preservar as restrições de APIs privilegiadas."
+		}),
+		"static-render-integrity-imports": staticImportRule({
+			matches: (specifier) => RENDER_INTEGRITY.test(specifier),
+			message: "Use import estático de renderIntegrity para preservar a restrição de observeRenderFailures."
+		})
+	}
+});
+export { backendPlugin as default };

package/dist/constants-DwOmJ9No.mjs

@@ -0,0 +1,7 @@
+// src/backendPolicy/constants.ts
+const RELATIVE_IMPORT_RESTRICTION = {
+	regex: String.raw`^(\.\./){4,}`,
+	message: "Imports relativos podem subir no máximo três níveis. Use o alias @/ para caminhos mais distantes."
+};
+const RENDER_INTEGRITY_MODULE = String.raw`(?:^|/)renderIntegrity(?:/index(?:\.ts)?)?$`;
+export { RENDER_INTEGRITY_MODULE as n, RELATIVE_IMPORT_RESTRICTION as t };

package/dist/css-filename.d.mts

@@ -0,0 +1,2 @@
+export declare function cssFilenameError(file: string): string | undefined;
+export declare const cssFilename: import("vite-plus/lint/plugins").Rule;

package/dist/css-filename.mjs

@@ -0,0 +1,40 @@
+import { n as resolveProjectPath, t as readStaticSpecifier } from "./import-specifier-C7HWhMXB.mjs";
+import { defineRule } from "vite-plus/lint/plugins";
+import path from "node:path";
+// src/css/css-filename.ts
+function cssFilenameError(file) {
+	const normalized = file.split("\\").join("/");
+	const basename = path.posix.basename(normalized);
+	if (normalized.startsWith("src/theme/")) return /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/u.test(basename.slice(0, -4)) ? void 0 : "Use nomeCamelCase.css dentro de src/theme/.";
+	return basename === "styles.module.css" ? void 0 : "Use styles.module.css fora de src/theme/, inclusive nas rotas.";
+}
+const cssFilename = defineRule({
+	meta: {
+		type: "problem",
+		schema: []
+	},
+	create(context) {
+		function check(node) {
+			const specifier = readStaticSpecifier(node);
+			if (specifier === void 0) return;
+			const relative = resolveProjectPath({
+				specifier,
+				filename: context.filename,
+				root: context.cwd
+			});
+			if (!relative.startsWith("src/") || !relative.endsWith(".css")) return;
+			const message = cssFilenameError(relative);
+			if (message) context.report({
+				node,
+				message
+			});
+		}
+		return {
+			ImportDeclaration: check,
+			ExportNamedDeclaration: check,
+			ExportAllDeclaration: check,
+			ImportExpression: check
+		};
+	}
+});
+export { cssFilename, cssFilenameError };

package/dist/fmt.d.mts

@@ -0,0 +1,2 @@
+import { UserConfig } from "vite-plus";
+export declare const fmt: NonNullable<UserConfig['fmt']>;

package/dist/fmt.mjs

@@ -0,0 +1,34 @@
+// src/fmt.ts
+const fmt = {
+	printWidth: 80,
+	singleQuote: true,
+	semi: false,
+	trailingComma: "none",
+	arrowParens: "avoid",
+	proseWrap: "always",
+	sortPackageJson: false,
+	embeddedLanguageFormatting: "off",
+	sortImports: { groups: [
+		"builtin",
+		"external",
+		["internal", "subpath"],
+		[
+			"parent",
+			"sibling",
+			"index"
+		],
+		"style",
+		"unknown"
+	] },
+	ignorePatterns: [
+		"public/**",
+		"src/assets/**",
+		"src/@types/routes.d.ts",
+		"**/*.svg",
+		"*.lock",
+		"AGENTS.md",
+		".agents/**",
+		".claude/**"
+	]
+};
+export { fmt };

package/dist/import-specifier-C7HWhMXB.mjs

@@ -0,0 +1,25 @@
+import path from "node:path";
+// src/lint/import-specifier.ts
+function resolveAbsolute({ specifier, filename, root }) {
+	if (specifier.startsWith("@paraglide/")) return path.resolve(root, "paraglide", specifier.slice(11));
+	if (specifier.startsWith("@/")) return path.resolve(root, "src", specifier.slice(2));
+	if (specifier.startsWith("/src/")) return path.resolve(root, specifier.slice(1));
+	if (specifier.startsWith(".")) return path.resolve(path.dirname(filename), specifier);
+}
+function readStaticSpecifier({ source }) {
+	if (source?.type === "Literal") return typeof source.value === "string" ? source.value : void 0;
+	if (source?.type !== "TemplateLiteral" || source.expressions.length > 0) return;
+	const cooked = source.quasis[0]?.value.cooked;
+	return typeof cooked === "string" ? cooked : void 0;
+}
+function resolveProjectPath({ specifier, filename, root }) {
+	const [clean = ""] = specifier.replaceAll("\\", "/").split(/[?#]/u);
+	const absolute = resolveAbsolute({
+		specifier: clean,
+		filename,
+		root
+	});
+	if (absolute === void 0) return "";
+	return path.relative(root, absolute).split(path.sep).join("/");
+}
+export { resolveProjectPath as n, readStaticSpecifier as t };

package/dist/lint.d.mts

@@ -0,0 +1,2 @@
+import { UserConfig } from "vite-plus";
+export declare const lint: NonNullable<UserConfig['lint']>;