@hanzogui/static 3.0.6 → 4.4.0

package/dist/extractor/bundleConfig.cjs

@@ -2,33 +2,35 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf,
-  __hasOwnProp = Object.prototype.hasOwnProperty;
+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: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  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;
-  };
+  }
+  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: !0
-  }) : target, mod)),
-  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-    value: !0
-  }), mod);
+// 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,
@@ -44,143 +46,203 @@ __export(bundleConfig_exports, {
   writeGuiCSS: () => writeGuiCSS
 });
 module.exports = __toCommonJS(bundleConfig_exports);
-var import_generator = __toESM(require("@babel/generator")),
-  import_traverse = __toESM(require("@babel/traverse")),
-  t = __toESM(require("@babel/types")),
-  import_node_crypto = require("node:crypto"),
-  import_node_fs = require("node:fs"),
-  import_node_path = require("node:path"),
-  import_node_url = require("node:url"),
-  import_cli_color = require("@hanzogui/cli-color"),
-  import_esbuild = __toESM(require("esbuild")),
-  FS = __toESM(require("fs-extra")),
-  import_promises = require("node:fs/promises"),
-  import_registerRequire = require("../registerRequire.cjs"),
-  import_babelParse = require("./babelParse.cjs"),
-  import_bundle = require("./bundle.cjs"),
-  import_getGuiConfigPathFromOptionsConfig = require("./getGuiConfigPathFromOptionsConfig.cjs"),
-  import_requireGuiCore = require("../helpers/requireGuiCore.cjs"),
-  import_detectModuleFormat = require("./detectModuleFormat.cjs");
+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",
-    hash = (0, import_node_crypto.createHash)("sha1").update(name).update("\0").update(format).update("\0").update(contents).digest("hex").slice(0, 10);
+  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(), ".gui", `dynamic-eval-${hash}-${(0, import_node_path.basename)(name)}.${ext}`);
 }
 function getEsbuildStdinLoader(filePath) {
-  return filePath.endsWith(".tsx") ? "tsx" : filePath.endsWith(".ts") ? "ts" : filePath.endsWith(".jsx") ? "jsx" : "js";
+  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`),
-    packageJson = JSON.parse((0, import_node_fs.readFileSync)(packageJsonPath, "utf-8")),
-    packageRoot = (0, import_node_path.dirname)(packageJsonPath),
-    exportEntry = packageJson.exports?.["."],
-    esmEntry = exportEntry?.import || exportEntry?.module || exportEntry?.browser || packageJson.module;
-  return typeof esmEntry == "string" ? (0, import_node_path.join)(packageRoot, esmEntry) : require.resolve(packageName);
+  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 {}
+  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();
+  cleanupTempFiles();
+  process.exit();
 });
 process.on("SIGTERM", () => {
-  cleanupTempFiles(), process.exit();
+  cleanupTempFiles();
+  process.exit();
 });
-const external = ["@hanzogui/core", "@hanzogui/web", "react", "react-dom", "react-native-svg"],
-  esbuildExtraOptions = {
-    define: {
-      __DEV__: `${process.env.NODE_ENV === "development"}`
-    }
-  },
-  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 || args.path.includes("node_modules") && !args.path.includes("@gui")) return null;
-        let contents = (0, import_node_fs.readFileSync)(args.path, "utf8"),
-          modified = !1;
-        return contents.includes("import.meta.env") && (contents = contents.replace(/import\.meta\.env/g, "process.env"), modified = !0), contents.includes("import.meta.url") && (contents = contents.replace(/import\.meta\.url/g, '""'), modified = !0), contents.includes("import.meta.main") && (contents = contents.replace(/import\.meta\.main/g, "false"), modified = !0), /^\s*(?:const|let|var|export)\s+[^=]*=\s*await\b/m.test(contents) || /^await\s/m.test(contents) ? (process.env.DEBUG?.startsWith("@hanzo/gui") && console.info(`[hanzo-gui] stubbing file with top-level await: ${args.path}`), {
+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("@gui")) {
+        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("@hanzo/gui")) {
+          console.info(`[hanzo-gui] 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
-module.exports = {}`,
+export default {}`,
           loader: "js"
-        }) : modified ? {
+        };
+      }
+      if (modified) {
+        return {
           contents,
           loader: args.path.endsWith(".tsx") ? "tsx" : args.path.endsWith(".ts") ? "ts" : args.path.endsWith(".jsx") ? "jsx" : "js"
-        } : null;
-      });
-    }
-  },
-  esbuildTransformOptions = {
-    target: "es2022",
-    format: "cjs",
-    jsx: "automatic",
-    platform: "node",
-    ...esbuildExtraOptions
-  },
-  esbuildOptions = {
-    ...esbuildTransformOptions
-  },
-  esbuildOptionsWithPlugins = {
-    ...esbuildTransformOptions,
-    plugins: [handleEsmFeaturesPlugin]
-  };
-let currentBundle = null,
-  isBundling = !1,
-  lastBundle = null;
+        };
+      }
+      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() {
-  return lastBundle === currentBundle ? !1 : (lastBundle = currentBundle, !0);
+  if (lastBundle === currentBundle) {
+    return false;
+  }
+  lastBundle = currentBundle;
+  return true;
 }
 let loadedConfig = null;
 const getLoadedConfig = () => loadedConfig;
