synthesisui 0.16.82 → 0.16.84

package/dist/doctor/coverage.js

@@ -0,0 +1,129 @@
+/**
+ * WHAT THIS VERSION CAN AND CANNOT READ, MEASURED ON THEIR OWN REPO.
+ *
+ * The most commercially important thing in the pipeline, and it took a person saying
+ * "nothing works" to see it (dono, 01/08).
+ *
+ * Before this, importing a CSS-Modules app produced 283 components with zero
+ * declarations and said nothing about why. A person seeing that concludes the product is
+ * broken, and they are reasoning correctly from what they were shown. The defect was
+ * never the gap - every reader has a boundary. The defect was the SILENCE about it.
+ *
+ * So the census measures its own coverage and says the number before anything is sent:
+ * how each component expresses style, how many of those this version reads, and which
+ * ones it does not - by name, with the count from their repo rather than a disclaimer.
+ *
+ * A governance product that cannot state what it does not govern is not trustworthy.
+ */
+/**
+ * Every shape, in the order the enumeration found them. Each entry survived being
+ * counted on a real repo: a shape with no evidence is a shape I assumed.
+ */
+export const STYLE_SHAPES = [
+    {
+        key: "static",
+        label: "a class list written out",
+        reads: "full",
+        test: /className=["'][^"']+["']/,
+    },
+    {
+        key: "module",
+        label: "CSS Modules",
+        reads: "full",
+        test: /from\s+["'][^"']*\.module\.(?:css|scss|sass|less)["']/,
+    },
+    {
+        key: "cva",
+        label: "cva / tailwind-variants",
+        reads: "full",
+        test: /\b(?:cva|tv)\s*\(/,
+    },
+    {
+        key: "record",
+        label: "a lookup record of option to classes",
+        reads: "full",
+        test: /(?:const|let)\s+\w*(?:[Ss]tyles?|[Cc]lasses|[Vv]ariants?|[Mm]ap|[Cc]olors?|[Ss]izes?|[Tt]ones?)\w*\s*(?::\s*[^=]+)?=\s*\{/,
+    },
+    {
+        key: "ternary",
+        label: "a ternary between class literals",
+        reads: "full",
+        test: /\?\s*["'][^"']*(?:bg-|text-|border-|p-|px-|rounded-)/,
+    },
+    {
+        key: "inline",
+        label: "style={{ }}",
+        reads: "partial",
+        because: "a literal travels as a literal, so it re-themes nowhere until you promote it - and a value computed at render time is not in the source at all",
+        test: /style=\{\{/,
+    },
+    {
+        key: "interpolated",
+        label: "a template with a runtime value in it",
+        reads: "partial",
+        because: "the literal halves are read and a `${cond ? a : b}` between two known classes is read as a variant; a class assembled from a variable does not exist in the source, so there is nothing to read",
+        test: /className=\{`[^`]*\$\{/,
+    },
+    {
+        key: "styled",
+        label: "styled-components / emotion",
+        reads: "none",
+        because: "not read by this version. It was left out deliberately rather than guessed at: zero files in the repo this was measured against, and building for a shape with no evidence is the same mistake as building for one file",
+        test: /styled[.(]|@emotion/,
+    },
+    {
+        key: "sx",
+        label: "a style-prop system (Chakra, Panda, MUI sx)",
+        reads: "none",
+        because: "the styling lives in props this version does not read; a component that only forwards to that library is reported as an adapter instead",
+        test: /\bsx=\{|@chakra-ui|@pandacss/,
+    },
+];
+export function countShape(source, name, into) {
+    for (const shape of STYLE_SHAPES) {
+        if (!shape.test.test(source))
+            continue;
+        const at = into.get(shape.key) ?? { shape, files: 0, examples: [] };
+        at.files += 1;
+        if (at.examples.length < 4)
+            at.examples.push(name);
+        into.set(shape.key, at);
+    }
+}
+export function summarizeCoverage(counts, components, read, declarations) {
+    return {
+        components,
+        read,
+        declarations,
+        counts: [...counts.values()].sort((a, b) => b.files - a.files),
+    };
+}
+/**
+ * The report, in the words a person needs before they decide whether to import.
+ *
+ * Leads with the number that matters - how many components came out with a look - and
+ * then names every shape that is not fully read, with the reason. No percentages without
+ * the count behind them: "75%" of an unknown total is a marketing number.
+ */
+export function describeCoverage(c) {
+    if (c.components === 0)
+        return [];
+    const lines = [];
+    const pct = Math.round((c.read / c.components) * 100);
+    lines.push(`${c.read} of ${c.components} components came out with a look - ${pct}%, ${c.declarations} declarations in total. This is measured on your files, not an estimate.`);
+    for (const { shape, files, examples } of c.counts) {
+        const share = Math.round((files / c.components) * 100);
+        const head = `  ${files} (${share}%) ${shape.label}`;
+        if (shape.reads === "full") {
+            lines.push(`${head} - read`);
+            continue;
+        }
+        lines.push(`${head} - ${shape.reads === "none" ? "NOT read" : "partly read"}. ${shape.because ?? ""}`);
+        lines.push(`      ${examples.join(", ")}`);
+    }
+    const missing = c.components - c.read;
+    if (missing > 0) {
+        lines.push(`${missing} came out with no look at all. They still arrive as contracts - the axes their types declare, their name, their place in your tree - and the look stays yours to write. That is the design, but you should know the number before you decide.`);
+    }
+    return lines;
+}

package/dist/doctor/crosswalk.js

@@ -155,11 +155,41 @@ const AXIS_SYNONYM = {
     placement: "side",
     position: "side",
 };
+/**
+ * THE LIVE TABLE, when a run fetched one.
+ *
+ * Module-level and set once per run, so every call site gets the same answer without
+ * threading the table through nine functions that do not care about it. Absent means the
+ * written `SYNONYM` floor answers - which is a smaller answer, and the run says so.
+ *
+ * The written table had 26 names against a catalogue of 41: twenty of our own components
+ * could not be matched at all (dono, 01/08). It stays as the offline floor, not as truth.
+ */
+let live = null;
+export function useLiveCatalogue(table) {
+    live = table;
+}
+/** How many names the written floor knows - the number a fallback message needs. */
+export function floorSize() {
+    return new Set(Object.values(SYNONYM)).size;
+}
 export function canonicalName(name) {
     const head = name
         .split(".")[0]
         .toLowerCase()
         .replace(/[^a-z]/g, "");
+    /**
+     * The live catalogue first, and its own name counts as a synonym for itself: their
+     * `Textarea` matching our `textarea` needed nothing clever, only a table that knew
+     * `textarea` exists.
+     */
+    if (live) {
+        for (const [canonical, also] of Object.entries(live.synonyms)) {
+            const words = [canonical, ...also].map((w) => w.replace(/[^a-z]/g, ""));
+            if (words.includes(head))
+                return canonical;
+        }
+    }
     if (SYNONYM[head])
         return SYNONYM[head];
     // A compound like `WidgetCard` or `ArrowDownIcon` is only canonical when the
@@ -379,7 +409,10 @@ opts) {
             sharedCount(component.props, mine.find((m) => m.name === t.name)?.props ?? {}) >= TWIN_MIN_SHARED &&
             sharedMeaning(component.props, mine.find((m) => m.name === t.name)?.props ?? {}) >= 1)
             .sort((a, b) => b.overlap - a.overlap);
-        if (canonical && CATALOGUE[canonical]) {
+        // The LIVE catalogue counts as knowing the name: gating on the written table
+        // meant a component matched by the live one fell through to `nearly` (the same
+        // staleness, one branch down).
+        if (canonical && (CATALOGUE[canonical] || live?.axes[canonical])) {
             const alsoClaiming = (claims.get(canonical) ?? []).filter((n) => n !== component.name);
             /**
              * LIBRARY MODE: the match is a NOTE, not a verdict.