@hanzogui/static 4.3.1 → 7.0.0

package/dist/extractor/{loadGui.cjs → loadHanzogui.cjs}

@@ -31,38 +31,37 @@ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
   value: true
 }), mod);
-var loadGui_exports = {};
-__export(loadGui_exports, {
+var loadHanzogui_exports = {};
+__export(loadHanzogui_exports, {
   esbuildWatchFiles: () => esbuildWatchFiles,
   generateThemesAndLog: () => generateThemesAndLog,
   getOptions: () => getOptions,
-  loadGui: () => loadGui,
-  loadGuiBuildConfigAsync: () => loadGuiBuildConfigAsync,
-  loadGuiBuildConfigSync: () => loadGuiBuildConfigSync,
-  loadGuiSync: () => loadGuiSync,
+  loadHanzogui: () => loadHanzogui,
+  loadHanzoguiBuildConfigAsync: () => loadHanzoguiBuildConfigAsync,
+  loadHanzoguiBuildConfigSync: () => loadHanzoguiBuildConfigSync,
+  loadHanzoguiSync: () => loadHanzoguiSync,
   resolveWebOrNativeSpecificEntry: () => resolveWebOrNativeSpecificEntry
 });
-module.exports = __toCommonJS(loadGui_exports);
+module.exports = __toCommonJS(loadHanzogui_exports);
 var import_node_path = require("node:path");
 var import_cli_color = require("@hanzogui/cli-color");
 var import_esbuild = __toESM(require("esbuild"));
 var esbuildWasm = __toESM(require("esbuild-wasm"));
 var fsExtra = __toESM(require("fs-extra"));
 var import_constants = require("../constants.cjs");
-var import_requireGuiCore = require("../helpers/requireGuiCore.cjs");
+var import_requireHanzoguiCore = require("../helpers/requireHanzoguiCore.cjs");
 var import_registerRequire = require("../registerRequire.cjs");
 var import_bundleConfig = require("./bundleConfig.cjs");
-var import_getGuiConfigPathFromOptionsConfig = require("./getGuiConfigPathFromOptionsConfig.cjs");
+var import_getHanzoguiConfigPathFromOptionsConfig = require("./getHanzoguiConfigPathFromOptionsConfig.cjs");
 var import_regenerateConfig = require("./regenerateConfig.cjs");
 const getFilledOptions = propsIn => ({
-  // defaults
   platform: "web",
-  config: "gui.config.ts",
-  components: ["@hanzo/gui"],
+  config: "hanzogui.config.ts",
+  components: ["hanzogui"],
   ...propsIn
 });
 let isLoadingPromise;
-async function loadGui(propsIn) {
+async function loadHanzogui(propsIn) {
   if (isLoadingPromise) return await isLoadingPromise;
   let resolvePromise;
   let rejectPromise;
@@ -74,17 +73,17 @@ async function loadGui(propsIn) {
     const props = getFilledOptions(propsIn);
     const bundleInfo = await (0, import_bundleConfig.getBundledConfig)(props);
     if (!bundleInfo) {
-      console.warn(`No bundled config generated, maybe an error in bundling. Set DEBUG=hanzo-gui and re-run to get logs.`);
+      console.warn(`No bundled config generated, maybe an error in bundling. Set DEBUG=hanzogui and re-run to get logs.`);
       resolvePromise(null);
       return null;
     }
     await generateThemesAndLog(props);
-    const maybeGuiConfig = bundleInfo.guiConfig;
-    if (maybeGuiConfig && !maybeGuiConfig.parsed) {
+    const maybeHanzoguiConfig = bundleInfo.hanzoguiConfig;
+    if (maybeHanzoguiConfig && !maybeHanzoguiConfig.parsed) {
       const {
-        createGui
-      } = (0, import_requireGuiCore.requireGuiCore)(props.platform || "web");
-      bundleInfo.guiConfig = createGui(bundleInfo.guiConfig);
+        createHanzogui
+      } = (0, import_requireHanzoguiCore.requireHanzoguiCore)(props.platform || "web");
+      bundleInfo.hanzoguiConfig = createHanzogui(bundleInfo.hanzoguiConfig);
     }
     if (!(0, import_bundleConfig.hasBundledConfigChanged)()) {
       resolvePromise(bundleInfo);
@@ -107,15 +106,11 @@ const generateThemesAndLog = async (options, force = false) => {
   try {
     waiting = true;
     await new Promise(res => setTimeout(res, 30));
-    const didGenerate = await (0, import_regenerateConfig.generateGuiThemes)(options, force);
-    if (didGenerate) {
-      const whitespaceBefore = `  `;
-      (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `${whitespaceBefore}\u27A1 [hanzo-gui] generated themes: ${(0, import_node_path.relative)(process.cwd(), options.themeBuilder.output)}`);
+    if (await (0, import_regenerateConfig.generateHanzoguiThemes)(options, force)) {
+      (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `  \u27A1 [hanzogui] generated themes: ${(0, import_node_path.relative)(process.cwd(), options.themeBuilder.output)}`);
       if (options.outputCSS) {
         const loadedConfig = (0, import_bundleConfig.getLoadedConfig)();
-        if (loadedConfig) {
-          await (0, import_bundleConfig.writeGuiCSS)(options.outputCSS, loadedConfig);
-        }
+        if (loadedConfig) await (0, import_bundleConfig.writeHanzoguiCSS)(options.outputCSS, loadedConfig);
       }
     }
   } finally {
@@ -125,90 +120,77 @@ const generateThemesAndLog = async (options, force = false) => {
 const last = {};
 const lastVersion = {};
 let esbuildWasmInitialized = false;
-async function loadGuiBuildConfigAsync(guiOptions) {
-  const buildFilePath = guiOptions?.buildFile ?? "./gui.build.ts";
+async function loadHanzoguiBuildConfigAsync(hanzoguiOptions) {
+  const buildFilePath = hanzoguiOptions?.buildFile ?? "./hanzogui.build.ts";
   const 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");
-      if (!esbuildWasmInitialized) {
-        await esbuildWasm.initialize({});
-        esbuildWasmInitialized = true;
-      }
-      const result = await esbuildWasm.transform(source, {
-        loader: "ts",
-        format: "cjs",
-        target: "node18",
-        sourcefile: absolutePath
-      });
-      const module2 = {
-        exports: {}
-      };
-      const fn = new Function("module", "exports", "require", "process", result.code);
-      fn(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) {
-      console.error(`[hanzo-gui] Error loading ${buildFilePath}:`, err);
-      throw err;
+  if (fsExtra.existsSync(absolutePath)) try {
+    const source = await fsExtra.readFile(absolutePath, "utf-8");
+    if (!esbuildWasmInitialized) {
+      await esbuildWasm.initialize({});
+      esbuildWasmInitialized = true;
     }
+    const result = await esbuildWasm.transform(source, {
+      loader: "ts",
+      format: "cjs",
+      target: "node18",
+      sourcefile: absolutePath
+    });
+    const 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}`);
+    hanzoguiOptions = {
+      ...hanzoguiOptions,
+      ...out
+    };
+  } catch (err) {
+    console.error(`[hanzogui] Error loading ${buildFilePath}:`, err);
+    throw err;
   }
-  if (!guiOptions) {
-    throw new Error(`No hanzo-gui build options found either via input props or at gui.build.ts`);
-  }
+  if (!hanzoguiOptions) throw new Error(`No hanzogui build options found either via input props or at hanzogui.build.ts`);
   return {
-    config: "gui.config.ts",
-    components: ["@hanzo/gui", "@hanzogui/core"],
-    ...guiOptions
+    config: "hanzogui.config.ts",
+    components: ["hanzogui", "@hanzogui/core"],
+    ...hanzoguiOptions
   };
 }
-function loadGuiBuildConfigSync(guiOptions) {
-  const buildFilePath = guiOptions?.buildFile ?? "./gui.build.ts";
+function loadHanzoguiBuildConfigSync(hanzoguiOptions) {
+  const buildFilePath = hanzoguiOptions?.buildFile ?? "./hanzogui.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,
+      if (!out) throw new Error(`No default export found in ${buildFilePath}: ${out}`);
+      hanzoguiOptions = {
+        ...hanzoguiOptions,
         ...out
       };
     } finally {
       registered.unregister();
     }
   }
-  if (!guiOptions) {
-    throw new Error(`No hanzo-gui build options found either via input props or at gui.build.ts`);
-  }
+  if (!hanzoguiOptions) throw new Error(`No hanzogui build options found either via input props or at hanzogui.build.ts`);
   return {
-    config: "gui.config.ts",
-    components: ["@hanzo/gui", "@hanzogui/core"],
-    ...guiOptions
+    config: "hanzogui.config.ts",
+    components: ["hanzogui", "@hanzogui/core"],
+    ...hanzoguiOptions
   };
 }
-function loadGuiSync({
+function loadHanzoguiSync({
   forceExports,
   cacheKey,
   ...propsIn
 }) {
   const key = JSON.stringify(propsIn);
   if (last[key] && !(0, import_bundleConfig.hasBundledConfigChanged)()) {
-    if (!lastVersion[key] || lastVersion[key] === cacheKey) {
-      return last[key];
-    }
+    if (!lastVersion[key] || lastVersion[key] === cacheKey) return last[key];
   }
   lastVersion[key] = cacheKey || "";
   const props = getFilledOptions(propsIn);
   process.env.IS_STATIC = "is_static";
-  process.env.GUI_IS_SERVER = "true";
+  process.env.TAMAGUI_IS_SERVER = "true";
   const {
     unregister
   } = (0, import_registerRequire.registerRequire)(props.platform || "web", {
@@ -218,48 +200,40 @@ function loadGuiSync({
     const devValueOG = globalThis["__DEV__"];
     globalThis["__DEV__"] = process.env.NODE_ENV === "development";
     try {
-      let guiConfig = null;
+      let hanzoguiConfig = null;
       if (propsIn.config) {
-        const configPath = (0, import_getGuiConfigPathFromOptionsConfig.getGuiConfigPathFromOptionsConfig)(propsIn.config);
+        const configPath = (0, import_getHanzoguiConfigPathFromOptionsConfig.getHanzoguiConfigPathFromOptionsConfig)(propsIn.config);
         const exp = require(configPath);
-        if (!exp || exp._isProxyWorm) {
-          throw new Error(`Got a empty / proxied config!`);
-        }
-        guiConfig = exp["default"] || exp["config"] || exp;
-        if (!guiConfig || !guiConfig.parsed) {
+        if (!exp || exp._isProxyWorm) throw new Error(`Got a empty / proxied config!`);
+        hanzoguiConfig = exp["default"] || exp["config"] || exp;
+        if (!hanzoguiConfig || !hanzoguiConfig.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) {
+        if (hanzoguiConfig) {
           const {
-            createGui
-          } = (0, import_requireGuiCore.requireGuiCore)(props.platform || "web");
-          createGui(guiConfig);
+            createHanzogui
+          } = (0, import_requireHanzoguiCore.requireHanzoguiCore)(props.platform || "web");
+          createHanzogui(hanzoguiConfig);
         }
       }
       const components = (0, import_bundleConfig.loadComponentsSync)(props, forceExports);
-      if (!components) {
-        throw new Error(`No components loaded`);
-      }
-      if (process.env.DEBUG === "@hanzo/gui") {
-        console.info(`components`, components);
-      }
+      if (!components) throw new Error(`No components loaded`);
+      if (process.env.DEBUG === "hanzogui") console.info(`components`, components);
       process.env.IS_STATIC = void 0;
       globalThis["__DEV__"] = devValueOG;
       const info = {
         components,
-        guiConfig,
+        hanzoguiConfig,
         nameToPaths: (0, import_registerRequire.getNameToPaths)()
       };
-      if (guiConfig) {
+      if (hanzoguiConfig) {
         const {
           outputCSS
         } = props;
-        if (outputCSS) {
-          (0, import_bundleConfig.writeGuiCSS)(outputCSS, guiConfig);
-        }
+        if (outputCSS) (0, import_bundleConfig.writeHanzoguiCSS)(outputCSS, hanzoguiConfig);
         (0, import_regenerateConfig.regenerateConfigSync)(props, info);
       }
       last[key] = {
@@ -270,23 +244,17 @@ function loadGuiSync({
     } catch (err) {
       if (err instanceof Error) {
         if (!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.warn(`Error loading hanzogui.config.ts (set DEBUG=hanzogui to see full stack), running hanzogui without custom config`);
           console.info(`
 
     ${err.message}
 
 `);
-        } else {
-          if (import_constants.SHOULD_DEBUG) {
-            console.error(err);
-          }
-        }
-      } else {
-        console.error(`Error loading gui.config.ts`, err);
-      }
+        } else if (import_constants.SHOULD_DEBUG) console.error(err);
+      } else console.error(`Error loading hanzogui.config.ts`, err);
       return {
         components: [],
-        guiConfig: null,
+        hanzoguiConfig: null,
         nameToPaths: {}
       };
     }
@@ -297,11 +265,11 @@ function loadGuiSync({
 async function getOptions({
   root = process.cwd(),
   tsconfigPath = "tsconfig.json",
-  guiOptions,
+  hanzoguiOptions,
   host,
   debug
 } = {}) {
-  const dotDir = (0, import_node_path.join)(root, ".gui");
+  const dotDir = (0, import_node_path.join)(root, ".hanzogui");
   let pkgJson = {};
   try {
     pkgJson = await fsExtra.readJSON((0, import_node_path.join)(root, "package.json"));
@@ -313,16 +281,16 @@ async function getOptions({
     pkgJson,
     debug,
     tsconfigPath,
-    guiOptions: {
+    hanzoguiOptions: {
       platform: "web",
-      components: ["@hanzo/gui"],
-      ...guiOptions,
-      config: guiOptions?.config ?? (await getDefaultGuiConfigPath(root, guiOptions?.config))
+      components: ["hanzogui"],
+      ...hanzoguiOptions,
+      config: hanzoguiOptions?.config ?? (await getDefaultHanzoguiConfigPath(root, hanzoguiOptions?.config))
     },
     paths: {
       root,
       dotDir,
-      conf: (0, import_node_path.join)(dotDir, "gui.config.json"),
+      conf: (0, import_node_path.join)(dotDir, "hanzogui.config.json"),
       types: (0, import_node_path.join)(dotDir, "types.json")
     }
   };
@@ -334,25 +302,18 @@ function resolveWebOrNativeSpecificEntry(entry) {
   });
   const ext = (0, import_node_path.extname)(resolved);
   const fileName = (0, import_node_path.basename)(resolved).replace(ext, "");
-  const specificExt = true ? "web" : "native";
-  const specificFile = (0, import_node_path.join)((0, import_node_path.dirname)(resolved), fileName + "." + specificExt + ext);
-  if (fsExtra.existsSync(specificFile)) {
-    return specificFile;
-  }
+  const specificFile = (0, import_node_path.join)((0, import_node_path.dirname)(resolved), fileName + ".web" + ext);
+  if (fsExtra.existsSync(specificFile)) return specificFile;
   return entry;
 }
-const defaultPaths = ["gui.config.ts", (0, import_node_path.join)("src", "gui.config.ts")];
+const defaultPaths = ["hanzogui.config.ts", (0, import_node_path.join)("src", "hanzogui.config.ts")];
 let hasWarnedOnce = false;
-async function getDefaultGuiConfigPath(root, configPath) {
+async function getDefaultHanzoguiConfigPath(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;
-    }
-  }
+  for (const path of searchPaths) if (await fsExtra.pathExists(path)) return path;
   if (!hasWarnedOnce) {
     hasWarnedOnce = true;
-    console.warn(`Warning: couldn't find gui.config.ts in the following paths given configuration "${configPath}":
+    console.warn(`Warning: couldn't find hanzogui.config.ts in the following paths given configuration "${configPath}":
     ${searchPaths.join(`
   `)}
   `);
@@ -387,24 +348,19 @@ async function esbuildWatchFiles(entry, onChanged) {
         onEnd,
         onResolve
       }) {
-        let filter = /^[^./]|^\.[^./]|^\.\.[^/]/;
         onResolve({
-          filter
+          filter: /^[^./]|^\.[^./]|^\.\.[^/]/
         }, args => ({
           path: args.path,
           external: true
         }));
         onEnd(() => {
-          if (!hasRunOnce) {
-            hasRunOnce = true;
-          } else {
-            onChanged();
-          }
+          if (!hasRunOnce) hasRunOnce = true;else onChanged();
         });
       }
     }]
   });
-  void context.watch();
+  context.watch();
   return () => {
     context.dispose();
   };

package/dist/extractor/regenerateConfig.cjs

@@ -33,7 +33,7 @@ var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
 }), mod);
 var regenerateConfig_exports = {};
 __export(regenerateConfig_exports, {
-  generateGuiThemes: () => generateGuiThemes,
+  generateHanzoguiThemes: () => generateHanzoguiThemes,
   regenerateConfig: () => regenerateConfig,
   regenerateConfigSync: () => regenerateConfigSync
 });
@@ -41,45 +41,45 @@ module.exports = __toCommonJS(regenerateConfig_exports);
 var import_node_path = require("node:path");
 var import_generate_themes = require("@hanzogui/generate-themes");
 var FS = __toESM(require("fs-extra"));
-var import_requireGuiCore = require("../helpers/requireGuiCore.cjs");
+var import_requireHanzoguiCore = require("../helpers/requireHanzoguiCore.cjs");
 var import_bundleConfig = require("./bundleConfig.cjs");
-const guiDir = (0, import_node_path.join)(process.cwd(), ".gui");
-const confFile = (0, import_node_path.join)(guiDir, "gui.config.json");
-async function regenerateConfig(guiOptions, configIn, rebuild = false) {
+const hanzoguiDir = (0, import_node_path.join)(process.cwd(), ".hanzogui");
+const confFile = (0, import_node_path.join)(hanzoguiDir, "hanzogui.config.json");
+async function regenerateConfig(hanzoguiOptions, configIn, rebuild = false) {
   try {
-    const config = configIn ?? (await (0, import_bundleConfig.getBundledConfig)(guiOptions, rebuild));
+    const config = configIn ?? (await (0, import_bundleConfig.getBundledConfig)(hanzoguiOptions, rebuild));
     if (!config) return;
-    const out = transformConfig(config, guiOptions.platform || "web");
+    const out = transformConfig(config, hanzoguiOptions.platform || "web");
     await FS.ensureDir((0, import_node_path.dirname)(confFile));
     await FS.writeJSON(confFile, out, {
       spaces: 2
     });
   } catch (err) {
-    if (process.env.DEBUG?.includes("@hanzo/gui") || process.env.IS_GUI_DEV) {
+    if (process.env.DEBUG?.includes("hanzogui") || process.env.IS_TAMAGUI_DEV) {
       console.warn("regenerateConfig error", err);
     }
   }
 }
-function regenerateConfigSync(_guiOptions, config) {
+function regenerateConfigSync(_hanzoguiOptions, config) {
   try {
     FS.ensureDirSync((0, import_node_path.dirname)(confFile));
-    FS.writeJSONSync(confFile, transformConfig(config, _guiOptions.platform || "web"), {
+    FS.writeJSONSync(confFile, transformConfig(config, _hanzoguiOptions.platform || "web"), {
       spaces: 2
     });
   } catch (err) {
-    if (process.env.DEBUG?.includes("@hanzo/gui") || process.env.IS_GUI_DEV) {
+    if (process.env.DEBUG?.includes("hanzogui") || process.env.IS_TAMAGUI_DEV) {
       console.warn("regenerateConfig error", err);
     }
   }
 }
-async function generateGuiThemes(guiOptions, force = false) {
-  if (!guiOptions.themeBuilder) {
+async function generateHanzoguiThemes(hanzoguiOptions, force = false) {
+  if (!hanzoguiOptions.themeBuilder) {
     return;
   }
   const {
     input,
     output
-  } = guiOptions.themeBuilder;
+  } = hanzoguiOptions.themeBuilder;
   const inPath = resolveRelativePath(input);
   const outPath = resolveRelativePath(output);
   const generatedOutput = await (0, import_generate_themes.generateThemes)(inPath);
@@ -93,7 +93,7 @@ async function generateGuiThemes(guiOptions, force = false) {
     return true;
   })());
   if (hasChanged) {
-    await (0, import_generate_themes.writeGeneratedThemes)(guiDir, outPath, generatedOutput);
+    await (0, import_generate_themes.writeGeneratedThemes)(hanzoguiDir, outPath, generatedOutput);
   }
   return hasChanged;
 }
@@ -112,19 +112,19 @@ function transformConfig(config, platform) {
   }
   const {
     getVariableValue
-  } = (0, import_requireGuiCore.requireGuiCore)(platform);
+  } = (0, import_requireHanzoguiCore.requireHanzoguiCore)(platform);
   const next = cloneDeepSafe(config, {
     validStyles: true
   });
   const {
     components,
     nameToPaths,
-    guiConfig
+    hanzoguiConfig
   } = next;
   const {
     themes,
     tokens
-  } = guiConfig;
+  } = hanzoguiConfig;
   for (const key in themes) {
     const theme = themes[key];
     theme.id = key;
@@ -165,11 +165,11 @@ function transformConfig(config, platform) {
     shorthands: _shorthands,
     userShorthands,
     ...cleanedConfig
-  } = next.guiConfig;
+  } = next.hanzoguiConfig;
   return {
     components,
     nameToPaths,
-    guiConfig: {
+    hanzoguiConfig: {
       ...cleanedConfig,
       // Output userShorthands as shorthands (excludes built-ins)
       shorthands: userShorthands

package/dist/extractor/{watchGuiConfig.cjs → watchHanzoguiConfig.cjs}

@@ -20,15 +20,15 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
   value: true
 }), mod);
-var watchGuiConfig_exports = {};
-__export(watchGuiConfig_exports, {
-  watchGuiConfig: () => watchGuiConfig
+var watchHanzoguiConfig_exports = {};
+__export(watchHanzoguiConfig_exports, {
+  watchHanzoguiConfig: () => watchHanzoguiConfig
 });
-module.exports = __toCommonJS(watchGuiConfig_exports);
-var import_loadGui = require("./loadGui.cjs");
+module.exports = __toCommonJS(watchHanzoguiConfig_exports);
+var import_loadHanzogui = require("./loadHanzogui.cjs");
 var import_regenerateConfig = require("./regenerateConfig.cjs");
 let isWatching = false;
-async function watchGuiConfig(guiOptions) {
+async function watchHanzoguiConfig(hanzoguiOptions) {
   if (process.env.NODE_ENV === "production") {
     return {
       dispose() {}
@@ -38,26 +38,26 @@ async function watchGuiConfig(guiOptions) {
     return;
   }
   isWatching = true;
-  const options = await (0, import_loadGui.getOptions)({
-    guiOptions
+  const options = await (0, import_loadHanzogui.getOptions)({
+    hanzoguiOptions
   });
-  if (!options.guiOptions.config) {
+  if (!options.hanzoguiOptions.config) {
     isWatching = false;
     throw new Error(`No config`);
   }
-  const disposeConfigWatcher = await (0, import_loadGui.esbuildWatchFiles)(options.guiOptions.config, async () => {
-    await (0, import_loadGui.generateThemesAndLog)(options.guiOptions);
-    await (0, import_regenerateConfig.regenerateConfig)(options.guiOptions, null, true);
+  const disposeConfigWatcher = await (0, import_loadHanzogui.esbuildWatchFiles)(options.hanzoguiOptions.config, async () => {
+    await (0, import_loadHanzogui.generateThemesAndLog)(options.hanzoguiOptions);
+    await (0, import_regenerateConfig.regenerateConfig)(options.hanzoguiOptions, null, true);
   });
-  const themeBuilderInput = options.guiOptions.themeBuilder?.input;
+  const themeBuilderInput = options.hanzoguiOptions.themeBuilder?.input;
   let disposeThemesWatcher;
   if (themeBuilderInput) {
     let inputPath = themeBuilderInput;
     try {
       inputPath = require.resolve(themeBuilderInput);
     } catch {}
-    disposeThemesWatcher = await (0, import_loadGui.esbuildWatchFiles)(inputPath, async () => {
-      await (0, import_loadGui.generateThemesAndLog)(options.guiOptions);
+    disposeThemesWatcher = await (0, import_loadHanzogui.esbuildWatchFiles)(inputPath, async () => {
+      await (0, import_loadHanzogui.generateThemesAndLog)(options.hanzoguiOptions);
     });
   }
   return {

package/dist/getPragmaOptions.cjs

@@ -38,14 +38,14 @@ function getPragmaOptions({
     if (trimmed && !trimmed.startsWith("//") && !trimmed.startsWith("/*")) {
       break;
     }
-    pragma = trimmed.match(/(\/\/|\/\*)\s?!?\s?(gui-ignore|debug|debug-verbose)(\n|\s|$).*/)?.[2].trim() || "";
+    pragma = trimmed.match(/(\/\/|\/\*)\s?!?\s?(hanzogui-ignore|debug|debug-verbose)(\n|\s|$).*/)?.[2].trim() || "";
     if (pragma) {
       pragma = pragma.replace("!", "").trim();
       break;
     }
   }
   switch (pragma) {
-    case "gui-ignore":
+    case "hanzogui-ignore":
       shouldDisable = true;
       break;
     case "debug":
@@ -55,15 +55,15 @@ function getPragmaOptions({
       shouldPrintDebug = "verbose";
       break;
   }
-  if (process.env.GUI_DEBUG_FILE) {
-    if (path.includes(process.env.GUI_DEBUG_FILE)) {
+  if (process.env.TAMAGUI_DEBUG_FILE) {
+    if (path.includes(process.env.TAMAGUI_DEBUG_FILE)) {
       shouldPrintDebug = "verbose";
     }
   }
-  if (process.env.DEBUG?.includes("@hanzo/gui")) {
+  if (process.env.DEBUG?.includes("hanzogui")) {
     shouldPrintDebug ||= true;
   }
-  if (process.env.DEBUG?.includes("gui-verbose")) {
+  if (process.env.DEBUG?.includes("hanzogui-verbose")) {
     shouldPrintDebug = "verbose";
   }
   return {

package/dist/helpers/{requireGuiCore.cjs → requireHanzoguiCore.cjs}

@@ -20,21 +20,21 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
   value: true
 }), mod);
-var requireGuiCore_exports = {};
-__export(requireGuiCore_exports, {
-  requireGuiCore: () => requireGuiCore
+var requireHanzoguiCore_exports = {};
+__export(requireHanzoguiCore_exports, {
+  requireHanzoguiCore: () => requireHanzoguiCore
 });
-module.exports = __toCommonJS(requireGuiCore_exports);
-function requireGuiCore(platform, ogRequire = require) {
+module.exports = __toCommonJS(requireHanzoguiCore_exports);
+function requireHanzoguiCore(platform, ogRequire = require) {
   if (!platform) {
-    throw new Error(`No platform given to requireGuiCore`);
+    throw new Error(`No platform given to requireHanzoguiCore`);
   }
-  const og1 = process.env.GUI_IS_SERVER;
-  const og2 = process.env.GUI_KEEP_THEMES;
-  process.env.GUI_IS_SERVER ||= "1";
-  process.env.GUI_KEEP_THEMES ||= "1";
+  const og1 = process.env.TAMAGUI_IS_SERVER;
+  const og2 = process.env.TAMAGUI_KEEP_THEMES;
+  process.env.TAMAGUI_IS_SERVER ||= "1";
+  process.env.TAMAGUI_KEEP_THEMES ||= "1";
   const exported = ogRequire(platform === "native" ? "@hanzogui/core/native" : "@hanzogui/core");
-  process.env.GUI_IS_SERVER = og1;
-  process.env.GUI_KEEP_THEMES = og2;
+  process.env.TAMAGUI_IS_SERVER = og1;
+  process.env.TAMAGUI_KEEP_THEMES = og2;
   return exported;
 }