bestax-migrate 2.2.1 → 2.3.0

package/dist/sources/_shared/specials-utils.js

@@ -7,7 +7,8 @@
  * Source-agnostic. `makeStripModifierProps` is a factory precisely because
  * the modifier vocabulary is the one thing here that differs per source.
  */
-import { addTodo, findAttr, literalValueOf, removeAttr, } from './jsx-utils.js';
+import { addAttrOnce } from './props.js';
+import { addAttr, addTodo, attributesOf, findAttr, literalValueOf, makeAttr, plainElement, removeAttr, } from './jsx-utils.js';
 /** Pick a target based on a literal align-style prop, removing the prop. */
 export function alignTarget(ctx, path, element, prop, targets, fallback) {
     const attr = findAttr(element, prop);
@@ -77,7 +78,10 @@ export function mergeClassName(ctx, path, element, base, where) {
         : `dynamic ${where} className; re-apply it to the emitted element by hand`);
     return base;
 }
-/** Parse an icon-font <i className="..."> into bestax Icon name/library/variant. */
+/**
+ * Parse an icon-font class string (`fas fa-home fa-spin`, `mdi mdi-account`)
+ * into bestax Icon props. Returns null when no icon name can be read.
+ */
 export function parseIconClasses(className) {
     const tokens = className.trim().split(/\s+/);
     const faVariant = {
@@ -109,16 +113,172 @@ export function parseIconClasses(className) {
     const FA_MODIFIER = /^fa-(?:solid|regular|brands|light|duotone|thin|sharp|classic|2xs|xs|sm|lg|xl|2xl|\d{1,2}x|fw|ul|li|border|inverse|stack|stack-1x|stack-2x|pull-(?:left|right)|spin|spin-pulse|spin-reverse|pulse|beat|fade|beat-fade|bounce|flash|shake|swap-opacity|rotate-(?:90|180|270|by)|flip-(?:horizontal|vertical|both))$/;
     const faName = tokens.find(t => /^fa-/.test(t) && !FA_MODIFIER.test(t));
     if (faStyle && faName) {
+        // The style word itself (`fa-solid`) is not a feature; `fa` is FA4's
+        // style token and, when it accompanies a v5+ style, harmless.
+        const features = tokens.filter(t => FA_MODIFIER.test(t) && !faVariant[t]);
+        const leftovers = tokens.filter(t => t !== faStyle && t !== faName && t !== 'fa' && !features.includes(t));
         return {
             name: faName.replace(/^fa-/, ''),
             library: 'fa',
             variant: faVariant[faStyle],
+            features,
+            leftovers,
         };
     }
     if (tokens.includes('mdi')) {
-        const mdiName = tokens.find(t => /^mdi-/.test(t) && t !== 'mdi');
-        if (mdiName)
-            return { name: mdiName.replace(/^mdi-/, ''), library: 'mdi' };
+        // MDI's documented modifiers: sizes, spin, rotation, flips, light/dark,
+        // inactive. Any other `mdi-*` token is the icon — whichever comes first,
+        // since `mdi mdi-24px mdi-account` is as legal as the other order.
+        const MDI_MODIFIER = /^mdi-(?:(?:18|24|36|48)px|spin|rotate-(?:45|90|135|180|225|270|315)|flip-[hv]|light|dark|inactive)$/;
+        const mdiName = tokens.find(t => /^mdi-/.test(t) && t !== 'mdi' && !MDI_MODIFIER.test(t));
+        if (mdiName) {
+            const features = tokens.filter(t => MDI_MODIFIER.test(t));
+            const leftovers = tokens.filter(t => t !== 'mdi' && t !== mdiName && !features.includes(t));
+            return {
+                name: mdiName.replace(/^mdi-/, ''),
+                library: 'mdi',
+                features,
+                leftovers,
+            };
+        }
     }
     return null;
 }
+/**
+ * Write a parsed icon onto a bestax `Icon`-shaped element: `name`, then
+ * `library`/`variant` when known, then `features` — one string, or an array
+ * literal when there are several — and make the element self-closing.
+ */
+export function applyIconProps(ctx, path, element, parsed) {
+    const { j } = ctx;
+    // The source forwarded HTML props, so the element may already carry a
+    // `name` (or any of these): the existing one is kept and the clash named,
+    // rather than writing a duplicate attribute.
+    const once = (attr) => addAttrOnce(ctx, path, element, 'className', attr);
+    once(makeAttr(j, 'name', parsed.name));
+    if (parsed.library)
+        once(makeAttr(j, 'library', parsed.library));
+    if (parsed.variant)
+        once(makeAttr(j, 'variant', parsed.variant));
+    if (parsed.features.length === 1) {
+        once(makeAttr(j, 'features', parsed.features[0]));
+    }
+    else if (parsed.features.length > 1) {
+        once(j.jsxAttribute(j.jsxIdentifier('features'), j.jsxExpressionContainer(j.arrayExpression(parsed.features.map(f => j.stringLiteral(f))))));
+    }
+    element.children = [];
+    element.openingElement.selfClosing = true;
+    element.closingElement = null;
+    ctx.dirty = true;
+}
+/**
+ * Turn a literal modifier prop into an `is-*` class fragment for an element
+ * on its way to becoming plain HTML. Returns the class (or undefined) and
+ * always removes the attribute.
+ */
+export function modifierClass(ctx, path, element, prop, base, where) {
+    const attr = findAttr(element, prop);
+    if (!attr)
+        return base;
+    const literal = literalValueOf(attr);
+    removeAttr(element, attr);
+    if (literal.kind === 'string' || literal.kind === 'number') {
+        return `${base} is-${literal.value}`;
+    }
+    addTodo(ctx, path, `prop:${prop}`, `dynamic ${where} \`${prop}\`; add the matching is-* class by hand`);
+    return base;
+}
+/**
+ * A source that puts `as` (or its own name for it) on every component can
+ * land, through a handler that picks its target from a prop value, on a
+ * bestax component that has no `as` — Media.Item resolves to
+ * Left/Content/Right where only Left declares one. Opting into `as` in the
+ * mapping table cannot express that, so the target has to be checked after
+ * it is picked.
+ */
+export function restrictAsToTargets(ctx, path, element, target, allowed, prop = 'as') {
+    const asAttr = findAttr(element, prop);
+    if (!asAttr || (target && allowed.includes(target)))
+        return;
+    removeAttr(element, asAttr);
+    addTodo(ctx, path, `prop:${prop}`, `bestax's \`${target}\` has no \`as\` prop (of the targets this can resolve to, only ${allowed
+        .map(a => `\`${a}\``)
+        .join(' / ')} does); render the tag directly or restructure`);
+    ctx.dirty = true;
+}
+/**
+ * The two structural rewrites every source needs, bound to that source's own
+ * attribute strip (its modifier vocabulary is the one thing that differs):
+ * replacing an element with plain HTML, and folding a wrapper onto the single
+ * child it exists to wrap.
+ */
+export function makeStructuralHelpers(strip) {
+    /** Replace the element with a plain HTML tag carrying `className`. */
+    function replaceWithPlain(ctx, path, element, tag, className, where) {
+        const merged = mergeClassName(ctx, path, element, className, where);
+        const kept = new Set(strip(ctx, path, attributesOf(element), where));
+        // Spread attributes pass through untouched, in their original places:
+        // they are the caller's own props, and a plain element takes them as
+        // readily as the component did, with the same JSX precedence. The Bulma
+        // class the element exists for is written right AFTER the last spread,
+        // so a `className` inside a spread cannot override it — the source
+        // merged such a className with its own; a plain element cannot, so the
+        // spread is named.
+        const all = element.openingElement.attributes ?? [];
+        const spreads = all.filter((a) => a.type === 'JSXSpreadAttribute');
+        const ordered = all.filter((a) => a.type === 'JSXSpreadAttribute' || kept.has(a));
+        if (spreads.length > 0 && merged) {
+            addTodo(ctx, path, 'plain-element', `${where} became a plain <${tag}> with \`className="${merged}"\`; a \`className\` inside its spread prop(s) would have been merged with that class by the source, and is overridden here — merge it by hand`);
+        }
+        path.replace(plainElement(ctx.j, tag, merged, ordered, element.children ?? []));
+        ctx.dirty = true;
+        return { replaced: true };
+    }
+    /**
+     * A wrapper that owns the modifiers, where bestax's component renders that
+     * wrapper itself: move the wrapper's (already-converted) attributes onto
+     * its single child and replace the wrapper with it — otherwise both would
+     * rename to the same bestax component and nest, which is invalid.
+     *
+     * Returns null when the element isn't the single-JSX-child shape, or the
+     * child is not one of the components this wrapper exists to wrap (a
+     * ratio-box `<iframe>`, a native `<select>`), so the caller can keep the
+     * wrapper.
+     */
+    function collapseOntoChild(ctx, path, element, where, expected) {
+        const children = (element.children ?? []).filter((c) => !(c.type === 'JSXText' && c.value.trim() === ''));
+        if (children.length !== 1 || children[0].type !== 'JSXElement') {
+            return null;
+        }
+        const child = children[0];
+        const childPath = ctx.resolve?.(child.openingElement?.name);
+        const accepted = Array.isArray(expected) ? expected : [expected];
+        if (!childPath || !accepted.includes(childPath.join('.')))
+            return null;
+        // Spreads have no name to collide on; they move across as written — as
+        // one block, in source order, placed FIRST so the child's own explicit
+        // props still win over them, the same rule the named branch keeps.
+        const spreads = (element.openingElement.attributes ?? []).filter((a) => a.type === 'JSXSpreadAttribute');
+        for (const spread of spreads)
+            removeAttr(element, spread);
+        if (spreads.length > 0) {
+            child.openingElement.attributes = [
+                ...spreads,
+                ...(child.openingElement.attributes ?? []),
+            ];
+        }
+        for (const attr of [...(element.openingElement.attributes ?? [])]) {
+            const name = attr.name.name;
+            if (findAttr(child, name)) {
+                addTodo(ctx, path, `prop:${name}`, `\`${where}\` folded into its child, but both set \`${name}\`; the child's value was kept — reconcile by hand`);
+                continue;
+            }
+            removeAttr(element, attr);
+            addAttr(child, attr);
+        }
+        path.replace(child);
+        ctx.dirty = true;
+        return { replaced: true };
+    }
+    return { replaceWithPlain, collapseOntoChild };
+}