-async function getBundledConfig(props, rebuild = !1) {
-  if (isBundling) await new Promise(res => {
-    waitForBundle.add(res);
-  });else if (!currentBundle || rebuild) return await bundleConfig(props);
+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.guiLastLoaded ||= 0;
 function updateLastLoaded(config) {
-  global.guiLastLoaded = Date.now(), global.guiLastBundledConfig = config;
+  global.guiLastLoaded = Date.now();
+  global.guiLastBundledConfig = config;
 }
-let hasBundledOnce = !1,
-  hasLoggedBuild = !1;
+let hasBundledOnce = false;
+let hasLoggedBuild = false;
 async function bundleConfig(props) {
-  if (global.guiLastBundledConfig && Date.now() - global.guiLastLoaded < 3e3) return global.guiLastBundledConfig;
+  if (global.guiLastBundledConfig && Date.now() - global.guiLastLoaded < 3e3) {
+    return global.guiLastBundledConfig;
+  }
   try {
-    isBundling = !0;
-    const configEntry = props.config ? (0, import_getGuiConfigPathFromOptionsConfig.getGuiConfigPathFromOptionsConfig)(props.config) : "",
-      tmpDir = (0, import_node_path.join)(process.cwd(), ".gui"),
-      configFormat = configEntry ? (0, import_detectModuleFormat.detectModuleFormat)(configEntry) : "cjs",
-      configOutPath = (0, import_node_path.join)(tmpDir, `gui.config${configFormat === "esm" ? ".mjs" : ".cjs"}`),
-      baseComponents = (props.components || []).filter(x => x !== "@hanzogui/core"),
-      componentFormats = baseComponents.map(mod => {
-        try {
-          const pkgJson = require.resolve(mod + "/package.json");
-          return JSON.parse((0, import_node_fs.readFileSync)(pkgJson, "utf-8")).type === "module" ? "esm" : "cjs";
-        } catch {
-          return "cjs";
-        }
-      }),
-      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}`);
-      });
-    process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("@hanzo/gui") && console.info("Building config entry", configEntry);
+    isBundling = true;
+    const configEntry = props.config ? (0, import_getGuiConfigPathFromOptionsConfig.getGuiConfigPathFromOptionsConfig)(props.config) : "";
+    const tmpDir = (0, import_node_path.join)(process.cwd(), ".gui");
+    const configFormat = configEntry ? (0, import_detectModuleFormat.detectModuleFormat)(configEntry) : "cjs";
+    const configExt = configFormat === "esm" ? ".mjs" : ".cjs";
+    const configOutPath = (0, import_node_path.join)(tmpDir, `gui.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("@hanzo/gui")) {
+      console.info(`Building config entry`, configEntry);
+    }
     let shouldBuild = !props.disableInitialBuild;
     if (shouldBuild && props.config) {
       const allOutFiles = [configOutPath, ...componentOutPaths];
       try {
-        (await Promise.all(allOutFiles.map(f => FS.stat(f).catch(() => null)))).every(s => s !== null && Date.now() - s.mtimeMs < 3e3) && (shouldBuild = !1);
+        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) {
@@ -195,80 +257,129 @@ async function bundleConfig(props) {
         target: "node24",
         format: configFormat,
         ...esbuildExtraOptions
-      }, props.platform || "web") : null, ...baseComponents.map((componentModule, i) => (0, import_bundle.esbundleGuiConfig)({
-        entryPoints: [componentModule],
-        resolvePlatformSpecificEntries: !0,
-        external,
-        outfile: componentOutPaths[i],
-        target: "node24",
-        format: componentFormats[i],
-        ...esbuildExtraOptions
-      }, props.platform || "web"))]), !hasLoggedBuild && !props._skipBuildLog && (hasLoggedBuild = !0, (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `
-  \u27A1 [hanzo-gui] built config, components, prompt (${Date.now() - start}ms)`), process.env.DEBUG?.startsWith("@hanzo/gui") && (0, import_cli_color.colorLog)(import_cli_color.Color.Dim, `
+      }, 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 [hanzo-gui] built config, components, prompt (${Date.now() - start}ms)`);
+        if (process.env.DEBUG?.startsWith("@hanzo/gui")) {
+          (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(`
-             `)}
-          `));
+          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 = !0;
+      for (const p of componentOutPaths) {
+        try {
+          delete require.cache[require.resolve(p)];
+        } catch {}
+      }
+    } else {
+      hasBundledOnce = true;
+    }
     let out;
-    configFormat === "esm" ? out = await import((0, import_node_url.pathToFileURL)(configOutPath).href) : out = require(configOutPath);
+    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), !config) throw new Error(`No config: ${config}`);
-    if (config._isProxyWorm) throw new Error("Got a proxied config - likely a module loading error. Set DEBUG=hanzo-gui for details.");
-    if (loadedConfig = config, !config.parsed) {
+    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=hanzo-gui for details.`);
+    }
+    loadedConfig = config;
+    if (!config.parsed) {
       const {
         createGui
       } = (0, import_requireGuiCore.requireGuiCore)(props.platform || "web");
       config = createGui(config);
     }
