@rendra-ui/web 2.3.0 → 2.5.0

package/dist/cli/executar-auditar.js

@@ -0,0 +1,634 @@
+/*! Rendra Design System v2.5.0 | MIT | © 2026 Bruno Magalhaes | brunomagalhaes.me */
+import { EXTENSAO_VARRIDA, IDS_REGRAS_GENERICAS, auditLines, auditar, casaPrefixo, coletarArquivos, percorrer, relativoA } from "./auditar.js";
+import { formatHelp } from "./help.js";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+//#region src/cli/help-length.ts
+/** Limite de caracteres da orientação abaixo do campo, pela largura (span) do Field. */
+var HELP_LIMITS = {
+	full: 150,
+	xl: 100,
+	lg: 70,
+	md: 40,
+	half: 40,
+	sm: 30,
+	xs: 20
+};
+/** Verbos no imperativo que denunciam instrução num subtítulo. */
+var INSTRUCTION_VERBS = [
+	"Comece",
+	"Clique",
+	"Toque",
+	"Arraste",
+	"Preencha",
+	"Use",
+	"Escolha",
+	"Selecione",
+	"Digite",
+	"Informe",
+	"Veja",
+	"Confira"
+];
+/** Limite do span; sem span (ou span desconhecido), vale o padrão md. */
+function helpLimit(span) {
+	return span && span in HELP_LIMITS ? HELP_LIMITS[span] : HELP_LIMITS.md;
+}
+/** Quantidade de caracteres (por ponto de código, para acento e emoji contarem 1). */
+function textLength(text) {
+	return [...text.trim()].length;
+}
+var QUOTES = /* @__PURE__ */ new Set([
+	"\"",
+	"'",
+	"`"
+]);
+/** Pula uma string que começa em `i` (aspas); devolve o índice logo após o fechamento. */
+function skipString(text, i) {
+	const quote = text[i];
+	let j = i + 1;
+	while (j < text.length && text[j] !== quote) j += text[j] === "\\" ? 2 : 1;
+	return j + 1;
+}
+/**
+* Lê a tag de abertura JSX que começa em `start` (no "<") até o ">" que a fecha, ignorando o
+* que está dentro de chaves (render={(f) => <Input />}) e de strings.
+*/
+function readTag(text, start) {
+	let i = start + 1;
+	while (i < text.length && /[\w.]/.test(text[i])) i++;
+	if (text[i] === "<") {
+		let angle = 0;
+		for (; i < text.length; i++) if (text[i] === "<") angle++;
+		else if (text[i] === ">" && --angle === 0) {
+			i++;
+			break;
+		}
+	}
+	let depth = 0;
+	while (i < text.length) {
+		const c = text[i];
+		if (QUOTES.has(c)) {
+			i = skipString(text, i);
+			continue;
+		}
+		if (c === "{") depth++;
+		else if (c === "}") depth--;
+		else if (c === ">" && depth === 0) {
+			i++;
+			break;
+		}
+		i++;
+	}
+	return {
+		start,
+		end: i,
+		text: text.slice(start, i)
+	};
+}
+/** Atributo `name` no nível de topo da tag (fora de chaves), literal ou dinâmico. */
+function readAttr(tag, name) {
+	let depth = 0;
+	let i = 0;
+	while (i < tag.length) {
+		const c = tag[i];
+		if (depth > 0 && QUOTES.has(c)) {
+			i = skipString(tag, i);
+			continue;
+		}
+		if (c === "{") depth++;
+		else if (c === "}") depth--;
+		else if (depth === 0 && QUOTES.has(c)) {
+			i = skipString(tag, i);
+			continue;
+		} else if (depth === 0 && /\s/.test(tag[i - 1] ?? "") && tag.startsWith(`${name}=`, i)) return parseValue(tag, i + name.length + 1);
+		i++;
+	}
+}
+function parseValue(tag, i) {
+	const c = tag[i];
+	if (c === "\"" || c === "'") return { literal: tag.slice(i + 1, skipString(tag, i) - 1) };
+	if (c !== "{") return { dynamic: true };
+	let depth = 0;
+	let j = i;
+	for (; j < tag.length; j++) {
+		if (depth > 0 && QUOTES.has(tag[j])) {
+			j = skipString(tag, j) - 1;
+			continue;
+		}
+		if (tag[j] === "{") depth++;
+		else if (tag[j] === "}" && --depth === 0) break;
+	}
+	const inner = tag.slice(i + 1, j).trim();
+	const quoted = /^(["'`])([\s\S]*)\1$/.exec(inner);
+	if (quoted && !(quoted[1] === "`" && quoted[2].includes("${"))) return { literal: quoted[2] };
+	return { dynamic: true };
+}
+function lineOf(text, index) {
+	return text.slice(0, index).split("\n").length;
+}
+function firstLine(text) {
+	return text.split("\n")[0].trim();
+}
+/** Tags de abertura de um componente (nome exato, sem pegar <FieldGroup> por <Field>). */
+function tagsOf(text, names, from = 0, to = text.length) {
+	const re = new RegExp(`<(?:${names.join("|")})(?=[\\s<>/])`, "g");
+	re.lastIndex = from;
+	const tags = [];
+	for (let m = re.exec(text); m && m.index < to; m = re.exec(text)) {
+		const tag = readTag(text, m.index);
+		tags.push(tag);
+		re.lastIndex = tag.end;
+	}
+	return tags;
+}
+/** help literal (não vazio) de uma tag de Field ou FormField, ou undefined. */
+function literalHelp(tag) {
+	const help = readAttr(tag, "help");
+	return help && "literal" in help && help.literal.trim() ? help.literal : void 0;
+}
+/** Orientação abaixo do campo acima do limite do span. */
+function checkFieldHelp(text) {
+	const found = [];
+	for (const tag of tagsOf(text, ["Field", "FormField"])) {
+		const help = literalHelp(tag.text);
+		if (!help) continue;
+		const span = readAttr(tag.text, "span");
+		if (span && !("literal" in span)) continue;
+		const spanName = span && "literal" in span ? span.literal : "md";
+		const limit = helpLimit(spanName);
+		const size = textLength(help);
+		if (size <= limit) continue;
+		found.push({
+			line: lineOf(text, tag.start),
+			id: "texto-orientativo",
+			message: `Orientação do campo com ${size} caracteres; o limite para span="${spanName}" é ${limit}. Encurte, ou mova para help da seção (modal) ou um bloco recolhido.`,
+			src: firstLine(tag.text)
+		});
+	}
+	return found;
+}
+/** Por FormSection: no máximo metade dos campos com orientação literal. */
+function checkSectionHelp(text) {
+	const found = [];
+	for (const section of tagsOf(text, ["FormSection"])) {
+		const close = text.indexOf("</FormSection>", section.end);
+		const end = close === -1 ? text.length : close;
+		const fields = tagsOf(text, ["Field", "FormField"], section.end, end);
+		const withHelp = fields.filter((f) => literalHelp(f.text)).length;
+		if (withHelp * 2 <= fields.length) continue;
+		found.push({
+			line: lineOf(text, section.start),
+			id: "texto-orientativo",
+			message: `Seção com orientação em ${withHelp} de ${fields.length} campos. No máximo metade dos campos de uma seção tem orientação.`,
+			src: firstLine(section.text)
+		});
+	}
+	return found;
+}
+/** description literal do PageHeader acima de 150 caracteres. */
+function checkPageDescription(text) {
+	const found = [];
+	for (const tag of tagsOf(text, ["PageHeader"])) {
+		const description = readAttr(tag.text, "description");
+		if (!description || !("literal" in description)) continue;
+		const size = textLength(description.literal);
+		if (size <= 150) continue;
+		found.push({
+			line: lineOf(text, tag.start),
+			id: "texto-orientativo",
+			message: `Descrição da tela com ${size} caracteres; o limite é 150. Ela diz o que a tela é; orientação vai em PageHeader help.`,
+			src: firstLine(tag.text)
+		});
+	}
+	return found;
+}
+var INSTRUCTION = new RegExp(`(?:description=\\{?\\s*["'\`]|<CardDescription>\\s*)(?:${INSTRUCTION_VERBS.join("|")})\\b`, "g");
+/** Subtítulo que começa com verbo de instrução (description e CardDescription). */
+function checkInstruction(text) {
+	return [...text.matchAll(INSTRUCTION)].map((m) => ({
+		line: lineOf(text, m.index),
+		id: "texto-orientativo",
+		message: "Instrução no subtítulo. Use help (PageHeader, CardTitle ou FormSection): ícone de informação que abre um modal.",
+		src: firstLine(m[0])
+	}));
+}
+/** Todas as verificações de texto orientativo de uma tela, em ordem de linha. */
+function checkGuidance(text) {
+	return [
+		...checkFieldHelp(text),
+		...checkSectionHelp(text),
+		...checkPageDescription(text),
+		...checkInstruction(text)
+	].sort((a, b) => a.line - b.line);
+}
+//#endregion
+//#region src/cli/var-prefix.ts
+var RENDRA_VAR_EXACT = /* @__PURE__ */ new Set([
+	"primary",
+	"primary-foreground",
+	"primary-hover",
+	"primary-hover-foreground",
+	"secondary",
+	"secondary-foreground",
+	"secondary-hover",
+	"secondary-hover-foreground",
+	"primary-soft",
+	"primary-soft-foreground",
+	"primary-text",
+	"ring",
+	"accent",
+	"accent-foreground",
+	"background",
+	"background-image",
+	"foreground",
+	"card",
+	"card-foreground",
+	"popover",
+	"popover-foreground",
+	"muted",
+	"muted-foreground",
+	"border",
+	"input",
+	"field",
+	"overlay",
+	"destructive",
+	"destructive-hover",
+	"destructive-foreground",
+	"destructive-soft",
+	"destructive-soft-foreground",
+	"success",
+	"success-foreground",
+	"success-soft",
+	"success-soft-foreground",
+	"warning",
+	"warning-foreground",
+	"warning-soft",
+	"warning-soft-foreground",
+	"info",
+	"info-foreground",
+	"info-soft",
+	"info-soft-foreground",
+	"shadow-color",
+	"brand-font",
+	"radius",
+	"sidebar"
+]);
+var RENDRA_VAR_PREFIXES = [
+	"sidebar-",
+	"gradient-",
+	"chart-",
+	"elevation-",
+	"shape-",
+	"meter-",
+	"label-",
+	"help-"
+];
+/** Fonte da verdade: `name` (sem os `--`) é vocabulário próprio do tema do Rendra? */
+function isRendraOwnVar(name) {
+	if (RENDRA_VAR_EXACT.has(name)) return true;
+	return RENDRA_VAR_PREFIXES.some((p) => name.startsWith(p));
+}
+/**
+* Varre `var(--x)` do arquivo inteiro, pulando o bloco @theme / @theme inline (a ponte
+* documentada entre o nome do Tailwind e o nome do Rendra, ex.:
+* --color-primary: var(--rendra-primary)) e comentários.
+*/
+function checkVarPrefix(text) {
+	const found = [];
+	const lines = text.split("\n");
+	let themeDepth = 0;
+	lines.forEach((line, i) => {
+		if (themeDepth === 0 && /^\s*@theme\b/.test(line)) {
+			themeDepth += (line.match(/\{/g)?.length ?? 0) - (line.match(/\}/g)?.length ?? 0);
+			return;
+		}
+		if (themeDepth > 0) {
+			themeDepth += (line.match(/\{/g)?.length ?? 0) - (line.match(/\}/g)?.length ?? 0);
+			if (themeDepth < 0) themeDepth = 0;
+			return;
+		}
+		if (/^\s*(\/\/|\*|\/\*)/.test(line)) return;
+		for (const m of line.matchAll(/var\(--([a-zA-Z][\w-]*)\)/g)) {
+			const name = m[1];
+			if (name.startsWith("rendra-")) continue;
+			if (!isRendraOwnVar(name)) continue;
+			found.push({
+				line: i + 1,
+				name,
+				message: `Variável própria do Rendra sem o prefixo --rendra-. Use var(--rendra-${name}).`,
+				src: line.trim()
+			});
+		}
+	});
+	return found;
+}
+//#endregion
+//#region src/cli/regras-extras.ts
+/** Identificadores das regras extras, na ordem em que a documentação as lista. */
+var IDS_REGRAS_EXTRAS = [
+	"var-inline",
+	"svg-marca",
+	"classe-dinamica",
+	"texto-estreito",
+	"primaria-como-texto",
+	"componente-duplicado",
+	"css-fora-do-lugar",
+	"botao-solto",
+	"texto-orientativo",
+	"variavel-sem-prefixo-rendra"
+];
+/** As cinco regras de uma linha só, na ordem em que eram verificadas. */
+var REGRAS_POR_LINHA = [
+	{
+		id: "var-inline",
+		test: /var\(--(?:color|radius|shadow|font|spacing)-/g,
+		message: "Variáveis --color-*, --radius-* etc. do Tailwind são inline e não existem no CSS. Em JS use as do tema: var(--rendra-primary), var(--rendra-chart-1), var(--rendra-shape-control)."
+	},
+	{
+		id: "svg-marca",
+		test: /from\s+['"][^'"]*brand\/assets[^'"]*['"]/g,
+		message: "SVG de marca importado fora de src/brand. Leia o logotipo e o símbolo via useBrand()."
+	},
+	{
+		id: "classe-dinamica",
+		test: /(?<![\w-])(?:[a-z]+:)*-?(?:p[xytrbl]?|m[xytrbl]?|gap(?:-[xy])?|w|h|size|min-[wh]|max-[wh]|inset|top|left|right|bottom|z|text|bg|border(?:-[xytrbl])?|rounded(?:-[a-z]+)?|grid-cols|grid-rows|col-span|row-span|space-[xy]|translate-[xy]|opacity|font|leading|tracking|shadow|ring|fill|stroke|line-clamp|basis|order)-\$\{/g,
+		message: "Classe montada por template string não é gerada pelo Tailwind. Escreva a classe inteira (mapa de valores) ou use variável CSS.",
+		skipLine: (line) => /^\s*(\/\/|\*|\/\*)/.test(line)
+	},
+	{
+		id: "texto-estreito",
+		test: /<p\s[^>]*className=["'{][^>]*max-w-/g,
+		message: "Texto ocupa 100% da largura disponível. Limite de largura (max-w-*) em parágrafo só quando o layout pedir outra medida."
+	},
+	{
+		id: "primaria-como-texto",
+		test: /(?<![\w-])(?:[\w-]+:)*text-primary(?![\w-])/g,
+		message: "Primária como texto usa text-primary-text (tom que passa AA no claro e no escuro). text-primary é só para o preenchimento."
+	}
+];
+/**
+* Varre o texto linha a linha contra as cinco regras de uma linha (`var-inline`, `svg-marca`,
+* `classe-dinamica`, `texto-estreito`, `primaria-como-texto`). Por linha, as regras saem na
+* ordem da lista acima.
+*/
+function regrasPorLinha(text) {
+	const found = [];
+	text.split("\n").forEach((line, i) => {
+		for (const regra of REGRAS_POR_LINHA) {
+			if (regra.skipLine?.(line)) continue;
+			regra.test.lastIndex = 0;
+			if (regra.test.test(line)) found.push({
+				line: i + 1,
+				rule: regra.id,
+				message: regra.message,
+				source: line.trim()
+			});
+		}
+	});
+	return found;
+}
+var NOME_PROIBIDO = /(Mobile|Simples|Simple|ComBusca|Grande|Pequeno|Small|Large)\.(t|j)sx?$/i;
+var NOME_PROIBIDO_KEBAB = /-(mobile|simples|simple|com-busca|grande|pequeno)\.(t|j)sx?$/i;
+/** `componente-duplicado`: pelo NOME do arquivo (variante mobile ou paralela). Linha 0. */
+function componenteDuplicado(caminho) {
+	if (!NOME_PROIBIDO.test(caminho) && !NOME_PROIBIDO_KEBAB.test(caminho)) return void 0;
+	return {
+		line: 0,
+		rule: "componente-duplicado",
+		message: "Arquivo de variante paralela ou mobile. Resolva com props no componente único.",
+		source: ""
+	};
+}
+/** `css-fora-do-lugar`: quem chama já decidiu que o `.css` está fora das pastas de marca. */
+function cssForaDoLugar() {
+	return {
+		line: 0,
+		rule: "css-fora-do-lugar",
+		message: "CSS fora de src/styles e src/brand. Estilo de componente é classe do Tailwind; token vai em globals.css; marca, em theme.css.",
+		source: ""
+	};
+}
+var BOTAO_SOLTO = /<CardContent\b[^>]*>\s*(?:<Stack\b[^>]*>\s*)?<Button\b|<Button\b[^>]*\bself-(?:start|end|center)\b/g;
+/** `botao-solto`: olha o arquivo inteiro (JSX em várias linhas); só nas telas do sistema. */
+function botaoSolto(text) {
+	return [...text.matchAll(BOTAO_SOLTO)].map((m) => ({
+		line: text.slice(0, m.index).split("\n").length,
+		rule: "botao-solto",
+		message: "Botão solto no conteúdo. Ação de card vai em CardHeader actions; da tela, no PageHeader actions ou na ActionBar.",
+		source: m[0].split("\n")[0].trim()
+	}));
+}
+/** `texto-orientativo` (regra C7, em help-length.ts), no formato de `AuditViolation`. */
+function textoOrientativo(text) {
+	return checkGuidance(text).map((p) => ({
+		line: p.line,
+		rule: p.id,
+		message: p.message,
+		source: p.src
+	}));
+}
+/** `variavel-sem-prefixo-rendra` (em var-prefix.ts), no formato de `AuditViolation`. */
+function variavelSemPrefixo(text) {
+	return checkVarPrefix(text).map((p) => ({
+		line: p.line,
+		rule: "variavel-sem-prefixo-rendra",
+		message: p.message,
+		source: p.src
+	}));
+}
+//#endregion
+//#region src/cli/auditar-tudo.ts
+/** Os 17 identificadores de regra, na ordem da documentação (genéricas e depois extras). */
+var IDS_TODAS_AS_REGRAS = [...IDS_REGRAS_GENERICAS, ...IDS_REGRAS_EXTRAS];
+/** Padrões do boilerplate Rendra, usados quando o projeto não diz outra coisa. */
+var PASTAS_MARCA_PADRAO = ["src/brand", "src/styles"];
+var PASTAS_TELAS_PADRAO = ["src/pages/app"];
+var PASTAS_MARCA_REPOSITORIO = [...PASTAS_MARCA_PADRAO, "src/cli"];
+/** Arquivos do modo `repositorio`: tudo sob `src`, sem pular nada, na ordem do sistema. */
+function arquivosDoRepositorio(cwd) {
+	const src = join(cwd, "src");
+	if (!existsSync(src)) return [];
+	return percorrer(src, () => false).filter((f) => EXTENSAO_VARRIDA.test(f));
+}
+/**
+* Varre `cwd` com as 17 regras. Não lê `rendra.config.json` (quem lê é `executarAuditar`),
+* não imprime e não lança.
+*/
+function auditarTudo(cwd, opcoes = {}) {
+	const repositorio = opcoes.modo === "repositorio";
+	const marca = opcoes.pastasMarca ?? (repositorio ? PASTAS_MARCA_REPOSITORIO : PASTAS_MARCA_PADRAO);
+	const telas = opcoes.pastasTelas ?? PASTAS_TELAS_PADRAO;
+	const ligada = (id) => opcoes.regras?.[id] !== false;
+	const dentro = (arquivo, rel, pastas) => repositorio ? pastas.some((p) => arquivo.startsWith(join(cwd, p))) : casaPrefixo(rel, pastas);
+	const arquivos = repositorio ? arquivosDoRepositorio(cwd) : coletarArquivos(cwd, opcoes);
+	const problemas = [];
+	const emitir = (file, achados) => {
+		for (const a of achados) if (ligada(a.rule)) problemas.push({
+			file,
+			...a
+		});
+	};
+	for (const arquivo of arquivos) {
+		const rel = relativoA(cwd, arquivo);
+		const duplicado = componenteDuplicado(repositorio ? arquivo : rel);
+		if (duplicado) emitir(rel, [duplicado]);
+		const texto = readFileSync(arquivo, "utf8");
+		emitir(rel, variavelSemPrefixo(texto));
+		if (dentro(arquivo, rel, marca)) continue;
+		if (arquivo.endsWith(".css")) {
+			emitir(rel, [cssForaDoLugar()]);
+			continue;
+		}
+		if (dentro(arquivo, rel, telas)) {
+			emitir(rel, textoOrientativo(texto));
+			emitir(rel, botaoSolto(texto));
+		}
+		emitir(rel, auditLines(texto));
+		emitir(rel, regrasPorLinha(texto));
+	}
+	if (!repositorio) problemas.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
+	return {
+		violacoes: problemas,
+		arquivos: arquivos.length
+	};
+}
+//#endregion
+//#region src/cli/argumentos.ts
+/** As flags que `rendra auditar` entende. */
+var FLAGS_AUDITAR = [
+	"--all",
+	"--ignore",
+	"--help"
+];
+var MENSAGEM_SEM_VALOR = "Falta o valor de --ignore. Use --ignore a,b, --ignore a --ignore b ou --ignore=a,b.";
+var itens = (valor) => valor.split(",").map((s) => s.trim()).filter((s) => s !== "");
+/** Lê os argumentos que vêm depois de `auditar`. Erro volta como `{ erro }`, nunca lança. */
+function lerArgumentosAuditar(rest) {
+	const lido = {
+		pastas: [],
+		ignorar: [],
+		todas: false,
+		ajuda: false
+	};
+	for (let i = 0; i < rest.length; i++) {
+		const arg = rest[i];
+		if (arg === "--all") lido.todas = true;
+		else if (arg === "--help" || arg === "-h") lido.ajuda = true;
+		else if (arg === "--ignore" || arg.startsWith("--ignore=")) {
+			let bruto;
+			if (arg === "--ignore") {
+				const proximo = rest[i + 1];
+				if (proximo !== void 0 && !proximo.startsWith("-")) {
+					bruto = proximo;
+					i++;
+				}
+			} else bruto = arg.slice(9);
+			const valores = bruto === void 0 ? [] : itens(bruto);
+			if (valores.length === 0) return { erro: MENSAGEM_SEM_VALOR };
+			lido.ignorar.push(...valores);
+		} else if (arg.startsWith("-")) return { erro: `Flag desconhecida: ${arg}. Flags aceitas: ${FLAGS_AUDITAR.join(", ")}.` };
+		else lido.pastas.push(arg);
+	}
+	return lido;
+}
+//#endregion
+//#region src/cli/config.ts
+var NOME_ARQUIVO_CONFIG = "rendra.config.json";
+var CHAVES_CONFIG = [
+	"pastas",
+	"ignorar",
+	"regras",
+	"pastasMarca",
+	"pastasTelas"
+];
+var CHAVES_LISTA = [
+	"pastas",
+	"ignorar",
+	"pastasMarca",
+	"pastasTelas"
+];
+var ehObjeto = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var erro = (mensagem) => ({ erro: `${NOME_ARQUIVO_CONFIG}: ${mensagem}` });
+/** Lê e valida `rendra.config.json` em `base`. Ausente devolve `{ config: {} }`. */
+function carregarConfig(base) {
+	const caminho = join(base, NOME_ARQUIVO_CONFIG);
+	let texto;
+	try {
+		texto = readFileSync(caminho, "utf8");
+	} catch (e) {
+		if (e.code === "ENOENT") return { config: {} };
+		return erro(`não consegui ler o arquivo (${e.message}).`);
+	}
+	let dados;
+	try {
+		dados = JSON.parse(texto.charCodeAt(0) === 65279 ? texto.slice(1) : texto);
+	} catch (e) {
+		return erro(`JSON inválido (${e.message}).`);
+	}
+	if (!ehObjeto(dados)) return erro("o conteúdo precisa ser um objeto JSON ({ ... }).");
+	for (const chave of Object.keys(dados)) if (!CHAVES_CONFIG.includes(chave)) return erro(`chave desconhecida "${chave}". Chaves aceitas: ${CHAVES_CONFIG.join(", ")}.`);
+	const config = {};
+	for (const chave of CHAVES_LISTA) {
+		const valor = dados[chave];
+		if (valor === void 0) continue;
+		if (!Array.isArray(valor) || !valor.every((x) => typeof x === "string")) return erro(`"${chave}" precisa ser uma lista de textos.`);
+		config[chave] = valor;
+	}
+	if (dados.regras !== void 0) {
+		if (!ehObjeto(dados.regras)) return erro("\"regras\" precisa ser um objeto ({ \"<id>\": false }).");
+		const regras = {};
+		for (const [id, ligada] of Object.entries(dados.regras)) {
+			if (!IDS_TODAS_AS_REGRAS.includes(id)) return erro(`regra desconhecida "${id}". Regras válidas: ${IDS_TODAS_AS_REGRAS.join(", ")}.`);
+			if (typeof ligada !== "boolean") return erro(`"regras.${id}" precisa ser true ou false.`);
+			regras[id] = ligada;
+		}
+		config.regras = regras;
+	}
+	return { config };
+}
+//#endregion
+//#region src/cli/executar-auditar.ts
+/**
+* Pasta relativa à base, com `/`, ou `undefined` quando resolve fora dela. Pasta absoluta
+* dentro da base vale; a própria base vira `.`.
+*/
+function pastaNaBase(base, pasta) {
+	const rel = relative(base, resolve(base, pasta));
+	if (rel === ".." || rel.startsWith(".." + sep) || isAbsolute(rel)) return void 0;
+	return rel === "" ? "." : rel.split(sep).join("/");
+}
+/** Roda `rendra auditar` com os argumentos de `rest` (o que vem depois de `auditar`). */
+function executarAuditar(rest, cwdProcesso) {
+	const args = lerArgumentosAuditar(rest);
+	if ("erro" in args) return { erro: args.erro };
+	if (args.ajuda) return { ajuda: formatHelp() };
+	const base = args.pastas.length === 1 ? resolve(cwdProcesso, args.pastas[0]) : cwdProcesso;
+	const lida = carregarConfig(base);
+	if ("erro" in lida) return { erro: lida.erro };
+	const config = lida.config;
+	const pedidas = args.pastas.length >= 2 ? args.pastas : config.pastas ?? [];
+	const pastas = [];
+	for (const pasta of pedidas) {
+		const dentro = pastaNaBase(base, pasta);
+		if (dentro === void 0) return { erro: `A pasta "${pasta}" fica fora de ${base}. Use só pastas dentro do projeto.` };
+		pastas.push(dentro);
+	}
+	const opcoes = {
+		...pastas.length > 0 ? { pastas } : {},
+		ignorar: args.ignorar.length > 0 ? args.ignorar : config.ignorar ?? [],
+		...config.regras ? { regras: config.regras } : {}
+	};
+	if (args.todas) {
+		const { violacoes } = auditarTudo(base, {
+			...opcoes,
+			...config.pastasMarca ? { pastasMarca: config.pastasMarca } : {},
+			...config.pastasTelas ? { pastasTelas: config.pastasTelas } : {}
+		});
+		return { violacoes };
+	}
+	return { violacoes: auditar(base, opcoes) };
+}
+//#endregion
+export { executarAuditar };
+
+//# sourceMappingURL=executar-auditar.js.map