package/dist/sources/_shared/viewports.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Bulma's responsive viewports and the suffix bestax puts on its per-viewport
+ * helper props (`displayTabletOnly`, `visibilityTouch`, …).
+ *
+ * bestax's `validViewports` carries all nine, and the `display*` and
+ * `visibility*` families declare a prop for every one of them. The
+ * typography families (`textSize*`, `textAlign*`) declare only the five
+ * non-`only`, non-`touch` viewports — a source that flattens those must
+ * consult `TYPOGRAPHY_VIEWPORTS` rather than this table.
+ *
+ * Source-agnostic: keyed by Bulma's own suffixes, which every source library
+ * spells the same way.
+ */
+export declare const VIEWPORT_SUFFIX: Record<string, string>;
+/** The viewports bestax's `textSize*` / `textAlign*` props exist for. */
+export declare const TYPOGRAPHY_VIEWPORTS: readonly ["mobile", "tablet", "desktop", "widescreen", "fullhd"];
+//# sourceMappingURL=viewports.d.ts.map

package/dist/sources/_shared/viewports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewports.d.ts","sourceRoot":"","sources":["../../../src/sources/_shared/viewports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAUlD,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,kEAMvB,CAAC"}

package/dist/sources/_shared/viewports.js

@@ -0,0 +1,32 @@
+/**
+ * Bulma's responsive viewports and the suffix bestax puts on its per-viewport
+ * helper props (`displayTabletOnly`, `visibilityTouch`, …).
+ *
+ * bestax's `validViewports` carries all nine, and the `display*` and
+ * `visibility*` families declare a prop for every one of them. The
+ * typography families (`textSize*`, `textAlign*`) declare only the five
+ * non-`only`, non-`touch` viewports — a source that flattens those must
+ * consult `TYPOGRAPHY_VIEWPORTS` rather than this table.
+ *
+ * Source-agnostic: keyed by Bulma's own suffixes, which every source library
+ * spells the same way.
+ */
+export const VIEWPORT_SUFFIX = {
+    mobile: 'Mobile',
+    tablet: 'Tablet',
+    'tablet-only': 'TabletOnly',
+    touch: 'Touch',
+    desktop: 'Desktop',
+    'desktop-only': 'DesktopOnly',
+    widescreen: 'Widescreen',
+    'widescreen-only': 'WidescreenOnly',
+    fullhd: 'Fullhd',
+};
+/** The viewports bestax's `textSize*` / `textAlign*` props exist for. */
+export const TYPOGRAPHY_VIEWPORTS = [
+    'mobile',
+    'tablet',
+    'desktop',
+    'widescreen',
+    'fullhd',
+];