-    props.outputCSS && (await writeGuiCSS(props.outputCSS, 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, component.moduleName || (process.env.DEBUG?.includes("@hanzo/gui") || process.env.IS_HANZO_GUI_DEV) && console.warn(`\u26A0\uFE0F no module name found: ${component.moduleName} ${JSON.stringify(baseComponents)} in ${JSON.stringify(componentOutPaths)}`);
-    process.env.NODE_ENV === "development" && process.env.DEBUG?.startsWith("@hanzo/gui") && console.info("Loaded components", components);
+    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("@hanzo/gui") || 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("@hanzo/gui")) {
+      console.info("Loaded components", components);
+    }
     const res = {
       components,
       nameToPaths: {},
       guiConfig: config
     };
-    return currentBundle = res, updateLastLoaded(res), res;
+    currentBundle = res;
+    updateLastLoaded(res);
+    return res;
   } catch (err) {
-    console.error(`Error bundling gui config: ${err?.message} (run with DEBUG=hanzo-gui to see stack)`), process.env.DEBUG?.includes("@hanzo/gui") && console.error(err.stack);
+    console.error(`Error bundling gui config: ${err?.message} (run with DEBUG=hanzo-gui to see stack)`);
+    if (process.env.DEBUG?.includes("@hanzo/gui")) {
+      console.error(err.stack);
+    }
   } finally {
-    isBundling = !1, waitForBundle.forEach(cb => cb()), waitForBundle.clear();
+    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 [hanzo-gui] output css: ${outputCSS}`), await FS.writeFile(outputCSS, css);
-    },
-    css = config.getCSS();
-  if (typeof css != "string") throw new Error(`Invalid CSS: ${typeof css} ${css}`);
+    (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `  \u27A1 [hanzo-gui] 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 {
-    (0, import_node_fs.existsSync)(outputCSS) && (await (0, import_promises.readFile)(outputCSS, "utf8")) === css || (await flush());
+    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 = !1) {
-  const coreComponents = getCoreComponentsSync(props),
-    otherComponents = await loadComponentsInner(props, forceExports);
+async function loadComponents(props, forceExports = false) {
+  const coreComponents = getCoreComponentsSync(props);
+  const otherComponents = await loadComponentsInner(props, forceExports);
   return [...coreComponents, ...(otherComponents || [])];
 }
-function loadComponentsSync(props, forceExports = !1) {
-  const coreComponents = getCoreComponentsSync(props),
-    otherComponents = loadComponentsInnerSync(props, forceExports);
+function loadComponentsSync(props, forceExports = false) {
+  const coreComponents = getCoreComponentsSync(props);
+  const otherComponents = loadComponentsInnerSync(props, forceExports);
   return [...coreComponents, ...(otherComponents || [])];
 }
 function getCoreComponentsSync(props) {
@@ -276,16 +387,20 @@ function getCoreComponentsSync(props) {
     ...props,
     components: ["@hanzogui/core"]
   });
-  if (!loaded) throw new Error("Core should always load");
+  if (!loaded) {
+    throw new Error(`Core should always load`);
+  }
   return [{
     ...loaded[0],
     moduleName: "@hanzogui/core"
   }];
 }
-async function loadComponentsInner(props, forceExports = !1) {
-  const componentsModules = props.components || [],
-    key = componentsModules.join("\0");
-  if (!forceExports && cacheComponents[key]) return cacheComponents[key];
+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", {
@@ -294,17 +409,23 @@ async function loadComponentsInner(props, forceExports = !1) {
   try {
     const results = [];
     for (const name of componentsModules) {
-      const isLocal = !!(0, import_node_path.extname)(name),
-        isDynamic = isLocal && forceExports,
-        format = isLocal ? (0, import_detectModuleFormat.detectModuleFormat)(name) : "cjs",
-        fileContents = isDynamic ? (0, import_node_fs.readFileSync)(name, "utf-8") : "";
-      let loadModule = name,
-        writtenContents = fileContents,
-        didBabel = !1;
+      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 = !1
-        } = {}) => {
-          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({
+        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,
@@ -319,59 +440,91 @@ async function loadComponentsInner(props, forceExports = !1) {
               "@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: !0,
+            bundle: true,
             packages: "external",
-            allowOverwrite: !0,
-            sourcemap: !1,
+            allowOverwrite: true,
+            sourcemap: false,
             loader: import_bundle.esbuildLoaderConfig
-          })), process.env.DEBUG === "@hanzo/gui" && console.info("loadModule", loadModule, format);
-          let moduleResult;
-          format === "esm" ? moduleResult = await import((0, import_node_url.pathToFileURL)(loadModule).href) : moduleResult = require(loadModule), forceExports2 || (0, import_registerRequire.setRequireResult)(name, moduleResult);
-          const nameToInfo = getComponentStaticConfigByName(name, interopDefaultExport(moduleResult));
-          return {
-            moduleName: name,
-            nameToInfo
-          };
-        },
-        dispose = () => {
-          isDynamic && (FS.removeSync(loadModule), activeTempFiles.delete(loadModule));
+          });
+        }
+        if (process.env.DEBUG === "@hanzo/gui") {
+          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: !0
-        }), didBabel = !0;
+          forceExports: true
+        });
+        didBabel = true;
       } catch (err) {
-        console.info("babel err", err, writtenContents), writtenContents = fileContents, process.env.DEBUG?.startsWith("@hanzo/gui") && console.info("Error parsing babel likely", err);
+        console.info("babel err", err, writtenContents);
+        writtenContents = fileContents;
+        if (process.env.DEBUG?.startsWith("@hanzo/gui")) {
+          console.info(`Error parsing babel likely`, err);
+        }
         try {
           loaded = await attemptLoad({
-            forceExports: !1
+            forceExports: false
           });
         } catch (err2) {
-          process.env.HANZO_GUI_ENABLE_WARN_DYNAMIC_LOAD && (console.info(`
+          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}`, `
+`);
+            console.info(err2);
+            console.info(`At: ${loadModule}`, `
 didBabel: ${didBabel}`, `
 In:`, writtenContents, `
-isDynamic: `, isDynamic)), loaded = [];
+isDynamic: `, isDynamic);
+          }
+          loaded = [];
         }
       } finally {
         dispose();
       }
-      Array.isArray(loaded) ? results.push(...loaded) : loaded && results.push(loaded);
+      if (Array.isArray(loaded)) {
+        results.push(...loaded);
+      } else if (loaded) {
+        results.push(loaded);
+      }
     }
-    return cacheComponents[key] = results, results;
+    cacheComponents[key] = results;
+    return results;
   } catch (err) {
-    return console.info("Gui error bundling components", err.message, err.stack), null;
+    console.info(`Gui error bundling components`, err.message, err.stack);
+    return null;
   } finally {
     unregister();
   }
 }
-function loadComponentsInnerSync(props, forceExports = !1) {
-  const componentsModules = props.components || [],
-    key = componentsModules.join("\0");
-  if (!forceExports && cacheComponents[key]) return cacheComponents[key];
+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", {
@@ -379,36 +532,49 @@ function loadComponentsInnerSync(props, forceExports = !1) {
   });
   try {
     const info = componentsModules.flatMap(name => {
-      const isDynamic = !!(0, import_node_path.extname)(name) && forceExports,
-        fileContents = isDynamic ? (0, import_node_fs.readFileSync)(name, "utf-8") : "";
-      let loadModule = name,
-        writtenContents = fileContents,
-        didBabel = !1;
+      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 = !1
+        forceExports: forceExports2 = false
       } = {}) {
-        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: !0,
-          packages: "external",
-          allowOverwrite: !0,
-          sourcemap: !1,
-          loader: import_bundle.esbuildLoaderConfig
-        })), process.env.DEBUG === "@hanzo/gui" && console.info("loadModule", loadModule, require.resolve(loadModule));
+        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 === "@hanzo/gui") {
+          console.info(`loadModule`, loadModule, require.resolve(loadModule));
+        }
         const moduleResult = require(loadModule);
-        forceExports2 || (0, import_registerRequire.setRequireResult)(name, moduleResult);
+        if (!forceExports2) {
+          (0, import_registerRequire.setRequireResult)(name, moduleResult);
+        }
         const nameToInfo = getComponentStaticConfigByName(name, interopDefaultExport(moduleResult));
         return {
           moduleName: name,
@@ -416,55 +582,74 @@ function loadComponentsInnerSync(props, forceExports = !1) {
         };
       }
       const dispose = () => {
-        isDynamic && (FS.removeSync(loadModule), activeTempFiles.delete(loadModule));
+        if (isDynamic) {
+          FS.removeSync(loadModule);
+          activeTempFiles.delete(loadModule);
+        }
       };
       try {
         const res = attemptLoad({
-          forceExports: !0
+          forceExports: true
         });
-        return didBabel = !0, res;
+        didBabel = true;
+        return res;
       } catch (err) {
-        console.info("babel err", err, writtenContents), writtenContents = fileContents, process.env.DEBUG?.startsWith("@hanzo/gui") && console.info("Error parsing babel likely", err);
+        console.info("babel err", err, writtenContents);
+        writtenContents = fileContents;
+        if (process.env.DEBUG?.startsWith("@hanzo/gui")) {
+          console.info(`Error parsing babel likely`, err);
+        }
       } finally {
         dispose();
       }
       try {
         return attemptLoad({
-          forceExports: !1
+          forceExports: false
         });
       } catch (err) {
-        return process.env.HANZO_GUI_ENABLE_WARN_DYNAMIC_LOAD && (console.info(`
+        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}`, `
+`);
+          console.info(err);
+          console.info(`At: ${loadModule}`, `
 didBabel: ${didBabel}`, `
 In:`, writtenContents, `
-isDynamic: `, isDynamic)), [];
+isDynamic: `, isDynamic);
+        }
+        return [];
       } finally {
         dispose();
       }
     });
