bestax-migrate 2.3.8 → 2.4.0

package/dist/sources/bulma-classes/deps.d.ts

@@ -0,0 +1,14 @@
+/**
+ * package.json migration for an app that styled plain markup with Bulma:
+ * bestax-bulma comes in, and nothing goes out. Pure data-in/data-out: no
+ * package manager is ever invoked.
+ *
+ * Under the default `--css keep` the app's styling stack is left as it is:
+ * converted elements render the same classes, which the app's own Bulma
+ * stylesheet already styles, so its Bulma version and Sass compiler stay.
+ * `--css bestax` or `--css bulma` asks for the move to Bulma v1, so only then
+ * is a pre-1 Bulma bumped and node-sass swapped for sass.
+ */
+import type { DependenciesUpdate } from '../../types.js';
+export declare const updateDependencies: DependenciesUpdate;
+//# sourceMappingURL=deps.d.ts.map

package/dist/sources/bulma-classes/deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/deps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAoBzD,eAAO,MAAM,kBAAkB,EAAE,kBAgDhC,CAAC"}

package/dist/sources/bulma-classes/deps.js

@@ -0,0 +1,56 @@
+/**
+ * package.json migration for an app that styled plain markup with Bulma:
+ * bestax-bulma comes in, and nothing goes out. Pure data-in/data-out: no
+ * package manager is ever invoked.
+ *
+ * Under the default `--css keep` the app's styling stack is left as it is:
+ * converted elements render the same classes, which the app's own Bulma
+ * stylesheet already styles, so its Bulma version and Sass compiler stay.
+ * `--css bestax` or `--css bulma` asks for the move to Bulma v1, so only then
+ * is a pre-1 Bulma bumped and node-sass swapped for sass.
+ */
+import path from 'node:path';
+import { addBestax, DEP_SECTIONS, moveBulmaToV1, openManifest, replaceNodeSass, reportPeerRanges, } from '../_shared/deps-common.js';
+import { isPreV1 } from '../_shared/semver-range.js';
+import { runtimeOf } from './project.js';
+/** Packages that run PurgeCSS over the app's source. */
+const PURGECSS = [
+    'purgecss',
+    '@fullhuman/postcss-purgecss',
+    'purgecss-webpack-plugin',
+    'gulp-purgecss',
+];
+export const updateDependencies = (filePath, pkg, collector, options) => {
+    const manifest = openManifest(filePath, pkg, collector);
+    // Peers too: a shared UI package declares its runtime as one.
+    const deps = {
+        ...pkg.peerDependencies,
+    };
+    for (const name of DEP_SECTIONS)
+        Object.assign(deps, manifest.section(name));
+    // A Preact, Solid or other non-React package gets no React library.
+    const runtime = runtimeOf(path.dirname(path.resolve(filePath)), deps);
+    if (runtime !== null && runtime !== 'react') {
+        manifest.report('deps', `left package.json alone: this package's JSX renders through \`${runtime}\`, and @allxsmith/bestax-bulma is a React library`);
+        return manifest.result();
+    }
+    addBestax(manifest);
+    if ((options.cssMode ?? 'keep') === 'keep') {
+        for (const name of DEP_SECTIONS) {
+            const range = manifest.section(name)?.bulma;
+            if (range && isPreV1(range)) {
+                manifest.report('deps', `left bulma ${range} in ${name} as it is: under --css keep the app's own stylesheet styles the converted elements, which render the same classes; move to Bulma v1 when you are ready (--css bestax, or the Bulma 0.9 to 1 guide)`);
+            }
+        }
+    }
+    else {
+        moveBulmaToV1(manifest, options.bulmaReferenced);
+        replaceNodeSass(manifest);
+    }
+    reportPeerRanges(manifest);
+    const purger = PURGECSS.find(name => deps[name]);
+    if (purger) {
+        manifest.report('deps', `this app runs PurgeCSS (${purger}), and a converted element's Bulma classes are now written by @allxsmith/bestax-bulma, some of them built from props at runtime (\`mt="4"\` renders \`mt-4\`), so your source no longer spells them out; add ./node_modules/@allxsmith/bestax-bulma/dist/**/*.js to its content and safelist the patterns in https://bestax.io/docs/guides/getting-started/optimizing-css, or those styles are purged from production builds`);
+    }
+    return manifest.result();
+};

