rnwind 0.0.1 → 0.0.2

package/lib/cjs/metro/transformer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.cjs","sources":["../../../../src/metro/transformer.ts"],"sourcesContent":["import type { File } from '@babel/types'\nimport * as t from '@babel/types'\nimport { parse } from '@babel/parser'\nimport generate from '@babel/generator'\nimport { createHash } from 'node:crypto'\nimport { transformAst } from './transform-ast'\nimport { getClassNamePrefixes, getRnwindCacheKey, getRnwindState, onThemeChange } from './state'\nimport { STYLE_SPECIFIERS, THEME_SIGNATURE_MODULE } from './resolver'\nimport { filterUnknownClassCandidates } from './warn-unknown-classes'\n\n/** The shape of the upstream module we delegate parsing/babel work to. */\ninterface UpstreamTransformer {\n  transform: (args: BabelTransformerArgs) => Promise<BabelTransformerResult> | BabelTransformerResult\n}\n\n/** Env var that points at the upstream `babelTransformerPath` we override. */\nconst UPSTREAM_ENV = 'RNWIND_UPSTREAM_TRANSFORMER'\n\n/** Cached upstream module — required once, reused across every transform call. */\nlet cachedUpstream: UpstreamTransformer | null = null\n\nconst generateModule = (generate as unknown as { default?: typeof generate }).default ?? generate\n\n/**\n * Parse user source with the broad plugin set (Flow + JSX + TypeScript\n * + class properties). Permissive on purpose so we don't reject any\n * file the upstream could have handled. Returns `null` when parse\n * fails — caller falls back to the raw source string.\n * @param source Source text.\n * @returns Parsed AST, or null on parse failure.\n */\nfunction parseUserSource(source: string): File | null {\n  try {\n    return parse(source, {\n      sourceType: 'unambiguous',\n      allowReturnOutsideFunction: true,\n      allowImportExportEverywhere: true,\n      plugins: ['typescript', 'jsx'],\n    }) as unknown as File\n  } catch {\n    try {\n      return parse(source, {\n        sourceType: 'unambiguous',\n        allowReturnOutsideFunction: true,\n        allowImportExportEverywhere: true,\n        plugins: ['flow', 'jsx'],\n      }) as unknown as File\n    } catch {\n      return null\n    }\n  }\n}\n\n/**\n * Print Tailwind-shaped candidates oxide picked up but the parser\n * could NOT compile — typo, missing custom utility, or class not in\n * the user's theme. Filtering by candidates that ALSO appear inside a\n * `className=\"…\"` literal eliminates false positives from imports,\n * comments, and JSX prop values.\n * @param source Original source text — searched for className literals.\n * @param candidates Every candidate oxide surfaced from the source.\n * @param atoms Successfully resolved atoms (keys are class names).\n * @param filename Source path, prefixed onto the warning.\n */\nfunction warnUnknownClasses(\n  source: string,\n  candidates: readonly string[],\n  atoms: ReadonlyMap<string, unknown>,\n  filename: string,\n): void {\n  const atomNames = new Set(atoms.keys())\n  const unknown = filterUnknownClassCandidates(source, candidates, atomNames)\n  if (unknown.length === 0) return\n  // eslint-disable-next-line no-console\n  console.warn(`rnwind: unknown class${unknown.length > 1 ? 'es' : ''} in ${filename}: ${unknown.join(', ')}`)\n}\n\n/**\n * Extract the bare extension for oxide / internal switches.\n * @param filename Absolute path.\n * @returns Extension without the leading dot (`tsx` / `ts` / `js` / `jsx`).\n */\nfunction extensionOf(filename: string): string {\n  const index = filename.lastIndexOf('.')\n  if (index === -1) return 'tsx'\n  return filename.slice(index + 1)\n}\n\n/**\n * Read the project root Metro hands us per-transform. Falls back to\n * `process.cwd()` only when the upstream harness doesn't set it (unit\n * tests, standalone). Metro's production pipeline always sets it.\n * @param args Metro transformer args.\n * @returns Absolute project root.\n */\nfunction projectRootOf(args: BabelTransformerArgs): string {\n  const fromOptions = args.options?.projectRoot\n  if (typeof fromOptions === 'string' && fromOptions.length > 0) return fromOptions\n  return process.cwd()\n}\n\n/**\n * Whether a `.css` filename is the user's theme entry (the file\n * `withRnwindConfig` pointed us at via `RNWIND_CSS_ENTRY_FILE`).\n * Only the theme CSS should trigger a scheme rebuild — unrelated CSS\n * files in the project stay invisible to rnwind.\n * @param filename Absolute CSS path.\n * @returns Whether the file is the configured theme entry.\n */\nfunction isThemeCssEntry(filename: string): boolean {\n  const cssEntry = process.env.RNWIND_CSS_ENTRY_FILE\n  return typeof cssEntry === 'string' && cssEntry.length > 0 && cssEntry === filename\n}\n\n/**\n * Parse + run rnwind's JSX rewrite + regenerate source code. When\n * parsing or transformation fails, fall back to the original source —\n * we don't want a transient parse error to crash Metro for a file the\n * upstream might handle fine.\n * @param args Metro args; `src` is the original source text.\n * @returns Rewritten source text (with `className=` rewrites applied).\n */\nasync function rewriteSource(args: BabelTransformerArgs): Promise<string> {\n  const ast = parseUserSource(args.src)\n  if (!ast) return args.src\n\n  const state = getRnwindState(projectRootOf(args))\n  const extension = extensionOf(args.filename)\n  const parsed = await state.parser.parseAtoms({ content: args.src, extension })\n\n  warnUnknownClasses(args.src, parsed.candidates, parsed.atoms, args.filename)\n\n  const classNamePrefixes = getClassNamePrefixes()\n  if (parsed.atoms.size === 0) {\n    state.builder.dropFile(args.filename)\n    await state.builder.writeSchemes()\n    transformAst(ast, {\n      styleSpecifiers: [],\n      gradientAtoms: parsed.gradientAtoms,\n      hapticAtoms: parsed.hapticAtoms,\n      classNamePrefixes,\n    })\n    injectThemeSignatureImport(ast)\n    return generateModule(ast).code\n  }\n\n  const { changed } = await state.builder.recordFile(args.filename, parsed.atoms, parsed.keyframes)\n  if (changed) await state.builder.writeSchemes()\n\n  transformAst(ast, {\n    styleSpecifiers: STYLE_SPECIFIERS as unknown as readonly string[],\n    gradientAtoms: parsed.gradientAtoms,\n    hapticAtoms: parsed.hapticAtoms,\n    classNamePrefixes,\n  })\n  injectThemeSignatureImport(ast)\n  return generateModule(ast).code\n}\n\n/**\n * Prepend `import 'rnwind/__generated/theme-signature'` to every\n * rnwind-transformed file. The resolver maps that specifier to the\n * user's theme CSS so Metro's dependency graph carries a real edge\n * from this JS file to the CSS. When the user edits `global.css`,\n * the CSS module's SHA1 changes, and Metro invalidates every JS file\n * holding this import — forcing them to re-transform with the new\n * theme. The `.css` branch in {@link transform} returns an empty\n * `export {}` module so the runtime cost is one extra `require()`.\n * @param ast Babel File AST to mutate in place.\n */\nfunction injectThemeSignatureImport(ast: File): void {\n  const declaration = t.importDeclaration([], t.stringLiteral(THEME_SIGNATURE_MODULE))\n  ast.program.body.unshift(declaration)\n}\n\n/**\n * Read the upstream transformer's `getCacheKey()` so our cache-key\n * contribution composes with — rather than replaces — whatever the\n * host framework wants to mix in.\n * @returns Upstream cache key, or `null` when no upstream exposes one.\n */\nfunction loadUpstreamCacheKey(): string | null {\n  const upstream = loadUpstream() as (UpstreamTransformer & { getCacheKey?: () => string }) | null\n  if (!upstream) return null\n  try {\n    return typeof upstream.getCacheKey === 'function' ? upstream.getCacheKey() : null\n  } catch {\n    return null\n  }\n}\n\n/**\n * Invoke the upstream `babelTransformerPath` Metro originally had\n * configured. The path is read from `RNWIND_UPSTREAM_TRANSFORMER`,\n * which `withRnwindConfig` sets at Metro startup. When the env var is\n * unset (unit tests, standalone use), fall back to a typescript+jsx\n * parse.\n * @param args Metro's per-file args.\n * @returns Upstream transform result containing the post-babel AST.\n */\nasync function runUpstream(args: BabelTransformerArgs): Promise<BabelTransformerResult> {\n  if (args.ast && !process.env[UPSTREAM_ENV]) return { ast: args.ast }\n  const upstream = loadUpstream()\n  if (upstream) return await Promise.resolve(upstream.transform(args))\n  if (args.ast) return { ast: args.ast }\n  return { ast: parseSource(args.src) }\n}\n\n/**\n * Lazily require the upstream transformer module. Cached after first\n * load so per-file overhead is one cache lookup.\n * @returns Upstream module, or null when env is unset.\n */\nfunction loadUpstream(): UpstreamTransformer | null {\n  if (cachedUpstream) return cachedUpstream\n  const upstreamPath = process.env[UPSTREAM_ENV]\n  if (!upstreamPath || upstreamPath.length === 0) return null\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n    const required = require(upstreamPath) as UpstreamTransformer | { default?: UpstreamTransformer }\n    const upstream = (required as { default?: UpstreamTransformer }).default ?? (required as UpstreamTransformer)\n    if (typeof upstream.transform !== 'function') return null\n    cachedUpstream = upstream\n    return upstream\n  } catch (error) {\n    // eslint-disable-next-line no-console\n    if (process.env.RNWIND_DEBUG) console.error('rnwind: failed to load upstream transformer:', error)\n    return null\n  }\n}\n\n/**\n * Cheap guard — the file has to look JS/TS, live outside `node_modules`,\n * and mention `className=` before we spend AST cycles on it.\n * @param args Metro args.\n * @returns Whether the file might need the rnwind pass.\n */\nfunction isRewriteCandidate(args: BabelTransformerArgs): boolean {\n  if (!/\\.(?:tsx|ts|jsx|js)$/i.test(args.filename)) return false\n  if (args.filename.includes('/node_modules/')) return false\n  return args.src.includes('className=')\n}\n\n/**\n * Fallback parse when no upstream is configured AND Metro didn't hand\n * us an AST. Used by unit tests and standalone setups.\n * @param source Source text.\n * @returns Parsed Babel File.\n */\nfunction parseSource(source: string): File {\n  return parse(source, { sourceType: 'module', plugins: ['typescript', 'jsx'] }) as unknown as File\n}\n\n/** Metro's babel transformer signature. */\nexport interface BabelTransformerArgs {\n  filename: string\n  src: string\n  options: { projectRoot?: string; [key: string]: unknown }\n  ast?: File\n  plugins?: readonly unknown[]\n}\n\n/** Return shape Metro expects from a babel transformer. */\nexport interface BabelTransformerResult {\n  ast: File\n  metadata?: unknown\n}\n\n/**\n * rnwind's Metro babel transformer. Two phases per source file:\n *\n *  1. **Pre-process the source string before handing it to the upstream\n *     babel pipeline.** babel-preset-expo / React's JSX transform run\n *     inside the upstream and convert `<View className=\"...\"/>` into\n *     `React.createElement(View, {className})`. If we walked the AST\n *     AFTER the upstream, there'd be no JSX attributes left to\n *     rewrite. So we parse, run our pass, regenerate code, and feed\n *     THAT to the upstream as `src`.\n *  2. **Delegate to the upstream `babelTransformerPath`** (Expo's\n *     default handles Flow stripping, expo-router macros, etc.).\n *\n * Skip both phases when the file isn't a JS/TS source under user\n * code, or doesn't mention `className=` — hand straight to upstream.\n * @param args Metro's per-file args.\n * @returns Mutated AST + metadata.\n */\nexport async function transform(args: BabelTransformerArgs): Promise<BabelTransformerResult> {\n  // Short-circuit `.css` inputs: the theme CSS is pulled into the dep\n  // graph as a sentinel (see `THEME_SIGNATURE_MODULE` in resolver.ts)\n  // so Metro watches it and invalidates importers on edit, but the\n  // file's CSS syntax can't go through a JS babel transformer.\n  //\n  // When the CSS being transformed IS the user's theme entry, we\n  // piggyback on Metro's own file-watcher: Metro calls us here on\n  // every CSS save; we trigger `onThemeChange` to rebuild parser +\n  // rewrite scheme files with the new values. Metro's dep graph then\n  // HMRs the regenerated `common.style.js` to the running app.\n  //\n  // Emitting the CSS content hash in the fake JS output is what makes\n  // Metro propagate invalidation to downstream importers — constant\n  // `export {}` bytes would never look changed and Metro would skip\n  // the chain.\n  if (args.filename.endsWith('.css')) {\n    if (isThemeCssEntry(args.filename)) {\n      try {\n        await onThemeChange(projectRootOf(args))\n      } catch {\n        // CSS edit happened outside a configured project (e.g. tests).\n      }\n    }\n    const themeHash = createHash('sha256').update(args.src).digest('hex').slice(0, 16)\n    const stub = `export const __rnwindThemeHash = ${JSON.stringify(themeHash)};\\n`\n    return { ast: parse(stub, { sourceType: 'module' }) as unknown as File }\n  }\n  if (!isRewriteCandidate(args)) {\n    if (/\\.(?:tsx|ts|jsx|js)$/i.test(args.filename) && !args.filename.includes('/node_modules/')) {\n      try {\n        getRnwindState(projectRootOf(args)).builder.dropFile(args.filename)\n      } catch {\n        // State not configured (e.g. test). Nothing to drop.\n      }\n    }\n    return runUpstream(args)\n  }\n\n  const rewrittenSource = await rewriteSource(args)\n  return runUpstream({ ...args, src: rewrittenSource, ast: undefined })\n}\n\n/**\n * Metro's babel-transformer contract: a `getCacheKey()` export is\n * sampled per-file and mixed into the transform cache key. Returning\n * a string that includes the theme CSS content hash invalidates every\n * cached transform on every CSS edit — so the bundle rebuilds with\n * the new theme automatically on the next request.\n * @returns Cache-key segment that includes rnwind's current theme hash.\n */\nexport function getCacheKey(): string {\n  const upstreamKey = loadUpstreamCacheKey()\n  const ownKey = getRnwindCacheKey()\n  return upstreamKey ? `${upstreamKey}|${ownKey}` : ownKey\n}\n\n/** Test-only — drop the cached upstream so a new env var picks up next call. */\nexport function __resetUpstreamCache(): void {\n  cachedUpstream = null\n}\n"],"names":["parse","filterUnknownClassCandidates","state","getRnwindState","getClassNamePrefixes","transformAst","STYLE_SPECIFIERS","t","THEME_SIGNATURE_MODULE","onThemeChange","createHash","getRnwindCacheKey"],"mappings":"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"}

package/lib/cjs/metro/transformer.d.ts

@@ -0,0 +1,47 @@
+import type { File } from '@babel/types';
+/** Metro's babel transformer signature. */
+export interface BabelTransformerArgs {
+    filename: string;
+    src: string;
+    options: {
+        projectRoot?: string;
+        [key: string]: unknown;
+    };
+    ast?: File;
+    plugins?: readonly unknown[];
+}
+/** Return shape Metro expects from a babel transformer. */
+export interface BabelTransformerResult {
+    ast: File;
+    metadata?: unknown;
+}
+/**
+ * rnwind's Metro babel transformer. Two phases per source file:
+ *
+ *  1. **Pre-process the source string before handing it to the upstream
+ *     babel pipeline.** babel-preset-expo / React's JSX transform run
+ *     inside the upstream and convert `<View className="..."/>` into
+ *     `React.createElement(View, {className})`. If we walked the AST
+ *     AFTER the upstream, there'd be no JSX attributes left to
+ *     rewrite. So we parse, run our pass, regenerate code, and feed
+ *     THAT to the upstream as `src`.
+ *  2. **Delegate to the upstream `babelTransformerPath`** (Expo's
+ *     default handles Flow stripping, expo-router macros, etc.).
+ *
+ * Skip both phases when the file isn't a JS/TS source under user
+ * code, or doesn't mention `className=` — hand straight to upstream.
+ * @param args Metro's per-file args.
+ * @returns Mutated AST + metadata.
+ */
+export declare function transform(args: BabelTransformerArgs): Promise<BabelTransformerResult>;
+/**
+ * Metro's babel-transformer contract: a `getCacheKey()` export is
+ * sampled per-file and mixed into the transform cache key. Returning
+ * a string that includes the theme CSS content hash invalidates every
+ * cached transform on every CSS edit — so the bundle rebuilds with
+ * the new theme automatically on the next request.
+ * @returns Cache-key segment that includes rnwind's current theme hash.
+ */
+export declare function getCacheKey(): string;
+/** Test-only — drop the cached upstream so a new env var picks up next call. */
+export declare function __resetUpstreamCache(): void;

package/lib/cjs/metro/warn-unknown-classes.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * Yield every literal-text segment found at a `className=` site.
+ * @param source Raw source text.
+ * @yields Each literal's inner text.
+ */
+function* iterateClassNameLiterals(source) {
+    // className="..."  /  className='...'
+    for (const match of source.matchAll(/className\s*=\s*"([^"]*)"/g))
+        yield match[1] ?? '';
+    for (const match of source.matchAll(/className\s*=\s*'([^']*)'/g))
+        yield match[1] ?? '';
+    // className={"..."}  /  className={'...'}
+    for (const match of source.matchAll(/className\s*=\s*\{\s*"([^"]*)"\s*\}/g))
+        yield match[1] ?? '';
+    for (const match of source.matchAll(/className\s*=\s*\{\s*'([^']*)'\s*\}/g))
+        yield match[1] ?? '';
+    // className={`...`} — yield each static quasi between `${...}` substitutions.
+    for (const match of source.matchAll(/className\s*=\s*\{\s*`([^`]*)`\s*\}/g)) {
+        const body = match[1] ?? '';
+        for (const part of body.split(/\$\{[^}]*\}/))
+            yield part;
+    }
+}
+/**
+ * Pull every `className="…"`, `className={'…'}`, `className={"…"}`, and
+ * `className={\`…\`}` literal out of the source and union their
+ * whitespace-separated tokens. A regex-based scan is enough — the
+ * warning is best-effort, not load-bearing, and a regex sidesteps
+ * having to re-parse the file.
+ *
+ * Skipped on purpose:
+ *  - `className={someExpression}` with no inline literal (we can't
+ *    introspect the runtime value at build time).
+ *  - Template literals with substitutions (`` `text-${size}` ``) — we
+ *    only union the static-quasi parts, which is fine because the
+ *    warning fires only on candidates that ARE in the static parts.
+ * @param source Raw source text.
+ * @returns Set of whitespace-separated tokens drawn from every literal.
+ */
+function collectClassNameTokens(source) {
+    const out = new Set();
+    for (const literal of iterateClassNameLiterals(source)) {
+        for (const token of literal.split(/\s+/)) {
+            if (token.length > 0)
+                out.add(token);
+        }
+    }
+    return out;
+}
+/**
+ * Filter Tailwind candidate strings down to ones that actually appear
+ * as a token inside a `className="…"` literal in the source. Oxide
+ * scans the entire file and surfaces anything Tailwind-shaped — that
+ * includes import specifiers (`'expo-router'`), comment markers
+ * (`/* @rnwind-theme=… *\/`), JSX prop values (`keyboardType="email-
+ * address"`), and bare suffixes Tailwind splits out from compound
+ * utilities (`bg-sky-500` also produces `sky-500`). None of those are
+ * "unknown classes" worth nagging the user about; the genuine signal
+ * is a typo in a real `className`, e.g. `bg-srface` for `bg-surface`.
+ *
+ * The filter walks every `className="…" / {'…'} / {`…`}` literal in the
+ * source, splits each on whitespace, and unions the tokens. Only
+ * candidates in that token set survive. Then known-good atoms are
+ * subtracted, leaving genuine typos.
+ * @param source Raw source text the transformer received from Metro.
+ * @param candidates Every candidate oxide picked up.
+ * @param atoms Set of atom names the parser successfully resolved.
+ * @returns Candidates that look like real "unknown classes" the user typed.
+ */
+function filterUnknownClassCandidates(source, candidates, atoms) {
+    const literalTokens = collectClassNameTokens(source);
+    const out = [];
+    for (const candidate of candidates) {
+        if (atoms.has(candidate))
+            continue;
+        if (!literalTokens.has(candidate))
+            continue;
+        out.push(candidate);
+    }
+    return out;
+}
+
+exports.filterUnknownClassCandidates = filterUnknownClassCandidates;
+//# sourceMappingURL=warn-unknown-classes.cjs.map

package/lib/cjs/metro/warn-unknown-classes.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"warn-unknown-classes.cjs","sources":["../../../../src/metro/warn-unknown-classes.ts"],"sourcesContent":["/**\n * Yield every literal-text segment found at a `className=` site.\n * @param source Raw source text.\n * @yields Each literal's inner text.\n */\nfunction* iterateClassNameLiterals(source: string): Iterable<string> {\n  // className=\"...\"  /  className='...'\n  for (const match of source.matchAll(/className\\s*=\\s*\"([^\"]*)\"/g)) yield match[1] ?? ''\n  for (const match of source.matchAll(/className\\s*=\\s*'([^']*)'/g)) yield match[1] ?? ''\n  // className={\"...\"}  /  className={'...'}\n  for (const match of source.matchAll(/className\\s*=\\s*\\{\\s*\"([^\"]*)\"\\s*\\}/g)) yield match[1] ?? ''\n  for (const match of source.matchAll(/className\\s*=\\s*\\{\\s*'([^']*)'\\s*\\}/g)) yield match[1] ?? ''\n  // className={`...`} — yield each static quasi between `${...}` substitutions.\n  for (const match of source.matchAll(/className\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}/g)) {\n    const body = match[1] ?? ''\n    for (const part of body.split(/\\$\\{[^}]*\\}/)) yield part\n  }\n}\n\n/**\n * Pull every `className=\"…\"`, `className={'…'}`, `className={\"…\"}`, and\n * `className={\\`…\\`}` literal out of the source and union their\n * whitespace-separated tokens. A regex-based scan is enough — the\n * warning is best-effort, not load-bearing, and a regex sidesteps\n * having to re-parse the file.\n *\n * Skipped on purpose:\n *  - `className={someExpression}` with no inline literal (we can't\n *    introspect the runtime value at build time).\n *  - Template literals with substitutions (`` `text-${size}` ``) — we\n *    only union the static-quasi parts, which is fine because the\n *    warning fires only on candidates that ARE in the static parts.\n * @param source Raw source text.\n * @returns Set of whitespace-separated tokens drawn from every literal.\n */\nfunction collectClassNameTokens(source: string): Set<string> {\n  const out = new Set<string>()\n  for (const literal of iterateClassNameLiterals(source)) {\n    for (const token of literal.split(/\\s+/)) {\n      if (token.length > 0) out.add(token)\n    }\n  }\n  return out\n}\n\n/**\n * Filter Tailwind candidate strings down to ones that actually appear\n * as a token inside a `className=\"…\"` literal in the source. Oxide\n * scans the entire file and surfaces anything Tailwind-shaped — that\n * includes import specifiers (`'expo-router'`), comment markers\n * (`/* @rnwind-theme=… *\\/`), JSX prop values (`keyboardType=\"email-\n * address\"`), and bare suffixes Tailwind splits out from compound\n * utilities (`bg-sky-500` also produces `sky-500`). None of those are\n * \"unknown classes\" worth nagging the user about; the genuine signal\n * is a typo in a real `className`, e.g. `bg-srface` for `bg-surface`.\n *\n * The filter walks every `className=\"…\" / {'…'} / {`…`}` literal in the\n * source, splits each on whitespace, and unions the tokens. Only\n * candidates in that token set survive. Then known-good atoms are\n * subtracted, leaving genuine typos.\n * @param source Raw source text the transformer received from Metro.\n * @param candidates Every candidate oxide picked up.\n * @param atoms Set of atom names the parser successfully resolved.\n * @returns Candidates that look like real \"unknown classes\" the user typed.\n */\nexport function filterUnknownClassCandidates(\n  source: string,\n  candidates: readonly string[],\n  atoms: ReadonlySet<string>,\n): string[] {\n  const literalTokens = collectClassNameTokens(source)\n  const out: string[] = []\n  for (const candidate of candidates) {\n    if (atoms.has(candidate)) continue\n    if (!literalTokens.has(candidate)) continue\n    out.push(candidate)\n  }\n  return out\n}\n"],"names":[],"mappings":";;AAAA;;;;AAIG;AACH,UAAU,wBAAwB,CAAC,MAAc,EAAA;;IAE/C,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,4BAA4B,CAAC;AAAE,QAAA,MAAM,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;IACvF,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,4BAA4B,CAAC;AAAE,QAAA,MAAM,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;;IAEvF,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,sCAAsC,CAAC;AAAE,QAAA,MAAM,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;IACjG,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,sCAAsC,CAAC;AAAE,QAAA,MAAM,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;;IAEjG,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,sCAAsC,CAAC,EAAE;QAC3E,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;QAC3B,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC;AAAE,YAAA,MAAM,IAAI;IAC1D;AACF;AAEA;;;;;;;;;;;;;;;AAeG;AACH,SAAS,sBAAsB,CAAC,MAAc,EAAA;AAC5C,IAAA,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU;IAC7B,KAAK,MAAM,OAAO,IAAI,wBAAwB,CAAC,MAAM,CAAC,EAAE;QACtD,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;AACxC,YAAA,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;AAAE,gBAAA,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC;QACtC;IACF;AACA,IAAA,OAAO,GAAG;AACZ;AAEA;;;;;;;;;;;;;;;;;;;AAmBG;SACa,4BAA4B,CAC1C,MAAc,EACd,UAA6B,EAC7B,KAA0B,EAAA;AAE1B,IAAA,MAAM,aAAa,GAAG,sBAAsB,CAAC,MAAM,CAAC;IACpD,MAAM,GAAG,GAAa,EAAE;AACxB,IAAA,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;AAClC,QAAA,IAAI,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE;AAC1B,QAAA,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE;AACnC,QAAA,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC;IACrB;AACA,IAAA,OAAO,GAAG;AACZ;;;;"}

package/lib/cjs/metro/warn-unknown-classes.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Filter Tailwind candidate strings down to ones that actually appear
+ * as a token inside a `className="…"` literal in the source. Oxide
+ * scans the entire file and surfaces anything Tailwind-shaped — that
+ * includes import specifiers (`'expo-router'`), comment markers
+ * (`/* @rnwind-theme=… *\/`), JSX prop values (`keyboardType="email-
+ * address"`), and bare suffixes Tailwind splits out from compound
+ * utilities (`bg-sky-500` also produces `sky-500`). None of those are
+ * "unknown classes" worth nagging the user about; the genuine signal
+ * is a typo in a real `className`, e.g. `bg-srface` for `bg-surface`.
+ *
+ * The filter walks every `className="…" / {'…'} / {`…`}` literal in the
+ * source, splits each on whitespace, and unions the tokens. Only
+ * candidates in that token set survive. Then known-good atoms are
+ * subtracted, leaving genuine typos.
+ * @param source Raw source text the transformer received from Metro.
+ * @param candidates Every candidate oxide picked up.
+ * @param atoms Set of atom names the parser successfully resolved.
+ * @returns Candidates that look like real "unknown classes" the user typed.
+ */
+export declare function filterUnknownClassCandidates(source: string, candidates: readonly string[], atoms: ReadonlySet<string>): string[];

package/lib/cjs/metro/with-config.cjs

@@ -0,0 +1,196 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var path = require('node:path');
+var dts = require('./dts.cjs');
+var resolver = require('./resolver.cjs');
+var state = require('./state.cjs');
+
+/** Default cache directory at the project root. Visible for debugging. */
+const DEFAULT_CACHE_DIR = '.rnwind';
+/**
+ * Active CSS watcher — replaced (and the prior one closed) when
+ * `withRnwindConfig` is called again (Metro restart, repeated init).
+ * Only one watcher per process; no stacking.
+ */
+let activeCssWatcher = null;
+/**
+ * Watch the theme CSS for edits. On change, rewrite the per-scheme
+ * files with the fresh theme AND bump `mtime` on every source file
+ * rnwind has transformed so far — Metro's own watcher sees those
+ * mtime changes, invalidates the modules, and re-transforms them
+ * against the new CSS on the next request. `getCacheKey()` alone is
+ * NOT enough: Metro samples the cache key once per worker lifetime,
+ * so edits during an already-running dev server don't propagate
+ * without this explicit nudge.
+ * @param cssPath Absolute path to the theme CSS to watch.
+ * @param projectRoot Metro's project root (for `getRnwindState`).
+ */
+function watchThemeCss(cssPath, projectRoot) {
+    if (activeCssWatcher?.cssPath === cssPath)
+        return;
+    activeCssWatcher?.close();
+    if (!node_fs.existsSync(cssPath))
+        return;
+    let pending = false;
+    const watcher = node_fs.watch(cssPath, { persistent: false }, () => {
+        // Debounce: editors often emit 2-3 change events per save (atomic
+        // rename dance, tmp files). Coalesce to ONE rebuild per microtask.
+        if (pending)
+            return;
+        pending = true;
+        queueMicrotask(async () => {
+            pending = false;
+            try {
+                await state.onThemeChange(projectRoot);
+                touchRecordedFiles(projectRoot);
+            }
+            catch {
+                // Invalidation is best-effort — never crash the dev server.
+            }
+        });
+    });
+    activeCssWatcher = { cssPath, close: () => watcher.close() };
+}
+/**
+ * Bump the mtime on every file the builder has transformed. Metro's
+ * file watcher keys on `mtime`, so this is what makes it invalidate
+ * those modules and re-transform them.
+ * @param projectRoot Metro's project root.
+ */
+function touchRecordedFiles(projectRoot) {
+    const state$1 = state.getRnwindState(projectRoot);
+    const files = state$1.builder.recordedFiles();
+    const now = new Date();
+    for (const file of files) {
+        try {
+            if (node_fs.existsSync(file))
+                node_fs.utimesSync(file, now, now);
+        }
+        catch {
+            // One file's stat failure shouldn't stop the others.
+        }
+    }
+}
+/**
+ * Where the rnwind babel transformer lives — resolved relative to this
+ * module so the path works from both the `src/` tree (tests) and the
+ * built `lib/` output. Tries a few extensions because `require.resolve`
+ * doesn't auto-find `.cjs` / `.mjs` from a bare specifier.
+ * @returns Absolute path to the rnwind transformer module.
+ */
+function transformerPath() {
+    for (const candidate of ['./transformer.cjs', './transformer.mjs', './transformer.js', './transformer.ts', './transformer']) {
+        try {
+            return require.resolve(candidate);
+        }
+        catch {
+            // try the next extension
+        }
+    }
+    throw new Error('rnwind: could not resolve the metro transformer path');
+}
+/**
+ * Resolve the effective cache directory, honoring a user override and
+ * falling back to `<projectRoot>/.rnwind`.
+ * @param projectRoot Anchor for relative paths.
+ * @param override User-supplied option.
+ * @returns Absolute cache directory.
+ */
+function resolveCacheDir(projectRoot, override) {
+    if (!override || override.length === 0)
+        return path.resolve(projectRoot, DEFAULT_CACHE_DIR);
+    return path.isAbsolute(override) ? override : path.resolve(projectRoot, override);
+}
+/**
+ * Read the theme CSS and extract `@variant <name>` blocks for the .d.ts
+ * generator. Forces construction of `getRnwindState`, then reads
+ * `parser.declaredSchemes` (populated synchronously at construction).
+ * @param cssEntry Absolute path to theme CSS.
+ * @param projectRoot
+ * @returns Scheme names (empty when the theme has no variants; `'base'` is filtered).
+ */
+function discoverSchemes(cssEntry, projectRoot) {
+    if (!node_fs.existsSync(cssEntry))
+        return [];
+    try {
+        const { parser } = state.getRnwindState(projectRoot);
+        return parser.declaredSchemes.filter((name) => name !== 'base');
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Wrap a Metro config with rnwind's pipeline:
+ *  - Install the rnwind babel transformer.
+ *  - Chain a `resolveRequest` hook that serves
+ *    `rnwind/__generated/schemes` from `<cacheDir>/schemes.js`.
+ *  - Write the `.d.ts` so TypeScript accepts `className=` on RN components.
+ *  - Publish the theme CSS path + cache dir via env so Metro workers
+ *    can rebuild their local state.
+ *  - Ensure the cache dir is a watched folder Metro's haste-map indexes.
+ *
+ * Theme-edit hot reload happens implicitly: every transformed file
+ * imports `rnwind/__generated/schemes`, and that module eager-imports
+ * `common.style.js`. When the theme changes, the per-scheme files
+ * regenerate with new bytes; Metro's content SHA1 dedup detects the
+ * change and invalidates every importer automatically.
+ * `getCacheKey()` on the transformer covers the per-file transform
+ * cache. No file watcher / source-padding hack needed — the dep graph
+ * carries the signal.
+ * @param metroConfig Config from `getDefaultConfig(__dirname)` or equivalent.
+ * @param options rnwind options.
+ * @returns The same config, mutated.
+ */
+function withRnwindConfig(metroConfig, options) {
+    const projectRoot = options.projectRoot ?? metroConfig.projectRoot ?? process.cwd();
+    const cacheDir = resolveCacheDir(projectRoot, options.cacheDir);
+    const cssEntry = path.isAbsolute(options.cssEntryFile) ? options.cssEntryFile : path.resolve(projectRoot, options.cssEntryFile);
+    node_fs.mkdirSync(cacheDir, { recursive: true });
+    const watchFolders = (metroConfig.watchFolders ?? []).filter((p) => typeof p === 'string' && p.length > 0);
+    state.configureRnwindState(cssEntry, cacheDir, watchFolders, options.classNamePrefixes);
+    // Warm the state eagerly (in the Metro master process) so oxide's
+    // Scanner walks every project source (and every monorepo
+    // watch-folder) ONCE and the manifest + scheme files hold the
+    // complete union before Metro's resolver tries to SHA1 them on the
+    // first transform. Each worker lazy-repeats this scan on its first
+    // transform to converge on identical state.
+    try {
+        void state.getRnwindState(projectRoot).builder.ensureFilesExist();
+    }
+    catch {
+        // Any init error surfaces again at the first transform; don't crash Metro boot.
+    }
+    // Install transformer + resolver. Capture the existing
+    // babelTransformerPath BEFORE we override it — our worker chains to
+    // it (env-passed) so Flow / expo-router / babel-preset-expo etc. all
+    // continue to run.
+    const existingTransformerPath = metroConfig.transformer?.babelTransformerPath;
+    if (typeof existingTransformerPath === 'string' && existingTransformerPath.length > 0) {
+        process.env.RNWIND_UPSTREAM_TRANSFORMER = existingTransformerPath;
+    }
+    const upstream = metroConfig.resolver?.resolveRequest ?? null;
+    metroConfig.transformer = { ...metroConfig.transformer, babelTransformerPath: transformerPath() };
+    metroConfig.resolver = { ...metroConfig.resolver, resolveRequest: resolver.createRnwindResolver(upstream) };
+    // Metro's haste-map indexes `watchFolders` at startup. Adding the
+    // cache dir guarantees scheme style files + manifest get SHA1'd
+    // without a "Failed to get the SHA-1" race when the first transform
+    // writes them.
+    const existingWatch = metroConfig.watchFolders ?? [];
+    metroConfig.watchFolders = existingWatch.includes(cacheDir) ? existingWatch : [...existingWatch, cacheDir];
+    if (options.dtsFile !== false) {
+        const dtsPath = options.dtsFile ?? path.resolve(projectRoot, 'rnwind-types.d.ts');
+        const schemes = discoverSchemes(cssEntry, projectRoot);
+        dts.writeDtsFile(dtsPath, schemes, options.classNamePrefixes);
+    }
+    // Watch the theme CSS. On edit, we rewrite scheme files AND touch
+    // mtime on every transformed source file so Metro invalidates them
+    // and re-transforms — the only reliable way to propagate theme
+    // changes to an already-running dev server.
+    watchThemeCss(cssEntry, projectRoot);
+    return metroConfig;
+}
+
+exports.withRnwindConfig = withRnwindConfig;
+//# sourceMappingURL=with-config.cjs.map

package/lib/cjs/metro/with-config.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-config.cjs","sources":["../../../../src/metro/with-config.ts"],"sourcesContent":["import { existsSync, mkdirSync, utimesSync, watch as watchFile } from 'node:fs'\nimport path from 'node:path'\nimport { writeDtsFile } from './dts'\nimport { createRnwindResolver, type ResolveRequestFn } from './resolver'\nimport { configureRnwindState, getRnwindState, onThemeChange } from './state'\n\n/** Default cache directory at the project root. Visible for debugging. */\nconst DEFAULT_CACHE_DIR = '.rnwind'\n\n/**\n * Active CSS watcher — replaced (and the prior one closed) when\n * `withRnwindConfig` is called again (Metro restart, repeated init).\n * Only one watcher per process; no stacking.\n */\nlet activeCssWatcher: { cssPath: string; close: () => void } | null = null\n\n/**\n * Watch the theme CSS for edits. On change, rewrite the per-scheme\n * files with the fresh theme AND bump `mtime` on every source file\n * rnwind has transformed so far — Metro's own watcher sees those\n * mtime changes, invalidates the modules, and re-transforms them\n * against the new CSS on the next request. `getCacheKey()` alone is\n * NOT enough: Metro samples the cache key once per worker lifetime,\n * so edits during an already-running dev server don't propagate\n * without this explicit nudge.\n * @param cssPath Absolute path to the theme CSS to watch.\n * @param projectRoot Metro's project root (for `getRnwindState`).\n */\nfunction watchThemeCss(cssPath: string, projectRoot: string): void {\n  if (activeCssWatcher?.cssPath === cssPath) return\n  activeCssWatcher?.close()\n  if (!existsSync(cssPath)) return\n  let pending = false\n  const watcher = watchFile(cssPath, { persistent: false }, () => {\n    // Debounce: editors often emit 2-3 change events per save (atomic\n    // rename dance, tmp files). Coalesce to ONE rebuild per microtask.\n    if (pending) return\n    pending = true\n    queueMicrotask(async () => {\n      pending = false\n      try {\n        await onThemeChange(projectRoot)\n        touchRecordedFiles(projectRoot)\n      } catch {\n        // Invalidation is best-effort — never crash the dev server.\n      }\n    })\n  })\n  activeCssWatcher = { cssPath, close: () => watcher.close() }\n}\n\n/**\n * Bump the mtime on every file the builder has transformed. Metro's\n * file watcher keys on `mtime`, so this is what makes it invalidate\n * those modules and re-transform them.\n * @param projectRoot Metro's project root.\n */\nfunction touchRecordedFiles(projectRoot: string): void {\n  const state = getRnwindState(projectRoot)\n  const files = state.builder.recordedFiles()\n  const now = new Date()\n  for (const file of files) {\n    try {\n      if (existsSync(file)) utimesSync(file, now, now)\n    } catch {\n      // One file's stat failure shouldn't stop the others.\n    }\n  }\n}\n\n/**\n * Where the rnwind babel transformer lives — resolved relative to this\n * module so the path works from both the `src/` tree (tests) and the\n * built `lib/` output. Tries a few extensions because `require.resolve`\n * doesn't auto-find `.cjs` / `.mjs` from a bare specifier.\n * @returns Absolute path to the rnwind transformer module.\n */\nfunction transformerPath(): string {\n  for (const candidate of ['./transformer.cjs', './transformer.mjs', './transformer.js', './transformer.ts', './transformer']) {\n    try {\n      return require.resolve(candidate)\n    } catch {\n      // try the next extension\n    }\n  }\n  throw new Error('rnwind: could not resolve the metro transformer path')\n}\n\n/**\n * Resolve the effective cache directory, honoring a user override and\n * falling back to `<projectRoot>/.rnwind`.\n * @param projectRoot Anchor for relative paths.\n * @param override User-supplied option.\n * @returns Absolute cache directory.\n */\nfunction resolveCacheDir(projectRoot: string, override: string | undefined): string {\n  if (!override || override.length === 0) return path.resolve(projectRoot, DEFAULT_CACHE_DIR)\n  return path.isAbsolute(override) ? override : path.resolve(projectRoot, override)\n}\n\n/**\n * Read the theme CSS and extract `@variant <name>` blocks for the .d.ts\n * generator. Forces construction of `getRnwindState`, then reads\n * `parser.declaredSchemes` (populated synchronously at construction).\n * @param cssEntry Absolute path to theme CSS.\n * @param projectRoot\n * @returns Scheme names (empty when the theme has no variants; `'base'` is filtered).\n */\nfunction discoverSchemes(cssEntry: string, projectRoot: string): readonly string[] {\n  if (!existsSync(cssEntry)) return []\n  try {\n    const { parser } = getRnwindState(projectRoot)\n    return parser.declaredSchemes.filter((name) => name !== 'base')\n  } catch {\n    return []\n  }\n}\n\n/** User-facing options for `withRnwindConfig`. */\nexport interface RnwindMetroOptions {\n  /** Path to the theme CSS (absolute or relative to `projectRoot`). Required. */\n  cssEntryFile: string\n  /** Where rnwind writes the `.d.ts` file. Set `false` to disable. Defaults to `<projectRoot>/rnwind-types.d.ts`. */\n  dtsFile?: string | false\n  /** Optional project-root override — defaults to `metroConfig.projectRoot` then `process.cwd()`. */\n  projectRoot?: string\n  /** Cache directory. Absolute, or relative to `projectRoot`. Default: `.rnwind` at project root. */\n  cacheDir?: string\n  /**\n   * Extra JSX prop-name prefixes that rnwind should rewrite. Each\n   * prefix `P` turns `<Tag PClassName=\"…\">` into `<Tag\n   * PStyle={lookupCss(…)}>`. The built-in `'contentContainer'` prefix\n   * is always on (covers ScrollView / FlatList / SectionList); user\n   * entries merge on top.\n   */\n  classNamePrefixes?: readonly string[]\n}\n\n/** Shape we mutate on Metro's config. Loose so we don't pin Metro's internal types. */\nexport interface MetroConfigLike {\n  projectRoot?: string\n  watchFolders?: string[]\n  transformer?: {\n    babelTransformerPath?: string\n    [key: string]: unknown\n  }\n  resolver?: {\n    resolveRequest?: ResolveRequestFn | null\n    [key: string]: unknown\n  }\n  [key: string]: unknown\n}\n\n/**\n * Wrap a Metro config with rnwind's pipeline:\n *  - Install the rnwind babel transformer.\n *  - Chain a `resolveRequest` hook that serves\n *    `rnwind/__generated/schemes` from `<cacheDir>/schemes.js`.\n *  - Write the `.d.ts` so TypeScript accepts `className=` on RN components.\n *  - Publish the theme CSS path + cache dir via env so Metro workers\n *    can rebuild their local state.\n *  - Ensure the cache dir is a watched folder Metro's haste-map indexes.\n *\n * Theme-edit hot reload happens implicitly: every transformed file\n * imports `rnwind/__generated/schemes`, and that module eager-imports\n * `common.style.js`. When the theme changes, the per-scheme files\n * regenerate with new bytes; Metro's content SHA1 dedup detects the\n * change and invalidates every importer automatically.\n * `getCacheKey()` on the transformer covers the per-file transform\n * cache. No file watcher / source-padding hack needed — the dep graph\n * carries the signal.\n * @param metroConfig Config from `getDefaultConfig(__dirname)` or equivalent.\n * @param options rnwind options.\n * @returns The same config, mutated.\n */\nexport function withRnwindConfig<C extends MetroConfigLike>(metroConfig: C, options: RnwindMetroOptions): C {\n  const projectRoot = options.projectRoot ?? metroConfig.projectRoot ?? process.cwd()\n  const cacheDir = resolveCacheDir(projectRoot, options.cacheDir)\n  const cssEntry = path.isAbsolute(options.cssEntryFile) ? options.cssEntryFile : path.resolve(projectRoot, options.cssEntryFile)\n\n  mkdirSync(cacheDir, { recursive: true })\n  const watchFolders = (metroConfig.watchFolders ?? []).filter((p) => typeof p === 'string' && p.length > 0)\n  configureRnwindState(cssEntry, cacheDir, watchFolders, options.classNamePrefixes)\n\n  // Warm the state eagerly (in the Metro master process) so oxide's\n  // Scanner walks every project source (and every monorepo\n  // watch-folder) ONCE and the manifest + scheme files hold the\n  // complete union before Metro's resolver tries to SHA1 them on the\n  // first transform. Each worker lazy-repeats this scan on its first\n  // transform to converge on identical state.\n  try {\n    void getRnwindState(projectRoot).builder.ensureFilesExist()\n  } catch {\n    // Any init error surfaces again at the first transform; don't crash Metro boot.\n  }\n\n  // Install transformer + resolver. Capture the existing\n  // babelTransformerPath BEFORE we override it — our worker chains to\n  // it (env-passed) so Flow / expo-router / babel-preset-expo etc. all\n  // continue to run.\n  const existingTransformerPath = metroConfig.transformer?.babelTransformerPath\n  if (typeof existingTransformerPath === 'string' && existingTransformerPath.length > 0) {\n    process.env.RNWIND_UPSTREAM_TRANSFORMER = existingTransformerPath\n  }\n  const upstream = metroConfig.resolver?.resolveRequest ?? null\n  metroConfig.transformer = { ...metroConfig.transformer, babelTransformerPath: transformerPath() }\n  metroConfig.resolver = { ...metroConfig.resolver, resolveRequest: createRnwindResolver(upstream) }\n\n  // Metro's haste-map indexes `watchFolders` at startup. Adding the\n  // cache dir guarantees scheme style files + manifest get SHA1'd\n  // without a \"Failed to get the SHA-1\" race when the first transform\n  // writes them.\n  const existingWatch = metroConfig.watchFolders ?? []\n  metroConfig.watchFolders = existingWatch.includes(cacheDir) ? existingWatch : [...existingWatch, cacheDir]\n\n  if (options.dtsFile !== false) {\n    const dtsPath = options.dtsFile ?? path.resolve(projectRoot, 'rnwind-types.d.ts')\n    const schemes = discoverSchemes(cssEntry, projectRoot)\n    writeDtsFile(dtsPath, schemes, options.classNamePrefixes)\n  }\n\n  // Watch the theme CSS. On edit, we rewrite scheme files AND touch\n  // mtime on every transformed source file so Metro invalidates them\n  // and re-transforms — the only reliable way to propagate theme\n  // changes to an already-running dev server.\n  watchThemeCss(cssEntry, projectRoot)\n\n  return metroConfig\n}\n"],"names":["existsSync","watchFile","onThemeChange","state","getRnwindState","utimesSync","mkdirSync","configureRnwindState","createRnwindResolver","writeDtsFile"],"mappings":"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"}

package/lib/cjs/metro/with-config.d.ts

@@ -0,0 +1,57 @@
+import { type ResolveRequestFn } from './resolver';
+/** User-facing options for `withRnwindConfig`. */
+export interface RnwindMetroOptions {
+    /** Path to the theme CSS (absolute or relative to `projectRoot`). Required. */
+    cssEntryFile: string;
+    /** Where rnwind writes the `.d.ts` file. Set `false` to disable. Defaults to `<projectRoot>/rnwind-types.d.ts`. */
+    dtsFile?: string | false;
+    /** Optional project-root override — defaults to `metroConfig.projectRoot` then `process.cwd()`. */
+    projectRoot?: string;
+    /** Cache directory. Absolute, or relative to `projectRoot`. Default: `.rnwind` at project root. */
+    cacheDir?: string;
+    /**
+     * Extra JSX prop-name prefixes that rnwind should rewrite. Each
+     * prefix `P` turns `<Tag PClassName="…">` into `<Tag
+     * PStyle={lookupCss(…)}>`. The built-in `'contentContainer'` prefix
+     * is always on (covers ScrollView / FlatList / SectionList); user
+     * entries merge on top.
+     */
+    classNamePrefixes?: readonly string[];
+}
+/** Shape we mutate on Metro's config. Loose so we don't pin Metro's internal types. */
+export interface MetroConfigLike {
+    projectRoot?: string;
+    watchFolders?: string[];
+    transformer?: {
+        babelTransformerPath?: string;
+        [key: string]: unknown;
+    };
+    resolver?: {
+        resolveRequest?: ResolveRequestFn | null;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Wrap a Metro config with rnwind's pipeline:
+ *  - Install the rnwind babel transformer.
+ *  - Chain a `resolveRequest` hook that serves
+ *    `rnwind/__generated/schemes` from `<cacheDir>/schemes.js`.
+ *  - Write the `.d.ts` so TypeScript accepts `className=` on RN components.
+ *  - Publish the theme CSS path + cache dir via env so Metro workers
+ *    can rebuild their local state.
+ *  - Ensure the cache dir is a watched folder Metro's haste-map indexes.
+ *
+ * Theme-edit hot reload happens implicitly: every transformed file
+ * imports `rnwind/__generated/schemes`, and that module eager-imports
+ * `common.style.js`. When the theme changes, the per-scheme files
+ * regenerate with new bytes; Metro's content SHA1 dedup detects the
+ * change and invalidates every importer automatically.
+ * `getCacheKey()` on the transformer covers the per-file transform
+ * cache. No file watcher / source-padding hack needed — the dep graph
+ * carries the signal.
+ * @param metroConfig Config from `getDefaultConfig(__dirname)` or equivalent.
+ * @param options rnwind options.
+ * @returns The same config, mutated.
+ */
+export declare function withRnwindConfig<C extends MetroConfigLike>(metroConfig: C, options: RnwindMetroOptions): C;

package/lib/cjs/runtime/chain-handlers.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Compose a user-supplied press handler with rnwind's internal one.
+ * User fires first (its return / side-effects happen pre-gate flip); the
+ * rnwind handler then updates the active flag.
+ * @param user User-supplied handler from the original JSX (optional).
+ * @param ours rnwind's internal active-toggling handler.
+ * @returns Combined handler, or `ours` directly when the user didn't provide one.
+ */
+function chainPress(user, ours) {
+    if (user == null)
+        return ours;
+    return (event) => {
+        user(event);
+        ours(event);
+    };
+}
+/**
+ * Compose a user-supplied focus/blur handler with rnwind's internal one.
+ * Same ordering rule as {@link chainPress}: user first, rnwind second.
+ * @param user User-supplied handler (optional).
+ * @param ours rnwind's internal focus-toggling handler.
+ * @returns Combined handler, or `ours` directly when the user didn't provide one.
+ */
+function chainFocus(user, ours) {
+    if (user == null)
+        return ours;
+    return (event) => {
+        user(event);
+        ours(event);
+    };
+}
+
+exports.chainFocus = chainFocus;
+exports.chainPress = chainPress;
+//# sourceMappingURL=chain-handlers.cjs.map

package/lib/cjs/runtime/chain-handlers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain-handlers.cjs","sources":["../../../../src/runtime/chain-handlers.ts"],"sourcesContent":["/**\n * Tiny helpers that compose rnwind's press / focus handlers with any\n * user-provided ones the JSX site already has. The transformer uses\n * these when it rewrites a `<Pressable onPressIn={user}>` into\n * `<Pressable onPressIn={chainPress(user, _i.onPressIn)}>` so the user's\n * callback keeps firing.\n *\n * Both helpers bail out when the user's handler is `null` / `undefined`,\n * returning rnwind's handler directly — that gives the transformer a\n * cheap uniform rewrite (\"always chain\") without allocating a new\n * function per render when the user didn't opt in to the handler.\n */\nimport type { GestureResponderEvent, NativeSyntheticEvent, TargetedEvent } from 'react-native'\n\ntype PressHandler = (event: GestureResponderEvent) => void\ntype FocusHandler = (event: NativeSyntheticEvent<TargetedEvent>) => void\n\n/**\n * Compose a user-supplied press handler with rnwind's internal one.\n * User fires first (its return / side-effects happen pre-gate flip); the\n * rnwind handler then updates the active flag.\n * @param user User-supplied handler from the original JSX (optional).\n * @param ours rnwind's internal active-toggling handler.\n * @returns Combined handler, or `ours` directly when the user didn't provide one.\n */\nexport function chainPress(user: PressHandler | null | undefined, ours: PressHandler): PressHandler {\n  if (user == null) return ours\n  return (event: GestureResponderEvent): void => {\n    user(event)\n    ours(event)\n  }\n}\n\n/**\n * Compose a user-supplied focus/blur handler with rnwind's internal one.\n * Same ordering rule as {@link chainPress}: user first, rnwind second.\n * @param user User-supplied handler (optional).\n * @param ours rnwind's internal focus-toggling handler.\n * @returns Combined handler, or `ours` directly when the user didn't provide one.\n */\nexport function chainFocus(user: FocusHandler | null | undefined, ours: FocusHandler): FocusHandler {\n  if (user == null) return ours\n  return (event: NativeSyntheticEvent<TargetedEvent>): void => {\n    user(event)\n    ours(event)\n  }\n}\n"],"names":[],"mappings":";;AAiBA;;;;;;;AAOG;AACG,SAAU,UAAU,CAAC,IAAqC,EAAE,IAAkB,EAAA;IAClF,IAAI,IAAI,IAAI,IAAI;AAAE,QAAA,OAAO,IAAI;IAC7B,OAAO,CAAC,KAA4B,KAAU;QAC5C,IAAI,CAAC,KAAK,CAAC;QACX,IAAI,CAAC,KAAK,CAAC;AACb,IAAA,CAAC;AACH;AAEA;;;;;;AAMG;AACG,SAAU,UAAU,CAAC,IAAqC,EAAE,IAAkB,EAAA;IAClF,IAAI,IAAI,IAAI,IAAI;AAAE,QAAA,OAAO,IAAI;IAC7B,OAAO,CAAC,KAA0C,KAAU;QAC1D,IAAI,CAAC,KAAK,CAAC;QACX,IAAI,CAAC,KAAK,CAAC;AACb,IAAA,CAAC;AACH;;;;;"}

package/lib/cjs/runtime/chain-handlers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Tiny helpers that compose rnwind's press / focus handlers with any
+ * user-provided ones the JSX site already has. The transformer uses
+ * these when it rewrites a `<Pressable onPressIn={user}>` into
+ * `<Pressable onPressIn={chainPress(user, _i.onPressIn)}>` so the user's
+ * callback keeps firing.
+ *
+ * Both helpers bail out when the user's handler is `null` / `undefined`,
+ * returning rnwind's handler directly — that gives the transformer a
+ * cheap uniform rewrite ("always chain") without allocating a new
+ * function per render when the user didn't opt in to the handler.
+ */
+import type { GestureResponderEvent, NativeSyntheticEvent, TargetedEvent } from 'react-native';
+type PressHandler = (event: GestureResponderEvent) => void;
+type FocusHandler = (event: NativeSyntheticEvent<TargetedEvent>) => void;
+/**
+ * Compose a user-supplied press handler with rnwind's internal one.
+ * User fires first (its return / side-effects happen pre-gate flip); the
+ * rnwind handler then updates the active flag.
+ * @param user User-supplied handler from the original JSX (optional).
+ * @param ours rnwind's internal active-toggling handler.
+ * @returns Combined handler, or `ours` directly when the user didn't provide one.
+ */
+export declare function chainPress(user: PressHandler | null | undefined, ours: PressHandler): PressHandler;
+/**
+ * Compose a user-supplied focus/blur handler with rnwind's internal one.
+ * Same ordering rule as {@link chainPress}: user first, rnwind second.
+ * @param user User-supplied handler (optional).
+ * @param ours rnwind's internal focus-toggling handler.
+ * @returns Combined handler, or `ours` directly when the user didn't provide one.
+ */
+export declare function chainFocus(user: FocusHandler | null | undefined, ours: FocusHandler): FocusHandler;
+export {};