@hanzogui/static 8.3.1 → 8.3.2

package/dist/extractor/bundleConfig.cjs

@@ -1,729 +0,0 @@
-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,
-  writeGuiCSS: () => writeGuiCSS
-});
-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_getGuiConfigPathFromOptionsConfig = require("./getGuiConfigPathFromOptionsConfig.cjs");
-var import_hasTopLevelAwait = require("./hasTopLevelAwait.cjs");
-var import_requireGuiCore = require("../helpers/requireGuiCore.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 currentBundleKey = "";
-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;
-function getBundleKey(props) {
-  return JSON.stringify({
-    components: props.components,
-    config: props.config,
-    platform: props.platform
-  });
-}
-async function getBundledConfig(props, rebuild = false) {
-  const bundleKey = getBundleKey(props);
-  if (isBundling) {
-    await new Promise(res => {
-      waitForBundle.add(res);
-    });
-  }
-  if (!currentBundle || currentBundleKey !== bundleKey || rebuild) {
-    return await bundleConfig(props);
-  }
-  return currentBundle;
-}
-global.hanzoguiLastLoaded ||= 0;
-function updateLastLoaded(config, bundleKey) {
-  global.hanzoguiLastLoaded = Date.now();
-  global.hanzoguiLastBundledConfig = config;
-  global.hanzoguiLastBundledConfigKey = bundleKey;
-}
-let hasBundledOnce = false;
-let hasLoggedBuild = false;
-async function bundleConfig(props) {
-  const bundleKey = getBundleKey(props);
-  if (global.hanzoguiLastBundledConfig && global.hanzoguiLastBundledConfigKey === bundleKey && Date.now() - global.hanzoguiLastLoaded < 3e3) {
-    return global.hanzoguiLastBundledConfig;
-  }
-  try {
-    isBundling = true;
-    const configEntry = props.config ? (0, import_getGuiConfigPathFromOptionsConfig.getGuiConfigPathFromOptionsConfig)(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.esbundleGuiConfig)({
-        entryPoints: [configEntry],
-        external,
-        outfile: configOutPath,
-        target: "node24",
-        format: configFormat,
-        ...esbuildExtraOptions
-      }, props.platform || "web") : null, ...baseComponents.map((componentModule, i) => {
-        return (0, import_bundle.esbundleGuiConfig)({
-          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 {
-        createGui
-      } = (0, import_requireGuiCore.requireGuiCore)(props.platform || "web");
-      config = createGui(config);
-    }
-    if (props.outputCSS) {
-      await writeGuiCSS(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_GUI_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;
-    currentBundleKey = bundleKey;
-    updateLastLoaded(res, bundleKey);
-    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 writeGuiCSS(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.GUI_ENABLE_WARN_DYNAMIC_LOAD) {
-            console.info(`
-Gui 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(`Gui 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.GUI_ENABLE_WARN_DYNAMIC_LOAD) {
-          console.info(`
-Gui 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(`Gui 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 = getGuiComponent(key, exported[key]);
-      if (found) {
-        const {
-          Component,
-          ...sc
-        } = found.staticConfig;
-        components[key] = {
-          staticConfig: sc
-        };
-      }
-    }
-  } catch (err) {
-    if (process.env.GUI_ENABLE_WARN_DYNAMIC_LOAD) {
-      console.error(`Gui failed getting components from ${name} (Disable error by setting environment variable GUI_ENABLE_WARN_DYNAMIC_LOAD=1)`);
-      console.error(err);
-    }
-  }
-  return components;
-}
-function getGuiComponent(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;
-}