synthesisui 0.16.321 → 0.16.322

package/dist/commands/import.js

@@ -37,6 +37,7 @@ import { MUI_DEFAULT_SPACING, readStyledComponents, spacingOf, } from "../doctor
 import { buildTable } from "../doctor/tokens.js";
 import { definitionSpan, parseClass, readInlineStyle, rootClasses, rootTag, transcribe, } from "../doctor/transcribe.js";
 import { accountClasses, invariantHolds, sumAccounts, } from "../doctor/value-ledger.js";
+import { variantCallsIn } from "../doctor/variant-calls.js";
 import { transcribeVariants } from "../doctor/variant-read.js";
 import { frontierKind, packageRoot } from "../frontier-kind.js";
 import { keyframesInSheets } from "../global-keyframes.js";
@@ -787,6 +788,10 @@ export async function takeCensus(root, opts) {
                  * variant tables) belong to the PRIMARY definition; the root classes and
                  * the root tag are per component, scoped by name.
                  */
+                /** Os componentes deste arquivo - quem mora dentro do span de outro é recortado dele. */
+                const siblings = found.map((f) => f.name);
+                /** As tabelas que ESTE ARQUIVO declara - o conjunto contra o qual um consumo é casado. */
+                const declaredTables = new Set(transcribeVariants(src, declaredValues, globalClasses).reads.map((r) => r.symbol));
                 for (const extra of found.slice(1)) {
                     const ecls = rootClasses(src, extra.name);
                     const et = transcribe(ecls, declaredValues);
@@ -800,6 +805,24 @@ export async function takeCensus(root, opts) {
                     // sketch belonged to the first component and the second read an empty
                     // one (not-expressed.md, dono, 01/08).
                     const esketch = sketchOf(src, extra.name);
+                    /**
+                     * E AS TABELAS QUE ELE CHAMA (T42a, 27/08) - a família que faltava aqui.
+                     *
+                     * Este caminho nunca viu `transcribeVariants`, e o comentário abaixo dizia isso em voz
+                     * alta: "roda para o primeiro componente do arquivo, então aqui não há tabela de
+                     * variantes". Era limitação descrita, não decisão - e por causa dela o `TooltipContent`
+                     * e o `Layer` chegavam sem uma camada sequer enquanto o vizinho ficava com os eixos
+                     * deles.
+                     *
+                     * O CSS module continua FORA daqui de propósito: uma folha `.module.css` é do arquivo, e
+                     * `parts`/`tree` seguem sendo montados só no caminho primário. A fronteira é a origem do
+                     * dado - tabela pertence a quem chama, folha pertence ao arquivo.
+                     */
+                    const ev = transcribeVariants(src, declaredValues, globalClasses, {
+                        tables: variantCallsIn(src, extra.name, declaredTables, siblings),
+                        /** Só as tabelas dele: as formas de arquivo seguem sendo do primeiro exportado. */
+                        fileWideShapes: false,
+                    });
                     const esize = Object.keys(et.base).length +
                         Object.keys(et.dark).length +
                         Object.keys(et.states).length;
@@ -825,6 +848,25 @@ export async function takeCensus(root, opts) {
                                 }
                                 : {}),
                             ...et,
+                            /** A base dele soma o que a tabela que ELE chama traz - nunca a do vizinho. */
+                            base: { ...ev.base.base, ...et.base },
+                            ...(Object.keys({ ...ev.base.states, ...et.states }).length > 0
+                                ? { states: { ...ev.base.states, ...et.states } }
+                                : {}),
+                            ...(ev.layers.length > 0 ? { layers: ev.layers } : {}),
+                            ...(ev.raw.length > 0 ? { rawLayers: ev.raw } : {}),
+                            ...(Object.keys(ev.axes).length > 0
+                                ? { declaredAxes: { ...extra.axes, ...ev.axes } }
+                                : {}),
+                            ...(Object.keys(ev.defaults).length > 0
+                                ? { defaults: ev.defaults }
+                                : {}),
+                            ...(ev.unslotted.length > 0
+                                ? { unplaced: [...new Set(ev.unslotted)] }
+                                : {}),
+                            ...(ev.notes.length > 0
+                                ? { renderNotes: [...new Set(ev.notes)] }
+                                : {}),
                             ...(etag ? { rootTag: etag } : {}),
                             ...rootPackage(etag, esketch),
                             ...rootBehaviour(etag, esketch),
@@ -858,7 +900,23 @@ export async function takeCensus(root, opts) {
                  * for the result, which is the "valid and unread" failure this pipeline has
                  * paid for twice already.
                  */
-                const v = transcribeVariants(src, declaredValues, globalClasses);
+                /**
+                 * A TRANSCRIÇÃO É DO COMPONENTE QUE CONSOME A TABELA, não do arquivo (T42a, 27/08).
+                 *
+                 * Antes: `transcribeVariants(src, …)` fundia TODAS as tabelas do arquivo e o resultado era
+                 * gravado aqui, no primeiro componente exportado. Num arquivo com dois, o segundo perdia
+                 * tudo e o primeiro recebia o que não era dele - o `Tooltip` chegou ao censo com o eixo
+                 * `side`, que pertence ao `TooltipContent`.
+                 *
+                 * `variantCallsIn` responde quais tabelas ESTE componente chama, pelo span da definição
+                 * dele e só dentro do `className`. Um arquivo de um componente só - que é o caso do
+                 * `Button` e de todo app do corpus - devolve exatamente o mesmo resultado de antes.
+                 */
+                const v = transcribeVariants(src, declaredValues, globalClasses, {
+                    tables: variantCallsIn(src, found[0].name, declaredTables, siblings),
+                    /** O primeiro exportado continua levando as formas de arquivo, como hoje. */
+                    fileWideShapes: true,
+                });
                 /**
                  * THE RESTING OPTION, from the definition itself. `cva` says it in
                  * `defaultVariants`; a lookup-record component says it in the destructuring -

package/dist/doctor/variant-calls.js

@@ -0,0 +1,117 @@
+import { definitionSpan } from "./transcribe.js";
+/** Um literal que uma chamada pode travar: `true`, `false`, `"sm"`, `'md'`. */
+const LITERAL = /^(?:true|false|"[^"]*"|'[^']*'|`[^`$]*`)$/;
+/** Do delimitador de abertura até o que o fecha, respeitando aninhamento. */
+function through(source, open, pair = "{}") {
+    let depth = 0;
+    for (let i = open; i < source.length; i += 1) {
+        const c = source[i];
+        if (c === pair[0])
+            depth += 1;
+        else if (c === pair[1]) {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Os argumentos que a chamada TRAVA. `{ size, ring: true }` deixa `size` aberto - é o prop do
+ * componente viajando adiante - e trava `ring`, que é a diferença entre um eixo e uma decisão.
+ */
+function fixedArgs(args) {
+    const brace = args.indexOf("{");
+    if (brace === -1)
+        return [];
+    const end = through(args, brace);
+    if (end === -1)
+        return [];
+    const parts = [];
+    let depth = 0;
+    let start = brace + 1;
+    for (let i = brace + 1; i <= end; i += 1) {
+        const c = args[i];
+        if (c === "{" || c === "[" || c === "(")
+            depth += 1;
+        else if (c === "}" || c === "]" || c === ")") {
+            if (i === end) {
+                parts.push(args.slice(start, i));
+                break;
+            }
+            depth -= 1;
+        }
+        else if (c === "," && depth === 0) {
+            parts.push(args.slice(start, i));
+            start = i + 1;
+        }
+    }
+    const out = [];
+    for (const part of parts) {
+        const colon = part.indexOf(":");
+        /** Sem `:` é atalho de objeto (`{ size }`): o prop viaja e o eixo continua aberto. */
+        if (colon === -1)
+            continue;
+        const axis = part.slice(0, colon).trim();
+        const value = part.slice(colon + 1).trim();
+        if (!axis || !LITERAL.test(value))
+            continue;
+        out.push({ axis, option: value.replace(/^["'`]|["'`]$/g, "") });
+    }
+    return out;
+}
+/**
+ * As tabelas que ESTE componente consome, dentro do `className` dele.
+ *
+ * `symbols` é o conjunto que o arquivo declara - recebê-lo em vez de descobrir aqui é o que impede
+ * esta função de casar uma chamada qualquer (`cn`, `clsx`, um helper dele) com uma tabela.
+ */
+export function variantCallsIn(source, component, symbols, siblings = []) {
+    const span = definitionSpan(source, component);
+    if (!span)
+        return [];
+    /**
+     * O CORPO DELE, MENOS O DE QUEM MORA DENTRO. Um componente pode ser declarado dentro de outro, e
+     * então o span do de fora contém o do de dentro - herdar dali seria recriar a atribuição errada
+     * um nível abaixo. Recortar os irmãos é o que impede isso, e é por lista de nomes, nunca por
+     * heurística de posição.
+     */
+    const cuts = siblings
+        .filter((name) => name !== component)
+        .map((name) => definitionSpan(source, name))
+        .filter((s) => s !== null && s.from > span.from && s.to <= span.to)
+        .sort((a, b) => a.from - b.from);
+    let body = "";
+    let at = span.from;
+    for (const cut of cuts) {
+        if (cut.from > at)
+            body += source.slice(at, cut.from);
+        at = Math.max(at, cut.to);
+    }
+    body += source.slice(at, span.to);
+    const out = [];
+    const seen = new Set();
+    for (const symbol of symbols) {
+        /**
+         * TODA CHAMADA DENTRO DO CORPO DELE, não só a que está escrita no `className`.
+         *
+         * A primeira versão exigia a chamada dentro do atributo, e o `Card` do cliente monta as classes
+         * numa variável antes - `const classes = cn(cardVariants({…}), …)` e depois `className={classes}`.
+         * Ele perdia os cinco eixos dele de uma vez. O que associa é o SPAN da definição; onde a linha
+         * mora dentro dele é estilo de quem escreveu.
+         */
+        for (const call of body.matchAll(new RegExp(`\\b${symbol}\\s*\\(`, "g"))) {
+            const paren = (call.index ?? 0) + call[0].length - 1;
+            const close = through(body, paren, "()");
+            if (close === -1)
+                continue;
+            const key = `${symbol}@${paren}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            /** Só o que está ENTRE os parênteses da chamada - um `{` de depois é de outra linha. */
+            out.push({ symbol, fixed: fixedArgs(body.slice(paren + 1, close)) });
+        }
+    }
+    return out;
+}

package/dist/doctor/variant-read.js

@@ -1157,33 +1157,76 @@ export function transcribeVariants(source, declared,
  * Sem default de propósito. Um `Map` vazio é a resposta de quem não tem folha global, e ela se
  * escreve em voz alta; um parâmetro que se pode esquecer é o defeito que isto está desfazendo.
  */
-globals) {
-    const reads = readVariants(source);
+globals, 
+/**
+ * O QUE ESTE COMPONENTE CONSOME - e a razão de este parâmetro existir.
+ *
+ * Sem ele, a transcrição é do ARQUIVO: todas as tabelas fundidas num resultado só, que o import
+ * gravava no primeiro componente exportado. Num arquivo com dois, o segundo perdia tudo e o
+ * primeiro recebia o que não era dele (T42a, medido em 27/08).
+ *
+ * `undefined` mantém o comportamento de arquivo, que é o certo para quem pergunta sobre o
+ * arquivo. Uma lista restringe às tabelas que aquele componente CHAMA, e aplica o que a chamada
+ * dele trava - `avatarVariants({ size, ring: true })` fixa `ring`, então a camada do `ring` é
+ * base dele e o eixo sai da lista de eixos abertos.
+ */
+consumed) {
+    const all = readVariants(source);
+    /**
+     * SÓ AS TABELAS QUE ELE CHAMA. Um componente que não chama nenhuma fica sem camadas de variante -
+     * que é a verdade sobre ele, e não um efeito de ser o segundo do arquivo.
+     */
+    const wanted = consumed
+        ? new Map(consumed.tables.map((c) => [c.symbol, c.fixed]))
+        : null;
+    const reads = wanted ? all.filter((r) => wanted.has(r.symbol)) : all;
     const fromRecords = {};
     const unslotted = [];
     const notes = [];
-    const inline = [
-        ...readInlineConditions(source),
-        // The two shapes the enumeration found to be five times more common than `cva`.
-        ...readLookupRecords(source, fromRecords, unslotted),
-        ...readClassTernaries(source),
-    ];
+    const fileWide = consumed ? consumed.fileWideShapes : true;
+    const inline = fileWide
+        ? [
+            ...readInlineConditions(source),
+            // The two shapes the enumeration found to be five times more common than `cva`.
+            ...readLookupRecords(source, fromRecords, unslotted),
+            ...readClassTernaries(source),
+        ]
+        : [];
     /**
      * O record que um `style=` consome - valores prontos, sem tabela de escala no meio.
      * Entram direto nas camadas finais (e registram o eixo), nunca em `raw`: `raw` é
      * matéria-prima de reinterpretação por classes, e estes já são o valor final.
      */
-    const styleRecords = readStyleRecords(source, fromRecords);
+    const styleRecords = fileWide ? readStyleRecords(source, fromRecords) : [];
     const axes = {};
     const defaults = {};
     const allLayers = [];
     const baseClasses = [];
     for (const read of reads) {
+        /**
+         * O QUE A CHAMADA DELE TRAVA. `avatarVariants({ size, ring: true })` diz que este componente
+         * SEMPRE tem `ring` - então a camada daquele eixo aplica sempre (é base dele) e `ring` deixa de
+         * ser um eixo que alguém escolhe. Sem isto, o `AvatarStack` herdaria um eixo `ring` que o
+         * código dele não oferece a ninguém.
+         */
+        const fixed = new Map((wanted?.get(read.symbol) ?? []).map((f) => [f.axis, f.option]));
         baseClasses.push(...read.base);
-        allLayers.push(...read.layers);
+        for (const [axis, option] of fixed)
+            baseClasses.push(...(read.variants[axis]?.[option] ?? []));
+        allLayers.push(...(fixed.size === 0
+            ? read.layers
+            : read.layers.filter((l) => {
+                /** A travada já entrou como base; a de OUTRA opção do mesmo eixo não se aplica. */
+                for (const [axis] of fixed)
+                    if (l.when?.variant?.[axis] !== undefined)
+                        return false;
+                return true;
+            })));
         unslotted.push(...read.unslotted);
         Object.assign(defaults, read.defaults);
         for (const [axis, options] of Object.entries(read.variants)) {
+            if (fixed.has(axis))
+                continue;
             const names = Object.keys(options);
             // Two options is what makes a closed set somebody chose from - the same rule
             // the contract writer and the doctor already follow.

package/dist/install-marks.js

@@ -335,8 +335,16 @@ export const CHECKER_SINCE = "0.16.308";
  * forte dos três - um produto quase preto entrava na medição como página clara. O que não dá para
  * avaliar (`var(…)`, gradiente) deixa de ser emitido em vez de virar uma face. Isso muda a
  * EVIDÊNCIA que o relatório de import entrega ao agente, e é sobre ela que a face é julgada.
+ *
+ * 0.16.321 -> 0.16.322 em 27/08: uma tabela de variantes passa a pertencer ao componente que a
+ * CHAMA, e não ao primeiro componente exportado do arquivo. Num arquivo com dois, o segundo
+ * chegava sem uma camada sequer e o primeiro chegava com o estilo do vizinho - medido no
+ * `codelevel-ui`, o `Tooltip` carregava o fundo escuro e o eixo `side` do balão. O hash do corpus
+ * NÃO se moveu, e isso é a informação: os 21 apps dourados têm um componente por arquivo, então a
+ * estabilidade ali prova ausência de regressão e não ausência de efeito. Quem tem dois componentes
+ * num arquivo só vê a correção depois de remedir.
  */
-export const READER_SINCE = "0.16.321";
+export const READER_SINCE = "0.16.322";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synthesisui",
-  "version": "0.16.321",
+  "version": "0.16.322",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {