synthesisui 0.16.375 → 0.16.376

package/dist/doctor/apply-fix.js

@@ -132,6 +132,39 @@ export function planFix(d, read) {
             continue;
         const idx = f.line - 1;
         const current = body[idx];
+        /**
+         * A DECLARAÇÃO DE UM TOKEN NÃO É UM USO DELE - e trocar ali APAGA o token do app inteiro.
+         *
+         * O QUE ACONTECIA: `--color-brand-blue: #4f46e5;` é onde o token NASCE. O scan vê o literal, o
+         * sistema tem um nome para aquele valor - o próprio `--color-brand-blue` -, e a troca escrevia
+         * `--color-brand-blue: var(--color-brand-blue)`. Isso é um ciclo de custom property, e a regra do
+         * CSS é dura: a propriedade fica inválida no elemento E em todos os descendentes. Como esses
+         * tokens moram em `:root`, o app inteiro perde a cor.
+         *
+         * MEDIDO em 05/09, sobre uma cópia do repositório do dono: **26 declarações** viraram
+         * auto-referência numa passada. E cada uma delas é o destino de dezenas de trocas que o mesmo
+         * comando acabou de fazer - o conserto apagava aquilo que ele mesmo tinha acabado de apontar.
+         *
+         * É A MESMA FAMÍLIA DO CICLO DOS EASINGS que o dono encontrou em 04/09, e desta vez produzida
+         * pelo nosso comando de conserto. Sem erro no console: o navegador simplesmente descarta.
+         *
+         * A REGRA É ESTREITA DE PROPÓSITO. Apontar um token DELE para outro token DELE
+         * (`--brand-hover: #4f46e5` -> `var(--color-brand-blue)`) continua valendo e é bom. Só a
+         * auto-referência é fatal, e só ela é recusada.
+         *
+         * É GERAL: toda folha declara token com valor literal - 149 no repositório dele, 180 no
+         * frontend-hub.
+         */
+        const declaring = /^\s*(--[a-z0-9-]+)\s*:/i.exec(current ?? "");
+        if (declaring && declaring[1] === name) {
+            skipped.push({
+                file: f.file,
+                line: f.line,
+                literal: f.literal,
+                because: "self-reference",
+            });
+            continue;
+        }
         const swapped = current === undefined ? null : swap(current, f.literal, name);
         if (swapped === null) {
             /**
@@ -211,6 +244,8 @@ export function describeFix(result, dry) {
     const moved = skipped.filter((s) => s.because === "moved").length;
     /** O valor veio de forma abreviada - ver `not-written` em `planFix`. */
     const notWritten = skipped.filter((s) => s.because === "not-written").length;
+    /** A linha declara o próprio token - ver `self-reference` em `planFix`. */
+    const selfRef = skipped.filter((s) => s.because === "self-reference").length;
     const coincidence = skipped.filter((s) => s.because === "cross-family").length;
     const unread = skipped.filter((s) => s.because === "unreadable").length;
     const decisions = skipped.filter((s) => s.because === "no-token").length;
@@ -229,7 +264,13 @@ export function describeFix(result, dry) {
                    */
                     notWritten > 0
                         ? `Nothing to apply. All ${notWritten} findings are written as a shorthand - a utility class like \`duration-300\` carries the value in its name, so there is no literal on the line to replace. Changing them is a different rewrite.`
-                        : "Nothing to apply.");
+                        : /**
+                           * E quando tudo o que havia eram as linhas onde os tokens nascem, "Nothing to apply."
+                           * sozinho manda a pessoa procurar um defeito. O comando passou por ali de propósito.
+                           */
+                            selfRef > 0
+                                ? `Nothing to apply. ${selfRef === 1 ? "The one finding is" : `All ${selfRef} findings are`} on the line where the token itself is declared - replacing there would point it at itself, and the browser would drop it.`
+                                : "Nothing to apply.");
         return lines;
     }
     lines.push(`${dry ? "Would replace" : "Replaced"} ${applied.length} hand-written value${applied.length === 1 ? "" : "s"} with the token your system already has, across ${result.files} file${result.files === 1 ? "" : "s"}.`);
@@ -269,6 +310,12 @@ export function describeFix(result, dry) {
      * mudado: 13 de 13 eram `duration-300` e afins. Mandar rodar de novo não muda nada, e mandar
      * alguém procurar uma edição que ela não fez é pior que calar.
      */
+    /**
+     * DITO, e não calado: é a linha onde o token NASCE, e a pessoa precisa saber que o comando passou
+     * por ali de propósito - senão ela procura por que aquele valor não foi trocado.
+     */
+    if (selfRef > 0)
+        lines.push(`  ${selfRef} ${selfRef === 1 ? "is" : "are"} the line where the token itself is declared - replacing there would point it at itself and the browser would drop it. Left alone.`);
     if (notWritten > 0)
         lines.push(`  ${notWritten} more ${notWritten === 1 ? "is" : "are"} written as a shorthand - a utility class like \`duration-300\` carries the value in its name, so there is no literal on the line to replace. Changing ${notWritten === 1 ? "it" : "those"} is a different rewrite. Left alone.`);
     if (moved > 0)

package/package.json

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