@hanzogui/static 7.3.1 → 8.0.0

package/dist/extractor/loadGui.cjs

@@ -56,8 +56,8 @@ var import_getGuiConfigPathFromOptionsConfig = require("./getGuiConfigPathFromOp
 var import_regenerateConfig = require("./regenerateConfig.cjs");
 const getFilledOptions = propsIn => ({
   platform: "web",
-  config: "gui.config.ts",
-  components: ["gui"],
+  config: "hanzogui.config.ts",
+  components: ["hanzogui"],
   ...propsIn
 });
 let isLoadingPromise;
@@ -73,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=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;
+    const maybeGuiConfig = bundleInfo.hanzoguiConfig;
     if (maybeGuiConfig && !maybeGuiConfig.parsed) {
       const {
         createGui
       } = (0, import_requireGuiCore.requireGuiCore)(props.platform || "web");
-      bundleInfo.guiConfig = createGui(bundleInfo.guiConfig);
+      bundleInfo.hanzoguiConfig = createGui(bundleInfo.hanzoguiConfig);
     }
     if (!(0, import_bundleConfig.hasBundledConfigChanged)()) {
       resolvePromise(bundleInfo);
@@ -107,7 +107,7 @@ const generateThemesAndLog = async (options, force = false) => {
     waiting = true;
     await new Promise(res => setTimeout(res, 30));
     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)}`);
+      (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);
@@ -120,8 +120,8 @@ 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 loadGuiBuildConfigAsync(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");
@@ -141,41 +141,46 @@ async function loadGuiBuildConfigAsync(guiOptions) {
     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,
+    hanzoguiOptions = {
+      ...hanzoguiOptions,
       ...out
     };
   } catch (err) {
-    console.error(`[gui] Error loading ${buildFilePath}:`, err);
+    console.error(`[hanzogui] Error loading ${buildFilePath}:`, err);
     throw err;
+  } finally {
+    try {
+      esbuildWasm.stop();
+      esbuildWasmInitialized = false;
+    } catch {}
   }
-  if (!guiOptions) throw new Error(`No 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: ["gui", "@hanzogui/core"],
-    ...guiOptions
+    config: "hanzogui.config.ts",
+    components: ["hanzogui", "@hanzogui/core"],
+    ...hanzoguiOptions
   };
 }
-function loadGuiBuildConfigSync(guiOptions) {
-  const buildFilePath = guiOptions?.buildFile ?? "./gui.build.ts";
+function loadGuiBuildConfigSync(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,
+      hanzoguiOptions = {
+        ...hanzoguiOptions,
         ...out
       };
     } finally {
       registered.unregister();
     }
   }
-  if (!guiOptions) throw new Error(`No 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: ["gui", "@hanzogui/core"],
-    ...guiOptions
+    config: "hanzogui.config.ts",
+    components: ["hanzogui", "@hanzogui/core"],
+    ...hanzoguiOptions
   };
 }
 function loadGuiSync({
@@ -200,40 +205,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 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) {
+        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);
+          createGui(hanzoguiConfig);
         }
       }
       const components = (0, import_bundleConfig.loadComponentsSync)(props, forceExports);
       if (!components) throw new Error(`No components loaded`);
-      if (process.env.DEBUG === "gui") console.info(`components`, components);
+      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.writeGuiCSS)(outputCSS, hanzoguiConfig);
         (0, import_regenerateConfig.regenerateConfigSync)(props, info);
       }
       last[key] = {
@@ -244,17 +249,17 @@ function loadGuiSync({
     } catch (err) {
       if (err instanceof Error) {
         if (!import_constants.SHOULD_DEBUG && !forceExports) {
-          console.warn(`Error loading gui.config.ts (set DEBUG=gui to see full stack), running 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 console.error(`Error loading hanzogui.config.ts`, err);
       return {
         components: [],
-        guiConfig: null,
+        hanzoguiConfig: null,
         nameToPaths: {}
       };
     }
