@hanzogui/static 2.0.0

package/dist/extractor/loadGui.cjs

@@ -0,0 +1,322 @@
+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 __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, {
+      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: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var loadGui_exports = {};
+__export(loadGui_exports, {
+  esbuildWatchFiles: () => esbuildWatchFiles,
+  generateThemesAndLog: () => generateThemesAndLog,
+  getOptions: () => getOptions,
+  loadGui: () => loadGui,
+  loadGuiBuildConfigAsync: () => loadGuiBuildConfigAsync,
+  loadGuiBuildConfigSync: () => loadGuiBuildConfigSync,
+  loadGuiSync: () => loadGuiSync,
+  resolveWebOrNativeSpecificEntry: () => resolveWebOrNativeSpecificEntry
+});
+module.exports = __toCommonJS(loadGui_exports);
+var import_node_path = require("node:path"),
+  import_cli_color = require("@hanzogui/cli-color"),
+  import_esbuild = __toESM(require("esbuild")),
+  esbuildWasm = __toESM(require("esbuild-wasm")),
+  fsExtra = __toESM(require("fs-extra")),
+  import_constants = require("../constants.cjs"),
+  import_requireGuiCore = require("../helpers/requireGuiCore.cjs"),
+  import_registerRequire = require("../registerRequire.cjs"),
+  import_bundleConfig = require("./bundleConfig.cjs"),
+  import_getGuiConfigPathFromOptionsConfig = require("./getGuiConfigPathFromOptionsConfig.cjs"),
+  import_regenerateConfig = require("./regenerateConfig.cjs");
+const getFilledOptions = propsIn => ({
+  // defaults
+  platform: "web",
+  config: "gui.config.ts",
+  components: ["@hanzo/gui"],
+  ...propsIn
+});
+let isLoadingPromise;
+async function loadGui(propsIn) {
+  if (isLoadingPromise) return await isLoadingPromise;
+  let resolvePromise, rejectPromise;
+  isLoadingPromise = new Promise((res, rej) => {
+    resolvePromise = res, rejectPromise = rej;
+  });
+  try {
+    const props = getFilledOptions(propsIn),
+      bundleInfo = await (0, import_bundleConfig.getBundledConfig)(props);
+    if (!bundleInfo) return console.warn("No bundled config generated, maybe an error in bundling. Set DEBUG=hanzo-gui and re-run to get logs."), resolvePromise(null), null;
+    await generateThemesAndLog(props);
+    const maybeGuiConfig = bundleInfo.guiConfig;
+    if (maybeGuiConfig && !maybeGuiConfig.parsed) {
+      const {
+        createGui
+      } = (0, import_requireGuiCore.requireGuiCore)(props.platform || "web");
+      bundleInfo.guiConfig = createGui(bundleInfo.guiConfig);
+    }
+    return (0, import_bundleConfig.hasBundledConfigChanged)() ? (await (0, import_regenerateConfig.regenerateConfig)(props, bundleInfo), resolvePromise(bundleInfo), bundleInfo) : (resolvePromise(bundleInfo), bundleInfo);
+  } catch (err) {
+    throw rejectPromise(), err;
+  } finally {
+    isLoadingPromise = null;
+  }
+}
+let waiting = !1;
+const generateThemesAndLog = async (options, force = !1) => {
+    if (!waiting && options.themeBuilder) try {
+      if (waiting = !0, await new Promise(res => setTimeout(res, 30)), (await (0, import_regenerateConfig.generateGuiThemes)(options, force)) && ((0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `  \u27A1 [hanzo-gui] generated themes: ${(0, import_node_path.relative)(process.cwd(), options.themeBuilder.output)}`), options.outputCSS)) {
+        const loadedConfig = (0, import_bundleConfig.getLoadedConfig)();
+        loadedConfig && (await (0, import_bundleConfig.writeGuiCSS)(options.outputCSS, loadedConfig));
+      }
+    } finally {
+      waiting = !1;
+    }
+  },
+  last = {},
+  lastVersion = {};
+let esbuildWasmInitialized = !1;
+async function loadGuiBuildConfigAsync(guiOptions) {
+  const buildFilePath = guiOptions?.buildFile ?? "./gui.build.ts",
+    absolutePath = buildFilePath[0] === "." ? (0, import_node_path.join)(process.cwd(), buildFilePath) : buildFilePath;
+  if (fsExtra.existsSync(absolutePath)) try {
+    const source = await fsExtra.readFile(absolutePath, "utf-8");
+    esbuildWasmInitialized || (await esbuildWasm.initialize({}), esbuildWasmInitialized = !0);
+    const result = await esbuildWasm.transform(source, {
+        loader: "ts",
+        format: "cjs",
+        target: "node18",
+        sourcefile: absolutePath
+      }),
+      module2 = {
+        exports: {}
+      };
+    new Function("module", "exports", "require", "process", result.code)(module2, module2.exports, require, process);
+    const out = module2.exports.default || module2.exports;
+    if (!out || typeof out != "object") throw new Error(`No default export found in ${buildFilePath}: ${out}`);
+    guiOptions = {
+      ...guiOptions,
+      ...out
+    };
+  } catch (err) {
+    throw console.error(`[hanzo-gui] Error loading ${buildFilePath}:`, err), err;
+  }
+  if (!guiOptions) throw new Error("No hanzo-gui build options found either via input props or at gui.build.ts");
+  return {
+    config: "gui.config.ts",
+    components: ["@hanzo/gui", "@hanzogui/core"],
+    ...guiOptions
+  };
+}
+function loadGuiBuildConfigSync(guiOptions) {
+  const buildFilePath = guiOptions?.buildFile ?? "./gui.build.ts";
+  if (fsExtra.existsSync(buildFilePath)) {
+    const registered = (0, import_registerRequire.registerRequire)("web");
+    try {
+      const out = (buildFilePath[0] === "." ? require((0, import_node_path.join)(process.cwd(), buildFilePath)) : require(buildFilePath)).default;
+      if (!out) throw new Error(`No default export found in ${buildFilePath}: ${out}`);
+      guiOptions = {
+        ...guiOptions,
+        ...out
+      };
+    } finally {
+      registered.unregister();
+    }
+  }
+  if (!guiOptions) throw new Error("No hanzo-gui build options found either via input props or at gui.build.ts");
+  return {
+    config: "gui.config.ts",
+    components: ["@hanzo/gui", "@hanzogui/core"],
+    ...guiOptions
+  };
+}
+function loadGuiSync({
+  forceExports,
+  cacheKey,
+  ...propsIn
+}) {
+  const key = JSON.stringify(propsIn);
+  if (last[key] && !(0, import_bundleConfig.hasBundledConfigChanged)() && (!lastVersion[key] || lastVersion[key] === cacheKey)) return last[key];
+  lastVersion[key] = cacheKey || "";
+  const props = getFilledOptions(propsIn);
+  process.env.IS_STATIC = "is_static", process.env.HANZO_GUI_IS_SERVER = "true";
+  const {
+    unregister
+  } = (0, import_registerRequire.registerRequire)(props.platform || "web", {
+    proxyWormImports: !!forceExports
+  });
+  try {
+    const devValueOG = globalThis.__DEV__;
+    globalThis.__DEV__ = process.env.NODE_ENV === "development";
+    try {
+      let guiConfig = null;
+      if (propsIn.config) {
+        const configPath = (0, import_getGuiConfigPathFromOptionsConfig.getGuiConfigPathFromOptionsConfig)(propsIn.config),
+          exp = require(configPath);
+        if (!exp || exp._isProxyWorm) throw new Error("Got a empty / proxied config!");
+        if (guiConfig = exp.default || exp.config || exp, !guiConfig || !guiConfig.parsed) {
+          const confPath = require.resolve(configPath);
+          throw new Error(`Can't find valid config in ${confPath}:
+          
+  Be sure you "export default" or "export const config" the config.`);
+        }
+        if (guiConfig) {
+          const {
+            createGui
+          } = (0, import_requireGuiCore.requireGuiCore)(props.platform || "web");
+          createGui(guiConfig);
+        }
+      }
+      const components = (0, import_bundleConfig.loadComponentsSync)(props, forceExports);
+      if (!components) throw new Error("No components loaded");
+      process.env.DEBUG === "@hanzo/gui" && console.info("components", components), process.env.IS_STATIC = void 0, globalThis.__DEV__ = devValueOG;
+      const info = {
+        components,
+        guiConfig,
+        nameToPaths: (0, import_registerRequire.getNameToPaths)()
+      };
+      if (guiConfig) {
+        const {
+          outputCSS
+        } = props;
+        outputCSS && (0, import_bundleConfig.writeGuiCSS)(outputCSS, guiConfig), (0, import_regenerateConfig.regenerateConfigSync)(props, info);
+      }
+      return last[key] = {
+        ...info,
+        cached: !0
+      }, info;
+    } catch (err) {
+      return err instanceof Error ? !import_constants.SHOULD_DEBUG && !forceExports ? (console.warn("Error loading gui.config.ts (set DEBUG=hanzo-gui to see full stack), running hanzo-gui without custom config"), console.info(`
+
+    ${err.message}
+
+`)) : import_constants.SHOULD_DEBUG && console.error(err) : console.error("Error loading gui.config.ts", err), {
+        components: [],
+        guiConfig: null,
+        nameToPaths: {}
+      };
+    }
+  } finally {
+    unregister();
+  }
+}
+async function getOptions({
+  root = process.cwd(),
+  tsconfigPath = "tsconfig.json",
+  guiOptions,
+  host,
+  debug
+} = {}) {
+  const dotDir = (0, import_node_path.join)(root, ".gui");
+  let pkgJson = {};
+  try {
+    pkgJson = await fsExtra.readJSON((0, import_node_path.join)(root, "package.json"));
+  } catch {}
+  return {
+    mode: process.env.NODE_ENV === "production" ? "production" : "development",
+    root,
+    host: host || "127.0.0.1",
+    pkgJson,
+    debug,
+    tsconfigPath,
+    guiOptions: {
+      platform: "web",
+      components: ["@hanzo/gui"],
+      ...guiOptions,
+      config: guiOptions?.config ?? (await getDefaultGuiConfigPath(root, guiOptions?.config))
+    },
+    paths: {
+      root,
+      dotDir,
+      conf: (0, import_node_path.join)(dotDir, "gui.config.json"),
+      types: (0, import_node_path.join)(dotDir, "types.json")
+    }
+  };
+}
+function resolveWebOrNativeSpecificEntry(entry) {
+  const workspaceRoot = (0, import_node_path.resolve)(),
+    resolved = require.resolve(entry, {
+      paths: [workspaceRoot]
+    }),
+    ext = (0, import_node_path.extname)(resolved),
+    fileName = (0, import_node_path.basename)(resolved).replace(ext, ""),
+    specificFile = (0, import_node_path.join)((0, import_node_path.dirname)(resolved), fileName + "." + "web" + ext);
+  return fsExtra.existsSync(specificFile) ? specificFile : entry;
+}
+const defaultPaths = ["gui.config.ts", (0, import_node_path.join)("src", "gui.config.ts")];
+let hasWarnedOnce = !1;
+async function getDefaultGuiConfigPath(root, configPath) {
+  const searchPaths = [...new Set([configPath, ...defaultPaths].filter(Boolean).map(p => (0, import_node_path.join)(root, p)))];
+  for (const path of searchPaths) if (await fsExtra.pathExists(path)) return path;
+  hasWarnedOnce || (hasWarnedOnce = !0, console.warn(`Warning: couldn't find gui.config.ts in the following paths given configuration "${configPath}":
+    ${searchPaths.join(`
+  `)}
+  `));
+}
+async function esbuildWatchFiles(entry, onChanged) {
+  let hasRunOnce = !1;
+  const context = await import_esbuild.default.context({
+    bundle: !0,
+    entryPoints: [entry],
+    resolveExtensions: [".ts", ".tsx", ".js", ".mjs"],
+    logLevel: "silent",
+    write: !1,
+    alias: {
+      "@react-native/normalize-color": "@hanzogui/proxy-worm",
+      "react-native-web": "@hanzogui/react-native-web-lite",
+      "react-native": "@hanzogui/proxy-worm"
+    },
+    plugins: [
+    // to log what its watching:
+    // {
+    //   name: 'test',
+    //   setup({ onResolve }) {
+    //     onResolve({ filter: /.*/ }, (args) => {
+    //       console.log('wtf', args.path)
+    //     })
+    //   },
+    // },
+    {
+      name: "on-rebuild",
+      setup({
+        onEnd,
+        onResolve
+      }) {
+        onResolve({
+          filter: /^[^./]|^\.[^./]|^\.\.[^/]/
+        }, args => ({
+          path: args.path,
+          external: !0
+        })), onEnd(() => {
+          hasRunOnce ? onChanged() : hasRunOnce = !0;
+        });
+      }
+    }]
+  });
+  return context.watch(), () => {
+    context.dispose();
+  };
+}

package/dist/extractor/logLines.cjs

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !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, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var logLines_exports = {};
+__export(logLines_exports, {
+  logLines: () => logLines
+});
+module.exports = __toCommonJS(logLines_exports);
+const prefix = "           ",
+  logLines = (str, singleLine = !1) => {
+    if (singleLine) return prefix + str.split(" ").join(`
+${prefix}`);
+    const lines = [""],
+      items = str.split(" ");
+    for (const item of items) item.length + lines[lines.length - 1].length > 85 && lines.push(""), lines[lines.length - 1] += item + " ";
+    return lines.map((line, i) => prefix + (i == 0 ? "" : " ") + line.trim()).join(`
+`);
+  };

package/dist/extractor/normalizeTernaries.cjs

@@ -0,0 +1,73 @@
+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 __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, {
+      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: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var normalizeTernaries_exports = {};
+__export(normalizeTernaries_exports, {
+  normalizeTernaries: () => normalizeTernaries
+});
+module.exports = __toCommonJS(normalizeTernaries_exports);
+var import_generator = __toESM(require("@babel/generator")),
+  t = __toESM(require("@babel/types")),
+  import_web = require("@hanzogui/web"),
+  import_invariant = __toESM(require("invariant")),
+  import_propsToFontFamilyCache = require("./propsToFontFamilyCache.cjs");
+function normalizeTernaries(ternaries) {
+  if ((0, import_invariant.default)(Array.isArray(ternaries), "extractStaticTernaries expects param 1 to be an array of ternaries"), ternaries.length === 0) return [];
+  const ternariesByKey = {};
+  for (let idx = -1, len = ternaries.length; ++idx < len;) {
+    const {
+      test,
+      consequent,
+      alternate,
+      remove,
+      ...rest
+    } = ternaries[idx];
+    let ternaryTest = test;
+    t.isExpressionStatement(test) && (ternaryTest = test.expression);
+    let shouldSwap = !1;
+    t.isUnaryExpression(test) && test.operator === "!" ? (ternaryTest = test.argument, shouldSwap = !0) : t.isBinaryExpression(test) && (test.operator === "!==" || test.operator === "!=") && (ternaryTest = t.binaryExpression(test.operator.replace("!", "="), test.left, test.right), shouldSwap = !0);
+    const key = (0, import_generator.default)(ternaryTest).code;
+    ternariesByKey[key] || (ternariesByKey[key] = {
+      ...rest,
+      alternate: {},
+      consequent: {},
+      test: ternaryTest,
+      remove
+    });
+    const altStyle = (shouldSwap ? consequent : alternate) ?? {},
+      consStyle = (shouldSwap ? alternate : consequent) ?? {},
+      nextAlt = ternariesByKey[key].alternate;
+    ternariesByKey[key].alternate = (0, import_web.mergeProps)(altStyle, nextAlt), (0, import_propsToFontFamilyCache.forwardFontFamilyName)(altStyle, ternariesByKey[key].alternate);
+    const nextCons = ternariesByKey[key].consequent;
+    ternariesByKey[key].consequent = (0, import_web.mergeProps)(consStyle, nextCons), (0, import_propsToFontFamilyCache.forwardFontFamilyName)(consStyle, ternariesByKey[key].consequent);
+  }
+  return Object.keys(ternariesByKey).map(key => ternariesByKey[key]);
+}

package/dist/extractor/propsToFontFamilyCache.cjs

@@ -0,0 +1,38 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !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, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var propsToFontFamilyCache_exports = {};
+__export(propsToFontFamilyCache_exports, {
+  forwardFontFamilyName: () => forwardFontFamilyName,
+  getFontFamilyNameFromProps: () => getFontFamilyNameFromProps,
+  setPropsToFontFamily: () => setPropsToFontFamily
+});
+module.exports = __toCommonJS(propsToFontFamilyCache_exports);
+const cache = /* @__PURE__ */new WeakMap();
+function setPropsToFontFamily(props, ff) {
+  cache.set(props, ff.replace("$", "").trim());
+}
+function getFontFamilyNameFromProps(props) {
+  return cache.get(props);
+}
+function forwardFontFamilyName(prev, next, fallback) {
+  const ff = getFontFamilyNameFromProps(prev) || fallback;
+  ff && setPropsToFontFamily(next, ff);
+}

package/dist/extractor/regenerateConfig.cjs

@@ -0,0 +1,150 @@
+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 __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, {
+      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: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var regenerateConfig_exports = {};
+__export(regenerateConfig_exports, {
+  generateGuiThemes: () => generateGuiThemes,
+  regenerateConfig: () => regenerateConfig,
+  regenerateConfigSync: () => regenerateConfigSync
+});
+module.exports = __toCommonJS(regenerateConfig_exports);
+var import_node_path = require("node:path"),
+  import_generate_themes = require("@hanzogui/generate-themes"),
+  FS = __toESM(require("fs-extra")),
+  import_requireGuiCore = require("../helpers/requireGuiCore.cjs"),
+  import_bundleConfig = require("./bundleConfig.cjs");
+const guiDir = (0, import_node_path.join)(process.cwd(), ".gui"),
+  confFile = (0, import_node_path.join)(guiDir, "gui.config.json");
+async function regenerateConfig(guiOptions, configIn, rebuild = !1) {
+  try {
+    const config = configIn ?? (await (0, import_bundleConfig.getBundledConfig)(guiOptions, rebuild));
+    if (!config) return;
+    const out = transformConfig(config, guiOptions.platform || "web");
+    await FS.ensureDir((0, import_node_path.dirname)(confFile)), await FS.writeJSON(confFile, out, {
+      spaces: 2
+    });
+  } catch (err) {
+    (process.env.DEBUG?.includes("@hanzo/gui") || process.env.IS_HANZO_GUI_DEV) && console.warn("regenerateConfig error", err);
+  }
+}
+function regenerateConfigSync(_guiOptions, config) {
+  try {
+    FS.ensureDirSync((0, import_node_path.dirname)(confFile)), FS.writeJSONSync(confFile, transformConfig(config, _guiOptions.platform || "web"), {
+      spaces: 2
+    });
+  } catch (err) {
+    (process.env.DEBUG?.includes("@hanzo/gui") || process.env.IS_HANZO_GUI_DEV) && console.warn("regenerateConfig error", err);
+  }
+}
+async function generateGuiThemes(guiOptions, force = !1) {
+  if (!guiOptions.themeBuilder) return;
+  const {
+      input,
+      output
+    } = guiOptions.themeBuilder,
+    inPath = resolveRelativePath(input),
+    outPath = resolveRelativePath(output),
+    generatedOutput = await (0, import_generate_themes.generateThemes)(inPath),
+    hasChanged = force || (await (async () => {
+      try {
+        if (!generatedOutput) return !1;
+        const next = generatedOutput.generated,
+          current = await FS.readFile(outPath, "utf-8");
+        return next !== current;
+      } catch {}
+      return !0;
+    })());
+  return hasChanged && (await (0, import_generate_themes.writeGeneratedThemes)(guiDir, outPath, generatedOutput)), hasChanged;
+}
+const resolveRelativePath = inputPath => inputPath.startsWith(".") ? (0, import_node_path.join)(process.cwd(), inputPath) : require.resolve(inputPath);
+function cloneDeepSafe(x, excludeKeys = {}) {
+  return x && (Array.isArray(x) ? x.map(_ => cloneDeepSafe(_)) : typeof x == "function" ? "Function" : typeof x != "object" ? x : "$$typeof" in x ? "Component" : Object.fromEntries(Object.entries(x).flatMap(([k, v]) => excludeKeys[k] ? [] : [[k, cloneDeepSafe(v)]])));
+}
+function transformConfig(config, platform) {
+  if (!config) return null;
+  const {
+      getVariableValue
+    } = (0, import_requireGuiCore.requireGuiCore)(platform),
+    next = cloneDeepSafe(config, {
+      validStyles: !0
+    }),
+    {
+      components,
+      nameToPaths,
+      guiConfig
+    } = next,
+    {
+      themes,
+      tokens
+    } = guiConfig;
+  for (const key in themes) {
+    const theme = themes[key];
+    theme.id = key;
+    for (const tkey in theme) theme[tkey] = getVariableValue(theme[tkey]);
+  }
+  for (const key in tokens) {
+    const token = {
+      ...tokens[key]
+    };
+    for (const tkey in token) token[tkey] = getVariableValue(token[tkey]);
+  }
+  for (const component of components) for (const _ in component.nameToInfo) {
+    const compDefinition = {
+      ...component.nameToInfo[_]
+    };
+    component.nameToInfo[_] = compDefinition;
+    const {
+      parentStaticConfig,
+      ...rest
+    } = compDefinition.staticConfig;
+    compDefinition.staticConfig = rest;
+  }
+  next.nameToPaths = {};
+  for (const key in nameToPaths) next.nameToPaths[key] = [...nameToPaths[key]];
+  const {
+    fontsParsed,
+    getCSS,
+    tokensParsed,
+    themeConfig,
+    shorthands: _shorthands,
+    userShorthands,
+    ...cleanedConfig
+  } = next.guiConfig;
+  return {
+    components,
+    nameToPaths,
+    guiConfig: {
+      ...cleanedConfig,
+      // Output userShorthands as shorthands (excludes built-ins)
+      shorthands: userShorthands
+    }
+  };
+}