@hanzogui/static 7.0.0 → 7.3.0

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

@@ -31,37 +31,37 @@ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
   value: true
 }), mod);
-var loadHanzogui_exports = {};
-__export(loadHanzogui_exports, {
+var loadGui_exports = {};
+__export(loadGui_exports, {
   esbuildWatchFiles: () => esbuildWatchFiles,
   generateThemesAndLog: () => generateThemesAndLog,
   getOptions: () => getOptions,
-  loadHanzogui: () => loadHanzogui,
-  loadHanzoguiBuildConfigAsync: () => loadHanzoguiBuildConfigAsync,
-  loadHanzoguiBuildConfigSync: () => loadHanzoguiBuildConfigSync,
-  loadHanzoguiSync: () => loadHanzoguiSync,
+  loadGui: () => loadGui,
+  loadGuiBuildConfigAsync: () => loadGuiBuildConfigAsync,
+  loadGuiBuildConfigSync: () => loadGuiBuildConfigSync,
+  loadGuiSync: () => loadGuiSync,
   resolveWebOrNativeSpecificEntry: () => resolveWebOrNativeSpecificEntry
 });
-module.exports = __toCommonJS(loadHanzogui_exports);
+module.exports = __toCommonJS(loadGui_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_requireHanzoguiCore = require("../helpers/requireHanzoguiCore.cjs");
+var import_requireGuiCore = require("../helpers/requireGuiCore.cjs");
 var import_registerRequire = require("../registerRequire.cjs");
 var import_bundleConfig = require("./bundleConfig.cjs");
-var import_getHanzoguiConfigPathFromOptionsConfig = require("./getHanzoguiConfigPathFromOptionsConfig.cjs");
+var import_getGuiConfigPathFromOptionsConfig = require("./getGuiConfigPathFromOptionsConfig.cjs");
 var import_regenerateConfig = require("./regenerateConfig.cjs");
 const getFilledOptions = propsIn => ({
   platform: "web",
-  config: "hanzogui.config.ts",
-  components: ["hanzogui"],
+  config: "gui.config.ts",
+  components: ["gui"],
   ...propsIn
 });
 let isLoadingPromise;
-async function loadHanzogui(propsIn) {
+async function loadGui(propsIn) {
   if (isLoadingPromise) return await isLoadingPromise;
   let resolvePromise;
   let rejectPromise;
@@ -73,17 +73,17 @@ async function loadHanzogui(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=hanzogui and re-run to get logs.`);
+      console.warn(`No bundled config generated, maybe an error in bundling. Set DEBUG=gui and re-run to get logs.`);
       resolvePromise(null);
       return null;
     }
     await generateThemesAndLog(props);
-    const maybeHanzoguiConfig = bundleInfo.hanzoguiConfig;
-    if (maybeHanzoguiConfig && !maybeHanzoguiConfig.parsed) {
+    const maybeGuiConfig = bundleInfo.guiConfig;
+    if (maybeGuiConfig && !maybeGuiConfig.parsed) {
       const {
-        createHanzogui
-      } = (0, import_requireHanzoguiCore.requireHanzoguiCore)(props.platform || "web");
-      bundleInfo.hanzoguiConfig = createHanzogui(bundleInfo.hanzoguiConfig);
+        createGui
+      } = (0, import_requireGuiCore.requireGuiCore)(props.platform || "web");
+      bundleInfo.guiConfig = createGui(bundleInfo.guiConfig);
     }
     if (!(0, import_bundleConfig.hasBundledConfigChanged)()) {
       resolvePromise(bundleInfo);
@@ -106,11 +106,11 @@ const generateThemesAndLog = async (options, force = false) => {
   try {
     waiting = true;
     await new Promise(res => setTimeout(res, 30));
-    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 (await (0, import_regenerateConfig.generateGuiThemes)(options, force)) {
+      (0, import_cli_color.colorLog)(import_cli_color.Color.FgYellow, `  \u27A1 [gui] 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.writeHanzoguiCSS)(options.outputCSS, loadedConfig);
+        if (loadedConfig) await (0, import_bundleConfig.writeGuiCSS)(options.outputCSS, loadedConfig);
       }
     }
   } finally {
@@ -120,8 +120,8 @@ const generateThemesAndLog = async (options, force = false) => {
 const last = {};
 const lastVersion = {};
 let esbuildWasmInitialized = false;
-async function loadHanzoguiBuildConfigAsync(hanzoguiOptions) {
-  const buildFilePath = hanzoguiOptions?.buildFile ?? "./hanzogui.build.ts";
+async function loadGuiBuildConfigAsync(guiOptions) {
+  const buildFilePath = guiOptions?.buildFile ?? "./gui.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");
@@ -141,44 +141,44 @@ async function loadHanzoguiBuildConfigAsync(hanzoguiOptions) {
     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,
+    guiOptions = {
+      ...guiOptions,
       ...out
     };
   } catch (err) {
-    console.error(`[hanzogui] Error loading ${buildFilePath}:`, err);
+    console.error(`[gui] Error loading ${buildFilePath}:`, err);
     throw err;
   }
-  if (!hanzoguiOptions) throw new Error(`No hanzogui build options found either via input props or at hanzogui.build.ts`);
+  if (!guiOptions) throw new Error(`No gui build options found either via input props or at gui.build.ts`);
   return {
-    config: "hanzogui.config.ts",
-    components: ["hanzogui", "@hanzogui/core"],
-    ...hanzoguiOptions
+    config: "gui.config.ts",
+    components: ["gui", "@hanzogui/core"],
+    ...guiOptions
   };
 }
-function loadHanzoguiBuildConfigSync(hanzoguiOptions) {
-  const buildFilePath = hanzoguiOptions?.buildFile ?? "./hanzogui.build.ts";
+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}`);
-      hanzoguiOptions = {
-        ...hanzoguiOptions,
+      guiOptions = {
+        ...guiOptions,
         ...out
       };
     } finally {
       registered.unregister();
     }
   }
-  if (!hanzoguiOptions) throw new Error(`No hanzogui build options found either via input props or at hanzogui.build.ts`);
+  if (!guiOptions) throw new Error(`No gui build options found either via input props or at gui.build.ts`);
   return {
-    config: "hanzogui.config.ts",
-    components: ["hanzogui", "@hanzogui/core"],
-    ...hanzoguiOptions
+    config: "gui.config.ts",
+    components: ["gui", "@hanzogui/core"],
+    ...guiOptions
   };
 }
-function loadHanzoguiSync({
+function loadGuiSync({
   forceExports,
   cacheKey,
   ...propsIn
@@ -190,7 +190,7 @@ function loadHanzoguiSync({
   lastVersion[key] = cacheKey || "";
   const props = getFilledOptions(propsIn);
   process.env.IS_STATIC = "is_static";
-  process.env.TAMAGUI_IS_SERVER = "true";
+  process.env.GUI_IS_SERVER = "true";
   const {
     unregister
   } = (0, import_registerRequire.registerRequire)(props.platform || "web", {
@@ -200,40 +200,40 @@ function loadHanzoguiSync({
     const devValueOG = globalThis["__DEV__"];
     globalThis["__DEV__"] = process.env.NODE_ENV === "development";
     try {
-      let hanzoguiConfig = null;
+      let guiConfig = null;
       if (propsIn.config) {
-        const configPath = (0, import_getHanzoguiConfigPathFromOptionsConfig.getHanzoguiConfigPathFromOptionsConfig)(propsIn.config);
+        const configPath = (0, import_getGuiConfigPathFromOptionsConfig.getGuiConfigPathFromOptionsConfig)(propsIn.config);
         const exp = require(configPath);
         if (!exp || exp._isProxyWorm) throw new Error(`Got a empty / proxied config!`);
-        hanzoguiConfig = exp["default"] || exp["config"] || exp;
-        if (!hanzoguiConfig || !hanzoguiConfig.parsed) {
+        guiConfig = exp["default"] || exp["config"] || exp;
+        if (!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 (hanzoguiConfig) {
+        if (guiConfig) {
           const {
-            createHanzogui
-          } = (0, import_requireHanzoguiCore.requireHanzoguiCore)(props.platform || "web");
-          createHanzogui(hanzoguiConfig);
+            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`);
-      if (process.env.DEBUG === "hanzogui") console.info(`components`, components);
+      if (process.env.DEBUG === "gui") console.info(`components`, components);
       process.env.IS_STATIC = void 0;
       globalThis["__DEV__"] = devValueOG;
       const info = {
         components,
-        hanzoguiConfig,
+        guiConfig,
         nameToPaths: (0, import_registerRequire.getNameToPaths)()
       };
-      if (hanzoguiConfig) {
+      if (guiConfig) {
         const {
           outputCSS
         } = props;
-        if (outputCSS) (0, import_bundleConfig.writeHanzoguiCSS)(outputCSS, hanzoguiConfig);
+        if (outputCSS) (0, import_bundleConfig.writeGuiCSS)(outputCSS, guiConfig);
         (0, import_regenerateConfig.regenerateConfigSync)(props, info);
       }
       last[key] = {
@@ -244,17 +244,17 @@ function loadHanzoguiSync({
     } catch (err) {
       if (err instanceof Error) {
         if (!import_constants.SHOULD_DEBUG && !forceExports) {
-          console.warn(`Error loading hanzogui.config.ts (set DEBUG=hanzogui to see full stack), running hanzogui without custom config`);
+          console.warn(`Error loading gui.config.ts (set DEBUG=gui to see full stack), running gui without custom config`);
           console.info(`
 
     ${err.message}
 
 `);
         } else if (import_constants.SHOULD_DEBUG) console.error(err);
-      } else console.error(`Error loading hanzogui.config.ts`, err);
+      } else console.error(`Error loading gui.config.ts`, err);
       return {
         components: [],
-        hanzoguiConfig: null,
+        guiConfig: null,
         nameToPaths: {}
       };
     }
@@ -265,11 +265,11 @@ function loadHanzoguiSync({
 async function getOptions({
   root = process.cwd(),
   tsconfigPath = "tsconfig.json",
-  hanzoguiOptions,
+  guiOptions,
   host,
   debug
 } = {}) {
-  const dotDir = (0, import_node_path.join)(root, ".hanzogui");
+  const dotDir = (0, import_node_path.join)(root, ".gui");
   let pkgJson = {};
   try {
     pkgJson = await fsExtra.readJSON((0, import_node_path.join)(root, "package.json"));
@@ -281,16 +281,16 @@ async function getOptions({
     pkgJson,
     debug,
     tsconfigPath,
-    hanzoguiOptions: {
+    guiOptions: {
       platform: "web",
-      components: ["hanzogui"],
-      ...hanzoguiOptions,
-      config: hanzoguiOptions?.config ?? (await getDefaultHanzoguiConfigPath(root, hanzoguiOptions?.config))
+      components: ["gui"],
+      ...guiOptions,
+      config: guiOptions?.config ?? (await getDefaultGuiConfigPath(root, guiOptions?.config))
     },
     paths: {
       root,
       dotDir,
-      conf: (0, import_node_path.join)(dotDir, "hanzogui.config.json"),
+      conf: (0, import_node_path.join)(dotDir, "gui.config.json"),
       types: (0, import_node_path.join)(dotDir, "types.json")
     }
   };
@@ -306,14 +306,14 @@ function resolveWebOrNativeSpecificEntry(entry) {
   if (fsExtra.existsSync(specificFile)) return specificFile;
   return entry;
 }
-const defaultPaths = ["hanzogui.config.ts", (0, import_node_path.join)("src", "hanzogui.config.ts")];
+const defaultPaths = ["gui.config.ts", (0, import_node_path.join)("src", "gui.config.ts")];
 let hasWarnedOnce = false;
-async function getDefaultHanzoguiConfigPath(root, configPath) {
+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;
   if (!hasWarnedOnce) {
     hasWarnedOnce = true;
-    console.warn(`Warning: couldn't find hanzogui.config.ts in the following paths given configuration "${configPath}":
+    console.warn(`Warning: couldn't find gui.config.ts in the following paths given configuration "${configPath}":
     ${searchPaths.join(`
   `)}
   `);

package/dist/extractor/regenerateConfig.cjs

@@ -33,7 +33,7 @@ var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
 }), mod);
 var regenerateConfig_exports = {};
 __export(regenerateConfig_exports, {
-  generateHanzoguiThemes: () => generateHanzoguiThemes,
+  generateGuiThemes: () => generateGuiThemes,
   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_requireHanzoguiCore = require("../helpers/requireHanzoguiCore.cjs");
+var import_requireGuiCore = require("../helpers/requireGuiCore.cjs");
 var import_bundleConfig = require("./bundleConfig.cjs");
-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) {
+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) {
   try {
-    const config = configIn ?? (await (0, import_bundleConfig.getBundledConfig)(hanzoguiOptions, rebuild));
+    const config = configIn ?? (await (0, import_bundleConfig.getBundledConfig)(guiOptions, rebuild));
     if (!config) return;
-    const out = transformConfig(config, hanzoguiOptions.platform || "web");
+    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) {
-    if (process.env.DEBUG?.includes("hanzogui") || process.env.IS_TAMAGUI_DEV) {
+    if (process.env.DEBUG?.includes("gui") || process.env.IS_GUI_DEV) {
       console.warn("regenerateConfig error", err);
     }
   }
 }
-function regenerateConfigSync(_hanzoguiOptions, config) {
+function regenerateConfigSync(_guiOptions, config) {
   try {
     FS.ensureDirSync((0, import_node_path.dirname)(confFile));
-    FS.writeJSONSync(confFile, transformConfig(config, _hanzoguiOptions.platform || "web"), {
+    FS.writeJSONSync(confFile, transformConfig(config, _guiOptions.platform || "web"), {
       spaces: 2
     });
   } catch (err) {
-    if (process.env.DEBUG?.includes("hanzogui") || process.env.IS_TAMAGUI_DEV) {
+    if (process.env.DEBUG?.includes("gui") || process.env.IS_GUI_DEV) {
       console.warn("regenerateConfig error", err);
     }
   }
 }
-async function generateHanzoguiThemes(hanzoguiOptions, force = false) {
-  if (!hanzoguiOptions.themeBuilder) {
+async function generateGuiThemes(guiOptions, force = false) {
+  if (!guiOptions.themeBuilder) {
     return;
   }
   const {
     input,
     output
-  } = hanzoguiOptions.themeBuilder;
+  } = guiOptions.themeBuilder;
   const inPath = resolveRelativePath(input);
   const outPath = resolveRelativePath(output);
   const generatedOutput = await (0, import_generate_themes.generateThemes)(inPath);
@@ -93,7 +93,7 @@ async function generateHanzoguiThemes(hanzoguiOptions, force = false) {
     return true;
   })());
   if (hasChanged) {
-    await (0, import_generate_themes.writeGeneratedThemes)(hanzoguiDir, outPath, generatedOutput);
+    await (0, import_generate_themes.writeGeneratedThemes)(guiDir, outPath, generatedOutput);
   }
   return hasChanged;
 }
@@ -112,19 +112,19 @@ function transformConfig(config, platform) {
   }
   const {
     getVariableValue
-  } = (0, import_requireHanzoguiCore.requireHanzoguiCore)(platform);
+  } = (0, import_requireGuiCore.requireGuiCore)(platform);
   const next = cloneDeepSafe(config, {
     validStyles: true
   });
   const {
     components,
     nameToPaths,
-    hanzoguiConfig
+    guiConfig
   } = next;
   const {
     themes,
     tokens
-  } = hanzoguiConfig;
+  } = guiConfig;
   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.hanzoguiConfig;
+  } = next.guiConfig;
   return {
     components,
     nameToPaths,
-    hanzoguiConfig: {
+    guiConfig: {
       ...cleanedConfig,
       // Output userShorthands as shorthands (excludes built-ins)
       shorthands: userShorthands

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

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

package/dist/getPragmaOptions.cjs

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

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

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

package/dist/registerRequire.cjs

@@ -29,7 +29,7 @@ __export(registerRequire_exports, {
 module.exports = __toCommonJS(registerRequire_exports);
 var import_node = require("esbuild-register/dist/node");
 var import_bundle = require("./extractor/bundle.cjs");
-var import_requireHanzoguiCore = require("./helpers/requireHanzoguiCore.cjs");
+var import_requireGuiCore = require("./helpers/requireGuiCore.cjs");
 const nameToPaths = {};
 const getNameToPaths = () => nameToPaths;
 const Module = require("node:module");
@@ -83,7 +83,7 @@ function registerRequire(platform, {
 }) {
   if (isRegistered) {
     return {
-      hanzoguiRequire: require,
+      guiRequire: require,
       unregister: () => {}
     };
   }
@@ -94,7 +94,7 @@ function registerRequire(platform, {
     hookIgnoreNodeModules: false,
     // don't transform @hanzogui packages - they have pre-built dist files
     hookMatcher: filename => {
-      if (filename.includes("@hanzogui") || /\/hanzogui\/code\/(core|ui|packages)\//.test(filename)) {
+      if (filename.includes("@hanzogui") || /\/gui\/code\/(core|ui|packages)\//.test(filename)) {
         return false;
       }
       return true;
@@ -111,17 +111,17 @@ function registerRequire(platform, {
     og = Module.prototype.require;
   }
   isRegistered = true;
-  Module.prototype.require = hanzoguiRequire;
-  function hanzoguiRequire(path) {
+  Module.prototype.require = guiRequire;
+  function guiRequire(path) {
     const staticExtractionStub = getStaticExtractionStub(path);
     if (staticExtractionStub) {
       return staticExtractionStub;
     }
-    if (path === "hanzogui" && platform === "native") {
-      return og.apply(this, ["hanzogui/native"]);
+    if (path === "gui" && platform === "native") {
+      return og.apply(this, ["gui/native"]);
     }
     if (path === "@hanzogui/core") {
-      return (0, import_requireHanzoguiCore.requireHanzoguiCore)(platform, path2 => {
+      return (0, import_requireGuiCore.requireGuiCore)(platform, path2 => {
         return og.apply(this, [path2]);
       });
     }
@@ -145,11 +145,11 @@ function registerRequire(platform, {
       }
     }
     if (!whitelisted[path]) {
-      if (proxyWormImports && !path.includes(".hanzogui-dynamic-eval")) {
+      if (proxyWormImports && !path.includes(".gui-dynamic-eval")) {
         const callerFile = this?.filename || this?.id || "";
-        const isFromHanzoguiPkg = callerFile.includes("@hanzogui") || callerFile.includes("node_modules/hanzogui/");
-        const isFromStaticLoader = !callerFile || callerFile === "." || callerFile === "[eval]" || callerFile.endsWith("/[eval]") || callerFile.includes("/code/compiler/static/") || callerFile.includes("/.hanzogui/");
-        if (path === "hanzogui" || path.startsWith("@hanzogui/") || isFromHanzoguiPkg || isFromStaticLoader) {
+        const isFromGuiPkg = callerFile.includes("@hanzogui") || callerFile.includes("node_modules/gui/");
+        const isFromStaticLoader = !callerFile || callerFile === "." || callerFile === "[eval]" || callerFile.endsWith("/[eval]") || callerFile.includes("/code/compiler/static/") || callerFile.includes("/.gui/");
+        if (path === "gui" || path.startsWith("@hanzogui/") || isFromGuiPkg || isFromStaticLoader) {
           return og.apply(this, [path]);
         }
         return proxyWorm;
@@ -159,24 +159,24 @@ function registerRequire(platform, {
       const out = og.apply(this, arguments);
       return out;
     } catch (err) {
-      if (!process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD && path.includes("hanzogui-dynamic-eval")) {
+      if (!process.env.GUI_ENABLE_WARN_DYNAMIC_LOAD && path.includes("gui-dynamic-eval")) {
         return;
       }
-      if (allowedIgnores[path] || IGNORES === "true") {} else if (!process.env.TAMAGUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG) {
+      if (allowedIgnores[path] || IGNORES === "true") {} else if (!process.env.GUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG) {
         if (hasWarnedForModules.has(path)) {} else {
           hasWarnedForModules.add(path);
         }
       } else {
-        console.warn(`  [hanzogui] skipped "${path}" (set TAMAGUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`);
+        console.warn(`  [gui] skipped "${path}" (set GUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`);
       }
       return proxyWorm;
     }
   }
   return {
-    hanzoguiRequire,
+    guiRequire,
     unregister: () => {
       if (hasWarnedForModules.size) {
-        console.info(`  [hanzogui] skipped loading ${hasWarnedForModules.size} module, see: https://hanzogui.dev/docs/intro/errors#warning-001`);
+        console.info(`  [gui] skipped loading ${hasWarnedForModules.size} module, see: https://gui.dev/docs/intro/errors#warning-001`);
         hasWarnedForModules.clear();
       }
       unregister();
@@ -185,15 +185,15 @@ function registerRequire(platform, {
     }
   };
 }
-const IGNORES = process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS;
-const extraIgnores = IGNORES === "true" ? [] : process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS?.split(",");
+const IGNORES = process.env.GUI_IGNORE_BUNDLE_ERRORS;
+const extraIgnores = IGNORES === "true" ? [] : process.env.GUI_IGNORE_BUNDLE_ERRORS?.split(",");
 const knownIgnorableModules = {
   "@gorhom/bottom-sheet": true,
   "expo-modules": true,
   solito: true,
   "expo-linear-gradient": true,
   "@expo/vector-icons": true,
-  "hanzogui/linear-gradient": true,
+  "gui/linear-gradient": true,
   // animation libraries not needed for static extraction
   "@emotion/is-prop-valid": true,
   "framer-motion": true,