@@ -265,11 +270,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"));
@@ -281,39 +286,40 @@ async function getOptions({
     pkgJson,
     debug,
     tsconfigPath,
-    guiOptions: {
+    hanzoguiOptions: {
       platform: "web",
-      components: ["gui"],
-      ...guiOptions,
-      config: guiOptions?.config ?? (await getDefaultGuiConfigPath(root, guiOptions?.config))
+      components: ["hanzogui"],
+      ...hanzoguiOptions,
+      config: hanzoguiOptions?.config ?? (await getDefaultGuiConfigPath(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")
     }
   };
 }
-function resolveWebOrNativeSpecificEntry(entry) {
+function resolveWebOrNativeSpecificEntry(entry, platform) {
   const workspaceRoot = (0, import_node_path.resolve)();
   const resolved = require.resolve(entry, {
     paths: [workspaceRoot]
   });
   const ext = (0, import_node_path.extname)(resolved);
   const fileName = (0, import_node_path.basename)(resolved).replace(ext, "");
-  const specificFile = (0, import_node_path.join)((0, import_node_path.dirname)(resolved), fileName + ".web" + ext);
+  const specificExt = (platform || "web") === "web" ? "web" : "native";
+  const specificFile = (0, import_node_path.join)((0, import_node_path.dirname)(resolved), fileName + "." + specificExt + 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) {
   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 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(`
   `)}
   `);

package/dist/extractor/regenerateConfig.cjs

@@ -43,43 +43,43 @@ var import_generate_themes = require("@hanzogui/generate-themes");
 var FS = __toESM(require("fs-extra"));
 var import_requireGuiCore = require("../helpers/requireGuiCore.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("gui") || process.env.IS_GUI_DEV) {
+    if (process.env.DEBUG?.includes("hanzogui") || process.env.IS_GUI_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("gui") || process.env.IS_GUI_DEV) {
+    if (process.env.DEBUG?.includes("hanzogui") || process.env.IS_GUI_DEV) {
       console.warn("regenerateConfig error", err);
     }
   }
 }
-async function generateGuiThemes(guiOptions, force = false) {
-  if (!guiOptions.themeBuilder) {
+async function generateGuiThemes(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;
 }
@@ -119,12 +119,12 @@ function transformConfig(config, platform) {
   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

@@ -28,8 +28,8 @@ module.exports = __toCommonJS(watchGuiConfig_exports);
 var import_loadGui = require("./loadGui.cjs");
 var import_regenerateConfig = require("./regenerateConfig.cjs");
 let isWatching = false;
-async function watchGuiConfig(guiOptions) {
-  if (process.env.NODE_ENV === "production") {
+async function watchGuiConfig(hanzoguiOptions) {
+  if (process.env.NODE_ENV === "production" || hanzoguiOptions.disable) {
     return {
       dispose() {}
     };
@@ -39,17 +39,17 @@ async function watchGuiConfig(guiOptions) {
   }
   isWatching = true;
   const options = await (0, import_loadGui.getOptions)({
-    guiOptions
+    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_loadGui.esbuildWatchFiles)(options.hanzoguiOptions.config, async () => {
+    await (0, import_loadGui.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;
@@ -57,7 +57,7 @@ async function watchGuiConfig(guiOptions) {
       inputPath = require.resolve(themeBuilderInput);
     } catch {}
     disposeThemesWatcher = await (0, import_loadGui.esbuildWatchFiles)(inputPath, async () => {
-      await (0, import_loadGui.generateThemesAndLog)(options.guiOptions);
+      await (0, import_loadGui.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":
@@ -60,10 +60,10 @@ function getPragmaOptions({
       shouldPrintDebug = "verbose";
     }
   }
-  if (process.env.DEBUG?.includes("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/registerRequire.cjs

@@ -83,7 +83,7 @@ function registerRequire(platform, {
 }) {
   if (isRegistered) {
     return {
-      guiRequire: require,
+      hanzoguiRequire: 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") || /\/gui\/code\/(core|ui|packages)\//.test(filename)) {
+      if (filename.includes("@hanzogui") || /\/hanzogui\/code\/(core|ui|packages)\//.test(filename)) {
         return false;
       }
       return true;
@@ -111,14 +111,14 @@ function registerRequire(platform, {
     og = Module.prototype.require;
   }
   isRegistered = true;
-  Module.prototype.require = guiRequire;
-  function guiRequire(path) {
+  Module.prototype.require = hanzoguiRequire;
+  function hanzoguiRequire(path) {
     const staticExtractionStub = getStaticExtractionStub(path);
     if (staticExtractionStub) {
       return staticExtractionStub;
     }
-    if (path === "gui" && platform === "native") {
-      return og.apply(this, ["gui/native"]);
+    if (path === "hanzogui" && platform === "native") {
+      return og.apply(this, ["hanzogui/native"]);
     }
     if (path === "@hanzogui/core") {
       return (0, import_requireGuiCore.requireGuiCore)(platform, path2 => {
@@ -137,7 +137,7 @@ function registerRequire(platform, {
     if (path === "react-native/package.json") {
       return og.apply(this, ["react-native-web/package.json"]);
     }
-    if (path === "@hanzogui/react-native-web-lite" || path === "react-native" || path.startsWith("react-native/")) {
+    if (path === "@hanzogui/react-native-web-lite" || path === "react-native" || path.startsWith("react-native/") || path === "react-native-web" || path.startsWith("react-native-web/")) {
       try {
         return og.apply("react-native");
       } catch {
@@ -145,11 +145,12 @@ function registerRequire(platform, {
       }
     }
     if (!whitelisted[path]) {
-      if (proxyWormImports && !path.includes(".gui-dynamic-eval")) {
+      if (proxyWormImports && !path.includes(".hanzogui-dynamic-eval")) {
         const callerFile = this?.filename || this?.id || "";
-        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) {
+        const isFromGuiPkg = callerFile.includes("@hanzogui") || callerFile.includes("node_modules/hanzogui/") || /\/hanzogui\/code\/(core|ui|packages)\//.test(callerFile);
+        const isFromStaticLoader = !callerFile || callerFile === "." || callerFile === "[eval]" || callerFile.endsWith("/[eval]") || callerFile.includes("/pkgs/compiler/static/") || callerFile.includes("/.hanzogui/");
+        const isRelativeFromWhitelisted = path.startsWith(".") && Object.keys(whitelisted).some(pkg => callerFile.includes(`/node_modules/${pkg}/`));
+        if (path === "hanzogui" || path.startsWith("@hanzogui/") || isRelativeFromWhitelisted || isFromGuiPkg || isFromStaticLoader) {
           return og.apply(this, [path]);
         }
         return proxyWorm;
@@ -159,7 +160,7 @@ function registerRequire(platform, {
       const out = og.apply(this, arguments);
       return out;
     } catch (err) {
-      if (!process.env.GUI_ENABLE_WARN_DYNAMIC_LOAD && path.includes("gui-dynamic-eval")) {
+      if (!process.env.GUI_ENABLE_WARN_DYNAMIC_LOAD && path.includes("hanzogui-dynamic-eval")) {
         return;
       }
       if (allowedIgnores[path] || IGNORES === "true") {} else if (!process.env.GUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG) {
@@ -167,16 +168,16 @@ function registerRequire(platform, {
           hasWarnedForModules.add(path);
         }
       } else {
-        console.warn(`  [gui] skipped "${path}" (set GUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`);
+        console.warn(`  [hanzogui] skipped "${path}" (set GUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`);
       }
       return proxyWorm;
     }
   }
   return {
-    guiRequire,
+    hanzoguiRequire,
     unregister: () => {
       if (hasWarnedForModules.size) {
-        console.info(`  [gui] skipped loading ${hasWarnedForModules.size} module, see: https://gui.dev/docs/intro/errors#warning-001`);
+        console.info(`  [hanzogui] skipped loading ${hasWarnedForModules.size} module, see: https://hanzogui.dev/docs/intro/errors#warning-001`);
         hasWarnedForModules.clear();
       }
       unregister();
@@ -193,7 +194,7 @@ const knownIgnorableModules = {
   solito: true,
   "expo-linear-gradient": true,
   "@expo/vector-icons": true,
-  "gui/linear-gradient": true,
+  "hanzogui/linear-gradient": true,
   // animation libraries not needed for static extraction
   "@emotion/is-prop-valid": true,
   "framer-motion": true,

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@hanzogui/static",
-  "version": "7.3.1",
+  "version": "8.0.0",
   "gitHead": "a49cc7ea6b93ba384e77a4880ae48ac4a5635c14",
-  "license": "BSD-3-Clause",
+  "license": "MIT",
   "source": "src/index.ts",
   "files": [
     "src",
@@ -35,10 +35,10 @@
     "access": "public"
   },
   "scripts": {
-    "build": "gui-build --skip-native",
-    "watch": "gui-build --skip-native --watch",
-    "clean": "gui-build clean",
-    "clean:build": "gui-build clean:build"
+    "build": "hanzogui-build --skip-native",
+    "watch": "hanzogui-build --skip-native --watch",
+    "clean": "hanzogui-build clean",
+    "clean:build": "hanzogui-build clean:build"
   },
   "dependencies": {
     "@babel/core": "^7.25.2",
@@ -50,19 +50,19 @@
     "@babel/template": "^7.25.0",
     "@babel/traverse": "^7.25.4",
     "@babel/types": "^7.25.4",
-    "@hanzogui/cli-color": "7.3.1",
-    "@hanzogui/config-default": "7.3.1",
-    "@hanzogui/core": "7.3.1",
-    "@hanzogui/fake-react-native": "7.3.1",
-    "@hanzogui/generate-themes": "7.3.1",
-    "@hanzogui/helpers": "7.3.1",
-    "@hanzogui/helpers-node": "7.3.1",
-    "@hanzogui/proxy-worm": "7.3.1",
-    "@hanzogui/react-native-web-internals": "7.3.1",
-    "@hanzogui/react-native-web-lite": "7.3.1",
-    "@hanzogui/shorthands": "7.3.1",
-    "@hanzogui/types": "7.3.0",
-    "@hanzogui/web": "7.3.1",
+    "@hanzogui/cli-color": "8.0.0",
+    "@hanzogui/config-default": "8.0.0",
+    "@hanzogui/core": "8.0.0",
+    "@hanzogui/fake-react-native": "8.0.0",
+    "@hanzogui/generate-themes": "8.0.0",
+    "@hanzogui/helpers": "8.0.0",
+    "@hanzogui/helpers-node": "8.0.0",
+    "@hanzogui/proxy-worm": "8.0.0",
+    "@hanzogui/react-native-web-internals": "8.0.0",
+    "@hanzogui/react-native-web-lite": "8.0.0",
+    "@hanzogui/shorthands": "8.0.0",
+    "@hanzogui/types": "8.0.0",
+    "@hanzogui/web": "8.0.0",
     "babel-literal-to-ast": "^2.1.0",
     "browserslist": "^4.28.1",
     "check-dependency-version-consistency": "^4.1.0",
@@ -79,7 +79,7 @@
   },
   "devDependencies": {
     "@babel/plugin-syntax-typescript": "^7.25.4",
-    "@hanzogui/build": "7.3.1",
+    "@hanzogui/build": "8.0.0",
     "@types/babel__core": "^7.20.5",
     "@types/find-root": "^1.1.2",
     "@types/node": "^22.1.0",
@@ -92,16 +92,9 @@
     "typescript": "~5.9.2"
   },
   "peerDependencies": {
-    "react": ">=19",
-    "react-native": "*"
+    "react": ">=19"
   },
   "tests": {
     "parallel": true
-  },
-  "author": "Hanzo AI <dev@hanzo.ai>",
-  "peerDependenciesMeta": {
-    "react-native": {
-      "optional": true
-    }
   }
 }

package/src/check-dep-versions.ts

@@ -575,7 +575,7 @@ function check(path: string): {
   dependencies: Dependencies
 } {
   const options: Options = {
-    includeDepPattern: ['gui', 'react-native-web-lite', 'react-native-web-internals'],
+    includeDepPattern: ['hanzogui', 'react-native-web-lite', 'react-native-web-internals'],
   }
 
   if (