-    return cacheComponents[key] = info, info;
+    cacheComponents[key] = info;
+    return info;
   } catch (err) {
-    return console.info("Gui error bundling components", err.message, err.stack), null;
+    console.info(`Gui error bundling components`, err.message, err.stack);
+    return null;
   } finally {
     unregister();
   }
 }
-const esbuildit = (src, target) => import_esbuild.default.transformSync(src, {
-  ...esbuildTransformOptions,
-  ...(target === "modern" && {
-    target: "es2022",
-    jsx: "automatic",
-    loader: "tsx",
-    platform: "neutral",
-    format: "esm"
-  })
-}).code;
+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}`);
+    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) {
@@ -478,13 +663,21 @@ function getComponentStaticConfigByName(name, exported) {
       }
     }
   } catch (err) {
-    process.env.HANZO_GUI_ENABLE_WARN_DYNAMIC_LOAD && (console.error(`Gui failed getting components from ${name} (Disable error by setting environment variable HANZO_GUI_ENABLE_WARN_DYNAMIC_LOAD=1)`), console.error(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;
-  if (Component?.staticConfig) return Component;
+  if (name[0].toUpperCase() !== name[0]) {
+    return;
+  }
+  const staticConfig = Component?.staticConfig;
+  if (staticConfig) {
+    return Component;
+  }
 }
 function interopDefaultExport(mod) {
   return mod?.default ?? mod;
@@ -492,22 +685,32 @@ function interopDefaultExport(mod) {
 const cacheComponents = {};
 function transformAddExports(ast) {
   const usedNames = /* @__PURE__ */new Set();
-  return (0, import_traverse.default)(ast, {
+  (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);
+      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, {
+  });
+  (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;
-      t.isIdentifier(dec.id) && dec.init && (usedNames.has(dec.id.name) || (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))]))));
+      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))]));
     }
-  }), (0, import_generator.default)(ast, {
-    concise: !1,
+  });
+  return (0, import_generator.default)(ast, {
+    concise: false,
     filename: "test.tsx",
-    retainLines: !1,
-    sourceMaps: !1
+    retainLines: false,
+    sourceMaps: false
   }).code;
 }