@hanzogui/static 7.0.0 → 7.3.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 { HanzoguiOptions } from '../types'
+import type { GuiOptions } from '../types'
 import { createExtractor } from './createExtractor'
 import { createLogger } from './createLogger'
 import { isSimpleSpread } from './extractHelpers'
 import { literalToAst } from './literalToAst'
-import { loadHanzoguiBuildConfigSync } from './loadHanzogui'
+import { loadGuiBuildConfigSync } from './loadGui'
 
 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 hanzoguiBuildOptionsLoaded: HanzoguiOptions | null
+let guiBuildOptionsLoaded: GuiOptions | null
 
 export function extractToNative(
   sourceFileName: string,
   sourceCode: string,
-  options: HanzoguiOptions
+  options: GuiOptions
 ): BabelFileResult {
   const ast = parse(sourceCode, {
     sourceType: 'module',
@@ -55,15 +55,15 @@ export function extractToNative(
 }
 
 export function getBabelPlugin() {
-  return declare((api, options: HanzoguiOptions) => {
+  return declare((api, options: GuiOptions) => {
     api.assertVersion(7)
     return getBabelParseDefinition(options)
   })
 }
 
-export function getBabelParseDefinition(options: HanzoguiOptions) {
+export function getBabelParseDefinition(options: GuiOptions) {
   return {
-    name: 'hanzogui',
+    name: 'gui',
 
     visitor: {
       Program: {
@@ -106,16 +106,16 @@ export function getBabelParseDefinition(options: HanzoguiOptions) {
           }
 
           if (!options.config && !options.components) {
-            // if no config/components given try and load from the hanzogui.build.ts file
-            hanzoguiBuildOptionsLoaded ||= loadHanzoguiBuildConfigSync({})
+            // if no config/components given try and load from the gui.build.ts file
+            guiBuildOptionsLoaded ||= loadGuiBuildConfigSync({})
           }
 
           const finalOptions = {
             // @ts-ignore just in case they leave it out
             platform: 'native',
-            ...hanzoguiBuildOptionsLoaded,
+            ...guiBuildOptionsLoaded,
             ...options,
-          } satisfies HanzoguiOptions
+          } satisfies GuiOptions
 
           const printLog = createLogger(sourcePath, finalOptions)
 
@@ -419,7 +419,7 @@ export function getBabelParseDefinition(options: HanzoguiOptions) {
               if (message.includes('Unexpected return value from visitor method')) {
                 message = 'Unexpected return value from visitor method'
               }
-              console.warn('Error in Hanzogui parse, skipping', message, err.stack)
+              console.warn('Error in Gui 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('hanzogui')) {
+    if (process.env.DEBUG?.startsWith('gui')) {
       console.warn('⚠️ Cannot pass style attribute to extracted style')
     }
   }

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

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

package/src/extractor/getPrefixLogs.ts

@@ -1,9 +1,9 @@
 import { Color, colorString } from '@hanzogui/cli-color'
-import type { HanzoguiOptions } from '../types'
+import type { GuiOptions } from '../types'
 
-export function getPrefixLogs(options?: HanzoguiOptions) {
+export function getPrefixLogs(options?: GuiOptions) {
   return (
     options?.prefixLogs ??
-    ` 🐥 [hanzogui]  ${colorString(Color.FgYellow, options?.platform || 'web')}`
+    ` 🐥 [gui]  ${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=hanzogui for more)`
+            `    | Skipping partial evaluation of constant file: ${moduleName} (DEBUG=gui for more)`
           )
-        } else if (process.env.DEBUG?.startsWith('hanzogui')) {
+        } else if (process.env.DEBUG?.startsWith('gui')) {
           console.info(`Error in partial evaluation`, err.message, err.stack)
         }
       }

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