@hanzogui/static 2.0.0-rc.41-hanzoai.5

package/dist/extractor/bundleConfig.cjs

@@ -0,0 +1,716 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var bundleConfig_exports = {};
+__export(bundleConfig_exports, {
+  bundleConfig: () => bundleConfig,
+  esbuildOptions: () => esbuildOptions,
+  esbuildOptionsWithPlugins: () => esbuildOptionsWithPlugins,
+  getBundledConfig: () => getBundledConfig,
+  getLoadedConfig: () => getLoadedConfig,
+  hasBundledConfigChanged: () => hasBundledConfigChanged,
+  loadComponents: () => loadComponents,
+  loadComponentsInner: () => loadComponentsInner,
+  loadComponentsInnerSync: () => loadComponentsInnerSync,
+  loadComponentsSync: () => loadComponentsSync,
+  writeHanzoguiCSS: () => writeHanzoguiCSS
+});
+module.exports = __toCommonJS(bundleConfig_exports);
+var import_generator = __toESM(require("@babel/generator"));
+var import_traverse = __toESM(require("@babel/traverse"));
+var t = __toESM(require("@babel/types"));
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+var import_cli_color = require("@hanzogui/cli-color");
+var import_esbuild = __toESM(require("esbuild"));
+var FS = __toESM(require("fs-extra"));
+var import_promises = require("node:fs/promises");
+var import_registerRequire = require("../registerRequire.cjs");
+var import_babelParse = require("./babelParse.cjs");
+var import_bundle = require("./bundle.cjs");
+var import_getHanzoguiConfigPathFromOptionsConfig = require("./getHanzoguiConfigPathFromOptionsConfig.cjs");
+var import_hasTopLevelAwait = require("./hasTopLevelAwait.cjs");
+var import_requireHanzoguiCore = require("../helpers/requireHanzoguiCore.cjs");
+var import_detectModuleFormat = require("./detectModuleFormat.cjs");
+const activeTempFiles = /* @__PURE__ */new Set();
+function getDynamicEvalOutfile(name, format, contents) {
+  const ext = format === "esm" ? "mjs" : "cjs";
+  const hash = (0, import_node_crypto.createHash)("sha1").update(name).update("\0").update(format).update("\0").update(contents).digest("hex").slice(0, 10);
+  return (0, import_node_path.join)(process.cwd(), ".hanzogui", `dynamic-eval-${hash}-${(0, import_node_path.basename)(name)}.${ext}`);
+}
+function getEsbuildStdinLoader(filePath) {
+  if (filePath.endsWith(".tsx")) return "tsx";
+  if (filePath.endsWith(".ts")) return "ts";
+  if (filePath.endsWith(".jsx")) return "jsx";
+  return "js";
+}
+function resolvePackageEntry(packageName, format) {
+  if (format === "cjs") {
+    return require.resolve(packageName);
+  }
+  const packageJsonPath = require.resolve(`${packageName}/package.json`);
+  const packageJson = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf-8"));
+  const packageRoot = (0, import_node_path.dirname)(packageJsonPath);
+  const exportEntry = packageJson.exports?.["."];
+  const esmEntry = exportEntry?.import || exportEntry?.module || exportEntry?.browser || packageJson.module;
+  if (typeof esmEntry === "string") {
+    return (0, import_node_path.join)(packageRoot, esmEntry);
+  }
+  return require.resolve(packageName);
+}
+function cleanupTempFiles() {
+  for (const f of activeTempFiles) {
+    try {
+      (0, import_node_fs.unlinkSync)(f);
+    } catch {}
+  }
+  activeTempFiles.clear();
+}
+process.on("exit", cleanupTempFiles);
+process.on("SIGINT", () => {
+  cleanupTempFiles();
+  process.exit();
+});
+process.on("SIGTERM", () => {
+  cleanupTempFiles();
+  process.exit();
+});
+const external = ["@hanzogui/core", "@hanzogui/web", "react", "react-dom", "react-native-svg"];
+const esbuildExtraOptions = {
+  define: {
+    __DEV__: `${process.env.NODE_ENV === "development"}`
+  }
+};
+const handleEsmFeaturesPlugin = {
+  name: "handle-esm-features",
+  setup(build) {
+    const isCjs = build.initialOptions.format === "cjs" || !build.initialOptions.format;
+    build.onLoad({
+      filter: /\.(ts|tsx|js|jsx|mjs)$/
+    }, args => {
+      if (!isCjs) {
+        return null;
+      }
+      if (args.path.includes("node_modules") && !args.path.includes("@hanzogui")) {
+        return null;
+      }
+      let contents = (0, import_node_fs.readFileSync)(args.path, "utf8");
+      let modified = false;
+      if (contents.includes("import.meta.env")) {
+        contents = contents.replace(/import\.meta\.env/g, "process.env");
+        modified = true;
+      }
+      if (contents.includes("import.meta.url")) {
+        contents = contents.replace(/import\.meta\.url/g, '""');
+        modified = true;
+      }
+      if (contents.includes("import.meta.main")) {
+        contents = contents.replace(/import\.meta\.main/g, "false");
+        modified = true;
+      }
+      if ((0, import_hasTopLevelAwait.hasTopLevelAwait)(contents, args.path)) {
+        if (process.env.DEBUG?.startsWith("hanzogui")) {
+          console.info(`[hanzogui] stubbing file with top-level await: ${args.path}`);
+        }
+        return {
+          // Keep this as an ESM-shaped stub so esbuild doesn't inline a top-level
+          // `module.exports = {}` into the parent bundle and wipe its exports.
+          contents: `// stubbed - contains top-level await
+export default {}`,
+          loader: "js"
+        };
+      }
+      if (modified) {
+        return {
+          contents,
+          loader: args.path.endsWith(".tsx") ? "tsx" : args.path.endsWith(".ts") ? "ts" : args.path.endsWith(".jsx") ? "jsx" : "js"
+        };
+      }
+      return null;
+    });
+  }
+};
+const esbuildTransformOptions = {
+  target: "es2022",
+  format: "cjs",
+  jsx: "automatic",
+  platform: "node",
+  ...esbuildExtraOptions
+};
+const esbuildOptions = {
+  ...esbuildTransformOptions
+};
+const esbuildOptionsWithPlugins = {
+  ...esbuildTransformOptions,
+  plugins: [handleEsmFeaturesPlugin]
+};
+let currentBundle = null;
+let isBundling = false;
+let lastBundle = null;
+const waitForBundle = /* @__PURE__ */new Set();
+function hasBundledConfigChanged() {
+  if (lastBundle === currentBundle) {
+    return false;
+  }
+  lastBundle = currentBundle;
+  return true;
+}
+let loadedConfig = null;
+const getLoadedConfig = () => loadedConfig;
+async function getBundledConfig(props, rebuild = false) {
+  if (isBundling) {
+    await new Promise(res => {
+      waitForBundle.add(res);
+    });
+  } else if (!currentBundle || rebuild) {
+    return await bundleConfig(props);
+  }
+  return currentBundle;
+}
+global.hanzoguiLastLoaded ||= 0;
+function updateLastLoaded(config) {
+  global.hanzoguiLastLoaded = Date.now();
+  global.hanzoguiLastBundledConfig = config;
+}
+let hasBundledOnce = false;
+let hasLoggedBuild = false;
+async function bundleConfig(props) {
+  if (global.hanzoguiLastBundledConfig && Date.now() - global.hanzoguiLastLoaded < 3e3) {
+    return global.hanzoguiLastBundledConfig;
+  }
+  try {
+    isBundling = true;
+    const configEntry = props.config ? (0, import_getHanzoguiConfigPathFromOptionsConfig.getHanzoguiConfigPathFromOptionsConfig)(props.config) : "";
+    const tmpDir = (0, import_node_path.join)(process.cwd(), ".hanzogui");
+    const configFormat = configEntry ? (0, import_detectModuleFormat.detectModuleFormat)(configEntry) : "cjs";
+    const configExt = configFormat === "esm" ? ".mjs" : ".cjs";
+    const configOutPath = (0, import_node_path.join)(tmpDir, `hanzogui.config${configExt}`);
+    const baseComponents = (props.components || []).filter(x => x !== "@hanzogui/core");
+    const componentFormats = baseComponents.map(mod => {
+      try {
+        const pkgJson = require.resolve(mod + "/package.json");
+        const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgJson, "utf-8"));
+        return pkg.type === "module" ? "esm" : "cjs";
+      } catch {
+        return "cjs";
+      }
+    });
+    const componentOutPaths = baseComponents.map((componentModule, i) => {
+      const ext = componentFormats[i] === "esm" ? ".mjs" : ".cjs";
+      return (0, import_node_path.join)(tmpDir, `${componentModule.split(import_node_path.sep).join("-").replace(/[^a-z0-9]+/gi, "")}-components.config${ext}`);
+    });
+    if (process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("hanzogui")) {
+      console.info(`Building config entry`, configEntry);
+    }
+    let shouldBuild = !props.disableInitialBuild;
+    if (shouldBuild && props.config) {
+      const allOutFiles = [configOutPath, ...componentOutPaths];
+      try {
+        const stats = await Promise.all(allOutFiles.map(f => FS.stat(f).catch(() => null)));
+        const allExistAndRecent = stats.every(s => s !== null && Date.now() - s.mtimeMs < 3e3);
+        if (allExistAndRecent) {
+          shouldBuild = false;
+        }
+      } catch {}
+    }
+    if (shouldBuild) {
+      try {
+        await FS.ensureDir(tmpDir);
+      } catch {}
+      const start = Date.now();
+      await Promise.all([props.config ? (0, import_bundle.esbundleHanzoguiConfig)({
+        entryPoints: [configEntry],
+        external,
+        outfile: configOutPath,
+        target: "node24",
+        format: configFormat,
+        ...esbuildExtraOptions
+      }, props.platform || "web") : null, ...baseComponents.map((componentModule, i) => {
+        return (0, import_bundle.esbundleHanzoguiConfig)({
+          entryPoints: [componentModule],
+          resolvePlatformSpecificEntries: true,
+          external,
+          outfile: componentOutPaths[i],
+          target: "node24",
+          format: componentFormats[i],
+          ...esbuildExtraOptions
+        }, props.platform || "web");
+      })]);
+      if (!hasLoggedBuild && !props["_skipBuildLog"]) {
+        hasLoggedBuild = true;
+        (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `
+  \u27A1 [hanzogui] built config, components, prompt (${Date.now() - start}ms)`);
+        if (process.env.DEBUG?.startsWith("hanzogui")) {
+          (0, import_cli_color.colorLog)(import_cli_color.Color.Dim, `
+          Config     .${import_node_path.sep}${(0, import_node_path.relative)(process.cwd(), configOutPath)}
+          Components ${componentOutPaths.map(p => `.${import_node_path.sep}${(0, import_node_path.relative)(process.cwd(), p)}`).join("\n             ")}
+          `);
+        }
+      }
+    }
+    if (hasBundledOnce) {
+      try {
+        delete require.cache[require.resolve(configOutPath)];
+      } catch {}
+      for (const p of componentOutPaths) {
+        try {
+          delete require.cache[require.resolve(p)];
+        } catch {}
+      }
+    } else {
+      hasBundledOnce = true;
+    }
+    let out;
+    if (configFormat === "esm") {
+      out = await import((0, import_node_url.pathToFileURL)(configOutPath).href);
+    } else {
+      out = require(configOutPath);
+    }
+    let config = out.default || out || out.config;
+    if (config && config.config && !config.tokens) {
+      config = config.config;
+    }
+    if (!config) {
+      throw new Error(`No config: ${config}`);
+    }
+    if (config._isProxyWorm) {
+      throw new Error(`Got a proxied config - likely a module loading error. Set DEBUG=hanzogui for details.`);
+    }
+    loadedConfig = config;
+    if (!config.parsed) {
+      const {
+        createHanzogui
+      } = (0, import_requireHanzoguiCore.requireHanzoguiCore)(props.platform || "web");
+      config = createHanzogui(config);
+    }
+    if (props.outputCSS) {
+      await writeHanzoguiCSS(props.outputCSS, config);
+    }
+    let components = await loadComponents({
+      ...props,
+      components: componentOutPaths
+    });
+    if (!components) {
+      throw new Error(`No components found: ${componentOutPaths.join(", ")}`);
+    }
+    for (const component of components) {
+      component.moduleName = baseComponents[componentOutPaths.indexOf(component.moduleName)] || component.moduleName;
+      if (!component.moduleName) {
+        if (process.env.DEBUG?.includes("hanzogui") || process.env.IS_TAMAGUI_DEV) {
+          console.warn(`\u26A0\uFE0F no module name found: ${component.moduleName} ${JSON.stringify(baseComponents)} in ${JSON.stringify(componentOutPaths)}`);
+        }
+      }
+    }
+    if (process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("hanzogui")) {
+      console.info("Loaded components", components);
+    }
+    const res = {
+      components,
+      nameToPaths: {},
+      hanzoguiConfig: config
+    };
+    currentBundle = res;
+    updateLastLoaded(res);
+    return res;
+  } catch (err) {
+    console.error(`Error bundling hanzogui config: ${err?.message} (run with DEBUG=hanzogui to see stack)`);
+    if (process.env.DEBUG?.includes("hanzogui")) {
+      console.error(err.stack);
+    }
+  } finally {
+    isBundling = false;
+    waitForBundle.forEach(cb => cb());
+    waitForBundle.clear();
+  }
+}
+async function writeHanzoguiCSS(outputCSS, config) {
+  const flush = async () => {
+    (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `  \u27A1 [hanzogui] output css: ${outputCSS}`);
+    await FS.writeFile(outputCSS, css);
+  };
+  const css = config.getCSS();
+  if (typeof css !== "string") {
+    throw new Error(`Invalid CSS: ${typeof css} ${css}`);
+  }
+  try {
+    if ((0, import_node_fs.existsSync)(outputCSS) && (await (0, import_promises.readFile)(outputCSS, "utf8")) === css) {} else {
+      await flush();
+    }
+  } catch (err) {
+    console.info("Error writing themes", err);
+  }
+}
+async function loadComponents(props, forceExports = false) {
+  const coreComponents = getCoreComponentsSync(props);
+  const otherComponents = await loadComponentsInner(props, forceExports);
+  return [...coreComponents, ...(otherComponents || [])];
+}
+function loadComponentsSync(props, forceExports = false) {
+  const coreComponents = getCoreComponentsSync(props);
+  const otherComponents = loadComponentsInnerSync(props, forceExports);
+  return [...coreComponents, ...(otherComponents || [])];
+}
+function getCoreComponentsSync(props) {
+  const loaded = loadComponentsInnerSync({
+    ...props,
+    components: ["@hanzogui/core"]
+  });
+  if (!loaded) {
+    throw new Error(`Core should always load`);
+  }
+  return [{
+    ...loaded[0],
+    moduleName: "@hanzogui/core"
+  }];
+}
+async function loadComponentsInner(props, forceExports = false) {
+  const componentsModules = props.components || [];
+  const key = componentsModules.join("\0");
+  if (!forceExports && cacheComponents[key]) {
+    return cacheComponents[key];
+  }
+  const {
+    unregister
+  } = (0, import_registerRequire.registerRequire)(props.platform || "web", {
+    proxyWormImports: forceExports
+  });
+  try {
+    const results = [];
+    for (const name of componentsModules) {
+      const extension = (0, import_node_path.extname)(name);
+      const isLocal = Boolean(extension);
+      const isDynamic = isLocal && forceExports;
+      const format = isLocal ? (0, import_detectModuleFormat.detectModuleFormat)(name) : "cjs";
+      const fileContents = isDynamic ? (0, import_node_fs.readFileSync)(name, "utf-8") : "";
+      let loadModule = name;
+      let writtenContents = fileContents;
+      let didBabel = false;
+      const attemptLoad = async ({
+        forceExports: forceExports2 = false
+      } = {}) => {
+        if (isDynamic) {
+          writtenContents = forceExports2 ? transformAddExports((0, import_babelParse.babelParse)(esbuildit(fileContents, "modern"), name)) : fileContents;
+          loadModule = getDynamicEvalOutfile(name, format, writtenContents);
+          FS.ensureDirSync((0, import_node_path.dirname)(loadModule));
+          activeTempFiles.add(loadModule);
+          await import_esbuild.default.build({
+            ...esbuildOptionsWithPlugins,
+            format,
+            outfile: loadModule,
+            stdin: {
+              contents: writtenContents,
+              resolveDir: (0, import_node_path.dirname)(name),
+              sourcefile: name,
+              loader: getEsbuildStdinLoader(name)
+            },
+            alias: {
+              "react-native": resolvePackageEntry("@hanzogui/react-native-web-lite", format),
+              "@hanzogui/react-native-web-lite": resolvePackageEntry("@hanzogui/react-native-web-lite", format),
+              "@hanzogui/react-native-web-internals": resolvePackageEntry("@hanzogui/react-native-web-internals", format)
+            },
+            bundle: true,
+            packages: "external",
+            allowOverwrite: true,
+            sourcemap: false,
+            loader: import_bundle.esbuildLoaderConfig
+          });
+        }
+        if (process.env.DEBUG === "hanzogui") {
+          console.info(`loadModule`, loadModule, format);
+        }
+        let moduleResult;
+        if (format === "esm") {
+          moduleResult = await import((0, import_node_url.pathToFileURL)(loadModule).href);
+        } else {
+          moduleResult = require(loadModule);
+        }
+        if (!forceExports2) {
+          (0, import_registerRequire.setRequireResult)(name, moduleResult);
+        }
+        const nameToInfo = getComponentStaticConfigByName(name, interopDefaultExport(moduleResult));
+        return {
+          moduleName: name,
+          nameToInfo
+        };
+      };
+      const dispose = () => {
+        if (isDynamic) {
+          FS.removeSync(loadModule);
+          activeTempFiles.delete(loadModule);
+        }
+      };
+      let loaded;
+      try {
+        loaded = await attemptLoad({
+          forceExports: true
+        });
+        didBabel = true;
+      } catch (err) {
+        console.info("babel err", err, writtenContents);
+        writtenContents = fileContents;
+        if (process.env.DEBUG?.startsWith("hanzogui")) {
+          console.info(`Error parsing babel likely`, err);
+        }
+        try {
+          loaded = await attemptLoad({
+            forceExports: false
+          });
+        } catch (err2) {
+          if (process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD) {
+            console.info(`
+Hanzogui attempted but failed to dynamically optimize components in:
+  ${name}
+`);
+            console.info(err2);
+            console.info(`At: ${loadModule}`, `
+didBabel: ${didBabel}`, `
+In:`, writtenContents, `
+isDynamic: `, isDynamic);
+          }
+          loaded = [];
+        }
+      } finally {
+        dispose();
+      }
+      if (Array.isArray(loaded)) {
+        results.push(...loaded);
+      } else if (loaded) {
+        results.push(loaded);
+      }
+    }
+    cacheComponents[key] = results;
+    return results;
+  } catch (err) {
+    console.info(`Hanzogui error bundling components`, err.message, err.stack);
+    return null;
+  } finally {
+    unregister();
+  }
+}
+function loadComponentsInnerSync(props, forceExports = false) {
+  const componentsModules = props.components || [];
+  const key = componentsModules.join("\0");
+  if (!forceExports && cacheComponents[key]) {
+    return cacheComponents[key];
+  }
+  const {
+    unregister
+  } = (0, import_registerRequire.registerRequire)(props.platform || "web", {
+    proxyWormImports: forceExports
+  });
+  try {
+    const info = componentsModules.flatMap(name => {
+      const extension = (0, import_node_path.extname)(name);
+      const isLocal = Boolean(extension);
+      const isDynamic = isLocal && forceExports;
+      const fileContents = isDynamic ? (0, import_node_fs.readFileSync)(name, "utf-8") : "";
+      let loadModule = name;
+      let writtenContents = fileContents;
+      let didBabel = false;
+      function attemptLoad({
+        forceExports: forceExports2 = false
+      } = {}) {
+        if (isDynamic) {
+          writtenContents = forceExports2 ? transformAddExports((0, import_babelParse.babelParse)(esbuildit(fileContents, "modern"), name)) : fileContents;
+          loadModule = getDynamicEvalOutfile(name, "cjs", writtenContents);
+          FS.ensureDirSync((0, import_node_path.dirname)(loadModule));
+          activeTempFiles.add(loadModule);
+          import_esbuild.default.buildSync({
+            ...esbuildOptions,
+            outfile: loadModule,
+            stdin: {
+              contents: writtenContents,
+              resolveDir: (0, import_node_path.dirname)(name),
+              sourcefile: name,
+              loader: getEsbuildStdinLoader(name)
+            },
+            alias: {
+              "react-native": resolvePackageEntry("@hanzogui/react-native-web-lite", "esm"),
+              "@hanzogui/react-native-web-lite": resolvePackageEntry("@hanzogui/react-native-web-lite", "esm"),
+              "@hanzogui/react-native-web-internals": resolvePackageEntry("@hanzogui/react-native-web-internals", "esm")
+            },
+            bundle: true,
+            packages: "external",
+            allowOverwrite: true,
+            sourcemap: false,
+            loader: import_bundle.esbuildLoaderConfig
+          });
+        }
+        if (process.env.DEBUG === "hanzogui") {
+          console.info(`loadModule`, loadModule, require.resolve(loadModule));
+        }
+        const moduleResult = require(loadModule);
+        if (!forceExports2) {
+          (0, import_registerRequire.setRequireResult)(name, moduleResult);
+        }
+        const nameToInfo = getComponentStaticConfigByName(name, interopDefaultExport(moduleResult));
+        return {
+          moduleName: name,
+          nameToInfo
+        };
+      }
+      const dispose = () => {
+        if (isDynamic) {
+          FS.removeSync(loadModule);
+          activeTempFiles.delete(loadModule);
+        }
+      };
+      try {
+        const res = attemptLoad({
+          forceExports: true
+        });
+        didBabel = true;
+        return res;
+      } catch (err) {
+        console.info("babel err", err, writtenContents);
+        writtenContents = fileContents;
+        if (process.env.DEBUG?.startsWith("hanzogui")) {
+          console.info(`Error parsing babel likely`, err);
+        }
+      } finally {
+        dispose();
+      }
+      try {
+        return attemptLoad({
+          forceExports: false
+        });
+      } catch (err) {
+        if (process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD) {
+          console.info(`
+Hanzogui attempted but failed to dynamically optimize components in:
+  ${name}
+`);
+          console.info(err);
+          console.info(`At: ${loadModule}`, `
+didBabel: ${didBabel}`, `
+In:`, writtenContents, `
+isDynamic: `, isDynamic);
+        }
+        return [];
+      } finally {
+        dispose();
+      }
+    });
+    cacheComponents[key] = info;
+    return info;
+  } catch (err) {
+    console.info(`Hanzogui error bundling components`, err.message, err.stack);
+    return null;
+  } finally {
+    unregister();
+  }
+}
+const esbuildit = (src, target) => {
+  return import_esbuild.default.transformSync(src, {
+    ...esbuildTransformOptions,
+    ...(target === "modern" && {
+      target: "es2022",
+      jsx: "automatic",
+      loader: "tsx",
+      platform: "neutral",
+      format: "esm"
+    })
+  }).code;
+};
+function getComponentStaticConfigByName(name, exported) {
+  const components = {};
+  try {
+    if (!exported || typeof exported !== "object" || Array.isArray(exported)) {
+      throw new Error(`Invalid export from package ${name}: ${typeof exported}`);
+    }
+    for (const key in exported) {
+      const found = getHanzoguiComponent(key, exported[key]);
+      if (found) {
+        const {
+          Component,
+          ...sc
+        } = found.staticConfig;
+        components[key] = {
+          staticConfig: sc
+        };
+      }
+    }
+  } catch (err) {
+    if (process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD) {
+      console.error(`Hanzogui failed getting components from ${name} (Disable error by setting environment variable TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD=1)`);
+      console.error(err);
+    }
+  }
+  return components;
+}
+function getHanzoguiComponent(name, Component) {
+  if (name[0].toUpperCase() !== name[0]) {
+    return;
+  }
+  const staticConfig = Component?.staticConfig;
+  if (staticConfig) {
+    return Component;
+  }
+}
+function interopDefaultExport(mod) {
+  return mod?.default ?? mod;
+}
+const cacheComponents = {};
+function transformAddExports(ast) {
+  const usedNames = /* @__PURE__ */new Set();
+  (0, import_traverse.default)(ast, {
+    ExportNamedDeclaration(nodePath) {
+      if (nodePath.node.specifiers) {
+        for (const spec of nodePath.node.specifiers) {
+          usedNames.add(t.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value);
+        }
+      }
+    }
+  });
+  (0, import_traverse.default)(ast, {
+    VariableDeclaration(nodePath) {
+      if (!t.isProgram(nodePath.parent)) return;
+      const decs = nodePath.node.declarations;
+      if (decs.length > 1) return;
+      const [dec] = decs;
+      if (!t.isIdentifier(dec.id)) return;
+      if (!dec.init) return;
+      if (usedNames.has(dec.id.name)) return;
+      usedNames.add(dec.id.name);
+      nodePath.replaceWith(t.exportNamedDeclaration(t.variableDeclaration("let", [dec]), [t.exportSpecifier(t.identifier(dec.id.name), t.identifier(dec.id.name))]));
+    }
+  });
+  return (0, import_generator.default)(ast, {
+    concise: false,
+    filename: "test.tsx",
+    retainLines: false,
+    sourceMaps: false
+  }).code;
+}