inkbridge 0.1.0-beta.2 → 0.1.0-beta.21

package/src/{config.ts → plugin/config.ts}

@@ -1,6 +1,6 @@
 // Figma Plugin API types are provided by the runtime
 
-import type { TokenSourceMode } from './token-source';
+import type { TokenSourceMode } from '../tokens';
 
 export interface ProjectConfig {
   owner: string;
@@ -21,7 +21,7 @@ export const DEFAULT_CONFIG: ProjectConfig = {
   repo: '',
   baseBranch: 'main',
   tokenPath: 'design-tokens/tokens.dtcg.json',
-  tokenSourceMode: 'auto',
+  tokenSourceMode: 'css',
   cssTokenPath: '',
   syncDtcgOnPush: false,
   allowNewTokensFromFigma: false,
@@ -43,8 +43,8 @@ function normalizeTokenPath(tokenPath: unknown): string {
 }
 
 function normalizeTokenSourceMode(mode: unknown): TokenSourceMode {
-  if (mode === 'css' || mode === 'dtcg' || mode === 'auto') return mode;
-  return 'auto';
+  if (mode === 'dtcg') return 'dtcg';
+  return 'css';
 }
 
 function normalizeCssTokenPath(cssTokenPath: unknown): string {
@@ -89,15 +89,15 @@ export async function loadConfig(): Promise<ProjectConfig> {
         tokenSourceMode: normalizeTokenSourceMode(storedConfig.tokenSourceMode),
         cssTokenPath: normalizeCssTokenPath(storedConfig.cssTokenPath),
         syncDtcgOnPush: normalizeSyncDtcgOnPush(storedConfig.syncDtcgOnPush),
-        allowNewTokensFromFigma: normalizeAllowNewTokensFromFigma((storedConfig as any).allowNewTokensFromFigma),
-        newTokenPrefixes: normalizeNewTokenPrefixes((storedConfig as any).newTokenPrefixes),
+        allowNewTokensFromFigma: normalizeAllowNewTokensFromFigma(storedConfig.allowNewTokensFromFigma),
+        newTokenPrefixes: normalizeNewTokenPrefixes(storedConfig.newTokenPrefixes),
       };
       // Persist one-time migrations so old installs stop carrying stale settings.
       await figma.clientStorage.setAsync('project_config', GITHUB_CONFIG);
     } else {
       GITHUB_CONFIG = Object.assign({}, DEFAULT_CONFIG);
     }
-  } catch (e) {
+  } catch (_e) {
     GITHUB_CONFIG = Object.assign({}, DEFAULT_CONFIG);
   }
   return GITHUB_CONFIG;
@@ -105,11 +105,11 @@ export async function loadConfig(): Promise<ProjectConfig> {
 
 export async function saveConfig(config: ProjectConfig): Promise<void> {
   config.tokenPath = normalizeTokenPath(config.tokenPath);
-  config.tokenSourceMode = normalizeTokenSourceMode((config as any).tokenSourceMode);
-  config.cssTokenPath = normalizeCssTokenPath((config as any).cssTokenPath);
-  config.syncDtcgOnPush = normalizeSyncDtcgOnPush((config as any).syncDtcgOnPush);
-  (config as any).allowNewTokensFromFigma = normalizeAllowNewTokensFromFigma((config as any).allowNewTokensFromFigma);
-  (config as any).newTokenPrefixes = normalizeNewTokenPrefixes((config as any).newTokenPrefixes);
+  config.tokenSourceMode = normalizeTokenSourceMode(config.tokenSourceMode);
+  config.cssTokenPath = normalizeCssTokenPath(config.cssTokenPath);
+  config.syncDtcgOnPush = normalizeSyncDtcgOnPush(config.syncDtcgOnPush);
+  config.allowNewTokensFromFigma = normalizeAllowNewTokensFromFigma(config.allowNewTokensFromFigma);
+  config.newTokenPrefixes = normalizeNewTokenPrefixes(config.newTokenPrefixes);
   GITHUB_CONFIG = config;
   await figma.clientStorage.setAsync('project_config', config);
 }

package/src/{dev-server.ts → plugin/dev-server.ts}

@@ -7,7 +7,7 @@
 //   4. UI fetches from localhost dev server
 //   5. UI sends 'component-defs-result' back to code.js
 
-import { debug } from './colors';
+import { debug } from '../tokens';
 
 interface ComponentDefsResult {
   requestId: string;
@@ -123,7 +123,7 @@ export async function prefetchImages(
   await waitForUIReady();
   const hashMap = new Map<string, string>();
   const svgMap = new Map<string, string>();
-  const unique = [...new Set(srcs.filter(Boolean))];
+  const unique = Array.from(new Set(srcs.filter(Boolean)));
 
   const entries = await Promise.all(
     unique.map(async (src) => {
@@ -138,7 +138,7 @@ export async function prefetchImages(
       svgMap.set(src, svgText);
     } else if (bytes && bytes.length > 0) {
       try {
-        const img = (figma as any).createImage(new Uint8Array(bytes));
+        const img = figma.createImage(new Uint8Array(bytes));
         hashMap.set(src, img.hash);
       } catch (_e) { /* ignore */ }
     }

package/src/plugin/image-src-collector.ts

@@ -0,0 +1,52 @@
+import type { ComponentDef } from '../components';
+
+/**
+ * Path/URL shapes the dev-server prefetch can resolve to a fetchable
+ * resource. Excludes data:/blob:/javascript: schemes (data: is handled by
+ * the browser directly; the others aren't useful in Figma).
+ */
+export function looksLikeImageSrc(src: string): boolean {
+  if (src.startsWith('/')) return true;
+  if (src.startsWith('http://') || src.startsWith('https://')) return true;
+  if (src.startsWith('./') || src.startsWith('../')) return true;
+  return false;
+}
+
+/**
+ * Walk a scanner-emitted JSX tree, capturing every `src` prop that points
+ * at a fetchable path/URL. Covers raw `<img>`, Next.js `<Image>`, AND
+ * shadcn-style image wrappers (`<AvatarImage>`, `<AvatarPrimitive.Image>`,
+ * any leaf component that forwards `src` to an underlying `<img>`).
+ *
+ * The wider net is required because `flattenComponentNodes` rewrites those
+ * compound primitives to `kind: 'element', tagLower: 'div'` with the `src`
+ * prop preserved — the renderer treats them as images, so the prefetch
+ * step must capture their srcs too. A tagName-only filter would silently
+ * skip every `<AvatarImage>` in user code.
+ */
+export function collectImageSrcsFromJsxTree(node: unknown, out: Set<string>): void {
+  if (!node || typeof node !== 'object') return;
+  const obj = node as Record<string, unknown>;
+  const props = obj.props && typeof obj.props === 'object' ? (obj.props as Record<string, unknown>) : null;
+  const src = props ? props.src : undefined;
+  if (typeof src === 'string' && src.length > 0 && src !== 'src' && looksLikeImageSrc(src)) {
+    out.add(src);
+  }
+  if (Array.isArray(obj.children)) {
+    for (const child of obj.children) collectImageSrcsFromJsxTree(child, out);
+  }
+}
+
+export function collectImageSrcs(components: ComponentDef[]): string[] {
+  const srcs = new Set<string>();
+  for (const comp of components) {
+    const analysis = comp?.analysis;
+    if (!analysis) continue;
+    collectImageSrcsFromJsxTree(analysis.jsxTree, srcs);
+    for (const story of analysis.stories ?? []) {
+      collectImageSrcsFromJsxTree(story.jsxTree, srcs);
+    }
+  }
+  // sandbox: spread isn't supported on Sets either; Array.from is safe.
+  return Array.from(srcs);
+}

package/src/plugin/index.ts

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './dev-server';
+export * from '../plugin/packs';

package/src/plugin/packs/index.ts

@@ -0,0 +1,2 @@
+export * from './packs';
+export * from './pack-provider';

package/src/{pack-provider.ts → plugin/packs/pack-provider.ts}

@@ -1,20 +1,20 @@
-import { debug } from './colors';
-import { waitForUIReady } from './dev-server';
+import { debug } from '../../tokens';
+import { waitForUIReady } from '../../plugin';
 import { normalizePack } from './packs';
 import type { Pack } from './packs';
-import type { ProjectConfig } from './config';
+import type { ProjectConfig } from '../../plugin';
 
 type PackFetchResult = {
   requestId: string;
-  data: any | null;
+  data: unknown | null;
   source?: string;
   error?: string;
 };
 
 type PackFetchConfig = Pick<ProjectConfig, 'tokenPath' | 'tokenSourceMode' | 'cssTokenPath'>;
 
-const PACK_PORTS = [4000, 3000, 5173];
-const PACK_PATHS = ['api/figma/scan-components'];
+const PACK_PORTS = [3000, 4000, 5173];
+const PACK_PATHS = ['api/inkbridge/scan-components'];
 const SUPPORTED_SCHEMA_VERSION = 1;
 const SUPPORTED_COMPONENT_DEFS_MAJOR = 1;
 
@@ -29,13 +29,13 @@ function getComponentDefsPayload(raw: unknown): Record<string, unknown> | null {
   if (!isPlainObject(raw)) return null;
 
   // Direct component-definitions payload
-  if (Array.isArray((raw as any).components)) {
+  if (Array.isArray(raw.components)) {
     return raw;
   }
 
   // Pack envelope payload: { components: { ...componentDefs } }
-  const nested = (raw as any).components;
-  if (isPlainObject(nested) && Array.isArray((nested as any).components)) {
+  const nested = raw.components;
+  if (isPlainObject(nested) && Array.isArray(nested.components)) {
     return nested;
   }
   return null;
@@ -53,7 +53,7 @@ function validateComponentDefsContract(raw: unknown): { ok: true } | { ok: false
   const defs = getComponentDefsPayload(raw);
   if (!defs) return { ok: false, error: 'invalid-pack' };
 
-  const schemaVersion = (defs as any).schemaVersion;
+  const schemaVersion = defs.schemaVersion;
   if (typeof schemaVersion === 'number') {
     if (schemaVersion !== SUPPORTED_SCHEMA_VERSION) {
       return { ok: false, error: 'incompatible-schema-version' };
@@ -62,7 +62,7 @@ function validateComponentDefsContract(raw: unknown): { ok: true } | { ok: false
   }
 
   // Backward compatibility with older payloads that only had `version`.
-  const major = parseMajor((defs as any).version);
+  const major = parseMajor(defs.version);
   if (major != null && major !== SUPPORTED_COMPONENT_DEFS_MAJOR) {
     return { ok: false, error: 'incompatible-pack-version' };
   }
@@ -79,7 +79,7 @@ function buildPackCandidates(config?: PackFetchConfig): string[] {
       const baseUrl = 'http://localhost:' + port + '/' + path;
       const query: string[] = [];
       const requestedMode = config?.tokenSourceMode;
-      if (requestedMode === 'auto' || requestedMode === 'css' || requestedMode === 'dtcg') {
+      if (requestedMode === 'css' || requestedMode === 'dtcg') {
         query.push('tokenSourceMode=' + encodeURIComponent(requestedMode));
       }
       const cssTokenPath = (config?.cssTokenPath || '').trim();

package/src/{packs.ts → plugin/packs/packs.ts}

@@ -1,13 +1,16 @@
-import { COMPONENT_DEFS } from './tokens';
-import type { ComponentDefs } from './tokens';
-import { createEmptyScannedTokenMap, type ScannedTokenMap } from './token-source';
+import { COMPONENT_DEFS } from '../../tokens';
+import { resetComponentLookupCaches } from '../../components';
+import type { ComponentDefs } from '../../tokens';
+import type { ComponentInstance } from '../../components';
+import { createEmptyScannedTokenMap, type ScannedTokenMap } from '../../tokens';
+import type { JsxNode } from '../../tailwind';
 
 export type StoryDefinition = {
   id: string;
   name: string;
   layoutClasses?: string[] | string;
-  jsxTree?: any;
-  instances?: any[];
+  jsxTree?: JsxNode;
+  instances?: ComponentInstance[];
   tags?: string[];
 };
 
@@ -27,7 +30,7 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function normalizeComponentDefs(raw: any): ComponentDefs {
+function normalizeComponentDefs(raw: unknown): ComponentDefs {
   const out: ComponentDefs = {
     schemaVersion: undefined,
     version: undefined,
@@ -46,20 +49,20 @@ function normalizeComponentDefs(raw: any): ComponentDefs {
   if (typeof raw.version === 'string') out.version = raw.version;
   if (typeof raw.generatedAt === 'string') out.generatedAt = raw.generatedAt;
   if (Array.isArray(raw.components)) out.components = raw.components;
-  if (isPlainObject(raw.spacingScale)) out.spacingScale = raw.spacingScale as Record<string, any>;
+  if (isPlainObject(raw.spacingScale)) out.spacingScale = raw.spacingScale as Record<string, number>;
   if (Array.isArray(raw.colorTokens)) out.colorTokens = raw.colorTokens;
   if (isPlainObject(raw.paletteTokens)) out.paletteTokens = raw.paletteTokens as Record<string, string>;
-  if (isPlainObject(raw.iconRegistry)) out.iconRegistry = raw.iconRegistry as Record<string, any>;
-  if (isPlainObject(raw.styleMap)) out.styleMap = raw.styleMap as Record<string, any>;
+  if (isPlainObject(raw.iconRegistry)) out.iconRegistry = raw.iconRegistry as ComponentDefs['iconRegistry'];
+  if (isPlainObject(raw.styleMap)) out.styleMap = raw.styleMap as ComponentDefs['styleMap'];
   return out;
 }
 
-function normalizeTokenMap(raw: any): ScannedTokenMap | undefined {
+function normalizeTokenMap(raw: unknown): ScannedTokenMap | undefined {
   if (!raw || !isPlainObject(raw)) return undefined;
   const mode = raw.mode === 'css' || raw.mode === 'dtcg' || raw.mode === 'embedded'
     ? raw.mode
     : 'embedded';
-  const requestedMode = raw.requestedMode === 'css' || raw.requestedMode === 'dtcg' || raw.requestedMode === 'auto'
+  const requestedMode = raw.requestedMode === 'css' || raw.requestedMode === 'dtcg'
     ? raw.requestedMode
     : undefined;
   const out = createEmptyScannedTokenMap(
@@ -73,15 +76,16 @@ function normalizeTokenMap(raw: any): ScannedTokenMap | undefined {
   if (isPlainObject(raw.spacing)) out.spacing = raw.spacing as Record<string, number>;
   if (isPlainObject(raw.fontSize)) out.fontSize = raw.fontSize as Record<string, number>;
   if (isPlainObject(raw.shadows)) out.shadows = raw.shadows as Record<string, string>;
-  if (isPlainObject(raw.themes)) out.themes = raw.themes as Record<string, any>;
+  if (isPlainObject(raw.breakpoints)) out.breakpoints = raw.breakpoints as Record<string, number>;
+  if (isPlainObject(raw.themes)) out.themes = raw.themes as ScannedTokenMap['themes'];
   return out;
 }
 
-export function normalizePack(raw: any, fallbackId: string): Pack | null {
-  if (!raw) return null;
+export function normalizePack(raw: unknown, fallbackId: string): Pack | null {
+  if (!raw || !isPlainObject(raw)) return null;
 
-  let componentDefs: any = null;
-  if (raw.components && Array.isArray(raw.components)) {
+  let componentDefs: unknown = null;
+  if (Array.isArray(raw.components)) {
     componentDefs = raw;
   } else if (raw.components && isPlainObject(raw.components) && Array.isArray(raw.components.components)) {
     componentDefs = raw.components;
@@ -97,7 +101,7 @@ export function normalizePack(raw: any, fallbackId: string): Pack | null {
     name: packName,
     version: typeof raw.version === 'string' ? raw.version : undefined,
     components: normalizeComponentDefs(componentDefs),
-    tokens: normalizeTokenMap((raw as any).tokens),
+    tokens: normalizeTokenMap(raw.tokens),
     stories: Array.isArray(raw.stories) ? raw.stories : undefined,
     tags: Array.isArray(raw.tags) ? raw.tags : undefined,
   };
@@ -115,6 +119,7 @@ export function applyPack(pack: Pack): void {
   COMPONENT_DEFS.paletteTokens = defs.paletteTokens;
   COMPONENT_DEFS.iconRegistry = defs.iconRegistry;
   COMPONENT_DEFS.styleMap = defs.styleMap;
+  resetComponentLookupCaches();
 }
 
 export function getActivePack(): Pack | null {

package/src/render-engine-version.ts

@@ -0,0 +1,2 @@
+// Auto-generated by build.mjs. Do not edit manually.
+export const RENDER_ENGINE_VERSION = '011e89524e15bfda';

package/src/tailwind/adapter-utils.ts

@@ -0,0 +1,137 @@
+/**
+ * Shared utilities for tree-transform "adapters" — both framework-specific
+ * (shadcn / Radix data-slot patches in `framework-adapters/shadcn.ts`) and
+ * native-HTML rewrites (e.g. `<input type="range">` in `node-ir.ts`'s
+ * transform chain).
+ *
+ * Why a separate file
+ * -------------------
+ * `framework-adapters/shadcn.ts` and `tailwind/node-ir.ts` already have a
+ * one-way `node-ir → framework-adapters` dependency for the dispatcher.
+ * Putting these helpers in either would either deepen that cycle (shadcn →
+ * node-ir for `isClassedElement`) or hide them in a "framework adapter"
+ * module when they aren't framework-specific. A sibling utility module
+ * keeps the import graph clean: both sides import down into this file.
+ *
+ * All helpers must be sandbox-safe — no value-side spread, no DOM, no
+ * external I/O — these run inside the Figma plugin's code.js.
+ */
+
+import type { NodeIR } from './node-ir';
+
+/**
+ * Type guard for nodes that carry `props` + `classes`. `text`, `fragment`,
+ * `divider`, and `ring` nodes do not; `ring` wraps a single child via a
+ * separate field. Tree-transform code typically branches first on this.
+ */
+export function isClassedElement(
+  node: NodeIR,
+): node is Extract<NodeIR, { kind: 'element' | 'component' }> {
+  return node.kind === 'element' || node.kind === 'component';
+}
+
+/**
+ * Additive class merge: append `extras` to `existing` only when not
+ * already present. Preserves order. Returns `existing` by reference when
+ * nothing was added so callers can detect "no change" and keep object
+ * identity stable (downstream caches like `NODE_LAYOUT_CACHE` rely on
+ * this).
+ *
+ * Note: this is the "injection" merge, distinct from `class-utils.ts`'s
+ * `mergeClasses` which implements Tailwind override semantics
+ * (last-wins). Use this when an adapter wants to ADD classes without
+ * disturbing the consumer's own class order.
+ */
+export function mergeMissing(existing: string[], extras: readonly string[]): string[] {
+  if (extras.length === 0) return existing;
+  const set = new Set(existing);
+  let out: string[] | null = null;
+  for (const cls of extras) {
+    if (set.has(cls)) continue;
+    if (!out) out = existing.slice();
+    out.push(cls);
+    set.add(cls);
+  }
+  return out ?? existing;
+}
+
+/**
+ * Resolve a value/min/max trio into an array of percent positions
+ * (0-100). The scanner stringifies every JSX prop, so `<input value={5}>`
+ * arrives as `props.value === "5"`. We accept numbers, strings,
+ * JSON-array strings ("[25, 75]" for shadcn range sliders), and an actual
+ * array of numbers/strings.
+ *
+ * Defaults — when `min` or `max` is missing / unparseable:
+ *   - `min` defaults to 0
+ *   - `max` defaults to 100
+ *   - If `max <= min` after parsing (degenerate range), we fall back to
+ *     `min + 100` so the percent math doesn't divide by zero.
+ *
+ * If `value` can't be parsed at all, returns `[0]` — a recognisable
+ * "left-edge" position. Callers that want a different default (e.g. HTML
+ * `<input type=range>`'s `(min+max)/2`) can post-process.
+ *
+ * Used by:
+ *   - shadcn Slider adapter (`applySliderPositioning`) — passes min=0
+ *     unconditionally because base-ui's Slider is min=0 max=`max` only.
+ *   - `<input type="range">` IR transform — passes the actual min from
+ *     the element's prop (HTML default min is 0 but consumers commonly
+ *     override).
+ */
+export function resolveValuePercents(
+  rawValue: unknown,
+  rawMin: unknown,
+  rawMax: unknown,
+): number[] {
+  const min = parseNumeric(rawMin, 0);
+  let max = parseNumeric(rawMax, 100);
+  if (!(max > min)) max = min + 100;
+  const range = max - min;
+  const toPct = (v: number): number =>
+    Math.max(0, Math.min(100, ((v - min) / range) * 100));
+
+  if (Array.isArray(rawValue)) {
+    const nums: number[] = [];
+    for (const v of rawValue) {
+      const n = typeof v === 'number' ? v : typeof v === 'string' ? parseFloat(v) : NaN;
+      if (Number.isFinite(n)) nums.push(toPct(n));
+    }
+    if (nums.length > 0) return nums;
+  }
+  if (typeof rawValue === 'number' && Number.isFinite(rawValue)) {
+    return [toPct(rawValue)];
+  }
+  if (typeof rawValue === 'string') {
+    const trimmed = rawValue.trim();
+    if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+          const nums: number[] = [];
+          for (const v of parsed) {
+            const n = typeof v === 'number' ? v : parseFloat(String(v));
+            if (Number.isFinite(n)) nums.push(toPct(n));
+          }
+          if (nums.length > 0) return nums;
+        }
+      } catch (_e) {
+        // Not valid JSON — fall through to numeric parse.
+      }
+    }
+    const num = parseFloat(trimmed);
+    if (Number.isFinite(num)) return [toPct(num)];
+  }
+  return [0];
+}
+
+function parseNumeric(raw: unknown, fallback: number): number {
+  if (typeof raw === 'number' && Number.isFinite(raw)) return raw;
+  if (typeof raw === 'string') {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) return fallback;
+    const n = parseFloat(trimmed);
+    if (Number.isFinite(n)) return n;
+  }
+  return fallback;
+}

package/src/{class-utils.ts → tailwind/class-utils.ts}

@@ -1,6 +1,18 @@
 import { type JsxNode, type JsxElement, splitClassName } from './node-ir';
+import type { ComponentDef } from '../components/scanner-types';
 
-export type ComponentDefResolver = (name: string) => any | null;
+export type { ComponentDef };
+export type ComponentDefResolver = (name: string) => ComponentDef | null;
+
+// Returns the class as-is if it has no variant prefix (e.g. `hover:`, `md:`),
+// or null if any variant is present. Use this when only the unprefixed default
+// class should drive a layout/styling decision. To strip variants and keep the
+// base, see `effects/icon-builder.ts` which intentionally takes the inner.
+export function getBaseClass(value: string): string | null {
+  if (!value) return null;
+  if (value.indexOf(':') !== -1) return null;
+  return value;
+}
 
 export function mergeClasses(base: string[], extra: string[]): string[] {
   const seen: Record<string, boolean> = {};
@@ -30,10 +42,25 @@ export function mergeClasses(base: string[], extra: string[]): string[] {
   return out;
 }
 
-export function getCompoundClasses(def: any, tagName: string): string[] {
+export function getCompoundClasses(def: ComponentDef, tagName: string): string[] {
   if (!def || def.type !== 'compound' || !def.subComponents) return [];
+  // Strict lowercase match. We previously tried using the same elaborate
+  // normalization as `getComponentDefByName` here (so
+  // `<AvatarPrimitive.Image>` would resolve to the `AvatarImage`
+  // subComponent and get flattened to a div), but that side-effect
+  // also flattened portal primitives like `<DialogPrimitive.Trigger>`
+  // / `<SheetPrimitive.Content>` / `<SelectPrimitive.Content>` /
+  // `<AccordionPrimitive.Content>`, which need to stay `kind: 'component'`
+  // so the portal-aware rendering path can position them as overlays.
+  // Net effect: Dialog/Sheet/Select/Accordion-open/Mobile-Nav rendered
+  // their portal content as inline siblings of the trigger.
+  //
+  // AvatarPrimitive.Image is unaffected because the image branch in
+  // ui-builder accepts both `kind: 'element'` and `kind: 'component'`
+  // via `isLeafImageLike` — the strict lookup leaves it as `'component'`
+  // but the image branch still picks it up by the `src` prop.
   const target = tagName.toLowerCase();
-  let fallback: any = null;
+  let fallback: ComponentDef = null;
   for (const sub of def.subComponents) {
     if (!sub || !sub.name) continue;
     const subName = String(sub.name).toLowerCase();
@@ -50,12 +77,12 @@ export function getCompoundClasses(def: any, tagName: string): string[] {
 
 export function treeHasFullWidth(
   node: JsxNode | undefined,
-  parentCompoundDef: any | null,
+  parentCompoundDef: ComponentDef | null,
   options: {
     getComponentDefByName: ComponentDefResolver;
-    normalizeComponentDef: (def: any) => any;
+    normalizeComponentDef: (def: ComponentDef) => ComponentDef;
     hasWidthHintInClasses: (classes: string[]) => boolean;
-    propsContainWidthHint: (props: Record<string, any> | undefined) => boolean;
+    propsContainWidthHint: (props: Record<string, unknown> | undefined) => boolean;
   }
 ): boolean {
   if (!node || node.type !== 'element') return false;

package/src/tailwind/index.ts

@@ -0,0 +1,8 @@
+export * from './tailwind';
+export * from './utility-resolver';
+export * from './class-utils';
+export * from './jsx-utils';
+export * from './node-ir';
+export * from './responsive-analyzer';
+export * from './state-analyzer';
+export * from './transform-math';