@bsuite/page-builder 1.0.7 → 2.0.0

package/dist/scanner/cardHeadingScanner.js

@@ -0,0 +1,278 @@
+/**
+ * Which headings are CARD headings, and do they carry the gradient?
+ *
+ * WHY THIS EXISTS. The estate's heading gradient was implemented as a
+ * PAGE-TITLE convention and shipped: 183 of 232 crm7 `<h1>` page titles carry
+ * `.text-gradient-accent`. Card headings were never in scope, and the numbers
+ * say so plainly — 0 of 304 crm7 `<h2>`/`<h3>`, 15 of 734 estate-wide. The work
+ * was done, declared complete, and covered a DIFFERENT ELEMENT than the one the
+ * operator keeps pointing at. On the very dashboard he screenshotted,
+ * "Dashboard" (h1) has the gradient and "Quick Actions", "Communication Center"
+ * and "Pipeline Overview" (h2/h3) do not.
+ *
+ * SO WHY NOT JUST GREP `<h2`? Because `<h2>` is not the same thing as "card
+ * heading", and a sweep that treats them as equal gradients dialog titles,
+ * empty-state titles, section labels and table captions along with the cards.
+ * The operator asked for card headings. A detector that cannot tell a card
+ * heading from any other heading would deliver 734 changes to satisfy a request
+ * about roughly 600 of them, and the excess is what gets noticed.
+ *
+ * A heading is a CARD heading here when an enclosing element paints card chrome
+ * — a card component, or a border+radius+background surface — which is the same
+ * definition `cardSurfaceScanner` already uses for nested chrome. One definition
+ * of "card", two scanners.
+ *
+ * FAIL CLOSED. A file whose JSX tags do not balance is UNKNOWN, not clean: a
+ * tag stack that has lost its place cannot say what encloses what, and
+ * "checked nothing" must not share an exit code with "found nothing" (D-92).
+ *
+ * Node-only: filesystem access, exported from `@bsuite/page-builder/scanner`.
+ */
+import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { stripComments, elementDeclaresCardChrome } from './cardSurfaceScanner.js';
+const DEFAULT_HEADINGS = ['h2', 'h3'];
+const DEFAULT_GRADIENT_CLASSES = ['text-gradient-accent', 'gradient-text'];
+/**
+ * Classes whose effect DEPENDS on the heading filling its box.
+ *
+ * `.text-gradient-accent` sets `width: fit-content`, and that is load-bearing —
+ * `background-clip: text` paints across the ELEMENT BOX, so a block-level
+ * heading spanning its container samples only the first slice of the gradient
+ * and renders flat, indistinguishable from having no gradient at all. Shrinking
+ * the box is therefore not optional; it is the effect.
+ *
+ * But shrinking the box is VISIBLE wherever the box itself is visible or
+ * positioned. Three families, and the first was the only one measured on the
+ * first pass:
+ *
+ *   1. SIZE — `truncate`, `flex-1`, `w-full`, `line-clamp-*`. Fit-content never
+ *      truncates and never fills.
+ *   2. POSITION — `text-center`, `mx-auto`. A centred heading stops centring the
+ *      moment its box hugs the glyphs, because there is nothing left to centre
+ *      the text inside.
+ *   3. PAINT — the heading's OWN `border-*` or `bg-*`. A rule or a tinted strip
+ *      that used to span the card suddenly ends at the last letter. This is the
+ *      most visible of the three and the easiest to miss in a diff.
+ *
+ * A first, loose measurement over a three-line window put family 1 at 2 and
+ * implied the sweep was nearly free. Reading the heading's OWN attributes puts
+ * the full hazard set an order of magnitude higher. The loose number was the
+ * kind that makes a codemod look safe.
+ */
+const WIDTH_DEPENDENT = [
+    'truncate',
+    'flex-1',
+    'w-full',
+    'grow',
+    'flex-grow',
+    'text-center',
+    'mx-auto',
+];
+const WIDTH_DEPENDENT_PREFIXES = ['line-clamp-', 'basis-', 'w-', 'min-w-', 'max-w-'];
+/** The heading paints its own box — a border or a background of its own. */
+const OWN_PAINT = /(?:^|\s)(?:border(?:-[a-z0-9[\]().\-/]+)?|bg-[a-z0-9[\]().\-/]+)(?=$|\s)/;
+/** Void HTML elements never carry a closing tag. */
+const VOID_TAGS = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+]);
+/**
+ * Tokenise JSX tags with their kind and offset.
+ *
+ * `openingTags` in the sibling module is deliberately kind-blind — it only has
+ * to find chrome inside a known block. Ancestry needs a stack, and a stack
+ * needs to know which tags close.
+ */
+export function jsxTags(source) {
+    const out = [];
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] !== '<')
+            continue;
+        const close = /^<\/([A-Za-z][A-Za-z0-9._-]*)\s*>/.exec(source.slice(i, i + 80));
+        if (close) {
+            out.push({ kind: 'close', tag: close[1], attrs: '', index: i });
+            i += close[0].length - 1;
+            continue;
+        }
+        const open = /^<([A-Za-z][A-Za-z0-9._-]*)/.exec(source.slice(i, i + 64));
+        if (!open)
+            continue;
+        // KNOWN LIMITATION, measured rather than papered over. A TypeScript type
+        // argument presents as a tag to any matcher this cheap:
+        // `row.getValue<string>('code')` pushes `<string>`, and every ancestry
+        // answer after it in that file is fiction. The file is therefore reported
+        // UNKNOWN by the stack check below — 23 files across six apps, 0.8% of the
+        // tree, named individually rather than absorbed.
+        //
+        // A GUARD WAS TRIED AND REVERTED, and the measurement is why. Skipping a
+        // tag whose `<` is preceded by an identifier character catches the generics
+        // — and also catches JSX that follows TEXT (`Total<span>`), which is
+        // ordinary markup. Skipping an OPENING tag while its CLOSING tag is still
+        // counted unbalances the stack outright, so UNKNOWN went from 23 to 106.
+        // An over-eager filter feeding a stack is strictly worse than no filter,
+        // and a real parser is the fix if 23 ever stops being acceptable.
+        let j = i + open[0].length;
+        let depth = 0;
+        let quote = null;
+        let closed = false;
+        for (; j < source.length; j++) {
+            const c = source[j];
+            if (quote) {
+                if (c === quote && source[j - 1] !== '\\')
+                    quote = null;
+                continue;
+            }
+            if (c === '"' || c === "'" || c === '`') {
+                quote = c;
+                continue;
+            }
+            if (c === '{')
+                depth++;
+            else if (c === '}')
+                depth--;
+            else if (c === '>' && depth === 0) {
+                closed = true;
+                break;
+            }
+        }
+        if (!closed)
+            continue;
+        const attrs = source.slice(i + open[0].length, j);
+        const selfClosing = /\/\s*$/.test(attrs) || VOID_TAGS.has(open[1]);
+        out.push({
+            kind: selfClosing ? 'self' : 'open',
+            tag: open[1],
+            attrs: attrs.replace(/\/\s*$/, ''),
+            index: i,
+        });
+        i = j;
+    }
+    return out;
+}
+function classText(attrs) {
+    const m = /class(?:Name)?\s*=\s*(?:"([^"]*)"|'([^']*)'|\{([\s\S]*)\})/.exec(attrs);
+    if (!m)
+        return '';
+    if (m[1] !== undefined)
+        return m[1];
+    if (m[2] !== undefined)
+        return m[2];
+    const lit = /(?:"([^"]*)"|'([^']*)'|`([^`]*)`)/g;
+    const parts = [];
+    let l;
+    while ((l = lit.exec(m[3] ?? '')) !== null)
+        parts.push(l[1] ?? l[2] ?? l[3] ?? '');
+    return parts.join(' ');
+}
+function widthDependent(classes) {
+    const tokens = classes.split(/\s+/).filter(Boolean);
+    const hits = tokens.filter((t) => WIDTH_DEPENDENT.includes(t) ||
+        WIDTH_DEPENDENT_PREFIXES.some((p) => t.startsWith(p)));
+    // A heading that paints its own box: shrinking the box moves the paint.
+    for (const t of tokens)
+        if (OWN_PAINT.test(` ${t} `) && !hits.includes(t))
+            hits.push(t);
+    return hits;
+}
+function walk(dir, extensions, acc) {
+    for (const entry of readdirSync(dir)) {
+        if (entry === 'node_modules' || entry === 'dist' || entry === '.git')
+            continue;
+        const full = join(dir, entry);
+        const st = statSync(full);
+        if (st.isDirectory())
+            walk(full, extensions, acc);
+        else if (extensions.some((e) => entry.endsWith(e)) && !/\.(test|spec)\./.test(entry))
+            acc.push(full);
+    }
+}
+export function scanCardHeadings(config) {
+    const extensions = config.extensions ?? ['.tsx'];
+    const headings = new Set(config.headingTags ?? DEFAULT_HEADINGS);
+    const gradientClasses = config.gradientClasses ?? DEFAULT_GRADIENT_CLASSES;
+    const chromeTags = new Set([...config.cardTags, ...(config.nestedChromeTags ?? [])]);
+    const findings = [];
+    const unknownFiles = [];
+    const files = [];
+    const scanRootsResolved = [];
+    // D-92: assert the inputs before reporting a verdict.
+    for (const root of config.scanRoots) {
+        const abs = join(config.projectRoot, root);
+        if (!existsSync(abs))
+            throw new Error(`[cardHeadingScanner] scan root "${root}" does not exist at ${abs}. ` +
+                `A scanner that silently skips a missing root reports a false pass.`);
+        const before = files.length;
+        walk(abs, extensions, files);
+        if (files.length === before)
+            throw new Error(`[cardHeadingScanner] scan root "${root}" matched ZERO files. ` +
+                `Refusing to report a verdict from an empty scan.`);
+        scanRootsResolved.push(root);
+    }
+    for (const file of files) {
+        const rel = relative(config.projectRoot, file);
+        let src;
+        try {
+            src = stripComments(readFileSync(file, 'utf8'));
+        }
+        catch {
+            unknownFiles.push(rel);
+            continue;
+        }
+        if (!/<h[1-6][\s/>]/.test(src))
+            continue;
+        const tags = jsxTags(src);
+        const stack = [];
+        let lostPlace = false;
+        for (const t of tags) {
+            if (t.kind === 'self')
+                continue;
+            if (t.kind === 'close') {
+                // A close with nothing to close, or closing something else, means the
+                // stack no longer describes the tree. Ancestry answers become fiction
+                // from here, so stop and report UNKNOWN rather than guess.
+                const top = stack[stack.length - 1];
+                if (!top || top.tag !== t.tag) {
+                    lostPlace = true;
+                    break;
+                }
+                stack.pop();
+                continue;
+            }
+            if (headings.has(t.tag)) {
+                const surface = stack
+                    .slice()
+                    .reverse()
+                    .map((a) => elementDeclaresCardChrome(a, chromeTags))
+                    .find((hit) => Boolean(hit));
+                if (surface) {
+                    const classes = classText(t.attrs);
+                    findings.push({
+                        file: rel,
+                        tag: t.tag,
+                        line: src.slice(0, t.index).split('\n').length,
+                        enclosingSurface: surface,
+                        hasGradient: gradientClasses.some((g) => new RegExp(`(?:^|\\s)${g}(?:$|\\s)`).test(classes)),
+                        widthDependentClasses: widthDependent(classes),
+                    });
+                }
+            }
+            stack.push({ tag: t.tag, attrs: t.attrs });
+        }
+        if (lostPlace) {
+            unknownFiles.push(rel);
+            // Drop this file's findings — an ancestry answer from a broken stack is
+            // worse than no answer, because it looks like a measurement.
+            for (let i = findings.length - 1; i >= 0; i--)
+                if (findings[i].file === rel)
+                    findings.splice(i, 1);
+        }
+    }
+    const missing = findings.filter((f) => !f.hasGradient);
+    const risky = missing.filter((f) => f.widthDependentClasses.length > 0);
+    const summary = `scanned ${files.length} files across ${scanRootsResolved.length} root(s) [${scanRootsResolved.join(', ')}]; ` +
+        `${findings.length} card heading(s), ${findings.length - missing.length} already gradient, ` +
+        `${missing.length} without — of which ${risky.length} carry a width-dependent class and need a ` +
+        `decision rather than a codemod; ${unknownFiles.length} UNKNOWN file(s) — an UNKNOWN is not a clean file.`;
+    return { findings, filesScanned: files.length, scanRootsResolved, unknownFiles, summary };
+}

