@ecrindigital/facetpack 0.1.10 → 0.2.0

package/dist/transformer.cjs

@@ -48,9 +48,359 @@ function setCachedResolutions(originModulePath, resolutions) {
   resolutionCache.set(originModulePath, cached);
 }
 
+// src/stats.ts
+var import_fs = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+var ANSI = {
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+var STATS_DIR = import_path.join(import_os.tmpdir(), "facetpack-stats");
+var STATS_FILE_PREFIX = "stats-";
+var LOCK_FILE = import_path.join(STATS_DIR, ".print-lock");
+var PRINT_DELAY = 1000;
+function getStatsFilePath() {
+  const workerId = process.env.METRO_WORKER_ID || process.pid.toString();
+  return import_path.join(STATS_DIR, `${STATS_FILE_PREFIX}${workerId}.json`);
+}
+function ensureStatsDir() {
+  if (!import_fs.existsSync(STATS_DIR)) {
+    import_fs.mkdirSync(STATS_DIR, { recursive: true });
+  }
+}
+function acquirePrintLock() {
+  try {
+    ensureStatsDir();
+    if (import_fs.existsSync(LOCK_FILE)) {
+      const lockTime = parseInt(import_fs.readFileSync(LOCK_FILE, "utf-8"), 10);
+      if (Date.now() - lockTime < 5000) {
+        return false;
+      }
+    }
+    import_fs.writeFileSync(LOCK_FILE, Date.now().toString());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releasePrintLock() {
+  try {
+    if (import_fs.existsSync(LOCK_FILE)) {
+      import_fs.unlinkSync(LOCK_FILE);
+    }
+  } catch {}
+}
+
+class GlobalStats {
+  stats = this.createEmptyStats();
+  exitHandlerRegistered = false;
+  hasPrinted = false;
+  printTimer = null;
+  createEmptyStats() {
+    return {
+      transformer: { oxc: 0, babel: 0 },
+      resolver: { facetpack: 0, metro: 0 },
+      minifier: { files: 0, originalSize: 0, minifiedSize: 0 },
+      treeShaking: { modulesAnalyzed: 0, modulesRemoved: 0, exportsRemoved: 0 },
+      startTime: Date.now()
+    };
+  }
+  recordTransform(engine) {
+    this.stats.transformer[engine]++;
+    this.persistStats();
+    this.schedulePrint();
+  }
+  adjustTransformFallback() {
+    this.stats.transformer.oxc--;
+    this.stats.transformer.babel++;
+    this.persistStats();
+  }
+  recordResolve(engine) {
+    this.stats.resolver[engine]++;
+  }
+  flush() {
+    this.persistStats();
+  }
+  schedulePrint() {
+    if (this.printTimer) {
+      clearTimeout(this.printTimer);
+    }
+    this.printTimer = setTimeout(() => {
+      if (acquirePrintLock()) {
+        this.print();
+        releasePrintLock();
+      }
+    }, PRINT_DELAY);
+  }
+  recordMinify(originalSize, minifiedSize) {
+    this.stats.minifier.files++;
+    this.stats.minifier.originalSize += originalSize;
+    this.stats.minifier.minifiedSize += minifiedSize;
+  }
+  recordTreeShaking(analyzed, removed, exports2) {
+    this.stats.treeShaking.modulesAnalyzed += analyzed;
+    this.stats.treeShaking.modulesRemoved += removed;
+    this.stats.treeShaking.exportsRemoved += exports2;
+  }
+  get() {
+    return JSON.parse(JSON.stringify(this.stats));
+  }
+  reset() {
+    this.stats = this.createEmptyStats();
+    this.hasPrinted = false;
+    this.cleanupStatsFiles();
+  }
+  persistStats() {
+    try {
+      ensureStatsDir();
+      import_fs.writeFileSync(getStatsFilePath(), JSON.stringify(this.stats));
+    } catch {}
+  }
+  cleanupStatsFiles() {
+    try {
+      if (import_fs.existsSync(STATS_DIR)) {
+        const { readdirSync } = require("fs");
+        const files = readdirSync(STATS_DIR);
+        for (const file of files) {
+          if (file.startsWith(STATS_FILE_PREFIX)) {
+            try {
+              import_fs.unlinkSync(import_path.join(STATS_DIR, file));
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+  aggregateWorkerStats() {
+    const aggregated = this.createEmptyStats();
+    aggregated.startTime = this.stats.startTime;
+    try {
+      if (import_fs.existsSync(STATS_DIR)) {
+        const { readdirSync } = require("fs");
+        const files = readdirSync(STATS_DIR);
+        for (const file of files) {
+          if (file.startsWith(STATS_FILE_PREFIX)) {
+            try {
+              const content = import_fs.readFileSync(import_path.join(STATS_DIR, file), "utf-8");
+              const workerStats = JSON.parse(content);
+              aggregated.transformer.oxc += workerStats.transformer.oxc;
+              aggregated.transformer.babel += workerStats.transformer.babel;
+              aggregated.resolver.facetpack += workerStats.resolver.facetpack;
+              aggregated.resolver.metro += workerStats.resolver.metro;
+              if (workerStats.startTime < aggregated.startTime) {
+                aggregated.startTime = workerStats.startTime;
+              }
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+    aggregated.minifier = this.stats.minifier;
+    aggregated.treeShaking = this.stats.treeShaking;
+    return aggregated;
+  }
+  formatPercent(value, total) {
+    if (total === 0)
+      return "0.0";
+    return (value / total * 100).toFixed(1);
+  }
+  formatSize(bytes) {
+    if (bytes < 1024)
+      return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+      return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  }
+  formatDuration(ms) {
+    if (ms < 1000)
+      return `${ms}ms`;
+    return `${(ms / 1000).toFixed(2)}s`;
+  }
+  print() {
+    if (!process.env.FACETPACK_DEBUG || this.hasPrinted)
+      return;
+    const aggregated = this.aggregateWorkerStats();
+    const { transformer, resolver, minifier, treeShaking, startTime } = aggregated;
+    const duration = Date.now() - startTime;
+    const transformTotal = transformer.oxc + transformer.babel;
+    const resolveTotal = resolver.facetpack + resolver.metro;
+    if (transformTotal === 0 && resolveTotal === 0 && minifier.files === 0)
+      return;
+    this.hasPrinted = true;
+    const { cyan, green, yellow, white, gray, bold, dim, reset } = ANSI;
+    console.log(`
+`);
+    console.log(`${bold}${cyan}╔════════════════════════════════════════════════════════════════════╗${reset}`);
+    console.log(`${bold}${cyan}║${reset}                    ${bold}FACETPACK BUNDLE STATS${reset}                         ${cyan}║${reset}`);
+    console.log(`${bold}${cyan}╠════════════════════════════════════════════════════════════════════╣${reset}`);
+    if (transformTotal > 0) {
+      const oxcPct = this.formatPercent(transformer.oxc, transformTotal);
+      const babelPct = this.formatPercent(transformer.babel, transformTotal);
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}TRANSFORMER${reset}                                                      ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} OXC (native)    ${bold}${green}${transformer.oxc.toString().padStart(6)}${reset} files   ${green}${oxcPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${yellow}●${reset} Babel           ${bold}${yellow}${transformer.babel.toString().padStart(6)}${reset} files   ${yellow}${babelPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${dim}${white}  Total           ${transformTotal.toString().padStart(6)} files${reset}                            ${cyan}║${reset}`);
+    }
+    if (resolveTotal > 0) {
+      const fpPct = this.formatPercent(resolver.facetpack, resolveTotal);
+      const metroPct = this.formatPercent(resolver.metro, resolveTotal);
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}RESOLVER${reset}                                                         ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Facetpack       ${bold}${green}${resolver.facetpack.toString().padStart(6)}${reset} hits    ${green}${fpPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${yellow}●${reset} Metro           ${bold}${yellow}${resolver.metro.toString().padStart(6)}${reset} hits    ${yellow}${metroPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${dim}${white}  Total           ${resolveTotal.toString().padStart(6)} resolutions${reset}                      ${cyan}║${reset}`);
+    }
+    if (minifier.files > 0) {
+      const savings = minifier.originalSize - minifier.minifiedSize;
+      const savingsPct = this.formatPercent(savings, minifier.originalSize);
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}MINIFIER${reset}                                                         ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Files minified  ${bold}${green}${minifier.files.toString().padStart(6)}${reset}                                   ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${gray}●${reset} Original size   ${this.formatSize(minifier.originalSize).padStart(12)}                             ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Minified size   ${this.formatSize(minifier.minifiedSize).padStart(12)}  ${green}-${savingsPct}%${reset}                    ${cyan}║${reset}`);
+    }
+    if (treeShaking.modulesAnalyzed > 0) {
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}TREE SHAKING${reset}                                                     ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${gray}●${reset} Modules analyzed ${bold}${treeShaking.modulesAnalyzed.toString().padStart(5)}${reset}                                   ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Modules removed  ${bold}${green}${treeShaking.modulesRemoved.toString().padStart(5)}${reset}                                   ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Exports removed  ${bold}${green}${treeShaking.exportsRemoved.toString().padStart(5)}${reset}                                   ${cyan}║${reset}`);
+    }
+    console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+    console.log(`${cyan}║${reset}  ${dim}Duration: ${this.formatDuration(duration)}${reset}                                             ${cyan}║${reset}`);
+    console.log(`${bold}${cyan}╚════════════════════════════════════════════════════════════════════╝${reset}`);
+    console.log(`
+`);
+    this.cleanupStatsFiles();
+  }
+  registerExitHandler() {
+    if (this.exitHandlerRegistered)
+      return;
+    this.exitHandlerRegistered = true;
+    process.on("SIGINT", () => {
+      this.print();
+      process.exit(0);
+    });
+    process.on("beforeExit", () => this.print());
+  }
+}
+var globalStats = new GlobalStats;
+
 // src/transformer.ts
+var ANSI2 = {
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  bold: "\x1B[1m",
+  reset: "\x1B[0m"
+};
 var IMPORT_REGEX = /(?:import|export)\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
 var REQUIRE_REGEX = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var BABEL_REQUIRED_PATTERNS = [
+  /'worklet'/,
+  /"worklet"/,
+  /require\.context\s*\(/,
+  /useAnimatedStyle/,
+  /useAnimatedProps/,
+  /useAnimatedScrollHandler/,
+  /useAnimatedGestureHandler/,
+  /useAnimatedReaction/,
+  /useDerivedValue/,
+  /useAnimatedSensor/,
+  /useFrameCallback/,
+  /useScrollViewOffset/,
+  /runOnUI/,
+  /runOnJS/
+];
+var DEFAULT_OPTIONS = {
+  jsx: true,
+  jsxRuntime: "automatic",
+  jsxImportSource: "react",
+  jsxPragma: "React.createElement",
+  jsxPragmaFrag: "React.Fragment",
+  typescript: true,
+  sourceExts: ["ts", "tsx", "js", "jsx", "mjs", "cjs"],
+  minifier: true,
+  treeShake: true,
+  noAst: false
+};
+
+class Logger {
+  startupLogged = false;
+  logStartup() {
+    if (this.startupLogged || !process.env.FACETPACK_DEBUG)
+      return;
+    this.startupLogged = true;
+    console.log(`${ANSI2.cyan}${ANSI2.bold}[Facetpack]${ANSI2.reset} Transformer loaded`);
+  }
+  logTransform(decision, filename) {
+    if (!process.env.FACETPACK_DEBUG)
+      return;
+    const color = decision === "oxc" ? ANSI2.green : ANSI2.yellow;
+    console.log(`${color}[Facetpack]${ANSI2.reset} ${decision.toUpperCase()}: ${filename}`);
+  }
+  logFallback(filename, error) {
+    if (!process.env.FACETPACK_DEBUG)
+      return;
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(`${ANSI2.yellow}[Facetpack]${ANSI2.reset} OXC failed, falling back to Babel: ${filename}`);
+    console.log(`${ANSI2.yellow}[Facetpack]${ANSI2.reset} Error: ${message}`);
+  }
+}
+
+class OptionsManager {
+  globalOptions = {};
+  setGlobal(options) {
+    this.globalOptions = options;
+  }
+  get() {
+    return { ...DEFAULT_OPTIONS, ...this.globalOptions, ...this.getFromEnv() };
+  }
+  merge(options) {
+    return { ...DEFAULT_OPTIONS, ...options };
+  }
+  getFromEnv() {
+    try {
+      const json = process.env.FACETPACK_OPTIONS;
+      return json ? JSON.parse(json) : {};
+    } catch {
+      return {};
+    }
+  }
+}
+
+class FallbackTransformerManager {
+  instance = null;
+  get() {
+    if (this.instance)
+      return this.instance;
+    const envPath = process.env.FACETPACK_FALLBACK_TRANSFORMER;
+    if (envPath) {
+      try {
+        this.instance = require(envPath);
+        return this.instance;
+      } catch (e) {
+        console.warn(`[Facetpack] Failed to load fallback transformer from ${envPath}:`, e);
+      }
+    }
+    this.instance = {
+      transform: ({ src }) => ({ code: src, map: null })
+    };
+    return this.instance;
+  }
+}
+var logger = new Logger;
+var options = new OptionsManager;
+var fallback = new FallbackTransformerManager;
+logger.logStartup();
 function extractSpecifiers(code) {
   const specifiers = new Set;
   let match;
@@ -79,211 +429,126 @@ function preResolveImports(filename, code, sourceExts) {
     const specifier = specifiers[i];
     if (specifier) {
       resolutions.set(specifier, results[i]?.path ?? null);
+      if (results[i]?.path) {
+        globalStats.recordResolve("facetpack");
+      }
     }
   }
   setCachedResolutions(filename, resolutions);
 }
-var defaultOptions = {
-  jsx: true,
-  jsxRuntime: "automatic",
-  jsxImportSource: "react",
-  jsxPragma: "React.createElement",
-  jsxPragmaFrag: "React.Fragment",
-  typescript: true,
-  sourceExts: ["ts", "tsx", "js", "jsx", "mjs", "cjs"],
-  minifier: true,
-  treeShake: true,
-  noAst: false
-};
-var globalOptions = {};
-var fallbackTransformer = null;
-function getFallbackTransformer() {
-  if (fallbackTransformer) {
-    return fallbackTransformer;
-  }
-  const fallbackPath = process.env.FACETPACK_FALLBACK_TRANSFORMER;
-  if (fallbackPath) {
-    try {
-      fallbackTransformer = require(fallbackPath);
-      return fallbackTransformer;
-    } catch (e) {
-      console.warn(`[Facetpack] Failed to load fallback transformer from ${fallbackPath}:`, e);
-    }
-  }
-  fallbackTransformer = {
-    transform: ({ src }) => ({ code: src, map: null })
-  };
-  return fallbackTransformer;
-}
-function setTransformerOptions(options) {
-  globalOptions = options;
-}
-function getStoredOptions() {
-  try {
-    const optionsJson = process.env.FACETPACK_OPTIONS;
-    if (optionsJson) {
-      return JSON.parse(optionsJson);
-    }
-  } catch {}
-  return {};
-}
-function getOptions() {
-  const storedOptions = getStoredOptions();
-  return { ...defaultOptions, ...globalOptions, ...storedOptions };
+function requiresBabelTransform(src) {
+  return BABEL_REQUIRED_PATTERNS.some((pattern) => pattern.test(src));
 }
 function isNodeModules(filename) {
   return filename.includes("node_modules");
 }
-var BABEL_REQUIRED_PATTERNS = [
-  /'worklet'/,
-  /"worklet"/,
-  /useAnimatedStyle/,
-  /useAnimatedProps/,
-  /useDerivedValue/,
-  /useAnimatedReaction/,
-  /useAnimatedScrollHandler/,
-  /useAnimatedGestureHandler/,
-  /runOnUI/,
-  /runOnJS/
-];
-var HERMES_COMPAT_PATTERNS = [
-  /\basync\s+function\b/,
-  /\basync\s*\(/,
-  /\basync\s+\w+\s*\(/,
-  /=\s*async\s*\(/,
-  /=\s*async\s+function\b/
-];
-function requiresBabelTransform(src) {
-  return BABEL_REQUIRED_PATTERNS.some((pattern) => pattern.test(src));
+function getFileExtension(filename) {
+  return filename.split(".").pop()?.toLowerCase();
 }
-function requiresHermesCompat(src) {
-  return HERMES_COMPAT_PATTERNS.some((pattern) => pattern.test(src));
+function getTransformDecision(filename, src, opts) {
+  if (requiresBabelTransform(src))
+    return "babel";
+  if (isNodeModules(filename))
+    return "babel";
+  const ext = getFileExtension(filename);
+  if (!ext || !opts.sourceExts.includes(ext))
+    return "babel";
+  return "oxc";
 }
-function shouldTransform(filename, src, options) {
-  if (isNodeModules(filename)) {
-    return false;
-  }
-  if (requiresBabelTransform(src)) {
-    if (process.env.FACETPACK_DEBUG) {
-      console.log(`[Facetpack] Babel required for worklets: ${filename}`);
+function formatDiagnostics(diagnostics) {
+  return diagnostics.map((d) => {
+    if (d.formatted)
+      return d.formatted;
+    if (!d.message)
+      return "";
+    let output = `
+  × ${d.message}
+`;
+    if (d.snippet) {
+      output += `   ╭─[${d.filename}:${d.line}:${d.column}]
+`;
+      output += ` ${d.line} │ ${d.snippet}
+`;
+      output += `   ╰────
+`;
     }
-    return false;
+    if (d.help)
+      output += `  help: ${d.help}
+`;
+    return output;
+  }).join(`
+`);
+}
+function transformWithOxc(filename, src, opts, isDev) {
+  const parseResult = import_facetpack_native.parseSync(filename, src);
+  if (parseResult.errors.length > 0) {
+    const error = parseResult.diagnostics.length > 0 ? new Error(`
+${formatDiagnostics(parseResult.diagnostics)}`) : new Error(`Parse error in ${filename}:
+${parseResult.errors.join(`
+`)}`);
+    error.isParseError = true;
+    throw error;
   }
-  if (requiresHermesCompat(src)) {
-    if (process.env.FACETPACK_DEBUG) {
-      console.log(`[Facetpack] Babel required for async/await (Hermes compat): ${filename}`);
-    }
-    return false;
+  const isClassic = opts.jsxRuntime === "classic";
+  const result = import_facetpack_native.transformSync(filename, src, {
+    jsx: opts.jsx,
+    jsxRuntime: isClassic ? import_facetpack_native.JsxRuntime.Classic : import_facetpack_native.JsxRuntime.Automatic,
+    ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
+    typescript: opts.typescript,
+    sourcemap: isDev
+  });
+  if (result.errors.length > 0) {
+    throw new Error(`Facetpack transform error in ${filename}:
+${result.errors.join(`
+`)}`);
   }
-  const ext = filename.split(".").pop()?.toLowerCase();
-  if (!ext)
-    return false;
-  return options.sourceExts.includes(ext);
+  preResolveImports(filename, result.code, opts.sourceExts);
+  globalStats.flush();
+  const ast = import_parser.parse(result.code, {
+    sourceType: "unambiguous",
+    plugins: ["jsx"]
+  });
+  return {
+    ast,
+    code: result.code,
+    map: result.map ? JSON.parse(result.map) : null
+  };
+}
+function setTransformerOptions(opts) {
+  options.setGlobal(opts);
 }
 function transform(params) {
   const { filename, src, options: metroOptions } = params;
-  const opts = getOptions();
-  if (process.env.FACETPACK_DEBUG) {
-    console.log(`[Facetpack] Processing: ${filename}`);
-  }
-  if (!shouldTransform(filename, src, opts)) {
-    if (process.env.FACETPACK_DEBUG) {
-      console.log(`[Facetpack] Fallback: ${filename}`);
-    }
-    return getFallbackTransformer().transform(params);
-  }
-  if (process.env.FACETPACK_DEBUG) {
-    console.log(`[Facetpack] OXC Transform: ${filename}`);
+  const opts = options.get();
+  globalStats.registerExitHandler();
+  const decision = getTransformDecision(filename, src, opts);
+  globalStats.recordTransform(decision);
+  logger.logTransform(decision, filename);
+  if (decision === "babel") {
+    return fallback.get().transform(params);
   }
   try {
-    const parseResult = import_facetpack_native.parseSync(filename, src);
-    if (parseResult.errors.length > 0 && parseResult.diagnostics.length > 0) {
-      const formattedErrors = parseResult.diagnostics.map((d) => {
-        let output2 = d.formatted || "";
-        if (!output2 && d.message) {
-          output2 = `
-  × ${d.message}
-`;
-          if (d.snippet) {
-            output2 += `   ╭─[${d.filename}:${d.line}:${d.column}]
-`;
-            output2 += ` ${d.line} │ ${d.snippet}
-`;
-            output2 += `   ╰────
-`;
-          }
-          if (d.help) {
-            output2 += `  help: ${d.help}
-`;
-          }
-        }
-        return output2;
-      }).join(`
-`);
-      throw new Error(`
-${formattedErrors}`);
-    }
-    const isClassic = opts.jsxRuntime === "classic";
-    const result = import_facetpack_native.transformSync(filename, src, {
-      jsx: opts.jsx,
-      jsxRuntime: isClassic ? import_facetpack_native.JsxRuntime.Classic : import_facetpack_native.JsxRuntime.Automatic,
-      ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
-      typescript: opts.typescript,
-      sourcemap: metroOptions.dev
-    });
-    if (result.errors.length > 0) {
-      const errorMessage = result.errors.join(`
-`);
-      throw new Error(`Facetpack transform error in ${filename}:
-${errorMessage}`);
-    }
-    preResolveImports(filename, result.code, opts.sourceExts);
-    const ast = opts.noAst ? undefined : import_parser.parse(result.code, {
-      sourceType: "unambiguous",
-      plugins: ["jsx"]
-    });
-    const output = {
-      ast,
-      code: result.code,
-      map: result.map ? JSON.parse(result.map) : null
-    };
-    if (process.env.FACETPACK_DEBUG) {
-      console.log(`[Facetpack] Output for ${filename}:`);
-      console.log(result.code.slice(0, 500));
-    }
-    return output;
+    return transformWithOxc(filename, src, opts, metroOptions.dev);
   } catch (error) {
-    if (error instanceof Error) {
-      error.message = `[Facetpack] ${error.message}`;
+    if (error.isParseError) {
+      throw error;
     }
-    throw error;
+    logger.logFallback(filename, error);
+    globalStats.adjustTransformFallback();
+    return fallback.get().transform(params);
   }
 }
-function createTransformer(options = {}) {
-  const opts = { ...defaultOptions, ...options };
+function createTransformer(customOptions = {}) {
+  const opts = options.merge(customOptions);
   return {
     transform(params) {
       const { filename, src, options: metroOptions } = params;
-      if (!shouldTransform(filename, src, opts)) {
-        return getFallbackTransformer().transform(params);
-      }
-      const isClassic = opts.jsxRuntime === "classic";
-      const result = import_facetpack_native.transformSync(filename, src, {
-        jsx: opts.jsx,
-        jsxRuntime: isClassic ? import_facetpack_native.JsxRuntime.Classic : import_facetpack_native.JsxRuntime.Automatic,
-        ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
-        typescript: opts.typescript,
-        sourcemap: metroOptions.dev
-      });
-      if (result.errors.length > 0) {
-        throw new Error(`Facetpack transform error in ${filename}:
-${result.errors.join(`
-`)}`);
+      const decision = getTransformDecision(filename, src, opts);
+      globalStats.recordTransform(decision);
+      if (decision === "babel") {
+        return fallback.get().transform(params);
       }
-      return {
-        code: result.code,
-        map: result.map ? JSON.parse(result.map) : null
-      };
+      return transformWithOxc(filename, src, opts, metroOptions.dev);
     }
   };
 }

package/dist/transformer.d.ts

@@ -1,7 +1,9 @@
 import type { TransformParams, TransformResult, FacetpackOptions } from './types';
-export declare function setTransformerOptions(options: FacetpackOptions): void;
+interface Transformer {
+    transform: (params: TransformParams) => TransformResult;
+}
+export declare function setTransformerOptions(opts: FacetpackOptions): void;
 export declare function transform(params: TransformParams): TransformResult;
-export declare function createTransformer(options?: FacetpackOptions): {
-    transform(params: TransformParams): TransformResult;
-};
+export declare function createTransformer(customOptions?: FacetpackOptions): Transformer;
+export {};
 //# sourceMappingURL=transformer.d.ts.map

package/dist/transformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../src/transformer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAuFjF,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAErE;AA2ED,wBAAgB,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAuFlE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,gBAAqB;sBAI1C,eAAe,GAAG,eAAe;EA4BtD"}
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../src/transformer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAMjF,UAAU,WAAW;IACnB,SAAS,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,eAAe,CAAA;CACxD;AAiQD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAElE;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,CAwBlE;AAED,wBAAgB,iBAAiB,CAAC,aAAa,GAAE,gBAAqB,GAAG,WAAW,CAiBnF"}