@bluemarble/bi 0.0.0-stage → 0.1.2

package/dist/layout-iPByu6V0.js

@@ -0,0 +1,899 @@
+//#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"
+];
+/**
+* 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 AGGREGATION_LABEL = {
+	sum: "Soma",
+	count: "Contagem",
+	countDistinct: "Contagem distinta",
+	avg: "Média",
+	min: "Mínimo",
+	max: "Máximo"
+};
+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_]*$/;
+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 } } com números"];
+	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;
+		}
+	}
+	return errors;
+}
+const diagramValid = (diagram) => isRecord$1(diagram) && Object.values(diagram).every((point) => isRecord$1(point) && Number.isFinite(point.x) && Number.isFinite(point.y));
+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 from = parseColumnRef(relationship.from);
+		const to = parseColumnRef(relationship.to);
+		if (!from || !to) {
+			errors.push(`${context}: use \`tabela.coluna\` em \`from\` e \`to\``);
+			continue;
+		}
+		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);
+	}
+	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.
+*/
+/** 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, ({ x, y }) => `{ x: ${x}, y: ${y} }`)}\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" }));
+}
+/** 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");
+}
+//#endregion
+//#region src/layout.ts
+/**
+* Layout de gráficos de uma página: lista declarativa (JSON) que o `<DashboardCharts>` renderiza. É
+* JSON — e não JSX — para o devtools conseguir adicionar e editar gráficos pelo navegador e gravar o
+* arquivo de volta. Fica fora de `server/` porque o client e o servidor validam o mesmo formato.
+*
+* Os campos de cada tipo são descritos em `CHART_FIELDS`: é de lá que saem a validação, os avisos
+* de dimensão/medida inexistente e o formulário da aba Layout do devtools.
+*/
+const CHART_TYPES = [
+	"kpi",
+	"combo",
+	"bar",
+	"donut",
+	"table"
+];
+const CHART_TYPE_LABEL = {
+	kpi: "KPI (card)",
+	combo: "Combo (barras + linha)",
+	bar: "Barras",
+	donut: "Rosca",
+	table: "Tabela"
+};
+const LAYOUT_ID = /^[A-Za-z0-9_-]{1,80}$/;
+const common = (height) => ({
+	title: {
+		kind: "text",
+		label: "Título",
+		section: "Gráfico"
+	},
+	span: {
+		kind: "integer",
+		min: 1,
+		max: 12,
+		default: 12,
+		label: "Largura",
+		hint: "Colunas ocupadas em telas largas; no celular, cada gráfico ocupa a linha toda (menos com a tela de tamanho fixo)",
+		section: "Gráfico"
+	},
+	height: {
+		kind: "integer",
+		min: 120,
+		max: 2e3,
+		default: height,
+		label: "Altura (px)",
+		section: "Gráfico"
+	}
+});
+const formatDimension = {
+	kind: "formatter",
+	label: "Formatar dimensão",
+	hint: "Formatters passados ao <DashboardCharts formatters={{ ... }}> da página",
+	section: "Dados"
+};
+const clickToFilter = {
+	kind: "boolean",
+	default: false,
+	label: "Clique filtra o dashboard",
+	hint: "Ctrl/Cmd+clique acumula; clicar de novo no único selecionado limpa",
+	section: "Dados"
+};
+const hideEmpty = {
+	kind: "boolean",
+	default: true,
+	label: "Esconder grupos vazios",
+	section: "Dados"
+};
+const CHART_FIELDS = {
+	kpi: {
+		title: {
+			kind: "text",
+			label: "Título",
+			section: "Gráfico"
+		},
+		span: common(0).span,
+		measure: {
+			kind: "measure",
+			required: true,
+			label: "Medida",
+			section: "Dados"
+		},
+		secondary: {
+			kind: "measure",
+			label: "Medida secundária",
+			hint: "Linha menor embaixo do número (ex.: volume, custo/t)",
+			section: "Dados"
+		},
+		secondaryLabel: {
+			kind: "text",
+			label: "Rótulo da secundária",
+			hint: "Padrão: rótulo da medida no dicionário",
+			section: "Aparência"
+		}
+	},
+	combo: {
+		...common(360),
+		maxLabels: {
+			kind: "integer",
+			min: 0,
+			max: 1e3,
+			default: 24,
+			label: "Máx. rótulos",
+			hint: "Acima dessa quantidade de barras, os valores aparecem só no tooltip",
+			section: "Gráfico"
+		},
+		dimension: {
+			kind: "dimension",
+			required: true,
+			label: "Dimensão (eixo X)",
+			section: "Dados"
+		},
+		formatDimension,
+		bar: {
+			kind: "measure",
+			required: true,
+			label: "Barra",
+			section: "Dados"
+		},
+		line: {
+			kind: "measure",
+			required: true,
+			label: "Linha",
+			section: "Dados"
+		},
+		detail: {
+			kind: "measure",
+			label: "Detalhe (2ª linha do rótulo)",
+			section: "Dados"
+		},
+		clickToFilter,
+		hideEmpty,
+		barLabel: {
+			kind: "text",
+			label: "Rótulo da barra",
+			section: "Aparência"
+		},
+		lineLabel: {
+			kind: "text",
+			label: "Rótulo da linha",
+			section: "Aparência"
+		},
+		detailLabel: {
+			kind: "text",
+			label: "Rótulo do detalhe",
+			section: "Aparência"
+		},
+		barColor: {
+			kind: "color",
+			default: "#F58220",
+			label: "Cor da barra",
+			section: "Aparência"
+		},
+		lineColor: {
+			kind: "color",
+			default: "#555555",
+			label: "Cor da linha",
+			section: "Aparência"
+		}
+	},
+	bar: {
+		...common(360),
+		dimension: {
+			kind: "dimension",
+			required: true,
+			label: "Dimensão (categorias)",
+			section: "Dados"
+		},
+		formatDimension,
+		measures: {
+			kind: "measures",
+			required: true,
+			label: "Medidas (uma série cada)",
+			section: "Dados"
+		},
+		sort: {
+			kind: "enum",
+			values: [
+				"dimension",
+				"desc",
+				"asc"
+			],
+			labels: {
+				dimension: "pela dimensão",
+				desc: "maior primeiro",
+				asc: "menor primeiro"
+			},
+			default: "dimension",
+			label: "Ordem",
+			hint: "Maior/menor primeiro usa a primeira medida",
+			section: "Dados"
+		},
+		limit: {
+			kind: "integer",
+			min: 1,
+			max: 1e3,
+			label: "Só os N primeiros",
+			hint: "Aplicado depois de ordenar (ex.: top 10 navios)",
+			section: "Dados"
+		},
+		clickToFilter,
+		hideEmpty,
+		orientation: {
+			kind: "enum",
+			values: ["vertical", "horizontal"],
+			default: "vertical",
+			label: "Orientação",
+			hint: "Horizontal cabe nomes longos (navios, funções)",
+			section: "Aparência"
+		},
+		stacked: {
+			kind: "boolean",
+			default: false,
+			label: "Empilhar séries",
+			hint: "Só faz sentido com medidas somáveis (partes de um total)",
+			section: "Aparência"
+		},
+		showValues: {
+			kind: "boolean",
+			default: true,
+			label: "Mostrar valores",
+			section: "Aparência"
+		}
+	},
+	donut: {
+		...common(300),
+		dimension: {
+			kind: "dimension",
+			required: true,
+			label: "Dimensão (fatias)",
+			section: "Dados"
+		},
+		formatDimension,
+		measure: {
+			kind: "measure",
+			required: true,
+			label: "Medida",
+			section: "Dados"
+		},
+		maxSlices: {
+			kind: "integer",
+			min: 2,
+			max: 8,
+			default: 6,
+			label: "Máx. fatias",
+			hint: "As menores além dessa quantidade viram \"Outros\"",
+			section: "Dados"
+		},
+		clickToFilter
+	},
+	table: {
+		...common(400),
+		dimensions: {
+			kind: "dimensions",
+			label: "Dimensões (linhas)",
+			section: "Dados"
+		},
+		formatDimensions: {
+			kind: "formatters",
+			label: "Formatar dimensões",
+			hint: "Formatters passados ao <DashboardCharts formatters={{ ... }}> da página",
+			section: "Dados"
+		},
+		measures: {
+			kind: "measures",
+			required: true,
+			label: "Medidas (colunas)",
+			section: "Dados"
+		},
+		sortBy: {
+			kind: "column",
+			label: "Ordenar por",
+			hint: "Ordem inicial; quem usa reordena clicando no cabeçalho",
+			section: "Dados"
+		},
+		sortDirection: {
+			kind: "enum",
+			values: ["desc", "asc"],
+			labels: {
+				desc: "decrescente",
+				asc: "crescente"
+			},
+			default: "desc",
+			label: "Direção",
+			section: "Dados"
+		},
+		showTotal: {
+			kind: "boolean",
+			default: true,
+			label: "Linha de total",
+			section: "Dados"
+		},
+		clickToFilter: {
+			...clickToFilter,
+			hint: "Clicar numa linha filtra pela primeira dimensão"
+		}
+	}
+};
+const FILTER_FIELDS = {
+	dimension: {
+		kind: "dimension",
+		required: true,
+		label: "Dimensão",
+		section: "Filtro"
+	},
+	label: {
+		kind: "text",
+		label: "Rótulo",
+		hint: "Padrão: rótulo da dimensão no dicionário",
+		section: "Filtro"
+	},
+	width: {
+		kind: "integer",
+		min: 80,
+		max: 800,
+		default: 200,
+		label: "Largura (px)",
+		section: "Filtro"
+	},
+	formatLabel: {
+		kind: "formatter",
+		label: "Formatar opções",
+		hint: "Formatters passados ao <DashboardFilters formatters={{ ... }}> da página",
+		section: "Filtro"
+	}
+};
+const CANVAS_FIELDS = {
+	width: {
+		kind: "integer",
+		min: 320,
+		max: 7680,
+		required: true,
+		label: "Largura (px)",
+		section: "Tela"
+	},
+	height: {
+		kind: "integer",
+		min: 200,
+		max: 4320,
+		label: "Altura mínima (px)",
+		hint: "Conteúdo mais alto que isso estende a tela",
+		section: "Tela"
+	}
+};
+/** Tamanhos comuns de tela para o devtools. */
+const CANVAS_PRESETS = [
+	{
+		width: 1920,
+		height: 1080
+	},
+	{
+		width: 1600,
+		height: 900
+	},
+	{
+		width: 1366,
+		height: 768
+	},
+	{
+		width: 1280,
+		height: 720
+	}
+];
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isName = (value) => typeof value === "string" && !!value;
+function fieldError(spec, value) {
+	if (value === void 0) return spec.required ? "é obrigatório" : null;
+	switch (spec.kind) {
+		case "text": return typeof value === "string" ? null : "precisa ser texto";
+		case "color": return typeof value === "string" && /^#[0-9a-fA-F]{3,8}$/.test(value) ? null : "precisa ser uma cor (#rrggbb)";
+		case "boolean": return typeof value === "boolean" ? null : "precisa ser true/false";
+		case "integer": return typeof value === "number" && Number.isInteger(value) && value >= spec.min && value <= spec.max ? null : `precisa ser um inteiro de ${spec.min} a ${spec.max}`;
+		case "enum": return spec.values.includes(value) ? null : `precisa ser ${spec.values.join(", ")}`;
+		case "dimension":
+		case "measure":
+		case "formatter":
+		case "column": return isName(value) ? null : spec.required ? "é obrigatório" : "precisa ser texto";
+		case "dimensions":
+		case "measures":
+			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 }";
+	}
+}
+/**
+* Problemas de forma do layout (vazio = válido). Confere a forma do objeto porque o rascunho do
+* devtools chega como JSON da request.
+*/
+function validateLayout(layout) {
+	if (!isRecord(layout)) return ["layout inválido"];
+	if (typeof layout.id !== "string" || !LAYOUT_ID.test(layout.id)) return ["`id` do layout: letras, números, \"-\" e \"_\" (até 80)"];
+	if (!Array.isArray(layout.charts)) return ["`charts` precisa ser uma lista"];
+	const errors = [];
+	const ids = /* @__PURE__ */ new Set();
+	layout.charts.forEach((chart, index) => {
+		const context = `gráfico ${index + 1}`;
+		if (!isRecord(chart)) {
+			errors.push(`${context} inválido`);
+			return;
+		}
+		if (typeof chart.id !== "string" || !LAYOUT_ID.test(chart.id)) errors.push(`${context}: \`id\` inválido`);
+		else if (ids.has(chart.id)) errors.push(`${context}: id repetido "${chart.id}"`);
+		else ids.add(chart.id);
+		const fields = CHART_FIELDS[chart.type];
+		if (!CHART_TYPES.includes(chart.type) || !fields) {
+			errors.push(`${context}: tipo inválido "${chart.type}"`);
+			return;
+		}
+		if (typeof chart.title !== "string") errors.push(`${context}: \`title\` precisa ser texto`);
+		const rest = Object.fromEntries(Object.entries(fields).filter(([key]) => key !== "title"));
+		errors.push(...fieldsErrors(context, rest, chart, [
+			"id",
+			"type",
+			"title"
+		]));
+	});
+	if (layout.canvas !== void 0) {
+		if (!isRecord(layout.canvas)) errors.push("`canvas` precisa ser { width, height? }");
+		else errors.push(...fieldsErrors("canvas", CANVAS_FIELDS, layout.canvas));
+	}
+	if (layout.filters !== void 0) {
+		if (!Array.isArray(layout.filters)) return [...errors, "`filters` precisa ser uma lista"];
+		const dimensions = /* @__PURE__ */ new Set();
+		layout.filters.forEach((filter, index) => {
+			const context = `filtro ${index + 1}`;
+			if (!isRecord(filter)) {
+				errors.push(`${context} inválido`);
+				return;
+			}
+			errors.push(...fieldsErrors(context, FILTER_FIELDS, filter));
+			if (isName(filter.dimension)) {
+				if (dimensions.has(filter.dimension)) errors.push(`${context}: dimensão repetida "${filter.dimension}"`);
+				dimensions.add(filter.dimension);
+			}
+		});
+	}
+	return errors;
+}
+function fieldsErrors(context, fields, values, extraKeys = []) {
+	const errors = [];
+	for (const [key, spec] of Object.entries(fields)) {
+		const error = fieldError(spec, values[key]);
+		if (error) errors.push(`${context}: \`${key}\` ${error}`);
+	}
+	const known = /* @__PURE__ */ new Set([...extraKeys, ...Object.keys(fields)]);
+	for (const key of Object.keys(values)) if (!known.has(key)) errors.push(`${context}: campo desconhecido \`${key}\``);
+	return errors;
+}
+/** Dimensões, medidas e formatters que o gráfico referencia (lidos pelos campos do tipo). */
+const chartReferences = (chart) => fieldReferences(CHART_FIELDS[chart.type] ?? {}, chart);
+/** Idem para um filtro da página. */
+const filterReferences = (filter) => fieldReferences(FILTER_FIELDS, filter);
+function fieldReferences(fields, item) {
+	const refs = {
+		dimensions: [],
+		measures: [],
+		formatters: []
+	};
+	const values = item;
+	for (const [key, spec] of Object.entries(fields)) {
+		const value = values[key];
+		if (value === void 0 || value === "") continue;
+		if (spec.kind === "dimension") refs.dimensions.push(value);
+		if (spec.kind === "dimensions") refs.dimensions.push(...value);
+		if (spec.kind === "measure") refs.measures.push(value);
+		if (spec.kind === "measures") refs.measures.push(...value);
+		if (spec.kind === "formatter") refs.formatters.push(value);
+		if (spec.kind === "formatters") refs.formatters.push(...Object.values(value));
+	}
+	return refs;
+}
+/** Colunas que o gráfico mostra (para `sortBy`): as dimensões e medidas escolhidas nele. */
+function chartColumns(chart) {
+	const { dimensions, measures } = chartReferences(chart);
+	return [...dimensions, ...measures];
+}
+/**
+* Dimensões/medidas que o layout usa e o modelo não tem. Não impede salvar (o modelo pode estar
+* sendo editado junto), mas o gráfico vai mostrar erro.
+*/
+function layoutModelWarnings(layout, model) {
+	const warnings = [];
+	for (const chart of layout.charts) {
+		const name = `"${chart.title || chart.id}"`;
+		const { dimensions, measures } = chartReferences(chart);
+		for (const dimension of dimensions) if (!model.dimensions[dimension]) warnings.push(`${name}: dimensão "${dimension}" não existe`);
+		for (const measure of measures) if (!model.measures[measure]) warnings.push(`${name}: medida "${measure}" não existe`);
+		if (chart.type === "table" && chart.sortBy && !chartColumns(chart).includes(chart.sortBy)) warnings.push(`${name}: "${chart.sortBy}" (sortBy) não é coluna da tabela`);
+	}
+	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;
+}
+/**
+* Gráfico novo de um tipo, reaproveitando o que der do anterior (troca de tipo no devtools) ou
+* escolhendo dimensão/medidas do modelo.
+*/
+function chartOfType(type, model, base) {
+	const { id, title, span } = base;
+	const previous = chartReferences(base);
+	const measures = Object.entries(model.measures);
+	const firstSum = measures.find(([, measure]) => isAggregate(measure))?.[0];
+	const firstRatio = measures.find(([, measure]) => measure.type === "ratio")?.[0];
+	const dimension = previous.dimensions[0] ?? Object.keys(model.dimensions)[0] ?? "";
+	const measure = previous.measures[0] ?? firstSum ?? measures[0]?.[0] ?? "";
+	const shared = {
+		id,
+		title,
+		...span !== void 0 && { span }
+	};
+	switch (type) {
+		case "kpi": return {
+			...shared,
+			type,
+			measure,
+			...previous.measures[1] && { secondary: previous.measures[1] }
+		};
+		case "combo": return {
+			...shared,
+			type,
+			dimension,
+			bar: measure,
+			line: previous.measures[1] ?? firstRatio ?? measure
+		};
+		case "bar": return {
+			...shared,
+			type,
+			dimension,
+			measures: previous.measures.length ? previous.measures : [measure]
+		};
+		case "donut": return {
+			...shared,
+			type,
+			dimension,
+			measure
+		};
+		case "table": return {
+			...shared,
+			type,
+			dimensions: previous.dimensions.length ? previous.dimensions : [dimension],
+			measures: previous.measures.length ? previous.measures : [measure]
+		};
+	}
+}
+/** Conteúdo do arquivo `<id>.json`. */
+function layoutFileContent(layout) {
+	return `${JSON.stringify(layout, null, 2)}\n`;
+}
+//#endregion
+export { validateModel as C, parseColumnRef as D, modelEdges as E, reachFrom as O, modelMeta as S, measureHome as T, AGGREGATIONS as _, FILTER_FIELDS as a, aggregateSql as b, chartReferences as c, layoutModelWarnings as d, validateLayout as f, toModelCode as g, modelObjectCode as h, CHART_TYPE_LABEL as i, referencedTables as k, filterReferences as l, modelImports as m, CHART_FIELDS as n, chartColumns as o, canonicalJson as p, CHART_TYPES as r, chartOfType as s, CANVAS_PRESETS as t, layoutFileContent as u, AGGREGATION_LABEL as v, joinPlan as w, isAggregate as x, VALUE_FORMATS as y };
+
+//# sourceMappingURL=layout-iPByu6V0.js.map