@hanzogui/static 4.3.1 → 7.0.0

package/src/extractor/extractToNative.ts

@@ -6,12 +6,12 @@ import template from '@babel/template'
 import * as t from '@babel/types'
 import { basename } from 'node:path'
 import { getPragmaOptions } from '../getPragmaOptions'
-import type { GuiOptions } from '../types'
+import type { HanzoguiOptions } from '../types'
 import { createExtractor } from './createExtractor'
 import { createLogger } from './createLogger'
 import { isSimpleSpread } from './extractHelpers'
 import { literalToAst } from './literalToAst'
-import { loadGuiBuildConfigSync } from './loadGui'
+import { loadHanzoguiBuildConfigSync } from './loadHanzogui'
 
 const importNativeView = template(`
 const __ReactNativeView = require('react-native').View;
@@ -26,12 +26,12 @@ const importWithStyle = template.ast(`import { _withStableStyle } from '@hanzogu
 
 const extractor = createExtractor({ platform: 'native' })
 
-let guiBuildOptionsLoaded: GuiOptions | null
+let hanzoguiBuildOptionsLoaded: HanzoguiOptions | null
 
 export function extractToNative(
   sourceFileName: string,
   sourceCode: string,
-  options: GuiOptions
+  options: HanzoguiOptions
 ): BabelFileResult {
   const ast = parse(sourceCode, {
     sourceType: 'module',
@@ -55,15 +55,15 @@ export function extractToNative(
 }
 
 export function getBabelPlugin() {
-  return declare((api, options: GuiOptions) => {
+  return declare((api, options: HanzoguiOptions) => {
     api.assertVersion(7)
     return getBabelParseDefinition(options)
   })
 }
 
-export function getBabelParseDefinition(options: GuiOptions) {
+export function getBabelParseDefinition(options: HanzoguiOptions) {
   return {
-    name: 'hanzo-gui',
+    name: 'hanzogui',
 
     visitor: {
       Program: {
@@ -106,16 +106,16 @@ export function getBabelParseDefinition(options: GuiOptions) {
           }
 
           if (!options.config && !options.components) {
-            // if no config/components given try and load from the gui.build.ts file
-            guiBuildOptionsLoaded ||= loadGuiBuildConfigSync({})
+            // if no config/components given try and load from the hanzogui.build.ts file
+            hanzoguiBuildOptionsLoaded ||= loadHanzoguiBuildConfigSync({})
           }
 
           const finalOptions = {
             // @ts-ignore just in case they leave it out
             platform: 'native',
-            ...guiBuildOptionsLoaded,
+            ...hanzoguiBuildOptionsLoaded,
             ...options,
-          } satisfies GuiOptions
+          } satisfies HanzoguiOptions
 
           const printLog = createLogger(sourcePath, finalOptions)
 
@@ -419,7 +419,7 @@ export function getBabelParseDefinition(options: GuiOptions) {
               if (message.includes('Unexpected return value from visitor method')) {
                 message = 'Unexpected return value from visitor method'
               }
-              console.warn('Error in GUI parse, skipping', message, err.stack)
+              console.warn('Error in Hanzogui parse, skipping', message, err.stack)
               return
             }
           }
@@ -466,7 +466,7 @@ function assertValidTag(node: t.JSXOpeningElement) {
   if (node.attributes.find((x) => x.type === 'JSXAttribute' && x.name.name === 'style')) {
     // we can just deopt here instead and log warning
     // need to make onExtractTag have a special catch error or similar
-    if (process.env.DEBUG?.startsWith('@hanzo/gui')) {
+    if (process.env.DEBUG?.startsWith('hanzogui')) {
       console.warn('⚠️ Cannot pass style attribute to extracted style')
     }
   }

package/src/extractor/{getGuiConfigPathFromOptionsConfig.ts → getHanzoguiConfigPathFromOptionsConfig.ts}

@@ -1,10 +1,10 @@
 import { isAbsolute, join } from 'node:path'
 
 import { statSync } from 'node:fs'
-import type { GuiOptions } from '../types'
+import type { HanzoguiOptions } from '../types'
 
-export function getGuiConfigPathFromOptionsConfig(
-  config: NonNullable<GuiOptions['config']>
+export function getHanzoguiConfigPathFromOptionsConfig(
+  config: NonNullable<HanzoguiOptions['config']>
 ) {
   if (isAbsolute(config)) {
     return config

package/src/extractor/getPrefixLogs.ts

@@ -1,9 +1,9 @@
 import { Color, colorString } from '@hanzogui/cli-color'
-import type { GuiOptions } from '../types'
+import type { HanzoguiOptions } from '../types'
 
-export function getPrefixLogs(options?: GuiOptions) {
+export function getPrefixLogs(options?: HanzoguiOptions) {
   return (
     options?.prefixLogs ??
-    ` 🐥 [hanzo-gui]  ${colorString(Color.FgYellow, options?.platform || 'web')}`
+    ` 🐥 [hanzogui]  ${colorString(Color.FgYellow, options?.platform || 'web')}`
   )
 }

package/src/extractor/getStaticBindingsForScope.ts

@@ -137,9 +137,9 @@ export async function getStaticBindingsForScope(
       } catch (err: any) {
         if (shouldPrintDebug) {
           console.warn(
-            `    | Skipping partial evaluation of constant file: ${moduleName} (DEBUG=hanzo-gui for more)`
+            `    | Skipping partial evaluation of constant file: ${moduleName} (DEBUG=hanzogui for more)`
           )
-        } else if (process.env.DEBUG?.startsWith('@hanzo/gui')) {
+        } else if (process.env.DEBUG?.startsWith('hanzogui')) {
           console.info(`Error in partial evaluation`, err.message, err.stack)
         }
       }

package/src/extractor/hasTopLevelAwait.ts

@@ -0,0 +1,28 @@
+import traverse from '@babel/traverse'
+import { babelParse } from './babelParse'
+
+export function hasTopLevelAwait(contents: string, fileName?: string) {
+  if (!contents.includes('await')) {
+    return false
+  }
+
+  const ast = babelParse(contents, fileName)
+  let found = false
+
+  traverse(ast, {
+    AwaitExpression(path) {
+      if (!path.getFunctionParent()) {
+        found = true
+        path.stop()
+      }
+    },
+    ForOfStatement(path) {
+      if (path.node.await && !path.getFunctionParent()) {
+        found = true
+        path.stop()
+      }
+    },
+  })
+
+  return found
+}

package/src/extractor/{loadGui.ts → loadHanzogui.ts}

@@ -1,43 +1,43 @@
 import { basename, dirname, extname, join, relative, resolve } from 'node:path'
 // @ts-ignore why
 import { Color, colorLog } from '@hanzogui/cli-color'
-import type { CLIResolvedOptions, CLIUserOptions, GuiOptions } from '@hanzogui/types'
-import type { GuiInternalConfig } from '@hanzogui/web'
+import type { CLIResolvedOptions, CLIUserOptions, HanzoguiOptions } from '@hanzogui/types'
+import type { HanzoguiInternalConfig } from '@hanzogui/web'
 import esbuild from 'esbuild'
 import * as esbuildWasm from 'esbuild-wasm'
 import * as fsExtra from 'fs-extra'
 
 import { SHOULD_DEBUG } from '../constants'
-import { requireGuiCore } from '../helpers/requireGuiCore'
+import { requireHanzoguiCore } from '../helpers/requireHanzoguiCore'
 import { getNameToPaths, registerRequire } from '../registerRequire'
 import {
-  type GuiProjectInfo,
+  type HanzoguiProjectInfo,
   getBundledConfig,
   getLoadedConfig,
   hasBundledConfigChanged,
   loadComponentsSync,
-  writeGuiCSS,
+  writeHanzoguiCSS,
 } from './bundleConfig'
-import { getGuiConfigPathFromOptionsConfig } from './getGuiConfigPathFromOptionsConfig'
+import { getHanzoguiConfigPathFromOptionsConfig } from './getHanzoguiConfigPathFromOptionsConfig'
 import {
-  generateGuiThemes,
+  generateHanzoguiThemes,
   regenerateConfig,
   regenerateConfigSync,
 } from './regenerateConfig'
 
-const getFilledOptions = (propsIn: Partial<GuiOptions>): GuiOptions => ({
+const getFilledOptions = (propsIn: Partial<HanzoguiOptions>): HanzoguiOptions => ({
   // defaults
-  platform: (process.env.GUI_TARGET as any) || 'web',
-  config: 'gui.config.ts',
-  components: ['@hanzo/gui'],
-  ...(propsIn as Partial<GuiOptions>),
+  platform: (process.env.TAMAGUI_TARGET as any) || 'web',
+  config: 'hanzogui.config.ts',
+  components: ['hanzogui'],
+  ...(propsIn as Partial<HanzoguiOptions>),
 })
 
 let isLoadingPromise: null | Promise<any>
 
-export async function loadGui(
-  propsIn: Partial<GuiOptions>
-): Promise<GuiProjectInfo | null> {
+export async function loadHanzogui(
+  propsIn: Partial<HanzoguiOptions>
+): Promise<HanzoguiProjectInfo | null> {
   if (isLoadingPromise) return await isLoadingPromise
 
   let resolvePromise
@@ -53,7 +53,7 @@ export async function loadGui(
     const bundleInfo = await 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.`
+        `No bundled config generated, maybe an error in bundling. Set DEBUG=hanzogui and re-run to get logs.`
       )
       resolvePromise(null)
       return null
@@ -62,11 +62,11 @@ export async function loadGui(
     // this affects the bundled config so run it first
     await generateThemesAndLog(props)
 
-    // if they accidently pass in a config without createGui called,call it
-    const maybeGuiConfig = bundleInfo.guiConfig as GuiInternalConfig
-    if (maybeGuiConfig && !maybeGuiConfig.parsed) {
-      const { createGui } = requireGuiCore(props.platform || 'web')
-      bundleInfo.guiConfig = createGui(bundleInfo.guiConfig as any)
+    // if they accidently pass in a config without createHanzogui called,call it
+    const maybeHanzoguiConfig = bundleInfo.hanzoguiConfig as HanzoguiInternalConfig
+    if (maybeHanzoguiConfig && !maybeHanzoguiConfig.parsed) {
+      const { createHanzogui } = requireHanzoguiCore(props.platform || 'web')
+      bundleInfo.hanzoguiConfig = createHanzogui(bundleInfo.hanzoguiConfig as any)
     }
 
     if (!hasBundledConfigChanged()) {
@@ -89,20 +89,20 @@ export async function loadGui(
 // debounce a bit
 let waiting = false
 
-export const generateThemesAndLog = async (options: GuiOptions, force = false) => {
+export const generateThemesAndLog = async (options: HanzoguiOptions, force = false) => {
   if (waiting) return
   if (!options.themeBuilder) return
   try {
     waiting = true
     await new Promise((res) => setTimeout(res, 30))
-    const didGenerate = await generateGuiThemes(options, force)
+    const didGenerate = await generateHanzoguiThemes(options, force)
 
     // only logs when changed
     if (didGenerate) {
       const whitespaceBefore = `  `
       colorLog(
         Color.FgYellow,
-        `${whitespaceBefore}➡ [hanzo-gui] generated themes: ${relative(
+        `${whitespaceBefore}➡ [hanzogui] generated themes: ${relative(
           process.cwd(),
           options.themeBuilder.output
         )}`
@@ -111,7 +111,7 @@ export const generateThemesAndLog = async (options: GuiOptions, force = false) =
       if (options.outputCSS) {
         const loadedConfig = getLoadedConfig()
         if (loadedConfig) {
-          await writeGuiCSS(options.outputCSS, loadedConfig)
+          await writeHanzoguiCSS(options.outputCSS, loadedConfig)
         }
       }
     }
@@ -120,20 +120,20 @@ export const generateThemesAndLog = async (options: GuiOptions, force = false) =
   }
 }
 
-const last: Record<string, GuiProjectInfo | null> = {}
+const last: Record<string, HanzoguiProjectInfo | null> = {}
 const lastVersion: Record<string, string> = {}
 
 // esbuild-wasm state - initialized once per process
 let esbuildWasmInitialized = false
 
 /**
- * Load gui.build.ts config using esbuild-wasm transform
+ * Load hanzogui.build.ts config using esbuild-wasm transform
  * Uses WASM to avoid native esbuild service lifecycle issues (EPIPE errors)
  */
-export async function loadGuiBuildConfigAsync(
-  guiOptions: Partial<GuiOptions> | undefined
-): Promise<GuiOptions> {
-  const buildFilePath = guiOptions?.buildFile ?? './gui.build.ts'
+export async function loadHanzoguiBuildConfigAsync(
+  hanzoguiOptions: Partial<HanzoguiOptions> | undefined
+): Promise<HanzoguiOptions> {
+  const buildFilePath = hanzoguiOptions?.buildFile ?? './hanzogui.build.ts'
   const absolutePath =
     buildFilePath[0] === '.' ? join(process.cwd(), buildFilePath) : buildFilePath
 
@@ -166,34 +166,36 @@ export async function loadGuiBuildConfigAsync(
         throw new Error(`No default export found in ${buildFilePath}: ${out}`)
       }
 
-      guiOptions = {
-        ...guiOptions,
+      hanzoguiOptions = {
+        ...hanzoguiOptions,
         ...out,
       }
     } catch (err) {
-      console.error(`[hanzo-gui] Error loading ${buildFilePath}:`, err)
+      console.error(`[hanzogui] Error loading ${buildFilePath}:`, err)
       throw err
     }
   }
 
-  if (!guiOptions) {
+  if (!hanzoguiOptions) {
     throw new Error(
-      `No hanzo-gui build options found either via input props or at gui.build.ts`
+      `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,
-  } as GuiOptions
+    config: 'hanzogui.config.ts',
+    components: ['hanzogui', '@hanzogui/core'],
+    ...hanzoguiOptions,
+  } as HanzoguiOptions
 }
 
 /**
- * @deprecated Use loadGuiBuildConfigAsync instead to avoid EPIPE errors
+ * @deprecated Use loadHanzoguiBuildConfigAsync instead to avoid EPIPE errors
  */
-export function loadGuiBuildConfigSync(guiOptions: Partial<GuiOptions> | undefined) {
-  const buildFilePath = guiOptions?.buildFile ?? './gui.build.ts'
+export function loadHanzoguiBuildConfigSync(
+  hanzoguiOptions: Partial<HanzoguiOptions> | undefined
+) {
+  const buildFilePath = hanzoguiOptions?.buildFile ?? './hanzogui.build.ts'
   if (fsExtra.existsSync(buildFilePath)) {
     const registered = registerRequire('web')
     try {
@@ -204,35 +206,35 @@ export function loadGuiBuildConfigSync(guiOptions: Partial<GuiOptions> | undefin
         throw new Error(`No default export found in ${buildFilePath}: ${out}`)
       }
 
-      guiOptions = {
-        ...guiOptions,
+      hanzoguiOptions = {
+        ...hanzoguiOptions,
         ...out,
       }
     } finally {
       registered.unregister()
     }
   }
-  if (!guiOptions) {
+  if (!hanzoguiOptions) {
     throw new Error(
-      `No hanzo-gui build options found either via input props or at gui.build.ts`
+      `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,
-  } as GuiOptions
+    config: 'hanzogui.config.ts',
+    components: ['hanzogui', '@hanzogui/core'],
+    ...hanzoguiOptions,
+  } as HanzoguiOptions
 }
 
 // loads in-process using esbuild-register
-export function loadGuiSync({
+export function loadHanzoguiSync({
   forceExports,
   cacheKey,
   ...propsIn
-}: Partial<GuiOptions> & {
+}: Partial<HanzoguiOptions> & {
   forceExports?: boolean
   cacheKey?: string
-}): GuiProjectInfo {
+}): HanzoguiProjectInfo {
   const key = JSON.stringify(propsIn)
 
   if (last[key] && !hasBundledConfigChanged()) {
@@ -248,7 +250,7 @@ export function loadGuiSync({
   // lets shim require and avoid importing react-native + react-native-web
   // we just need to read the config around them
   process.env.IS_STATIC = 'is_static'
-  process.env.GUI_IS_SERVER = 'true'
+  process.env.TAMAGUI_IS_SERVER = 'true'
 
   const { unregister } = registerRequire(props.platform || 'web', {
     proxyWormImports: !!forceExports,
@@ -260,18 +262,18 @@ export function loadGuiSync({
 
     try {
       // config
-      let guiConfig: GuiInternalConfig | null = null
+      let hanzoguiConfig: HanzoguiInternalConfig | null = null
       if (propsIn.config) {
-        const configPath = getGuiConfigPathFromOptionsConfig(propsIn.config)
+        const configPath = 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) as GuiInternalConfig
+        hanzoguiConfig = (exp['default'] || exp['config'] || exp) as HanzoguiInternalConfig
 
-        if (!guiConfig || !guiConfig.parsed) {
+        if (!hanzoguiConfig || !hanzoguiConfig.parsed) {
           const confPath = require.resolve(configPath)
           throw new Error(`Can't find valid config in ${confPath}:
           
@@ -279,9 +281,9 @@ export function loadGuiSync({
         }
 
         // set up core
-        if (guiConfig) {
-          const { createGui } = requireGuiCore(props.platform || 'web')
-          createGui(guiConfig as any)
+        if (hanzoguiConfig) {
+          const { createHanzogui } = requireHanzoguiCore(props.platform || 'web')
+          createHanzogui(hanzoguiConfig as any)
         }
       }
 
@@ -290,7 +292,7 @@ export function loadGuiSync({
       if (!components) {
         throw new Error(`No components loaded`)
       }
-      if (process.env.DEBUG === '@hanzo/gui') {
+      if (process.env.DEBUG === 'hanzogui') {
         console.info(`components`, components)
       }
 
@@ -300,14 +302,14 @@ export function loadGuiSync({
 
       const info = {
         components,
-        guiConfig,
+        hanzoguiConfig,
         nameToPaths: getNameToPaths(),
-      } satisfies GuiProjectInfo
+      } satisfies HanzoguiProjectInfo
 
-      if (guiConfig) {
+      if (hanzoguiConfig) {
         const { outputCSS } = props
         if (outputCSS) {
-          writeGuiCSS(outputCSS, guiConfig)
+          writeHanzoguiCSS(outputCSS, hanzoguiConfig)
         }
 
         regenerateConfigSync(props, info)
@@ -323,7 +325,7 @@ export function loadGuiSync({
       if (err instanceof Error) {
         if (!SHOULD_DEBUG && !forceExports) {
           console.warn(
-            `Error loading gui.config.ts (set DEBUG=hanzo-gui to see full stack), running hanzo-gui without custom config`
+            `Error loading hanzogui.config.ts (set DEBUG=hanzogui to see full stack), running hanzogui without custom config`
           )
           console.info(`\n\n    ${err.message}\n\n`)
         } else {
@@ -332,12 +334,12 @@ export function loadGuiSync({
           }
         }
       } else {
-        console.error(`Error loading gui.config.ts`, err)
+        console.error(`Error loading hanzogui.config.ts`, err)
       }
 
       return {
         components: [],
-        guiConfig: null,
+        hanzoguiConfig: null,
         nameToPaths: {},
       }
     }
@@ -349,11 +351,11 @@ export function loadGuiSync({
 export async function getOptions({
   root = process.cwd(),
   tsconfigPath = 'tsconfig.json',
-  guiOptions,
+  hanzoguiOptions,
   host,
   debug,
 }: Partial<CLIUserOptions> = {}): Promise<CLIResolvedOptions> {
-  const dotDir = join(root, '.gui')
+  const dotDir = join(root, '.hanzogui')
   let pkgJson = {}
 
   try {
@@ -369,17 +371,18 @@ export async function getOptions({
     pkgJson,
     debug,
     tsconfigPath,
-    guiOptions: {
-      platform: (process.env.GUI_TARGET as any) || 'web',
-      components: ['@hanzo/gui'],
-      ...guiOptions,
+    hanzoguiOptions: {
+      platform: (process.env.TAMAGUI_TARGET as any) || 'web',
+      components: ['hanzogui'],
+      ...hanzoguiOptions,
       config:
-        guiOptions?.config ?? (await getDefaultGuiConfigPath(root, guiOptions?.config)),
+        hanzoguiOptions?.config ??
+        (await getDefaultHanzoguiConfigPath(root, hanzoguiOptions?.config)),
     },
     paths: {
       root,
       dotDir,
-      conf: join(dotDir, 'gui.config.json'),
+      conf: join(dotDir, 'hanzogui.config.json'),
       types: join(dotDir, 'types.json'),
     },
   }
@@ -390,7 +393,7 @@ export function resolveWebOrNativeSpecificEntry(entry: string) {
   const resolved = require.resolve(entry, { paths: [workspaceRoot] })
   const ext = extname(resolved)
   const fileName = basename(resolved).replace(ext, '')
-  const specificExt = process.env.GUI_TARGET === 'web' ? 'web' : 'native'
+  const specificExt = process.env.TAMAGUI_TARGET === 'web' ? 'web' : 'native'
   const specificFile = join(dirname(resolved), fileName + '.' + specificExt + ext)
   if (fsExtra.existsSync(specificFile)) {
     return specificFile
@@ -398,10 +401,10 @@ export function resolveWebOrNativeSpecificEntry(entry: string) {
   return entry
 }
 
-const defaultPaths = ['gui.config.ts', join('src', 'gui.config.ts')]
+const defaultPaths = ['hanzogui.config.ts', join('src', 'hanzogui.config.ts')]
 let hasWarnedOnce = false
 
-async function getDefaultGuiConfigPath(root: string, configPath?: string) {
+async function getDefaultHanzoguiConfigPath(root: string, configPath?: string) {
   const searchPaths = [
     ...new Set(
       [configPath, ...defaultPaths].filter(Boolean).map((p) => join(root, p as string))
@@ -416,13 +419,13 @@ async function getDefaultGuiConfigPath(root: string, configPath?: string) {
 
   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(`\n  `)}
   `)
   }
 }
 
-export type { GuiProjectInfo }
+export type { HanzoguiProjectInfo }
 
 export async function esbuildWatchFiles(entry: string, onChanged: () => void) {
   let hasRunOnce = false