synthesisui 0.16.198 → 0.16.199

package/dist/doctor/components-scan.js

@@ -2,14 +2,146 @@ import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 /**
  * Opens a JSX element whose name is capitalised - which is React's own rule for
- * "this is a component, not an html tag".
+ * "this is a component, not an html tag". The name allows dots (`Card.Header`).
  *
- * The name allows dots (`Card.Header`) and the body is captured lazily up to
- * the first `>` that is not inside a quoted value.
+ * SÓ A ABERTURA. O corpo NÃO vem daqui - ver `bodyOf`.
  */
-const ELEMENT = /<([A-Z][A-Za-z0-9_]*(?:\.[A-Z][A-Za-z0-9_]*)*)(\s[^>]*?)?\/?>/gs;
-/** `variant="primary"` or `variant={"primary"}` - a literal a person typed. */
-const LITERAL_PROP = /([a-zA-Z][a-zA-Z0-9_-]*)\s*=\s*\{?\s*["']([^"']*)["']\s*\}?/g;
+const OPENS = /<([A-Z][A-Za-z0-9_]*(?:\.[A-Z][A-Za-z0-9_]*)*)/g;
+/**
+ * ONDE A TAG TERMINA DE VERDADE - e isto era uma varredura de caractere.
+ *
+ * O corpo era `(\s[^>]*?)?`: para no primeiro `>` que aparecer, sem saber o que é aspa e
+ * sem saber o que é aninhamento. Medido no repositório do dono em 10/08, isso produzia
+ * DOIS defeitos que pareciam não ter relação:
+ *
+ *   <WidgetCard rightTitleSlot={ <Button variant="neutral" onClick={() => …
+ *     os atributos do FILHO caem no corpo do PAI - o censo registrou `variant: neutral`
+ *     no WidgetCard, que declara `default | left-border | full-border`. A tela reportou
+ *     "uso fora do contrato" sobre um uso que nunca existiu.
+ *
+ *   value="… Domain 'sg.futurescope.com' … the 'Sending' tab …"
+ *     a aspa simples dentro da dupla fechava o valor cedo, o resto da frase ficava no
+ *     corpo, e o passe de booleano nu colhia palavra por palavra: `the`, `following`,
+ *     `registrar`, `domains`. Dezenove palavras viraram props do Textarea.
+ *
+ * Um defeito INVENTADO é pior que um não achado: o não achado custa uma lacuna, o
+ * inventado custa a confiança na tela inteira. Por isso a resposta não é acrescentar
+ * casos à regex - é um scanner que sabe o que está lendo, e que fecha por construção.
+ *
+ * Devolve o corpo e onde continuar a varredura. Uma tag sem fechamento (arquivo cortado,
+ * TypeScript genérico que não era elemento) devolve `null` e não vira uso.
+ */
+function bodyOf(source, from) {
+    let quote = null;
+    let depth = 0;
+    for (let i = from; i < source.length; i++) {
+        const ch = source[i];
+        if (quote) {
+            /** Escape dentro de string: `\"` não fecha nada. */
+            if (ch === "\\")
+                i += 1;
+            else if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "{")
+            depth += 1;
+        else if (ch === "}")
+            depth -= 1;
+        /** Em profundidade zero e fora de aspas: aqui a tag realmente fecha. */ else if (ch === ">" &&
+            depth <= 0)
+            return {
+                body: withoutExpressions(source.slice(from, i)).replace(/\/$/, ""),
+                end: i + 1,
+            };
+    }
+    return null;
+}
+/**
+ * O QUE ESTÁ DENTRO DE CHAVES NÃO É PROP DESTA TAG - e sem isto o corpo termina no lugar certo
+ * e ainda entrega o filho errado.
+ *
+ * `<WidgetCard rightTitleSlot={<Button variant="neutral" />} />` fecha corretamente no `/>` do
+ * WidgetCard: o `>` do Button está em profundidade 1. Mas o corpo continua carregando
+ * `variant="neutral"`, porque a atribuição do filho mora dentro da expressão do slot.
+ *
+ * Então a expressão vira espaço - e o que ela contém não se perde: o `<Button` dentro dela é
+ * encontrado pela própria varredura, no lugar dele, com as props dele.
+ *
+ * COM UMA EXCEÇÃO, E ELA É MEDIDA: `variant={"info"}` é o MESMO literal que `variant="info"`, e um
+ * spec já dizia isso. A primeira versão deste passe apagava os dois e a suíte reprovou - eu tinha
+ * escrito no comentário que o `LITERAL_PROP` via o corpo cru antes, o que o código não fazia. Uma
+ * chave contendo só um literal volta como valor; qualquer outra coisa dentro é expressão.
+ */
+function withoutExpressions(body) {
+    let out = "";
+    let inner = "";
+    let depth = 0;
+    let quote = null;
+    /** Fecha uma expressão: um literal puro é VALOR e volta; o resto é do que estiver dentro. */
+    const close = () => {
+        out += /^\s*(["'`])(?:\\.|(?!\1)[^\\])*\1\s*$/.test(inner)
+            ? `{${inner}}`
+            : " ";
+        inner = "";
+    };
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        const keep = (text) => {
+            if (depth === 0)
+                out += text;
+            else
+                inner += text;
+        };
+        if (quote) {
+            if (ch === "\\") {
+                keep(body.slice(i, i + 2));
+                i += 1;
+            }
+            else {
+                keep(ch);
+                if (ch === quote)
+                    quote = null;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            keep(ch);
+            continue;
+        }
+        if (ch === "{") {
+            depth += 1;
+            if (depth > 1)
+                inner += ch;
+            continue;
+        }
+        if (ch === "}") {
+            depth -= 1;
+            if (depth === 0)
+                close();
+            else if (depth > 0)
+                inner += ch;
+            else
+                depth = 0;
+            continue;
+        }
+        keep(ch);
+    }
+    return out;
+}
+/**
+ * `variant="primary"` ou `variant={'primary'}` - um literal que alguém digitou.
+ *
+ * A ASPA CASA COM ELA MESMA (`(["'])…\2`), e não com qualquer uma. `["']([^"']*)["']`
+ * tratava as duas como intercambiáveis, então um valor com apóstrofo dentro truncava - e o
+ * que sobrava virava prop. Ver `bodyOf`.
+ */
+const LITERAL_PROP = /([a-zA-Z][a-zA-Z0-9_-]*)\s*=\s*\{?\s*(["'])((?:\\.|(?!\2)[^\\])*)\2\s*\}?/g;
 /** `dense` with no value is a boolean prop set to true, and that IS a literal
  *  decision worth counting. */
 const BARE_PROP = /(^|\s)([a-z][a-zA-Z0-9_]*)(?=\s|$)/g;
@@ -171,8 +303,12 @@ internal = []) {
         return;
     const owners = importedNames(source, internal);
     const private_ = localOnlyNames(source);
-    ELEMENT.lastIndex = 0;
-    for (const m of source.matchAll(ELEMENT)) {
+    /**
+     * Abertura por regex, corpo por SCANNER - ver `bodyOf`. A regex só encontra `<Nome`; onde a
+     * tag termina é uma pergunta que só um scanner com estado responde.
+     */
+    OPENS.lastIndex = 0;
+    for (const m of source.matchAll(OPENS)) {
         if (m.index != null && looksLikeType(source, m.index))
             continue;
         const name = m[1];
@@ -180,11 +316,25 @@ internal = []) {
         // shadow nothing and still bind a name it also imports.
         if (!owners.has(name) && private_.has(name.split(".")[0]))
             continue;
-        const body = m[2] ?? "";
+        const read = bodyOf(source, (m.index ?? 0) + m[0].length);
+        /** Tag sem fechamento não é uso: arquivo cortado, ou um genérico que não era elemento. */
+        if (!read)
+            continue;
+        const body = read.body;
         // A dotted name belongs to whoever exported its root (`Popover.Root`).
         const owner = owners.get(name) ?? owners.get(name.split(".")[0]);
-        /** Ver `ComponentTally`: dois `Button` de pacotes diferentes são duas linhas, não uma. */
-        let hit = tally.get(name);
+        /**
+         * A ORIGEM ENTRA NA CHAVE - a lei 13 do CLAUDE.md, que este comentário já afirmava e o código
+         * não cumpria: a chave era só o nome.
+         *
+         * Medido no repositório do dono em 10/08: os apps usam o `Button` DELE e o do MUI, e as
+         * variantes do MUI (`contained`, `outlined`, `text`) caíam na conta do Button dele, que declara
+         * `ocean`, `royal`, `neutral`. O mesmo com `CircularProgress` e `determinate`. E era a mesma
+         * causa do `own: true` valer em 7 de 128: uma linha que mistura duas origens nunca tem TODAS
+         * as origens de dentro.
+         */
+        const key = `${name}\u0000${owner ?? ""}`;
+        let hit = tally.get(key);
         if (!hit) {
             hit = {
                 count: 0,
@@ -194,7 +344,7 @@ internal = []) {
                 ...(owner && owner !== OWN ? { from: owner } : {}),
                 origins: new Set(),
             };
-            tally.set(name, hit);
+            tally.set(key, hit);
         }
         /** TODA origem vista, e não só a primeira - ver `origins` no tipo. */
         if (owner)
@@ -204,7 +354,8 @@ internal = []) {
         LITERAL_PROP.lastIndex = 0;
         const named = new Set();
         for (const p of body.matchAll(LITERAL_PROP)) {
-            const [, prop, value] = p;
+            /** O grupo 2 é a ASPA (a backreference); o valor é o 3 - ver `LITERAL_PROP`. */
+            const [, prop, , value] = p;
             named.add(prop);
             if (NOT_A_DECISION.test(prop))
                 continue;
@@ -239,8 +390,9 @@ internal = []) {
 /** The inventory, commonest first. */
 export function tallyToInventory(tally, max = 80) {
     return [...tally.entries()]
-        .map(([name, v]) => ({
-        name,
+        .map(([key, v]) => ({
+        /** A chave carrega a origem para separar as linhas - o nome é a primeira metade dela. */
+        name: key.split("\u0000")[0],
         ...(v.from ? { from: v.from } : {}),
         /** Só dele quando TODA aparição veio de dentro - ver `origins` e `OWN`. */
         ...(v.origins.size > 0 && [...v.origins].every((o) => o === OWN)

package/package.json

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