@vxrn/compiler 1.25.3 → 1.25.5

package/dist/cjs/index.cjs

@@ -1,425 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
-var index_exports = {};
-__export(index_exports, {
-  createVXRNCompilerPlugin: () => createVXRNCompilerPlugin
-});
-module.exports = __toCommonJS(index_exports);
-var import_node_fs = require("node:fs");
-var import_promises = require("node:fs/promises");
-var import_node_path = require("node:path");
-var import_node_url = require("node:url");
-var import_utils = require("@vxrn/utils");
-var import_css_to_rn = require("react-native-css-interop/css-to-rn/index.js");
-var import_configure = require("./configure.cjs");
-var import_constants = require("./constants.cjs");
-var import_transformBabel = require("./transformBabel.cjs");
-var import_cache = require("./cache.cjs");
-__reExport(index_exports, require("./configure.cjs"), module.exports);
-__reExport(index_exports, require("./transformBabel.cjs"), module.exports);
-__reExport(index_exports, require("./transformSWC.cjs"), module.exports);
-const import_meta = {};
-const perfStats = {
-  babel: {
-    totalCalls: 0,
-    totalTransforms: 0,
-    totalTime: 0,
-    byEnvironment: {}
-  },
-  optimizeDeps: {
-    byEnvironment: {}
-  }
-};
-function logPerfSummary() {
-  if (!process.env.DEBUG_COMPILER_PERF) {
-    return;
-  }
-  console.info("\n\u{1F4CA} [Compiler Performance Summary]");
-  console.info(`Babel: ${perfStats.babel.totalTransforms} transforms / ${perfStats.babel.totalCalls} calls (${(perfStats.babel.totalTransforms / Math.max(perfStats.babel.totalCalls, 1) * 100).toFixed(1)}% transform rate)`);
-  console.info(`Babel total time: ${perfStats.babel.totalTime}ms`);
-  for (const [env, stats] of Object.entries(perfStats.babel.byEnvironment)) {
-    if (stats.transforms > 0) {
-      console.info(`  ${env}: ${stats.transforms} transforms, ${stats.time}ms (${(stats.time / stats.transforms).toFixed(1)}ms avg)`);
-    }
-  }
-  for (const [env, stats] of Object.entries(perfStats.optimizeDeps.byEnvironment)) {
-    const elapsed = Date.now() - stats.startTime;
-    console.info(`optimizeDeps ${env}: checked ${stats.filesChecked} files, transformed ${stats.filesTransformed} (${elapsed}ms)`);
-  }
-}
-const compilerLog = {
-  compiled: 0,
-  cached: 0,
-  time: 0,
-  // typed loose because the dom lib types setTimeout as number, but node gives
-  // us a Timeout we need to unref so the debounce never holds the process open
-  timer: null
-};
-function logCompiled(cached, ms) {
-  if (cached) {
-    compilerLog.cached++;
-  } else {
-    compilerLog.compiled++;
-    compilerLog.time += ms;
-  }
-  if (compilerLog.timer) clearTimeout(compilerLog.timer);
-  compilerLog.timer = setTimeout(() => {
-    const total = compilerLog.compiled + compilerLog.cached;
-    const detail = compilerLog.compiled ? `${compilerLog.compiled} compiled in ${compilerLog.time}ms${compilerLog.cached ? `, ${compilerLog.cached} cached` : ""}` : `all cached`;
-    console.info(` \u{1FA84} [compiler] ${total} file${total === 1 ? "" : "s"} (${detail})`);
-    compilerLog.compiled = 0;
-    compilerLog.cached = 0;
-    compilerLog.time = 0;
-    compilerLog.timer = null;
-  }, 500);
-  compilerLog.timer.unref?.();
-}
-async function performBabelTransform({
-  id,
-  code,
-  environment,
-  production,
-  reactForRNVersion,
-  optionsIn
-}) {
-  perfStats.babel.totalCalls++;
-  if (!perfStats.babel.byEnvironment[environment]) {
-    perfStats.babel.byEnvironment[environment] = {
-      calls: 0,
-      transforms: 0,
-      time: 0
-    };
-  }
-  perfStats.babel.byEnvironment[environment].calls++;
-  const transformProps = {
-    id,
-    code,
-    development: !production,
-    environment,
-    reactForRNVersion
-  };
-  const userTransform = optionsIn?.transform?.(transformProps);
-  if (userTransform === false) {
-    return null;
-  }
-  if (userTransform !== "swc") {
-    const babelOptions = (0, import_transformBabel.getBabelOptions)({
-      ...transformProps,
-      userSetting: userTransform
-    });
-    if (babelOptions) {
-      const hasCompilerPlugin = babelOptions.plugins?.some(x => Array.isArray(x) && x[0] === "babel-plugin-react-compiler");
-      const cached = (0, import_cache.getCachedTransform)(id, code, environment);
-      if (cached) {
-        perfStats.babel.byEnvironment[environment].transforms++;
-        if (hasCompilerPlugin && (cached.code.includes("react/compiler-runtime") || cached.code.includes("react-compiler-runtime"))) {
-          (0, import_constants.debug)?.(` \u{1FA84} [compiler] ${(0, import_node_path.relative)(process.cwd(), id)} (cached)`);
-          logCompiled(true, 0);
-        }
-        (0, import_constants.debug)?.(`[babel/cached] ${id}`);
-        return cached;
-      }
-      const compilerOnly = hasCompilerPlugin && babelOptions.plugins?.length === 1;
-      const compilerTarget = compilerOnly ? babelOptions.plugins[0][1]?.target ?? "19" : "19";
-      const startTime = Date.now();
-      const babelOut = compilerOnly ? await (0, import_transformBabel.transformOxcReactCompiler)(id, code, compilerTarget) : await (0, import_transformBabel.transformBabel)(id, code, babelOptions);
-      const babelTime = Date.now() - startTime;
-      if (babelOut?.code) {
-        perfStats.babel.totalTransforms++;
-        perfStats.babel.totalTime += babelTime;
-        perfStats.babel.byEnvironment[environment].transforms++;
-        perfStats.babel.byEnvironment[environment].time += babelTime;
-        if (hasCompilerPlugin && (babelOut.code.includes("react/compiler-runtime") || babelOut.code.includes("react-compiler-runtime"))) {
-          (0, import_constants.debug)?.(` \u{1FA84} [compiler] ${(0, import_node_path.relative)(process.cwd(), id)} (${babelTime}ms)`);
-          logCompiled(false, babelTime);
-        }
-        (0, import_constants.debug)?.(`[babel] ${id}`);
-        const outCode = `${babelOut.code}
-// vxrn-did-babel`;
-        const result = {
-          code: outCode,
-          map: babelOut.map
-        };
-        (0, import_cache.setCachedTransform)(id, code, result, environment);
-        return result;
-      }
-    }
-  }
-  return null;
-}
-async function createVXRNCompilerPlugin(optionsIn) {
-  const reactVersion = await (async () => {
-    const path = (0, import_utils.resolvePath)("react/package.json");
-    const json = JSON.parse(await (0, import_promises.readFile)(path, "utf-8"));
-    return json.version;
-  })();
-  const envNames = {
-    ios: true,
-    android: true,
-    client: true,
-    ssr: true
-  };
-  function getEnvName(name) {
-    if (!envNames[name]) throw new Error(`Invalid env: ${name}`);
-    return name;
-  }
-  const reactForRNVersion = reactVersion.split(".")[0];
-  const cssTransformCache = /* @__PURE__ */new Map();
-  const rolldownPath = (0, import_utils.resolvePath)("rolldown");
-  const rolldownNodeMods = rolldownPath.slice(0, rolldownPath.indexOf(import_node_path.sep + "node_modules"));
-  let config;
-  return [{
-    name: "one:compiler-resolve-refresh-runtime",
-    apply: "serve",
-    enforce: "pre",
-    // Run before Vite default resolve to avoid syscalls
-    resolveId: id => id === import_constants.runtimePublicPath || id === `${import_constants.runtimePublicPath}.map` ? id : void 0,
-    load: id => {
-      const basePath = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-      if (id === import_constants.runtimePublicPath) {
-        return (0, import_node_fs.readFileSync)((0, import_node_path.join)(basePath, "refresh-runtime.mjs"), "utf-8").replace(/\/\/# sourceMappingURL=.*/, "");
-      }
-      if (id === `${import_constants.runtimePublicPath}.map`) {
-        return JSON.stringify({
-          version: 3,
-          sources: [],
-          mappings: ""
-        });
-      }
-      return void 0;
-    }
-  }, {
-    name: `one:compiler-css-to-js`,
-    // only .css files can match, so let rust reject everything else
-    transform: {
-      filter: {
-        id: /\.css$/
-      },
-      handler(codeIn, id) {
-        const environment = getEnvName(this.environment.name);
-        if (import_configure.configuration.enableNativeCSS && (environment === "ios" || environment === "android")) {
-          {
-            const data = JSON.stringify((0, import_css_to_rn.cssToReactNativeRuntime)(codeIn, {
-              inlineRem: 16
-            }));
-            const code = `require("nativewind/dist/index.js").__require().StyleSheet.registerCompiled(${data})`;
-            const newId = `${id}.js`;
-            const cssId = newId.replace(rolldownNodeMods + import_node_path.sep, "");
-            cssTransformCache.set(cssId, code);
-            return {
-              code,
-              id: newId,
-              map: null
-            };
-          }
-        }
-      }
-    },
-    generateBundle(_, bundle) {
-      const environment = getEnvName(this.environment.name);
-      if (import_configure.configuration.enableNativeCSS && (environment === "ios" || environment === "android")) {
-        const rootJSName = Object.keys(bundle).find(i => {
-          const chunk = bundle[i];
-          return chunk.type == "chunk" && chunk.fileName.match(/.[cm]?js(?:\?.+)?$/) != null;
-        });
-        if (!rootJSName) {
-          throw new Error(`Can't find root js, internal one error`);
-        }
-        const rootJS = bundle[rootJSName];
-        const cssAssets = Object.keys(bundle).filter(i => bundle[i].fileName.endsWith(".css.js"));
-        for (const name of cssAssets) {
-          delete bundle[name];
-          const jsCSS = cssTransformCache.get(name);
-          rootJS.code = `
-${jsCSS}
-${rootJS.code}
-`;
-        }
-      }
-    }
-  }, {
-    name: "one:compiler",
-    enforce: "pre",
-    config: () => {
-      const nodeModulesFilter = /node_modules[/\\].*\.(tsx?|jsx?|mjs|cjs)$/;
-      const createEnvironmentConfig = environment => {
-        if (!perfStats.optimizeDeps.byEnvironment[environment]) {
-          perfStats.optimizeDeps.byEnvironment[environment] = {
-            filesChecked: 0,
-            filesTransformed: 0,
-            startTime: Date.now()
-          };
-        }
-        return {
-          optimizeDeps: {
-            rolldownOptions: {
-              plugins: [{
-                name: `transform-before-optimize-deps-${environment}`,
-                async transform(code, id) {
-                  if (!nodeModulesFilter.test(id)) {
-                    return null;
-                  }
-                  perfStats.optimizeDeps.byEnvironment[environment].filesChecked++;
-                  const production = process.env.NODE_ENV === "production" || process.env.NODE_ENV === "test";
-                  (0, import_constants.debug)?.(`[rolldown optimizeDeps] ${id}`);
-                  const result = await performBabelTransform({
-                    id,
-                    code,
-                    environment,
-                    production,
-                    reactForRNVersion,
-                    optionsIn
-                  });
-                  if (!result) {
-                    return null;
-                  }
-                  perfStats.optimizeDeps.byEnvironment[environment].filesTransformed++;
-                  return {
-                    code: result.code,
-                    map: result.map
-                  };
-                },
-                buildEnd() {
-                  if (process.env.DEBUG_COMPILER_PERF) {
-                    const stats = perfStats.optimizeDeps.byEnvironment[environment];
-                    const elapsed = Date.now() - stats.startTime;
-                    console.info(`[optimizeDeps ${environment}] Done: ${stats.filesChecked} files checked, ${stats.filesTransformed} transformed (${elapsed}ms)`);
-                  }
-                  const allDone = Object.keys(perfStats.optimizeDeps.byEnvironment).length >= 2;
-                  if (allDone) {
-                    (0, import_cache.logCacheStats)();
-                    logPerfSummary();
-                  }
-                }
-              }]
-            }
-          },
-          define: {
-            "process.env.NATIVEWIND_OS": JSON.stringify(environment === "ios" || environment === "android" ? "native" : "web")
-          }
-        };
-      };
-      return {
-        environments: {
-          ios: createEnvironmentConfig("ios"),
-          android: createEnvironmentConfig("android"),
-          client: createEnvironmentConfig("client"),
-          ssr: createEnvironmentConfig("ssr")
-        }
-      };
-    },
-    configResolved(resolvedConfig) {
-      config = resolvedConfig;
-    },
-    async transform(codeIn, _id) {
-      let code = codeIn;
-      const environment = getEnvName(this.environment.name);
-      const isNative = environment === "ios" || environment === "android";
-      const production = config.command === "build" || process.env.NODE_ENV === "production" || JSON.parse(this.environment.config?.define?.["process.env.NODE_ENV"] || '""') === "production";
-      const isEntry = _id.includes("one-entry-native");
-      if (isEntry) {
-        if (isNative && !production) {
-          code = `import '@vxrn/vite-native-client'
-${code}`;
-        }
-        if (isNative && import_configure.configuration.enableNativewind) {
-          code = `import * as x from 'nativewind'
-${code}`;
-        }
-        return code;
-      }
-      const id = _id.split("?")[0];
-      const extension = (0, import_node_path.extname)(id);
-      if (extension === ".css" || !import_constants.validParsers.has(extension)) {
-        return;
-      }
-      if (id.includes(`virtual:`)) {
-        return;
-      }
-      if (codeIn.endsWith(`// vxrn-did-babel`)) {
-        (0, import_constants.debug)?.(`[skip babel] ${id}`);
-        return;
-      }
-      return performBabelTransform({
-        id,
-        code: codeIn,
-        environment,
-        production,
-        reactForRNVersion,
-        optionsIn
-      });
-    }
-  },
-  // wraps client-side TSX/JSX with React Refresh preamble + import.meta.hot.accept
-  // runs after vite:oxc (no enforce:'pre') so it sees the already-transformed code
-  {
-    name: "one:react-refresh-web",
-    apply: "serve",
-    transform(code, _id) {
-      if (this.environment.name !== "client") return;
-      if (code.includes(import_constants.runtimePublicPath)) return;
-      const id = _id.split("?")[0];
-      if (id.includes("node_modules")) return;
-      if (id.includes("virtual:")) return;
-      if (id === import_constants.runtimePublicPath) return;
-      const ext = (0, import_node_path.extname)(id);
-      if (ext !== ".tsx" && ext !== ".jsx") return;
-      const hasRefreshCalls = /\$RefreshReg\$\(/.test(code);
-      let out = `import * as RefreshRuntime from "${import_constants.runtimePublicPath}";
-
-`;
-      if (hasRefreshCalls) {
-        out += `if (!window.$RefreshReg$) throw new Error("React refresh preamble was not loaded. Something is wrong.");
-const prevRefreshReg = window.$RefreshReg$;
-const prevRefreshSig = window.$RefreshSig$;
-window.$RefreshReg$ = RefreshRuntime.getRefreshReg("${id}");
-window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
-
-`;
-      }
-      out += code;
-      if (hasRefreshCalls) {
-        out += `
-
-window.$RefreshReg$ = prevRefreshReg;
-window.$RefreshSig$ = prevRefreshSig;
-`;
-      }
-      out += `
-RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
-  RefreshRuntime.registerExportsForReactRefresh("${id}", currentExports);
-  import.meta.hot.accept((nextExports) => {
-    if (!nextExports) return;
-    const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate("${id}", currentExports, nextExports);
-    if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
-  });
-});
-`;
-      return {
-        code: out,
-        map: null
-      };
-    }
-  }];
-}