package/dist/sources/bloomer/deps.d.ts

@@ -0,0 +1,17 @@
+/**
+ * package.json migration: swap bloomer for @allxsmith/bestax-bulma, move the
+ * app's own Bulma to v1, and replace the dead node-sass with dart-sass. Pure
+ * data-in/data-out — the CLI owns file IO, and no package manager is ever
+ * invoked (the report tells the user to install).
+ *
+ * bloomer is the react-bulma-components case, not the rbx one: it never
+ * depended on Bulma itself (its README says "npm install bulma"), so there is
+ * no pinned Bulma to free and no extension package to report — the manifest
+ * carries whatever 0.6-era `bulma` the app declared, and that is what gets
+ * bumped. `create-react-class` and `prop-types` were bloomer's dependencies,
+ * not the app's; if they appear here the app declared them for its own
+ * reasons, so they are left alone.
+ */
+import type { DependenciesUpdate } from '../../types.js';
+export declare const updateDependencies: DependenciesUpdate;
+//# sourceMappingURL=deps.d.ts.map

package/dist/sources/bloomer/deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps.d.ts","sourceRoot":"","sources":["../../../src/sources/bloomer/deps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAUzD,eAAO,MAAM,kBAAkB,EAAE,kBAsHhC,CAAC"}

package/dist/sources/bloomer/deps.js