package/dist/sources/bulma-classes/index.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationSource } from '../../types.js';
+export declare const bulmaClasses: MigrationSource;
+//# sourceMappingURL=index.d.ts.map

package/dist/sources/bulma-classes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AA6BtD,eAAO,MAAM,YAAY,EAAE,eAgB1B,CAAC"}

package/dist/sources/bulma-classes/index.js

@@ -0,0 +1,35 @@
+import { flaggableRoot } from './class-map.js';
+import { analyzeProject } from './project.js';
+import transform from './transform.js';
+import { transformStyles } from './styles.js';
+import { updateDependencies } from './deps.js';
+/**
+ * The first line of an unparseable file whose markup carries a class this
+ * source converts or flags: in a `class` or `className` attribute (not
+ * `data-class`), including the strings inside a computed one
+ * (`className={cn("button", x)}`).
+ */
+function findUnsupportedReference(text) {
+    const lines = text.split('\n');
+    const index = lines.findIndex(line => [
+        ...line.matchAll(/(?<![\w-])class(?:Name)?=(\{.*|"[^"]*"|'[^']*'|`[^`]*`)/g),
+    ].some(match => [...match[1].matchAll(/["'`]([^"'`]*)["'`]/g)].some(literal => literal[1].split(/\s+/).some(token => flaggableRoot(token)))));
+    return index === -1 ? null : index + 1;
+}
+export const bulmaClasses = {
+    name: 'bulma-classes',
+    label: 'Bulma classes → @allxsmith/bestax-bulma',
+    packageName: null,
+    // The app's own Bulma stylesheet already styles every class a converted
+    // element renders; swapping it for bestax.css would restyle the app's own
+    // markup too (bestax's extras use generic names, and its primary differs).
+    defaultCssMode: 'keep',
+    analyzeProject,
+    findUnsupportedReference,
+    // Formats that can render React components; a .vue or .svelte file cannot
+    // use bestax whatever classes it carries.
+    unsupportedExtensions: ['mdx', 'astro'],
+    transform,
+    transformStyles,
+    updateDependencies,
+};

package/dist/sources/bulma-classes/plan.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Decide what one plain JSX element becomes, from its tag, its static class
+ * tokens and the names of its other attributes. Pure and AST-free, so the
+ * render tests can drive it directly.
+ *
+ * The rule it enforces: an element converts only when the bestax component
+ * renders exactly the markup the element did. Anything that would change the
+ * markup is either left in `className` (a class with no prop here) or refuses
+ * the whole element with a TODO (an attribute or tag the component would
+ * render differently).
+ */
+export interface ElementFacts {
+    tag: string;
+    /** The static className, split on whitespace, in order. */
+    tokens: readonly string[];
+    /**
+     * The element's other attributes: a string value, `true` for a bare
+     * attribute, or null for an expression.
+     */
+    attributes: ReadonlyMap<string, string | true | null>;
+    hasSpread: boolean;
+    hasRef: boolean;
+    /** Whether the element has children (JSX text, elements or expressions). */
+    hasChildren: boolean;
+    /**
+     * The component this element is the only child of, if any (`Link` for
+     * `<Link href="/x"><a className="button">`), since that component can
+     * reach into it with `cloneElement`.
+     */
+    onlyChildOf?: string;
+}
+export interface Todo {
+    rule: string;
+    message: string;
+}
+export interface Conversion {
+    /** bestax JSX name, dotted for a part. */
+    target: string;
+    /** Attributes to write in place of `className`, in order. */
+    props: Array<[name: string, value: string | true]>;
+    /** What stays in `className`, or null when nothing does. */
+    className: string | null;
+    /** Attributes to remove: defaults the target renders by itself. */
+    drop: string[];
+    /** Attributes whose numeric string value becomes a number. */
+    numbers: string[];
+}
+export interface Plan {
+    conversion: Conversion | null;
+    todos: Todo[];
+}
+export declare function plan(facts: ElementFacts): Plan;
+//# sourceMappingURL=plan.d.ts.map

package/dist/sources/bulma-classes/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAiBH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,2DAA2D;IAC3D,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B;;;OAGG;IACH,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC;IACtD,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,WAAW,EAAE,OAAO,CAAC;IACrB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,KAAK,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC;IACnD,4DAA4D;IAC5D,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,mEAAmE;IACnE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,8DAA8D;IAC9D,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,IAAI;IACnB,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AA+BD,wBAAgB,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAgP9C"}

package/dist/sources/bulma-classes/plan.js

@@ -0,0 +1,231 @@
+/**
+ * Decide what one plain JSX element becomes, from its tag, its static class
+ * tokens and the names of its other attributes. Pure and AST-free, so the
+ * render tests can drive it directly.
+ *
+ * The rule it enforces: an element converts only when the bestax component
+ * renders exactly the markup the element did. Anything that would change the
+ * markup is either left in `className` (a class with no prop here) or refuses
+ * the whole element with a TODO (an attribute or tag the component would
+ * render differently).
+ */
+import { FORWARDS_REF, HELPER_PROPS, HELPER_TOKENS, inTagSet, legacyHint, modifierFor, PRECEDENCE, rootFor, WRAPPER_OWN_PROPS, wrapperFor, } from './class-map.js';
+import { ruleId } from './rules.js';
+function wrapperEntry(tag) {
+    const target = wrapperFor(tag);
+    if (!target)
+        return null;
+    return {
+        status: 'mapped',
+        target,
+        tag,
+        textColor: 'textColor',
+        bgColor: 'bgColor',
+        ownProps: WRAPPER_OWN_PROPS[target],
+    };
+}
+function precedence(token) {
+    const index = PRECEDENCE.indexOf(token);
+    return index === -1 ? PRECEDENCE.length : index;
+}
+/** The root class an element carries, for a message. */
+function rootLabel(tokens) {
+    return tokens.find(token => rootFor(token)?.status === 'mapped') ?? 'button';
+}
+function tagsItReaches(entry) {
+    if (entry.as === 'any')
+        return 'any tag through `as`';
+    if (entry.as)
+        return entry.as.map(tag => `<${tag}>`).join(', ');
+    return `only <${entry.tag}>`;
+}
+export function plan(facts) {
+    const todos = [];
+    const { tag, tokens } = facts;
+    for (const token of tokens) {
+        const hint = legacyHint(token);
+        if (hint)
+            todos.push({ rule: ruleId('legacy', token), message: hint });
+    }
+    // A family this source leaves as markup keeps its element as markup, even
+    // beside a class it would convert (`card box`): the family's parts carry no
+    // TODO of their own, so its outermost class is the one place it is flagged.
+    const family = tokens.find(token => {
+        const found = rootFor(token);
+        return found?.status === 'todo' && !found.part;
+    });
+    if (family) {
+        todos.push({
+            rule: ruleId('family', family),
+            message: `\`.${family}\` stays as markup: ${rootFor(family).why}`,
+        });
+        return { conversion: null, todos };
+    }
+    const root = tokens
+        .filter(token => rootFor(token)?.status === 'mapped')
+        .sort((a, b) => precedence(a) - precedence(b))[0];
+    let entry;
+    if (root) {
+        entry = rootFor(root);
+    }
+    else {
+        // A root the table does not convert keeps the element as markup, so a
+        // later pass (or a person) still finds it as the class it is.
+        if (tokens.some(token => rootFor(token))) {
+            return { conversion: null, todos };
+        }
+        entry = wrapperEntry(tag);
+        if (!entry)
+            return { conversion: null, todos };
+    }
+    const target = entry.target;
+    const refuse = (kind, token, message) => ({
+        conversion: null,
+        todos: [...todos, { rule: ruleId(kind, token), message }],
+    });
+    // ---- Refusals: the component would render something else ---------------
+    if (facts.hasSpread) {
+        return refuse('spread', target, `this element spreads props, which bestax \`${target}\` may read differently than the element did (a spread \`className\` merges with its classes instead of replacing them); convert it to \`${target}\` by hand`);
+    }
+    if (facts.hasRef && !FORWARDS_REF.includes(target)) {
+        return refuse('ref', target, `bestax \`${target}\` does not forward refs, so this \`ref\` would stop reaching the DOM node; keep this element as markup`);
+    }
+    if (facts.onlyChildOf) {
+        return refuse('only-child', target, `this element is the only child of \`<${facts.onlyChildOf}>\`, which may hand it props or a ref with \`cloneElement\` (next/link's legacy behavior, a tooltip, a Radix \`asChild\` trigger) that bestax \`${target}\` would not take the same way; convert it by hand if \`<${facts.onlyChildOf}>\` only renders its children`);
+    }
+    if (facts.attributes.has('dangerouslySetInnerHTML')) {
+        return refuse('attr', 'dangerouslySetInnerHTML', `\`dangerouslySetInnerHTML\` sets the element's content directly, and some bestax components render content of their own beside \`children\`, which React rejects; keep this element as markup`);
+    }
+    for (const name of facts.attributes.keys()) {
+        const readAsProp = entry.ownProps?.includes(name) || HELPER_PROPS.has(name);
+        if (readAsProp && !entry.passThrough?.includes(name)) {
+            return refuse('attr', name, `\`${name}\` is also a bestax \`${target}\` prop, which would read it differently; rename or drop the attribute, then re-run`);
+        }
+    }
+    const missing = Object.entries(entry.defaults ?? {}).filter(([name]) => !facts.attributes.has(name));
+    const drop = [];
+    for (const name of entry.untypedAttrs ?? []) {
+        if (!facts.attributes.has(name))
+            continue;
+        if (entry.defaults?.[name] === facts.attributes.get(name)) {
+            drop.push(name);
+            continue;
+        }
+        return refuse('attr', name, `bestax \`${target}\`'s props take no \`${name}\`${entry.defaults?.[name] ? `, and it renders \`${name}="${entry.defaults[name]}"\` when none is given` : ''}; keep this element as markup`);
+    }
+    const numbers = [];
+    for (const name of entry.numberAttrs ?? []) {
+        const value = facts.attributes.get(name);
+        if (typeof value !== 'string')
+            continue;
+        // Only a string that is already the number's own spelling: `040`, `1.50`
+        // and ` 40 ` would render as `40`, `1.5` and `40`.
+        if (!/^-?\d+(?:\.\d+)?$/.test(value) || String(Number(value)) !== value) {
+            return refuse('attr', name, `bestax \`${target}\` types \`${name}\` as a number, and \`${value}\` is not a number spelled the way it renders; keep this element as markup`);
+        }
+        numbers.push(name);
+    }
+    if (entry.requiresChildren && !facts.hasChildren) {
+        return refuse('children', target, `bestax \`${target}\` requires children, and this element has none; keep it as markup`);
+    }
+    if (missing.length > 0) {
+        const list = missing.map(([name, value]) => `\`${name}="${value}"\``);
+        return refuse('defaults', target, `bestax \`${target}\` renders ${list.join(' and ')} when the element does not set ${missing.length === 1 ? 'it' : 'them'}; add ${missing.length === 1 ? 'it' : 'them'} here if that is what you want, then re-run`);
+    }
+    for (const [name, tags] of Object.entries(entry.dropsAttr ?? {})) {
+        if (facts.attributes.has(name) && inTagSet(tags, tag)) {
+            // Bulma greys out `.button[disabled]` on any tag, so there it is not
+            // inert: dropping it changes how the element looks.
+            const visible = name === 'disabled';
+            return refuse('drops', target, visible
+                ? `bestax \`${target}\` drops \`disabled\` on a <${tag}>, and Bulma styles a disabled \`.${rootLabel(facts.tokens)}\` on any tag, so converting would change how it looks; keep this element as markup`
+                : `bestax \`${target}\` drops \`${name}\` on a <${tag}>, where it does nothing anyway; remove it, then re-run`);
+        }
+    }
+    // ---- Tokens → props ---------------------------------------------------------
+    const writes = new Map();
+    /** The tokens each written prop came from, so a group rule can undo it. */
+    const sourceOf = new Map();
+    const groupOf = new Map();
+    const converted = new Set(root ? [root] : []);
+    for (const token of tokens) {
+        if (converted.has(token))
+            continue;
+        const modifier = modifierFor(entry, token);
+        if (modifier) {
+            if (modifier.tagIn && !modifier.tagIn.includes(tag))
+                continue;
+            if (modifier.writes.some(write => writes.has(write.prop)))
+                continue;
+            for (const write of modifier.writes) {
+                writes.set(write.prop, write.value ?? true);
+                sourceOf.set(write.prop, token);
+            }
+            converted.add(token);
+            continue;
+        }
+        const helper = HELPER_TOKENS.get(token);
+        if (!helper)
+            continue;
+        const prop = helper.group === 'text-color'
+            ? entry.textColor
+            : helper.group === 'background'
+                ? entry.bgColor
+                : helper.write.prop;
+        if (!prop || writes.has(prop))
+            continue;
+        writes.set(prop, helper.write.value ?? true);
+        sourceOf.set(prop, token);
+        groupOf.set(prop, helper.group);
+        converted.add(token);
+    }
+    const undo = (prop) => {
+        converted.delete(sourceOf.get(prop));
+        writes.delete(prop);
+    };
+    const displayProps = [...writes.keys()].filter(prop => groupOf.get(prop) === 'display');
+    // bestax drops a base `display` whenever a per-viewport one is set.
+    if (displayProps.includes('display') && displayProps.length > 1) {
+        undo('display');
+    }
+    // Flex-container helpers only render beside a flex `display`.
+    const flexDisplay = [...writes].some(([prop, value]) => groupOf.get(prop) === 'display' &&
+        (value === 'flex' || value === 'inline-flex'));
+    if (!flexDisplay) {
+        for (const prop of [...writes.keys()]) {
+            if (groupOf.get(prop) === 'flex-container')
+                undo(prop);
+        }
+    }
+    // A wrapper exists only to carry helper props; with none, leave the tag.
+    if (!root && writes.size === 0)
+        return { conversion: null, todos };
+    // ---- The tag ------------------------------------------------------------
+    let renders = entry.tag;
+    if (entry.sizeDrivesTag && tag !== 'p' && writes.has('size')) {
+        renders = `h${writes.get('size')}`;
+    }
+    let as;
+    if (renders !== tag) {
+        const reachable = entry.as === 'any' || (entry.as?.includes(tag) ?? false);
+        if (!reachable) {
+            return refuse('tag', target, `bestax \`${target}\` renders ${tagsItReaches(entry)}, not a <${tag}>; keep the markup, or change the tag and re-run`);
+        }
+        as = tag;
+    }
+    const props = [];
+    if (as)
+        props.push(['as', as]);
+    props.push(...writes);
+    const rest = tokens.filter(token => !converted.has(token));
+    return {
+        conversion: {
+            target,
+            props,
+            className: rest.length > 0 ? rest.join(' ') : null,
+            drop,
+            numbers,
+        },
+        todos,
+    };
+}

package/dist/sources/bulma-classes/project.d.ts

@@ -0,0 +1,40 @@
+/**
+ * What the bulma-classes transform needs to know about the project and cannot
+ * see from one file: which files a Next.js App Router may render as server
+ * components, and which packages render JSX through a runtime other than
+ * React.
+ *
+ * Read once per run, from every package.json the run touches: the nearest one
+ * above each target, and every one below it, so a monorepo run from its root
+ * still finds `apps/web`.
+ */
+/** `jsxImportSource` values whose JSX is React's. */
+export declare const REACT_RUNTIMES: ReadonlySet<string>;
+export interface JsxRuntime {
+    /** A package's directory, absolute. */
+    dir: string;
+    /** `react`, or the other runtime its JSX renders through. */
+    runtime: string;
+}
+/**
+ * A Next.js package with an App Router. Any module in it can be rendered as a
+ * server component (a component under `components/` is one when a server page
+ * renders it), so every file counts but those under a Pages Router directory,
+ * which are always client code.
+ */
+export interface ServerComponentRoot {
+    dir: string;
+    except: string[];
+}
+export interface ProjectFacts {
+    serverComponentRoots: ServerComponentRoot[];
+    jsxRuntimes: JsxRuntime[];
+}
+/**
+ * The JSX runtime a package declares: what its tsconfig's `jsxImportSource`
+ * names, else React when it depends on React, else the first other runtime
+ * it depends on, else null.
+ */
+export declare function runtimeOf(dir: string, deps: Readonly<Record<string, string | undefined>>): string | null;
+export declare function analyzeProject(targets: string[]): ProjectFacts;
+//# sourceMappingURL=project.d.ts.map

package/dist/sources/bulma-classes/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/sources/bulma-classes/project.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,qDAAqD;AACrD,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,CAK7C,CAAC;AAqBH,MAAM,WAAW,UAAU;IACzB,uCAAuC;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,6DAA6D;IAC7D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;IAC5C,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AA2GD;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,GACjD,MAAM,GAAG,IAAI,CAKf;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,YAAY,CA4C9D"}

package/dist/sources/bulma-classes/project.js

@@ -0,0 +1,203 @@
+/**
+ * What the bulma-classes transform needs to know about the project and cannot
+ * see from one file: which files a Next.js App Router may render as server
+ * components, and which packages render JSX through a runtime other than
+ * React.
+ *
+ * Read once per run, from every package.json the run touches: the nearest one
+ * above each target, and every one below it, so a monorepo run from its root
+ * still finds `apps/web`.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+/** `jsxImportSource` values whose JSX is React's. */
+export const REACT_RUNTIMES = new Set([
+    'react',
+    '@emotion/react',
+    'theme-ui',
+    '@theme-ui/core',
+]);
+/** Packages that bring a JSX runtime of their own. */
+const OTHER_RUNTIMES = [
+    'preact',
+    'solid-js',
+    'inferno',
+    '@builder.io/qwik',
+    'hono',
+];
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.e2e-tmp',
+]);
+function nearestManifest(target) {
+    let dir = path.resolve(target);
+    if (fs.statSync(dir, { throwIfNoEntry: false })?.isFile()) {
+        dir = path.dirname(dir);
+    }
+    for (;;) {
+        const candidate = path.join(dir, 'package.json');
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function manifestsBelow(dir, out) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
+            manifestsBelow(path.join(dir, entry.name), out);
+        }
+        else if (entry.isFile() && entry.name === 'package.json') {
+            out.push(path.join(dir, entry.name));
+        }
+    }
+}
+/**
+ * JSONC without its comments. tsconfig allows them, and a commented-out
+ * `jsxImportSource` is not one the package sets. Strings are copied as they
+ * are, so a `//` inside one (a URL) survives.
+ */
+function withoutComments(text) {
+    let out = '';
+    for (let i = 0; i < text.length; i += 1) {
+        const char = text[i];
+        if (char === '"') {
+            let end = i + 1;
+            while (end < text.length && text[end] !== '"') {
+                end += text[end] === '\\' ? 2 : 1;
+            }
+            out += text.slice(i, end + 1);
+            i = end;
+        }
+        else if (char === '/' && text[i + 1] === '/') {
+            while (i < text.length && text[i] !== '\n')
+                i += 1;
+            out += '\n';
+        }
+        else if (char === '/' && text[i + 1] === '*') {
+            const end = text.indexOf('*/', i + 2);
+            i = end === -1 ? text.length : end + 1;
+        }
+        else {
+            out += char;
+        }
+    }
+    return out;
+}
+/** Where a relative `extends` points: the file as named, else with `.json`. */
+function extendedFile(fromDir, spec) {
+    const file = path.resolve(fromDir, spec);
+    return fs.statSync(file, { throwIfNoEntry: false })?.isFile()
+        ? file
+        : `${file}.json`;
+}
+/**
+ * The `jsxImportSource` a config sets, or inherits through `extends`: its own
+ * setting first, then its parents, a later one in an `extends` list over an
+ * earlier one, as TypeScript reads them. A parent named by path is followed
+ * (the usual monorepo base config); one named as a package is not.
+ */
+function importSourceOf(file, seen) {
+    if (seen.has(file))
+        return null;
+    seen.add(file);
+    let text;
+    try {
+        text = withoutComments(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    const own = text.match(/"jsxImportSource"\s*:\s*"([^"]+)"/);
+    if (own)
+        return own[1];
+    const extendsValue = text.match(/"extends"\s*:\s*("[^"]*"|\[[^\]]*\])/)?.[1];
+    const parents = [...(extendsValue ?? '').matchAll(/"([^"]+)"/g)]
+        .map(match => match[1])
+        .filter(spec => spec.startsWith('.') || path.isAbsolute(spec))
+        .map(spec => extendedFile(path.dirname(file), spec));
+    for (const parent of parents.reverse()) {
+        const inherited = importSourceOf(parent, seen);
+        if (inherited)
+            return inherited;
+    }
+    return null;
+}
+/** The `jsxImportSource` a package's tsconfig or jsconfig sets, if any. */
+function configuredImportSource(dir) {
+    for (const name of ['tsconfig.json', 'jsconfig.json']) {
+        const found = importSourceOf(path.join(dir, name), new Set());
+        if (found)
+            return found;
+    }
+    return null;
+}
+/**
+ * The JSX runtime a package declares: what its tsconfig's `jsxImportSource`
+ * names, else React when it depends on React, else the first other runtime
+ * it depends on, else null.
+ */
+export function runtimeOf(dir, deps) {
+    const configured = configuredImportSource(dir);
+    if (configured)
+        return REACT_RUNTIMES.has(configured) ? 'react' : configured;
+    if (deps.react)
+        return 'react';
+    return OTHER_RUNTIMES.find(name => deps[name]) ?? null;
+}
+export function analyzeProject(targets) {
+    const manifests = new Set();
+    for (const target of targets) {
+        const nearest = nearestManifest(target);
+        if (nearest)
+            manifests.add(path.resolve(nearest));
+        const below = [];
+        if (fs.statSync(target, { throwIfNoEntry: false })?.isDirectory()) {
+            manifestsBelow(path.resolve(target), below);
+        }
+        for (const manifest of below)
+            manifests.add(manifest);
+    }
+    const facts = { serverComponentRoots: [], jsxRuntimes: [] };
+    for (const manifest of [...manifests].sort()) {
+        let pkg;
+        try {
+            // A byte-order mark is legal in a file JSON.parse will not read.
+            pkg = JSON.parse(fs.readFileSync(manifest, 'utf8').replace(/^\uFEFF/, ''));
+        }
+        catch {
+            continue;
+        }
+        const deps = {
+            ...pkg.peerDependencies,
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        };
+        const dir = path.dirname(manifest);
+        const hasAppRouter = ['app', path.join('src', 'app')].some(candidate => fs.existsSync(path.join(dir, candidate)));
+        if (deps.next && hasAppRouter) {
+            facts.serverComponentRoots.push({
+                dir,
+                except: ['pages', path.join('src', 'pages')].map(pages => path.join(dir, pages)),
+            });
+        }
+        const runtime = runtimeOf(dir, deps);
+        if (runtime)
+            facts.jsxRuntimes.push({ dir, runtime });
+    }
+    return facts;
+}

package/dist/sources/bulma-classes/rules.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Rule ids for the bulma-classes source's TODOs.
+ *
+ * A rule id reaches opt-in telemetry (`todosByRule`), and this source reads
+ * the app's own class strings, so an id must never carry one of those. Every
+ * id is `kind:token`, where the token comes from a closed vocabulary: a Bulma
+ * class this table knows, a bestax component, or an attribute or prop name
+ * the table itself lists. A token outside it is dropped and the id is just the
+ * kind, so a gap in the vocabulary costs detail, never the file. The planner
+ * tests sweep every refusal the table can produce and hold each id to the
+ * vocabulary, so a gap is still caught.
+ */
+export declare const KINDS: ReadonlySet<string>;
+export declare function inVocabulary(token: string): boolean;
+export declare function ruleId(kind: string, token: string): string;
+//# sourceMappingURL=rules.d.ts.map