@bluemarble/bi 0.4.0 → 0.6.0

package/dist/{layout-676sEvvb.js → layout-BS51SQcJ.js}

@@ -1,350 +1,146 @@
-//#region src/star.ts
-/** `'tabela.coluna'` -> `{ table, column }` (nulo se não tiver esse formato). */
-function parseColumnRef(ref) {
-	if (typeof ref !== "string") return null;
-	const match = /^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)$/.exec(ref.trim());
-	return match ? {
-		table: match[1],
-		column: match[2]
-	} : null;
-}
-/** Relacionamentos válidos do modelo, como arestas N -> 1. */
-function modelEdges(model) {
-	return (model.relationships ?? []).flatMap((relationship, index) => {
-		const from = parseColumnRef(relationship?.from);
-		const to = parseColumnRef(relationship?.to);
-		return from && to ? [{
-			from,
-			to,
-			index,
-			inner: relationship.inner === true
-		}] : [];
-	});
-}
-const escapeRegex = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-/**
-* Tabelas citadas no SQL como `tabela.coluna`. O que está entre aspas simples é ignorado, para
-* `'a.b'` num literal não contar como referência.
-*/
-function referencedTables(sql, tables) {
-	const code = sql.replace(/'(?:[^'\\]|\\.)*'/g, "''");
-	return tables.filter((name) => new RegExp(`(?<![\\w.\`])${escapeRegex(name)}\\.`).test(code));
-}
-/** Busca em largura a partir de `start`, seguindo os relacionamentos no sentido N -> 1. */
-function reachFrom(start, edges) {
-	const paths = /* @__PURE__ */ new Map([[start, []]]);
-	let frontier = [start];
-	while (frontier.length) {
-		const next = [];
-		for (const table of frontier) for (const edge of edges) {
-			if (edge.from.table !== table || paths.has(edge.to.table)) continue;
-			paths.set(edge.to.table, [...paths.get(table) ?? [], {
-				table: edge.to.table,
-				edge
-			}]);
-			next.push(edge.to.table);
-		}
-		frontier = next;
-	}
-	const incoming = /* @__PURE__ */ new Map();
-	for (const edge of edges) if (paths.has(edge.from.table)) incoming.set(edge.to.table, (incoming.get(edge.to.table) ?? 0) + 1);
-	return {
-		paths,
-		ambiguous: [...incoming].filter(([table, count]) => table !== start && count > 1).map(([table]) => table)
-	};
-}
-/**
-* Tabelas que precisam entrar na consulta, na ordem do JOIN, para que a partir de `home` se chegue
-* a todas as `targets`. Como cada tabela é alcançada por um caminho só (o modelo valida ambiguidade),
-* a união dos caminhos é uma árvore: cada tabela entra uma vez, ligada pela aresta de quem veio antes.
-*/
-function joinPlan(home, targets, edges) {
-	const { paths } = reachFrom(home, edges);
-	const plan = [];
-	const added = /* @__PURE__ */ new Set([home]);
-	const include = (target) => {
-		for (const step of paths.get(target) ?? []) {
-			if (added.has(step.table)) continue;
-			added.add(step.table);
-			plan.push(step);
-		}
-	};
-	for (const target of targets) include(target);
-	for (let grew = true; grew;) {
-		grew = false;
-		for (const edge of edges) if (edge.inner && added.has(edge.from.table) && !added.has(edge.to.table)) {
-			include(edge.to.table);
-			grew = true;
-		}
-	}
-	const depth = (table) => paths.get(table)?.length ?? 0;
-	return plan.sort((a, b) => depth(a.table) - depth(b.table));
-}
-/**
-* Tabela de origem de uma medida `sum`: entre as tabelas que o SQL cita, a que alcança todas as
-* outras (ex.: `fPesagem.peso * dProduto.fator` agrega em `fPesagem`). Nulo se nenhuma alcança.
-*/
-function measureHome(tables, edges) {
-	if (!tables.length) return null;
-	return tables.find((candidate) => {
-		const { paths } = reachFrom(candidate, edges);
-		return tables.every((table) => paths.has(table));
-	}) ?? null;
-}
-//#endregion
-//#region src/model.ts
-const VALUE_FORMATS = [
-	"number",
-	"integer",
-	"currency",
-	"percent"
+import { l as isAggregate, s as VALUE_FORMATS } from "./codegen-DBe4-XW_.js";
+//#region src/formatRules.ts
+const COLUMN_ALIGNS = [
+	"left",
+	"center",
+	"right"
 ];
-/**
-* Agregações sobre uma expressão SQL (`tabela.coluna`). Todas valem nos dois formatos; no estrela,
-* agregam no grão da tabela de origem, como a soma.
-*/
-const AGGREGATIONS = [
-	"sum",
-	"count",
-	"countDistinct",
-	"avg",
-	"min",
-	"max"
+const COLUMN_VERTICAL_ALIGNS = [
+	"top",
+	"middle",
+	"bottom"
+];
+const RULE_OPERATORS = [
+	">",
+	">=",
+	"<",
+	"<=",
+	"=",
+	"!=",
+	"between",
+	"contains",
+	"empty",
+	"notEmpty"
 ];
-const AGGREGATION_LABEL = {
-	sum: "Soma",
-	count: "Contagem",
-	countDistinct: "Contagem distinta",
-	avg: "Média",
-	min: "Mínimo",
-	max: "Máximo"
+const RULE_OPERATOR_LABEL = {
+	">": "maior que",
+	">=": "maior ou igual a",
+	"<": "menor que",
+	"<=": "menor ou igual a",
+	"=": "igual a",
+	"!=": "diferente de",
+	between: "entre",
+	contains: "contém",
+	empty: "vazio",
+	notEmpty: "não vazio"
 };
-const isAggregate = (measure) => AGGREGATIONS.includes(measure.type);
-/** O SQL agregado da medida: `SUM(x)`, `COUNT(DISTINCT x)`, `AVG(x)`... */
-function aggregateSql(measure) {
-	if (measure.type === "countDistinct") return `COUNT(DISTINCT ${measure.sql})`;
-	return `${{
-		sum: "SUM",
-		count: "COUNT",
-		avg: "AVG",
-		min: "MIN",
-		max: "MAX"
-	}[measure.type]}(${measure.sql})`;
-}
-/** Nomes citados como `{nome}` numa fórmula. */
-const formulaRefs = (expression) => [...new Set([...expression.matchAll(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g)].map((match) => match[1]))];
-/** Medidas que uma medida usa diretamente (razão e fórmula). */
-function measureDeps(measure) {
-	if (measure.type === "ratio") return [measure.numerator, measure.denominator];
-	if (measure.type === "formula") return formulaRefs(measure.expression);
-	return [];
-}
-const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Operadores que comparam com número (`value`, e `to` no `between`). */
+const NUMERIC_OPERATORS = [
+	">",
+	">=",
+	"<",
+	"<=",
+	"between"
+];
+/** Operadores sem valor. */
+const UNARY_OPERATORS = ["empty", "notEmpty"];
 const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const isText = (value) => typeof value === "string" && !!value.trim();
-function metaErrors(context, field) {
-	const errors = [];
-	for (const key of ["label", "description"]) if (field[key] !== void 0 && typeof field[key] !== "string") errors.push(`${context}: \`${key}\` precisa ser texto`);
-	if (field.format !== void 0 && !VALUE_FORMATS.includes(field.format)) errors.push(`${context}: formato inválido "${field.format}"`);
-	const { decimals } = field;
-	if (decimals !== void 0 && (typeof decimals !== "number" || !Number.isInteger(decimals) || decimals < 0 || decimals > 10)) errors.push(`${context}: \`decimals\` precisa ser um inteiro entre 0 e 10`);
-	return errors;
-}
-function modelMeta(model) {
-	const pick = (field) => ({
-		...field.label !== void 0 && { label: field.label },
-		...field.description !== void 0 && { description: field.description },
-		...field.format !== void 0 && { format: field.format },
-		...field.decimals !== void 0 && { decimals: field.decimals }
-	});
-	return {
-		name: model.name,
-		dimensions: Object.fromEntries(Object.entries(model.dimensions).map(([name, dim]) => [name, {
-			type: dim.type,
-			...pick(dim)
-		}])),
-		measures: Object.fromEntries(Object.entries(model.measures).map(([name, measure]) => [name, {
-			type: measure.type,
-			...(measure.type === "count" || measure.type === "countDistinct") && { format: "integer" },
-			...pick(measure),
-			...measure.type === "ratio" && {
-				numerator: measure.numerator,
-				denominator: measure.denominator
-			},
-			...measure.type === "formula" && { refs: formulaRefs(measure.expression) }
-		}]))
-	};
-}
-/**
-* Lista os problemas do modelo (vazio = válido). Confere também a forma do objeto, porque o rascunho
-* do devtools chega como JSON da request.
-*/
-function validateModel(model) {
-	if (!isRecord$1(model)) return ["modelo inválido"];
-	if (!isRecord$1(model.dimensions) || !isRecord$1(model.measures)) return ["`dimensions` e `measures` são obrigatórios"];
-	if ("base" in model || "joins" in model) return ["o formato `base` + `joins` não existe mais: use `tables` + `relationships`"];
-	if (!isRecord$1(model.tables)) return ["`tables` é obrigatório"];
-	if (model.relationships !== void 0 && !Array.isArray(model.relationships)) return ["`relationships` precisa ser uma lista"];
-	if (model.diagram !== void 0 && !diagramValid(model.diagram)) return ["`diagram` precisa ser { nome: { x, y, width?, height? } } com números (tamanho > 0)"];
-	const errors = [];
-	const { tables } = model;
-	const names = [...Object.keys(model.dimensions), ...Object.keys(model.measures)];
-	for (const name of [...names, ...Object.keys(tables)]) if (!IDENTIFIER.test(name)) errors.push(`nome inválido: "${name}"`);
-	else if (name.startsWith("__")) errors.push(`nome reservado: "${name}" (começa com "__")`);
-	const duplicated = names.find((name, index) => names.indexOf(name) !== index);
-	if (duplicated) errors.push(`nome repetido: "${duplicated}"`);
-	for (const [name, table] of Object.entries(tables)) {
-		if (!isRecord$1(table) || !isText(table.sql)) {
-			errors.push(`tabela "${name}" sem SQL`);
-			continue;
-		}
-		if (table.key !== void 0 && (typeof table.key !== "string" || !IDENTIFIER.test(table.key))) errors.push(`tabela "${name}": key inválida`);
-		errors.push(...metaErrors(`tabela "${name}"`, table));
-	}
-	const tableNames = Object.keys(tables);
-	errors.push(...relationshipErrors(model, tableNames));
-	for (const [name, dimension] of Object.entries(model.dimensions)) if (!isRecord$1(dimension) || !isText(dimension.sql)) errors.push(`dimensão "${name}" sem SQL`);
-	else if (dimension.type !== "number" && dimension.type !== "string") errors.push(`dimensão "${name}" com tipo inválido`);
-	else {
-		errors.push(...metaErrors(`dimensão "${name}"`, dimension));
-		if (referencedTables(dimension.sql, tableNames).length !== 1) errors.push(`dimensão "${name}" precisa usar colunas de uma tabela só (\`tabela.coluna\`)`);
-	}
-	const edges = modelEdges(model);
-	for (const [name, measure] of Object.entries(model.measures)) {
-		if (!isRecord$1(measure)) errors.push(`medida "${name}" inválida`);
-		else if (isAggregate(measure)) {
-			if (!isText(measure.sql)) errors.push(`medida "${name}" sem SQL`);
-			else {
-				const used = referencedTables(measure.sql, tableNames);
-				if (!used.length) errors.push(`medida "${name}" precisa usar colunas de uma tabela (\`tabela.coluna\`)`);
-				else if (!measureHome(used, edges)) errors.push(`medida "${name}" usa ${used.join(", ")}, mas nenhuma delas chega às outras pelos relacionamentos`);
-			}
-		} else if (measure.type === "ratio" || measure.type === "formula") {
-			if (measure.type === "formula" && !isText(measure.expression)) errors.push(`medida "${name}" sem expressão`);
-			else if (measure.type === "formula" && !formulaRefs(measure.expression).length) errors.push(`medida "${name}": a fórmula precisa citar medidas como {nome}`);
-			for (const ref of measureDeps(measure)) if (typeof ref !== "string" || !model.measures[ref]) errors.push(`medida "${name}" referencia "${ref}", que não existe`);
-		} else errors.push(`medida "${name}" com tipo inválido`);
-		if (isRecord$1(measure)) errors.push(...metaErrors(`medida "${name}"`, measure));
-	}
-	if (errors.length) return errors;
-	const visit = (name, stack) => {
-		if (stack.includes(name)) return [...stack, name].join(" -> ");
-		for (const dep of measureDeps(model.measures[name])) {
-			const cycle = visit(dep, [...stack, name]);
-			if (cycle) return cycle;
-		}
-		return null;
-	};
-	for (const name of Object.keys(model.measures)) {
-		const cycle = visit(name, []);
-		if (cycle) {
-			errors.push(`medida circular: ${cycle}`);
-			break;
-		}
+const isColor = (value) => typeof value === "string" && /^#[0-9a-fA-F]{3,8}$/.test(value);
+const RULE_KEYS = [
+	"field",
+	"operator",
+	"value",
+	"to",
+	"target",
+	"column",
+	"color",
+	"background",
+	"bold",
+	"align",
+	"verticalAlign"
+];
+/** Problema de forma de uma regra (`null` = válida). */
+function formatRuleError(rule) {
+	if (!isRecord$1(rule)) return "precisa ser um objeto";
+	const unknown = Object.keys(rule).find((key) => !RULE_KEYS.includes(key));
+	if (unknown) return `campo desconhecido \`${unknown}\``;
+	if (typeof rule.field !== "string" || !rule.field) return "`field` é obrigatório";
+	if (!RULE_OPERATORS.includes(rule.operator)) return `\`operator\` precisa ser ${RULE_OPERATORS.join(", ")}`;
+	const operator = rule.operator;
+	if (NUMERIC_OPERATORS.includes(operator)) {
+		if (typeof rule.value !== "number" || !Number.isFinite(rule.value)) return "`value` precisa ser um número";
+		if (operator === "between" && (typeof rule.to !== "number" || !Number.isFinite(rule.to))) return "`to` precisa ser um número (fim do intervalo)";
+	} else if (!UNARY_OPERATORS.includes(operator)) {
+		if (typeof rule.value !== "number" && typeof rule.value !== "string") return "`value` precisa ser texto ou número";
 	}
-	return errors;
+	if (operator !== "between" && rule.to !== void 0) return "`to` só vale com `between`";
+	if (rule.target !== void 0 && rule.target !== "cell" && rule.target !== "row") return "`target` precisa ser cell ou row";
+	if (rule.column !== void 0 && (typeof rule.column !== "string" || !rule.column)) return "`column` precisa ser texto";
+	if (rule.target === "row" && rule.column !== void 0) return "`column` não vale com row";
+	for (const key of ["color", "background"]) if (rule[key] !== void 0 && !isColor(rule[key])) return `\`${key}\` precisa ser uma cor (#rrggbb)`;
+	if (rule.bold !== void 0 && typeof rule.bold !== "boolean") return "`bold` precisa ser true/false";
+	if (rule.align !== void 0 && !COLUMN_ALIGNS.includes(rule.align)) return `\`align\` precisa ser ${COLUMN_ALIGNS.join(", ")}`;
+	if (rule.verticalAlign !== void 0 && !COLUMN_VERTICAL_ALIGNS.includes(rule.verticalAlign)) return `\`verticalAlign\` precisa ser ${COLUMN_VERTICAL_ALIGNS.join(", ")}`;
+	if (rule.color === void 0 && rule.background === void 0 && !rule.bold && rule.align === void 0 && rule.verticalAlign === void 0) return "precisa de `color`, `background`, `bold`, `align` ou `verticalAlign`";
+	return null;
 }
-const diagramValid = (diagram) => isRecord$1(diagram) && Object.values(diagram).every((point) => isRecord$1(point) && Number.isFinite(point.x) && Number.isFinite(point.y) && [point.width, point.height].every((size) => size === void 0 || Number.isFinite(size) && size > 0));
-function relationshipErrors(model, tableNames) {
-	const errors = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const [index, relationship] of (model.relationships ?? []).entries()) {
-		const context = `relacionamento ${index + 1}`;
-		if (!isRecord$1(relationship)) {
-			errors.push(`${context} inválido`);
-			continue;
+const isEmpty = (value) => value === null || value === void 0 || value === "";
+/** A regra vale para esse valor? Valor vazio só casa com `empty` (e `!=`). */
+function matchesRule(rule, value) {
+	if (rule.operator === "empty") return isEmpty(value);
+	if (rule.operator === "notEmpty") return !isEmpty(value);
+	if (isEmpty(value)) return rule.operator === "!=";
+	const number = typeof value === "number" ? value : Number(value);
+	const target = rule.value;
+	switch (rule.operator) {
+		case ">": return number > Number(target);
+		case ">=": return number >= Number(target);
+		case "<": return number < Number(target);
+		case "<=": return number <= Number(target);
+		case "between": {
+			const [low, high] = [Number(target), Number(rule.to)].sort((a, b) => a - b);
+			return number >= low && number <= high;
 		}
-		const from = parseColumnRef(relationship.from);
-		const to = parseColumnRef(relationship.to);
-		if (!from || !to) {
-			errors.push(`${context}: use \`tabela.coluna\` em \`from\` e \`to\``);
-			continue;
+		case "=":
+		case "!=": {
+			const equal = typeof target === "number" || Number.isFinite(number) && typeof value === "number" ? number === Number(target) : String(value).toLowerCase() === String(target).toLowerCase();
+			return rule.operator === "=" ? equal : !equal;
 		}
-		for (const ref of [from, to]) if (!tableNames.includes(ref.table)) errors.push(`${context}: tabela "${ref.table}" não existe`);
-		if (from.table === to.table) errors.push(`${context}: liga a tabela "${from.table}" a ela mesma`);
-		if (relationship.inner !== void 0 && typeof relationship.inner !== "boolean") errors.push(`${context}: \`inner\` precisa ser true/false`);
-		const pair = `${from.table}->${to.table}`;
-		if (seen.has(pair)) errors.push(`${context}: já existe um relacionamento de "${from.table}" para "${to.table}"`);
-		seen.add(pair);
+		case "contains": return String(value).toLowerCase().includes(String(target ?? "").toLowerCase());
 	}
-	if (errors.length) return errors;
-	const edges = modelEdges(model);
-	for (const table of tableNames) {
-		const { ambiguous, paths } = reachFrom(table, edges);
-		if (ambiguous.length) {
-			errors.push(`caminho ambíguo de "${table}" até "${ambiguous[0]}": há mais de um relacionamento levando lá`);
-			break;
-		}
-		if (edges.some((edge) => edge.to.table === table && paths.has(edge.from.table))) {
-			errors.push(`relacionamentos em ciclo passando por "${table}"`);
-			break;
-		}
-	}
-	return errors;
 }
-//#endregion
-//#region src/codegen.ts
 /**
-* Gera o código TS de um modelo (`defineModel({...})`). Usado pelo "Copiar TS" do devtools e pelo
-* "Salvar no arquivo" do servidor, que troca só a chamada do `defineModel` dentro do arquivo.
+* Estilo de cada coluna de uma linha: as regras `row` valem para todas, as `cell` só para a coluna
+* delas, por cima das de linha. Entre regras do mesmo alcance, a de baixo ganha.
 */
-const diagramCode = ({ x, y, width, height }) => `{ x: ${x}, y: ${y}${width === void 0 ? "" : `, width: ${width}`}${height === void 0 ? "" : `, height: ${height}`} }`;
-/** JSON com as chaves ordenadas: compara modelos sem depender da ordem das propriedades. */
-function canonicalJson(value) {
-	return JSON.stringify(value, (_, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : item);
-}
-function literal(text) {
-	if (text.includes("\n")) return `\`${text.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${")}\``;
-	return `'${text.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
-}
-function metaEntries(field) {
-	const entries = [];
-	if (field.label !== void 0) entries.push(`label: ${literal(field.label)}`);
-	if (field.description !== void 0) entries.push(`description: ${literal(field.description)}`);
-	if (field.format !== void 0) entries.push(`format: '${field.format}'`);
-	if (field.decimals !== void 0) entries.push(`decimals: ${field.decimals}`);
-	return entries;
-}
-function measureCode(measure) {
-	const meta = metaEntries(measure);
-	const args = isAggregate(measure) ? [literal(measure.sql)] : measure.type === "formula" ? [literal(measure.expression)] : [literal(measure.numerator), literal(measure.denominator)];
-	if (meta.length) args.push(`{ ${meta.join(", ")} }`);
-	return `${measure.type}(${args.join(", ")})`;
-}
-function tableCode(table) {
-	return `{ ${[
-		...table.key !== void 0 ? [`key: ${literal(table.key)}`] : [],
-		`sql: ${literal(table.sql)}`,
-		...metaEntries(table)
-	].join(", ")} }`;
-}
-const entries = (record, render) => Object.entries(record).map(([name, value]) => `    ${name}: ${render(value)}`).join(",\n");
-/** O objeto passado ao `defineModel`, começando em `{` (sem indentação na primeira linha). */
-function modelObjectCode(model) {
-	const lines = ["{", `  name: ${literal(model.name)},`];
-	lines.push(Object.keys(model.tables).length ? `  tables: {\n${entries(model.tables, tableCode)}\n  },` : "  tables: {},");
-	if (model.relationships?.length) lines.push(`  relationships: [\n${model.relationships.map((relationship) => `    { from: ${literal(relationship.from)}, to: ${literal(relationship.to)}${relationship.inner ? ", inner: true" : ""} }`).join(",\n")}\n  ],`);
-	lines.push(`  dimensions: {\n${entries(model.dimensions, (dim) => [
-		`{ sql: ${literal(dim.sql)}`,
-		`type: '${dim.type}'`,
-		...metaEntries(dim)
-	].join(", ").concat(" }"))}\n  },`, `  measures: {\n${entries(model.measures, measureCode)}\n  }${model.diagram ? "," : ""}`);
-	if (model.diagram) lines.push(`  diagram: {\n${entries(model.diagram, diagramCode)}\n  }`);
-	lines.push("}");
-	return lines.join("\n");
-}
-/** Helpers do `@bluemarble/bi/server` que o código do modelo usa. */
-function modelImports(model) {
-	return ["defineModel", ...new Set(Object.values(model.measures).map((measure) => measure.type))].sort((a, b) => a.localeCompare(b, "en", { sensitivity: "base" }));
+function rowRuleStyles(rules, row, columns) {
+	const rowStyle = {};
+	const cells = {};
+	for (const rule of rules) {
+		if (!matchesRule(rule, row[rule.field])) continue;
+		const style = ruleStyle(rule);
+		if (rule.target === "row") Object.assign(rowStyle, style);
+		else {
+			const column = rule.column ?? rule.field;
+			cells[column] = {
+				...cells[column],
+				...style
+			};
+		}
+	}
+	return Object.fromEntries(columns.map((column) => [column, {
+		...rowStyle,
+		...cells[column]
+	}]));
 }
-/** Arquivo completo, pronto para colar em `src/dashboard/models/<nome>.ts`. */
-function toModelCode(model) {
-	return [
-		`import { ${modelImports(model).join(", ")} } from '@bluemarble/bi/server'`,
-		"",
-		`export const ${model.name} = defineModel(${modelObjectCode(model)})`,
-		""
-	].join("\n");
+function ruleStyle(rule) {
+	return {
+		...rule.color && { color: rule.color },
+		...rule.background && { background: rule.background },
+		...rule.bold && { bold: true },
+		...rule.align && { align: rule.align },
+		...rule.verticalAlign && { verticalAlign: rule.verticalAlign }
+	};
 }
 //#endregion
 //#region src/layout.ts
@@ -440,7 +236,7 @@ const percentDecimals = {
 	max: 6,
 	default: 1,
 	label: "Casas do %",
-	section: "Rótulos e formatos"
+	section: "Dados"
 };
 const CHART_FIELDS = {
 	kpi: {
@@ -634,16 +430,24 @@ const CHART_FIELDS = {
 			label: "Medidas (colunas)",
 			section: "Dados"
 		},
+		columnOrder: {
+			kind: "columnOrder",
+			label: "Ordem das colunas",
+			hint: "Dimensões, medidas e % do total em qualquer ordem; vazio = dimensões e depois medidas (cada % logo depois da medida)",
+			section: "Dados"
+		},
 		percentOf: {
 			kind: "measures",
+			percent: true,
 			label: "% do total",
 			hint: "Coluna extra com a participação de cada linha: valor da linha ÷ soma da coluna. Faz sentido com medidas somáveis (custo, volume), não com razões.",
 			section: "Dados"
 		},
 		sortBy: {
 			kind: "column",
+			outside: true,
 			label: "Ordenar por",
-			hint: "Ordem inicial; quem usa reordena clicando no cabeçalho",
+			hint: "Ordem inicial; quem usa reordena clicando no cabeçalho. Pode ser uma dimensão/medida fora da tabela (ex.: número do mês para o nome do mês) — uma dimensão de fora divide as linhas se tiver mais de um valor por linha.",
 			section: "Dados"
 		},
 		sortDirection: {
@@ -667,9 +471,40 @@ const CHART_FIELDS = {
 			...clickToFilter,
 			hint: "Clicar numa linha filtra pela primeira dimensão"
 		},
+		cellBorders: {
+			kind: "boolean",
+			default: false,
+			label: "Bordas entre as células",
+			hint: "Grade em volta de cada célula; desligado = só a linha embaixo de cada linha",
+			section: "Aparência"
+		},
+		borderColor: {
+			kind: "color",
+			default: "#e0e0e0",
+			label: "Cor das bordas",
+			section: "Aparência"
+		},
 		labels: LABELS_FIELD,
 		formats: FORMATS_FIELD,
-		percentDecimals
+		align: {
+			kind: "aligns",
+			label: "Alinhamento",
+			hint: "Alinhamento horizontal de cada coluna; vazio = dimensão à esquerda, número à direita",
+			section: "Rótulos e formatos"
+		},
+		verticalAlign: {
+			kind: "verticalAligns",
+			label: "Alinhamento vertical",
+			hint: "Alinhamento vertical de cada coluna (aparece com texto em mais de uma linha); vazio = no meio",
+			section: "Rótulos e formatos"
+		},
+		percentDecimals,
+		formatRules: {
+			kind: "formatRules",
+			label: "Regras",
+			hint: "Muda a cor do texto, o fundo ou o negrito da célula ou da linha conforme o valor de uma dimensão/medida (pode ser de fora da tabela). Regras de linha primeiro, de célula por cima; a de baixo ganha.",
+			section: "Formatação condicional"
+		}
 	}
 };
 const BUILTIN_CHART_TYPES = Object.fromEntries(CHART_TYPES.map((type) => [type, {
@@ -905,11 +740,21 @@ function fieldError(spec, value) {
 		case "column": return isName(value) ? null : spec.required ? "é obrigatório" : "precisa ser texto";
 		case "dimensions":
 		case "measures":
+		case "columnOrder":
 			if (!Array.isArray(value) || !value.every(isName)) return "precisa ser uma lista de nomes";
 			if (spec.required && !value.length) return "precisa de pelo menos um item";
 			return new Set(value).size === value.length ? null : "tem item repetido";
 		case "formatters": return isRecord(value) && Object.values(value).every(isName) ? null : "precisa ser { dimensão: formatter }";
 		case "labels": return isRecord(value) && Object.values(value).every((label) => typeof label === "string") ? null : "precisa ser { coluna: rótulo }";
+		case "aligns": return isRecord(value) && Object.values(value).every((align) => COLUMN_ALIGNS.includes(align)) ? null : `precisa ser { coluna: ${COLUMN_ALIGNS.join(" | ")} }`;
+		case "verticalAligns": return isRecord(value) && Object.values(value).every((align) => COLUMN_VERTICAL_ALIGNS.includes(align)) ? null : `precisa ser { coluna: ${COLUMN_VERTICAL_ALIGNS.join(" | ")} }`;
+		case "formatRules":
+			if (!Array.isArray(value)) return "precisa ser uma lista de regras";
+			for (const [index, rule] of value.entries()) {
+				const error = formatRuleError(rule);
+				if (error) return `regra ${index + 1}: ${error}`;
+			}
+			return null;
 		case "formats":
 			if (!isRecord(value)) return "precisa ser { medida: formato }";
 			for (const [measure, format] of Object.entries(value)) {
@@ -1033,10 +878,51 @@ function fieldReferences(fields, item) {
 	}
 	return refs;
 }
-/** Colunas que o gráfico mostra (para `sortBy`): as dimensões e medidas escolhidas nele. */
+/**
+* Colunas que o gráfico mostra (para `sortBy`, rótulos): as dimensões e medidas escolhidas nele e os
+* percentuais (`%:medida`), na ordem do campo `columnOrder` (se o tipo tiver) — ver `tableColumns`.
+*/
 function chartColumns(chart, types = BUILTIN_CHART_TYPES) {
-	const { dimensions, measures } = chartReferences(chart, types);
-	return [...dimensions, ...measures];
+	const values = chart;
+	const columns = [];
+	const percents = [];
+	for (const [key, spec] of Object.entries(types[chart.type]?.fields ?? {})) {
+		const value = values[key];
+		if (value === void 0 || value === "") continue;
+		if (spec.kind === "dimension" || spec.kind === "measure") columns.push(value);
+		if (spec.kind === "dimensions") columns.push(...value);
+		if (spec.kind === "measures") (spec.percent ? percents : columns).push(...value);
+	}
+	return tableColumns([...new Set(columns)], [...new Set(percents)], columnOrderOf(chart, types));
+}
+const percentColumn = (measure) => `%:${measure}`;
+/**
+* Ordem das colunas: as de `order` primeiro, o resto depois, na ordem em que veio (`orderedColumns`).
+* O % de uma medida que não está em `order` vem logo depois da medida (ou no fim, se ela não é
+* coluna) — layouts sem `%:` no `columnOrder` continuam como antes.
+*/
+function tableColumns(columns, percentOf, order) {
+	const percents = percentOf.map(percentColumn);
+	const result = orderedColumns([...columns, ...percents.filter((column) => order?.includes(column))], order);
+	for (const measure of percentOf) {
+		const column = percentColumn(measure);
+		if (result.includes(column)) continue;
+		const at = result.indexOf(measure);
+		if (at === -1) result.push(column);
+		else result.splice(at + 1, 0, column);
+	}
+	return result;
+}
+/** Valor do campo `columnOrder` do gráfico (o tipo pode não ter). */
+function columnOrderOf(chart, types = BUILTIN_CHART_TYPES) {
+	const values = chart;
+	for (const [key, spec] of Object.entries(types[chart.type]?.fields ?? {})) if (spec.kind === "columnOrder" && Array.isArray(values[key])) return values[key];
+}
+/** `columns` na ordem de `order`; os que não estão nela vão depois, na ordem em que vieram. */
+function orderedColumns(columns, order) {
+	if (!order?.length) return columns;
+	const first = order.filter((name) => columns.includes(name));
+	return [...first, ...columns.filter((name) => !first.includes(name))];
 }
 /**
 * Dimensões/medidas que o layout usa e o modelo não tem. Não impede salvar (o modelo pode estar
@@ -1052,15 +938,26 @@ function layoutModelWarnings(layout, model, types = BUILTIN_CHART_TYPES) {
 		const columns = chartColumns(chart, types);
 		for (const [key, spec] of Object.entries(types[chart.type]?.fields ?? {})) {
 			const value = chart[key];
-			if (spec.kind === "column" && isName(value) && !columns.includes(value)) warnings.push(`${name}: "${value}" (${key}) não é coluna do gráfico`);
-			if ((spec.kind === "labels" || spec.kind === "formats") && isRecord(value)) {
+			if (spec.kind === "column" && isName(value) && !columns.includes(value)) warnings.push(spec.outside ? isModelField(model, value) ? "" : `${name}: "${value}" (${key}) não existe no modelo` : `${name}: "${value}" (${key}) não é coluna do gráfico`);
+			if (spec.kind === "formatRules" && Array.isArray(value)) value.forEach((rule, index) => {
+				if (!isRecord(rule)) return;
+				const context = `${name}: regra ${index + 1} (${key})`;
+				if (isName(rule.field) && !columns.includes(rule.field) && !isModelField(model, rule.field)) warnings.push(`${context}: "${rule.field}" não existe no modelo`);
+				const painted = rule.target === "row" ? void 0 : rule.column ?? rule.field;
+				if (isName(painted) && !columns.includes(painted)) warnings.push(`${context}: "${painted}" não é coluna do gráfico (nada é pintado)`);
+			});
+			if ((spec.kind === "labels" || spec.kind === "formats" || spec.kind === "aligns" || spec.kind === "verticalAligns") && isRecord(value)) {
 				for (const column of Object.keys(value)) if (!columns.includes(column)) warnings.push(`${name}: "${column}" (${key}) não é coluna do gráfico`);
 			}
+			if (spec.kind === "columnOrder" && Array.isArray(value)) {
+				for (const column of value) if (isName(column) && !columns.includes(column)) warnings.push(`${name}: "${column}" (${key}) não é coluna do gráfico`);
+			}
 		}
 	}
 	for (const filter of layout.filters ?? []) if (!model.dimensions[filter.dimension]) warnings.push(`filtro "${filter.label || filter.dimension}": dimensão "${filter.dimension}" não existe`);
-	return warnings;
+	return warnings.filter(Boolean);
 }
+const isModelField = (model, name) => Object.hasOwn(model.dimensions, name) || Object.hasOwn(model.measures, name);
 /**
 * Gráfico novo de um tipo, reaproveitando o que der do anterior (troca de tipo no devtools) ou
 * escolhendo dimensão/medidas do modelo.
@@ -1158,6 +1055,6 @@ function layoutFileContent(layout) {
 	return `${JSON.stringify(layout, null, 2)}\n`;
 }
 //#endregion
-export { modelEdges as A, VALUE_FORMATS as C, validateModel as D, modelMeta as E, reachFrom as M, referencedTables as N, joinPlan as O, AGGREGATION_LABEL as S, isAggregate as T, canonicalJson as _, FILTER_FIELDS as a, toModelCode as b, chartOfType as c, filterReferences as d, isBuiltinChart as f, validateLayout as g, resolveChartTypes as h, CARD_FIELDS as i, parseColumnRef as j, measureHome as k, chartReferences as l, layoutModelWarnings as m, CANVAS_PRESETS as n, chartCardStyle as o, layoutFileContent as p, CARDS_FIELDS as r, chartColumns as s, BUILTIN_CHART_TYPES as t, customChartProps as u, modelImports as v, aggregateSql as w, AGGREGATIONS as x, modelObjectCode as y };
+export { RULE_OPERATOR_LABEL as C, RULE_OPERATORS as S, rowRuleStyles as T, tableColumns as _, FILTER_FIELDS as a, COLUMN_VERTICAL_ALIGNS as b, chartOfType as c, filterReferences as d, isBuiltinChart as f, resolveChartTypes as g, percentColumn as h, CARD_FIELDS as i, chartReferences as l, layoutModelWarnings as m, CANVAS_PRESETS as n, chartCardStyle as o, layoutFileContent as p, CARDS_FIELDS as r, chartColumns as s, BUILTIN_CHART_TYPES as t, customChartProps as u, validateLayout as v, UNARY_OPERATORS as w, NUMERIC_OPERATORS as x, COLUMN_ALIGNS as y };
 
-//# sourceMappingURL=layout-676sEvvb.js.map
+//# sourceMappingURL=layout-BS51SQcJ.js.map