@@ -0,0 +1,119 @@
+/**
+ * package.json migration: swap bloomer for @allxsmith/bestax-bulma, move the
+ * app's own Bulma to v1, and replace the dead node-sass with dart-sass. Pure
+ * data-in/data-out — the CLI owns file IO, and no package manager is ever
+ * invoked (the report tells the user to install).
+ *
+ * bloomer is the react-bulma-components case, not the rbx one: it never
+ * depended on Bulma itself (its README says "npm install bulma"), so there is
+ * no pinned Bulma to free and no extension package to report — the manifest
+ * carries whatever 0.6-era `bulma` the app declared, and that is what gets
+ * bumped. `create-react-class` and `prop-types` were bloomer's dependencies,
+ * not the app's; if they appear here the app declared them for its own
+ * reasons, so they are left alone.
+ */
+import { isPreV1 } from '../_shared/semver-range.js';
+const BESTAX_RANGE = '^5';
+const BULMA_RANGE = '^1.0.4';
+// Bulma v1's sass tree uses `color.channel(…)` — needs dart-sass ≥ 1.79.
+const SASS_RANGE = '^1.79.0';
+const DEP_SECTIONS = ['dependencies', 'devDependencies'];
+export const updateDependencies = (filePath, pkg, collector, options) => {
+    const changes = [];
+    const next = pkg;
+    const section = (name) => (next[name] ?? undefined);
+    const note = (message) => {
+        changes.push(message);
+        collector?.add({ file: filePath, line: null, rule: 'deps', message });
+    };
+    // bloomer goes away entirely.
+    let removedSource = false;
+    for (const name of DEP_SECTIONS) {
+        const deps = section(name);
+        if (deps && 'bloomer' in deps) {
+            delete deps.bloomer;
+            removedSource = true;
+            note(`removed bloomer from ${name}`);
+        }
+    }
+    // The transform deliberately RETAINS imports for components with no bestax
+    // equivalent (Tile, the Bulma 0.4 Nav family) so a partially migrated app
+    // still runs. Removing the package from the manifest strands exactly those
+    // imports once the user runs the install the report asks for, so say so
+    // rather than letting them find out at build time.
+    if (removedSource && options.sourceStillImported) {
+        collector?.add({
+            file: filePath,
+            line: null,
+            rule: 'deps',
+            message: 'bloomer was removed from package.json, but some files still import it for components with no bestax equivalent — resolve those `TODO(bestax-migrate)` imports before installing, or re-add bloomer until you have',
+        });
+    }
+    // @allxsmith/bestax-bulma comes in (runtime dependency).
+    const dependencies = (next.dependencies ??= {});
+    if (!dependencies['@allxsmith/bestax-bulma'] &&
+        !section('devDependencies')?.['@allxsmith/bestax-bulma']) {
+        dependencies['@allxsmith/bestax-bulma'] = BESTAX_RANGE;
+        note(`added @allxsmith/bestax-bulma ${BESTAX_RANGE} to dependencies`);
+    }
+    // Bulma: bump a pre-1 range; add only when sources still reference bulma/…
+    // directly (otherwise it arrives transitively via bestax-bulma).
+    let bulmaDeclared = false;
+    for (const name of DEP_SECTIONS) {
+        const deps = section(name);
+        if (deps?.bulma) {
+            bulmaDeclared = true;
+            if (isPreV1(deps.bulma)) {
+                deps.bulma = BULMA_RANGE;
+                note(`bumped bulma to ${BULMA_RANGE} in ${name} (was pre-1.0)`);
+            }
+        }
+    }
+    if (!bulmaDeclared && options.bulmaReferenced) {
+        dependencies.bulma = BULMA_RANGE;
+        note(`added bulma ${BULMA_RANGE} to dependencies (sources import bulma/… directly)`);
+    }
+    // bestax-bulma requires React 18/19; bloomer peer-depended on React ^16.2.
+    // Report only — a React major upgrade is the app's own migration step.
+    for (const name of DEP_SECTIONS) {
+        const range = section(name)?.react;
+        if (range && /^[~^]?(?:[0-9]|1[0-7])(?:[.x]|$)/.test(range.trim())) {
+            collector?.add({
+                file: filePath,
+                line: null,
+                rule: 'peer-deps',
+                message: `react ${range} predates bestax-bulma's peer range (^18 || ^19) — upgrade react and react-dom to 18 or 19 before installing`,
+            });
+        }
+    }
+    // Font Awesome older than 6 conflicts with bestax-bulma's optional peer
+    // range and makes `npm install` fail with ERESOLVE. Report only — icon
+    // names change across FA majors, so upgrading is the app's decision. (A
+    // bloomer-era app more often loads Font Awesome 4 from a CDN <link>, which
+    // no manifest pass can see; the Icon conversion flags those in the code.)
+    for (const name of DEP_SECTIONS) {
+        const range = section(name)?.['@fortawesome/fontawesome-free'];
+        if (range && /^[~^]?[0-5](?:[.x]|$)/.test(range.trim())) {
+            collector?.add({
+                file: filePath,
+                line: null,
+                rule: 'peer-deps',
+                message: `@fortawesome/fontawesome-free ${range} predates bestax-bulma's optional peer range (^6.7.2 || ^7.0.0) — upgrade it, or install with \`npm install --legacy-peer-deps\``,
+            });
+        }
+    }
+    // node-sass is dead; dart-sass replaces it in the same section.
+    for (const name of DEP_SECTIONS) {
+        const deps = section(name);
+        if (deps && 'node-sass' in deps) {
+            delete deps['node-sass'];
+            note(`removed node-sass from ${name}`);
+            const sassDeclared = DEP_SECTIONS.some(s => section(s)?.sass);
+            if (!sassDeclared) {
+                deps.sass = SASS_RANGE;
+                note(`added sass ${SASS_RANGE} to ${name} (replaces node-sass)`);
+            }
+        }
+    }
+    return changes.length > 0 ? next : null;
+};

package/dist/sources/bloomer/index.d.ts

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

package/dist/sources/bloomer/index.d.ts.map

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

package/dist/sources/bloomer/index.js

@@ -0,0 +1,10 @@
+import transform from './transform.js';
+import { transformStyles } from './styles.js';
+import { updateDependencies } from './deps.js';
+export const bloomer = {
+    name: 'bloomer',
+    label: 'bloomer (0.6) → @allxsmith/bestax-bulma',
+    transform,
+    transformStyles,
+    updateDependencies,
+};

package/dist/sources/bloomer/mapping.d.ts

@@ -0,0 +1,84 @@
+/**
+ * bloomer (0.6) → @allxsmith/bestax-bulma mapping tables.
+ *
+ * Data only — no AST work. `MAPPING` is the single source of truth for what
+ * the transform does with each bloomer export; `BLOOMER_EXPORTS` vendors
+ * bloomer's public surface so `mapping-coverage.test.ts` can close it in both
+ * directions.
+ *
+ * bloomer's shape is the reverse of rbx's: every export is a FLAT name
+ * (`CardHeaderTitle`, `NavbarItem`), while bestax groups the same components
+ * into dotted compounds (`Card.Header.Title`, `Navbar.Item`). So most rows
+ * here rename a flat identifier onto a dotted target — a shape the rename and
+ * value-reference passes already build, since the first segment of a dotted
+ * target is what gets imported.
+ *
+ * Its modifier vocabulary is already bestax's for the booleans (`isActive`,
+ * `isLoading`, `isOutlined`, …) — those are `{}` entries, present so the
+ * universal pass never sees them. What differs is the value-carrying props:
+ * `isColor` → `color`, `isSize` → `size` (claimed per component, because its
+ * type differs per component: numeric on Title/Subtitle, sizes-or-fractions on
+ * Column, `'128x128'` on Image, `'large'` elsewhere), `isAlign` → whatever
+ * the target calls it, and `tag` → `as` where bestax declares one.
+ */
+import type { ComponentMapping, PropAction } from '../../types.js';
+/**
+ * `render` (`Bulma.Render`) let a component hand its computed props to a
+ * custom renderer. bestax has no render-prop escape hatch, and there is no
+ * way to rewrite a function value into markup, so it is always a TODO.
+ */
+export declare const RENDER_TODO: PropAction;
+/**
+ * Helper props `withHelpersModifiers` mixes into EVERY bloomer component.
+ * Applied after each component's own prop map, to whatever attributes are
+ * left.
+ *
+ * `isDisplay` and `isHidden` are deliberately absent: they are consumed
+ * structurally by responsive.ts before this pass runs (their values are
+ * strings, arrays or objects that flatten to several bestax props), and
+ * bestax has no prop of either name, so a leftover would be an
+ * excess-property type error rather than a TODO.
+ */
+export declare const UNIVERSAL_PROPS: Record<string, PropAction>;
+/**
+ * The helper props responsive.ts consumes. Named here so the plain-element
+ * path can strip them from an element that is becoming intrinsic HTML: the
+ * structural pass runs before the rename step, which a `replaced: true`
+ * special skips.
+ */
+export declare const RESPONSIVE_PROPS: Record<string, string | null>;
+/**
+ * bestax targets that extend only React's HTML attributes — no
+ * `BulmaClassesProps` — so bloomer's universal helpers have no prop to land
+ * on. The transform turns each into a TODO naming the Bulma class instead of
+ * emitting an excess-property type error.
+ */
+/**
+ * Targets whose `className` cannot be used: `Navbar.Divider` and
+ * `Pagination.Ellipsis` spread `{...props}` AFTER their own className (so one
+ * written here replaces the class that makes them work), and
+ * `Dropdown.Divider` is a bare `React.FC` that declares no props at all and
+ * renders its own `<hr>` regardless. A helper on one of these is named, never
+ * converted.
+ */
+export declare const NO_CLASSNAME_TARGETS: Set<string>;
+export declare const HELPERLESS_TARGETS: Set<string>;
+/** The Bulma class a helper prop stood for, for the hint on those targets. */
+export declare function helperClassHint(name: string, value: string | number | boolean | undefined): string | null;
+/** Bloomer's fraction and width spellings → bestax's `BulmaColumnSize` names. */
+export declare const COLUMN_SIZE_MAP: Record<string, string>;
+export declare const MAPPING: Record<string, ComponentMapping>;
+/**
+ * bloomer's public export surface, vendored from `src/index.ts` at the SHA
+ * `scripts/validate-corpus-bloomer.mjs` pins, in that file's order. Every
+ * export is flat, so no entry carries sub-paths; the shape matches the other
+ * sources' tables so the coverage and doc tests port unchanged.
+ *
+ * `mapping-coverage.test.ts` walks this against `MAPPING` in both directions,
+ * so bloomer coverage cannot silently regress and `MAPPING` cannot grow an
+ * entry for something bloomer never exported.
+ */
+export declare const BLOOMER_EXPORTS: Record<string, string[]>;
+/** Walk a dotted component path through `MAPPING`. */
+export declare function resolveMapping(path: string[]): ComponentMapping | undefined;
+//# sourceMappingURL=mapping.d.ts.map

package/dist/sources/bloomer/mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.d.ts","sourceRoot":"","sources":["../../../src/sources/bloomer/mapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AA2BnE;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,UAEzB,CAAC;AA+CF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAsBtD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAG1D,CAAC;AAEF;;;;;GAKG;AACH;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,aAI/B,CAAC;AAEH,eAAO,MAAM,kBAAkB,aAqB7B,CAAC;AAEH,8EAA8E;AAC9E,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,GAC3C,MAAM,GAAG,IAAI,CA0Bf;AAED,iFAAiF;AACjF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAOlD,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAsoBpD,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAiIpD,CAAC;AAEF,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,gBAAgB,GAAG,SAAS,CAM3E"}