package/dist/scanner/cardSurfaceScanner.d.ts

@@ -46,7 +46,20 @@ export type CardSurfaceIdiom =
 /** autoHeight opt-out on a card that is not a virtualized list. */
  | 'autoheight-optout'
 /** autoHeight={false} with a seed height so small the card must clip. */
- | 'clipped-card';
+ | 'clipped-card'
+/**
+ * V-C5. A grid item whose child re-declares card chrome — border + radius +
+ * background — inside the chrome the grid item already paints. 28px inside
+ * 24px, two 1px borders. This is the idiom V-C4 (`glued-widget`) cannot see:
+ * ONE card in ONE slot is not glue, and it is still a double frame.
+ */
+ | 'nested-chrome'
+/**
+ * The file could not be parsed with confidence. NOT a clean verdict. A gate
+ * that cannot tell "checked nothing" from "found nothing" is not a gate
+ * (D-92), so an unparseable file gets its own idiom and its own exit path.
+ */
+ | 'unparseable';
 export interface CardSurfaceFinding {
     file: string;
     idiom: CardSurfaceIdiom;
@@ -95,6 +108,36 @@ export interface CardSurfaceScannerConfig {
     autoHeightEscapeHatch?: RegExp;
     /** File extensions to scan. Defaults to .tsx. */
     extensions?: string[];
+    /**
+     * Extra component names that count as CARD CHROME when they appear inside a
+     * grid slot — a component that paints its own border + radius + background.
+     * `cardTags` is always included; this is for app-local chrome components the
+     * glue check does not need (BSU `MagicCard`, conduit `CounterCard`, …).
+     */
+    nestedChromeTags?: string[];
+    /** file -> reason. A nested-chrome file listed here is allowed. */
+    nestedChromeExclusions?: Record<string, string>;
+    /**
+     * Does the GRID ITEM paint card chrome in the version this app resolves?
+     *
+     * TRUE for `@bsuite/page-builder` <= 1.0.7, where every grid item painted
+     * `rounded-3xl bg-card border border-border` unconditionally and there was
+     * no way to turn it off. On those versions a nested card is ALWAYS a double
+     * frame, so every nesting slot is a finding.
+     *
+     * FALSE from 2.0.0, where chrome is opt-in. A nested card then becomes the
+     * CORRECT shape — it is the only surface — and the defect narrows to a slot
+     * that opts back INTO chrome (`itemChrome`, or `chrome` on the item or the
+     * CanvasCard) AND still nests a card.
+     *
+     * DEFAULTS TO TRUE, i.e. it assumes the pre-inversion package until an app
+     * says otherwise. A shared-package fix that four consumers receive and one
+     * does not is this estate's recorded failure mode (conduit sat on a
+     * minor-locked `^0.6.3` while the fix shipped in 0.8.0, and nothing
+     * reported it), so each app must DECLARE which side of the inversion it is
+     * on rather than inherit an optimistic default.
+     */
+    gridItemPaintsChrome?: boolean;
 }
 export interface CardSurfaceScanResult {
     findings: CardSurfaceFinding[];
@@ -103,6 +146,14 @@ export interface CardSurfaceScanResult {
     scanRootsResolved: string[];
     /** Exclusion-ledger keys that no longer match any finding — stale entries. */
     staleExclusions: string[];
+    /**
+     * Files the scanner could NOT parse with confidence. These are UNKNOWN, not
+     * clean. A caller that treats an empty `findings` array as a pass while this
+     * array is non-empty has reproduced the exact defect D-92 names.
+     */
+    unknownFiles: string[];
+    /** Distinct files carrying at least one `nested-chrome` finding. */
+    nestedChromeFiles: string[];
     /** Human-readable account of how the verdict was reached. */
     summary: string;
 }
@@ -116,5 +167,54 @@ export interface CardSurfaceScanResult {
  * skipped entirely. Stripping first fixes both.
  */
 export declare function stripComments(source: string): string;
+/**
+ * Every opening tag in a JSX body, with its raw attribute text.
+ *
+ * Hand-rolled rather than regex-only because an attribute value can contain
+ * `>` inside a string, a template literal or a `{…}` expression — three of the
+ * five hand-rolled copies this module replaced were defeated by exactly that.
+ */
+export declare function openingTags(body: string): {
+    tag: string;
+    attrs: string;
+}[];
+/**
+ * Does this element paint its OWN card chrome?
+ *
+ * Chrome means all three of border, radius and background, because that is
+ * exactly what `PageGridLayout` already paints on the slot. Two of the three is
+ * a tinted panel or a divider, not a second card — requiring all three is what
+ * separates BSU's `glass-card rounded-2xl border-primary/30` (a real double
+ * frame) from a `rounded-lg bg-muted` inline chip (not one).
+ *
+ * Chrome declared through `style={{ background, border, borderRadius }}` counts
+ * the same as chrome declared through classes. BSU's `Settings.tsx` is chrome
+ * entirely in inline style; a class-only detector calls that file clean, which
+ * is how a nested card hides from a gate that only reads Tailwind.
+ */
+export declare function elementDeclaresCardChrome(el: {
+    tag: string;
+    attrs: string;
+}, chromeTags: Set<string>): string | null;
+/**
+ * Does this grid slot paint chrome of its OWN, post-inversion?
+ *
+ * Three ways to opt in, and all three have to be visible to the scanner or a
+ * re-chromed slot goes unnoticed: `itemChrome` on the grid component (whole
+ * app/page), `chrome: true` on the layout item, and `chrome` on the CanvasCard.
+ */
+export declare function slotOptsIntoChrome(fileSource: string, slotBody: string): boolean;
+/** The first nested-chrome element inside one grid slot, or null. */
+export declare function findNestedChrome(slotBody: string, config: Pick<CardSurfaceScannerConfig, 'cardTags' | 'nestedChromeTags'>): string | null;
+/**
+ * Can this file be parsed with confidence?
+ *
+ * Returns a reason when it CANNOT. Every `<CanvasCard` must pair with a
+ * `</CanvasCard>` the block regex can reach, and every `widgets={{` must close
+ * before EOF. A file that fails either is UNKNOWN — it is not reported clean,
+ * and it is not silently skipped. "Checked nothing" and "found nothing" do not
+ * share an exit code here.
+ */
+export declare function parseConfidence(src: string): string | null;
 export declare function scanCardSurfaces(config: CardSurfaceScannerConfig): CardSurfaceScanResult;
 //# sourceMappingURL=cardSurfaceScanner.d.ts.map

package/dist/scanner/cardSurfaceScanner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cardSurfaceScanner.d.ts","sourceRoot":"","sources":["../../src/scanner/cardSurfaceScanner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAKH,MAAM,MAAM,gBAAgB;AAC1B,2DAA2D;AACzD,cAAc;AAChB,6EAA6E;GAC3E,sBAAsB;AACxB,yEAAyE;GACvE,mBAAmB;AACrB,mEAAmE;GACjE,mBAAmB;AACrB,yEAAyE;GACvE,cAAc,CAAC;AAEnB,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,gBAAgB,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACvC,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,sDAAsD;IACtD,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,mFAAmF;IACnF,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,6DAA6D;IAC7D,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,2EAA2E;IAC3E,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC/B,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,8EAA8E;IAC9E,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;CACjB;AASD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKpD;AAwHD,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,wBAAwB,GAC/B,qBAAqB,CAwIvB"}
+{"version":3,"file":"cardSurfaceScanner.d.ts","sourceRoot":"","sources":["../../src/scanner/cardSurfaceScanner.ts"],"names":[],"mappings":"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"}