@hanzogui/static 4.4.0 → 7.0.0

package/src/extractor/regenerateConfig.ts

@@ -1,65 +1,75 @@
 import { dirname, join } from 'node:path'
 
 import { generateThemes, writeGeneratedThemes } from '@hanzogui/generate-themes'
-import type { GuiOptions } from '@hanzogui/types'
+import type { HanzoguiOptions } from '@hanzogui/types'
 import * as FS from 'fs-extra'
 
-import { requireGuiCore } from '../helpers/requireGuiCore'
-import type { GuiPlatform } from '../types'
+import { requireHanzoguiCore } from '../helpers/requireHanzoguiCore'
+import type { HanzoguiPlatform } from '../types'
 import type { BundledConfig } from './bundleConfig'
 import { getBundledConfig } from './bundleConfig'
 
-const guiDir = join(process.cwd(), '.gui')
-const confFile = join(guiDir, 'gui.config.json')
+const hanzoguiDir = join(process.cwd(), '.hanzogui')
+const confFile = join(hanzoguiDir, 'hanzogui.config.json')
 
 /**
  * Sort of a super-set of bundleConfig(), this code needs some refactoring ideally
  */
 
 export async function regenerateConfig(
-  guiOptions: GuiOptions,
+  hanzoguiOptions: HanzoguiOptions,
   configIn?: BundledConfig | null,
   rebuild = false
 ) {
   try {
     // this has a side effect of rebuilding config and css!
     // need to improve code here:
-    const config = configIn ?? (await getBundledConfig(guiOptions, rebuild))
+    const config = configIn ?? (await getBundledConfig(hanzoguiOptions, rebuild))
     if (!config) return
-    const out = transformConfig(config, guiOptions.platform || 'web')
+    const out = transformConfig(config, hanzoguiOptions.platform || 'web')
 
     await FS.ensureDir(dirname(confFile))
     await FS.writeJSON(confFile, out, {
       spaces: 2,
     })
   } catch (err) {
-    if (process.env.DEBUG?.includes('@hanzo/gui') || process.env.IS_GUI_DEV) {
+    if (process.env.DEBUG?.includes('hanzogui') || process.env.IS_TAMAGUI_DEV) {
       console.warn('regenerateConfig error', err)
     }
     // ignore for now
   }
 }
 
-export function regenerateConfigSync(_guiOptions: GuiOptions, config: BundledConfig) {
+export function regenerateConfigSync(
+  _hanzoguiOptions: HanzoguiOptions,
+  config: BundledConfig
+) {
   try {
     FS.ensureDirSync(dirname(confFile))
-    FS.writeJSONSync(confFile, transformConfig(config, _guiOptions.platform || 'web'), {
-      spaces: 2,
-    })
+    FS.writeJSONSync(
+      confFile,
+      transformConfig(config, _hanzoguiOptions.platform || 'web'),
+      {
+        spaces: 2,
+      }
+    )
   } catch (err) {
-    if (process.env.DEBUG?.includes('@hanzo/gui') || process.env.IS_GUI_DEV) {
+    if (process.env.DEBUG?.includes('hanzogui') || process.env.IS_TAMAGUI_DEV) {
       console.warn('regenerateConfig error', err)
     }
     // ignore for now
   }
 }
 
-export async function generateGuiThemes(guiOptions: GuiOptions, force = false) {
-  if (!guiOptions.themeBuilder) {
+export async function generateHanzoguiThemes(
+  hanzoguiOptions: HanzoguiOptions,
+  force = false
+) {
+  if (!hanzoguiOptions.themeBuilder) {
     return
   }
 
-  const { input, output } = guiOptions.themeBuilder
+  const { input, output } = hanzoguiOptions.themeBuilder
   const inPath = resolveRelativePath(input)
   const outPath = resolveRelativePath(output)
   const generatedOutput = await generateThemes(inPath)
@@ -80,7 +90,7 @@ export async function generateGuiThemes(guiOptions: GuiOptions, force = false) {
     })())
 
   if (hasChanged) {
-    await writeGeneratedThemes(guiDir, outPath, generatedOutput)
+    await writeGeneratedThemes(hanzoguiDir, outPath, generatedOutput)
   }
 
   return hasChanged
@@ -100,20 +110,20 @@ function cloneDeepSafe(x: any, excludeKeys = {}) {
   )
 }
 
-function transformConfig(config: BundledConfig, platform: GuiPlatform) {
+function transformConfig(config: BundledConfig, platform: HanzoguiPlatform) {
   if (!config) {
     return null
   }
 
-  const { getVariableValue } = requireGuiCore(platform)
+  const { getVariableValue } = requireHanzoguiCore(platform)
 
   // ensure we don't mangle anything in the original
   const next = cloneDeepSafe(config, {
     validStyles: true,
   }) as BundledConfig
 
-  const { components, nameToPaths, guiConfig } = next
-  const { themes, tokens } = guiConfig
+  const { components, nameToPaths, hanzoguiConfig } = next
+  const { themes, tokens } = hanzoguiConfig
 
   // reduce down to usable, smaller json
 
@@ -162,12 +172,12 @@ function transformConfig(config: BundledConfig, platform: GuiPlatform) {
     shorthands: _shorthands,
     userShorthands,
     ...cleanedConfig
-  } = next.guiConfig
+  } = next.hanzoguiConfig
 
   return {
     components,
     nameToPaths,
-    guiConfig: {
+    hanzoguiConfig: {
       ...cleanedConfig,
       // Output userShorthands as shorthands (excludes built-ins)
       shorthands: userShorthands,

package/src/extractor/{watchGuiConfig.ts → watchHanzoguiConfig.ts}

@@ -1,10 +1,10 @@
-import type { GuiOptions } from '@hanzogui/types'
-import { esbuildWatchFiles, generateThemesAndLog, getOptions } from './loadGui'
+import type { HanzoguiOptions } from '@hanzogui/types'
+import { esbuildWatchFiles, generateThemesAndLog, getOptions } from './loadHanzogui'
 import { regenerateConfig } from './regenerateConfig'
 
 let isWatching = false
 
-export async function watchGuiConfig(guiOptions: GuiOptions) {
+export async function watchHanzoguiConfig(hanzoguiOptions: HanzoguiOptions) {
   if (process.env.NODE_ENV === 'production') {
     return {
       dispose() {},
@@ -17,22 +17,22 @@ export async function watchGuiConfig(guiOptions: GuiOptions) {
 
   isWatching = true
 
-  const options = await getOptions({ guiOptions })
+  const options = await getOptions({ hanzoguiOptions })
 
-  if (!options.guiOptions.config) {
+  if (!options.hanzoguiOptions.config) {
     isWatching = false
     throw new Error(`No config`)
   }
 
   const disposeConfigWatcher = await esbuildWatchFiles(
-    options.guiOptions.config,
+    options.hanzoguiOptions.config,
     async () => {
-      await generateThemesAndLog(options.guiOptions)
-      await regenerateConfig(options.guiOptions, null, true)
+      await generateThemesAndLog(options.hanzoguiOptions)
+      await regenerateConfig(options.hanzoguiOptions, null, true)
     }
   )
 
-  const themeBuilderInput = options.guiOptions.themeBuilder?.input
+  const themeBuilderInput = options.hanzoguiOptions.themeBuilder?.input
   let disposeThemesWatcher: Function | undefined
 
   if (themeBuilderInput) {
@@ -43,7 +43,7 @@ export async function watchGuiConfig(guiOptions: GuiOptions) {
       // ok
     }
     disposeThemesWatcher = await esbuildWatchFiles(inputPath, async () => {
-      await generateThemesAndLog(options.guiOptions)
+      await generateThemesAndLog(options.hanzoguiOptions)
     })
   }
 

package/src/getPragmaOptions.ts

@@ -14,7 +14,7 @@ export function getPragmaOptions({ source, path }: { source: string; path: strin
     }
     pragma =
       trimmed
-        .match(/(\/\/|\/\*)\s?!?\s?(gui-ignore|debug|debug-verbose)(\n|\s|$).*/)?.[2]
+        .match(/(\/\/|\/\*)\s?!?\s?(hanzogui-ignore|debug|debug-verbose)(\n|\s|$).*/)?.[2]
         .trim() || ''
     if (pragma) {
       pragma = pragma.replace('!', '').trim()
@@ -23,7 +23,7 @@ export function getPragmaOptions({ source, path }: { source: string; path: strin
   }
 
   switch (pragma) {
-    case 'gui-ignore':
+    case 'hanzogui-ignore':
       shouldDisable = true
       break
 
@@ -36,17 +36,17 @@ export function getPragmaOptions({ source, path }: { source: string; path: strin
       break
   }
 
-  if (process.env.GUI_DEBUG_FILE) {
-    if (path.includes(process.env.GUI_DEBUG_FILE)) {
+  if (process.env.TAMAGUI_DEBUG_FILE) {
+    if (path.includes(process.env.TAMAGUI_DEBUG_FILE)) {
       shouldPrintDebug = 'verbose'
     }
   }
 
-  if (process.env.DEBUG?.includes('@hanzo/gui')) {
+  if (process.env.DEBUG?.includes('hanzogui')) {
     shouldPrintDebug ||= true
   }
 
-  if (process.env.DEBUG?.includes('gui-verbose')) {
+  if (process.env.DEBUG?.includes('hanzogui-verbose')) {
     shouldPrintDebug = 'verbose'
   }
 

package/src/helpers/requireHanzoguiCore.ts

@@ -0,0 +1,28 @@
+// this allows us to swap between core native and web in the same process:
+
+import type { HanzoguiPlatform } from '../types'
+
+export function requireHanzoguiCore(
+  platform: HanzoguiPlatform,
+  ogRequire: Function = require
+): typeof import('@hanzogui/core') {
+  if (!platform) {
+    throw new Error(`No platform given to requireHanzoguiCore`)
+  }
+
+  // avoid tree shaking out themes
+  const og1 = process.env.TAMAGUI_IS_SERVER
+  const og2 = process.env.TAMAGUI_KEEP_THEMES
+  process.env.TAMAGUI_IS_SERVER ||= '1'
+  process.env.TAMAGUI_KEEP_THEMES ||= '1'
+
+  const exported = ogRequire(
+    platform === 'native' ? '@hanzogui/core/native' : '@hanzogui/core'
+  )
+
+  // restore back
+  process.env.TAMAGUI_IS_SERVER = og1
+  process.env.TAMAGUI_KEEP_THEMES = og2
+
+  return exported
+}

package/src/registerRequire.ts

@@ -1,8 +1,8 @@
 import { register } from 'esbuild-register/dist/node'
 
 import { esbuildIgnoreFilesRegex } from './extractor/bundle'
-import { requireGuiCore } from './helpers/requireGuiCore'
-import type { GuiPlatform } from './types'
+import { requireHanzoguiCore } from './helpers/requireHanzoguiCore'
+import type { HanzoguiPlatform } from './types'
 
 const nameToPaths = {}
 
@@ -54,7 +54,7 @@ function getStaticExtractionStub(path: string) {
 }
 
 export function registerRequire(
-  platform: GuiPlatform,
+  platform: HanzoguiPlatform,
   { proxyWormImports } = {
     proxyWormImports: false,
   }
@@ -62,23 +62,22 @@ export function registerRequire(
   // already registered
   if (isRegistered) {
     return {
-      guiRequire: require,
+      hanzoguiRequire: require,
       unregister: () => {},
     }
   }
 
   // capture original resolve BEFORE esbuild-register patches it
-  // so we can use Node's native exports resolution for @gui packages
+  // so we can use Node's native exports resolution for @hanzogui packages
   const originalResolveFilename = Module._resolveFilename
 
   const { unregister } = register({
     hookIgnoreNodeModules: false,
-    // don't transform @hanzo/gui packages - they have pre-built dist files
+    // don't transform @hanzogui packages - they have pre-built dist files
     hookMatcher: (filename) => {
       if (
-        filename.includes('@hanzo/gui') ||
-        filename.includes('@gui') ||
-        /\/(hanzo\/gui|gui)\/code\/(core|ui|packages)\//.test(filename)
+        filename.includes('@hanzogui') ||
+        /\/hanzogui\/code\/(core|ui|packages)\//.test(filename)
       ) {
         return false
       }
@@ -88,10 +87,10 @@ export function registerRequire(
 
   // esbuild-register's registerTsconfigPaths replaces Module._resolveFilename
   // but tsconfig paths resolution bypasses Node's package exports
-  // we need to restore Node's native resolution for @gui packages
+  // we need to restore Node's native resolution for @hanzogui packages
   const tsconfigPatchedResolve = Module._resolveFilename
   Module._resolveFilename = function (request: string, ...args: any[]) {
-    // for @gui packages, use Node's native resolution (respects exports)
+    // for @hanzogui packages, use Node's native resolution (respects exports)
     if (request.startsWith('@hanzogui/')) {
       return originalResolveFilename.call(this, request, ...args)
     }
@@ -105,20 +104,20 @@ export function registerRequire(
 
   isRegistered = true
 
-  Module.prototype.require = guiRequire
+  Module.prototype.require = hanzoguiRequire
 
-  function guiRequire(this: any, path: string) {
+  function hanzoguiRequire(this: any, path: string) {
     const staticExtractionStub = getStaticExtractionStub(path)
     if (staticExtractionStub) {
       return staticExtractionStub
     }
 
-    if (path === '@hanzo/gui' && platform === 'native') {
-      return og.apply(this, ['@hanzo/gui/native'])
+    if (path === 'hanzogui' && platform === 'native') {
+      return og.apply(this, ['hanzogui/native'])
     }
 
     if (path === '@hanzogui/core') {
-      return requireGuiCore(platform, (path) => {
+      return requireHanzoguiCore(platform, (path) => {
         return og.apply(this, [path])
       })
     }
@@ -156,26 +155,25 @@ export function registerRequire(
     }
 
     if (!whitelisted[path]) {
-      if (proxyWormImports && !path.includes('.gui-dynamic-eval')) {
-        // allow @hanzo/gui and its sub-packages through - they re-export components
+      if (proxyWormImports && !path.includes('.hanzogui-dynamic-eval')) {
+        // allow hanzogui and its sub-packages through - they re-export components
         // with staticConfig needed for dynamic eval optimization.
-        // also allow requires FROM within gui packages (relative imports like ./Separator.cjs)
+        // also allow requires FROM within hanzogui packages (relative imports like ./Separator.cjs)
         const callerFile = this?.filename || this?.id || ''
-        const isFromGuiPkg =
-          callerFile.includes('@hanzo/gui') ||
-          callerFile.includes('@gui') ||
-          callerFile.includes('node_modules/@hanzo/')
+        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('/.gui/')
+          callerFile.includes('/.hanzogui/')
+
         if (
-          path === '@hanzo/gui' ||
+          path === 'hanzogui' ||
           path.startsWith('@hanzogui/') ||
-          isFromGuiPkg ||
+          isFromHanzoguiPkg ||
           isFromStaticLoader
         ) {
           return og.apply(this, [path])
@@ -212,15 +210,15 @@ export function registerRequire(
       return out
     } catch (err: any) {
       if (
-        !process.env.GUI_ENABLE_WARN_DYNAMIC_LOAD &&
-        path.includes('gui-dynamic-eval')
+        !process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD &&
+        path.includes('hanzogui-dynamic-eval')
       ) {
         // ok, dynamic eval fails
         return
       }
       if (allowedIgnores[path] || IGNORES === 'true') {
         // ignore
-      } else if (!process.env.GUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG) {
+      } else if (!process.env.TAMAGUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG) {
         if (hasWarnedForModules.has(path)) {
           // ignore
         } else {
@@ -233,7 +231,7 @@ export function registerRequire(
          */
 
         console.warn(
-          `  [hanzo-gui] skipped "${path}" (set GUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`
+          `  [hanzogui] skipped "${path}" (set TAMAGUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`
         )
       }
 
@@ -242,11 +240,11 @@ export function registerRequire(
   }
 
   return {
-    guiRequire,
+    hanzoguiRequire,
     unregister: () => {
       if (hasWarnedForModules.size) {
         console.info(
-          `  [hanzo-gui] skipped loading ${hasWarnedForModules.size} module, see: https://gui.hanzo.ai/docs/intro/errors#warning-001`
+          `  [hanzogui] skipped loading ${hasWarnedForModules.size} module, see: https://hanzogui.dev/docs/intro/errors#warning-001`
         )
         hasWarnedForModules.clear()
       }
@@ -258,9 +256,9 @@ export function registerRequire(
   }
 }
 
-const IGNORES =
-  process.env.GUI_IGNORE_BUNDLE_ERRORS || process.env.GUI_IGNORE_BUNDLE_ERRORS
-const extraIgnores = IGNORES === 'true' ? [] : IGNORES?.split(',')
+const IGNORES = process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS
+const extraIgnores =
+  IGNORES === 'true' ? [] : process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS?.split(',')
 
 const knownIgnorableModules = {
   '@gorhom/bottom-sheet': true,
@@ -268,7 +266,7 @@ const knownIgnorableModules = {
   solito: true,
   'expo-linear-gradient': true,
   '@expo/vector-icons': true,
-  '@hanzo/gui/linear-gradient': true,
+  'hanzogui/linear-gradient': true,
   // animation libraries not needed for static extraction
   '@emotion/is-prop-valid': true,
   'framer-motion': true,

package/src/server.ts

@@ -1,8 +1,8 @@
-import type { GuiOptions } from './types'
+import type { HanzoguiOptions } from './types'
 
 import net from 'node:net'
 
-export async function startServer(options: GuiOptions) {
+export async function startServer(options: HanzoguiOptions) {
   const port = await getAvailablePort()
   const server = net.createServer()
   server.unref()

package/src/types.ts

@@ -1,15 +1,15 @@
 import type { NodePath } from '@babel/traverse'
 import type * as t from '@babel/types'
-import type { PseudoStyles, StaticConfig, GuiConfig } from '@hanzogui/core'
+import type { PseudoStyles, StaticConfig, HanzoguiConfig } from '@hanzogui/core'
 import type { StyleObject } from '@hanzogui/helpers'
-import type { GuiOptions } from '@hanzogui/types'
+import type { HanzoguiOptions } from '@hanzogui/types'
 import type { ViewStyle } from 'react-native'
 
 import type { LoadedComponents } from './extractor/bundleConfig'
 
-export type GuiPlatform = 'native' | 'web'
+export type HanzoguiPlatform = 'native' | 'web'
 
-export type { GuiOptions, GuiBuildOptions } from '@hanzogui/types'
+export type { HanzoguiOptions, HanzoguiBuildOptions } from '@hanzogui/types'
 
 export type { StyleObject } from '@hanzogui/helpers'
 
@@ -33,7 +33,7 @@ export interface Logger {
 
 export type ExtractorOptions = {
   logger?: Logger
-  platform?: GuiPlatform
+  platform?: HanzoguiPlatform
 }
 
 export type ExtractedAttrAttr = {
@@ -58,7 +58,7 @@ export type ExtractedTernaryAttr = {
 export type ExtractedAttr = ExtractedAttrAttr | ExtractedTernaryAttr | ExtractedAttrStyle
 
 export type ExtractTagProps = {
-  parserProps: GuiOptionsWithFileInfo
+  parserProps: HanzoguiOptionsWithFileInfo
   attrs: ExtractedAttr[]
   node: t.JSXOpeningElement
   attemptEval: (exprNode: t.Node, evalFn?: ((node: t.Node) => any) | undefined) => any
@@ -70,16 +70,19 @@ export type ExtractTagProps = {
   filePath: string
   completeProps: Record<string, any>
   staticConfig: StaticConfig
-  config: GuiConfig
+  config: HanzoguiConfig
 }
 
-export type GuiOptionsWithFileInfo = GuiOptions & {
+export type HanzoguiOptionsWithFileInfo = HanzoguiOptions & {
   sourcePath?: string
   allLoadedComponents: LoadedComponents[]
 }
 
-export type ExtractorParseProps = Omit<GuiOptionsWithFileInfo, 'allLoadedComponents'> & {
-  platform: GuiPlatform
+export type ExtractorParseProps = Omit<
+  HanzoguiOptionsWithFileInfo,
+  'allLoadedComponents'
+> & {
+  platform: HanzoguiPlatform
   shouldPrintDebug?: boolean | 'verbose'
   onExtractTag: (props: ExtractTagProps) => void
   getFlattenedNode?: (props: { isTextView: boolean; tag: string }) => string

package/src/worker.ts

@@ -1,5 +1,5 @@
 /**
- * Worker thread implementation for GUI extraction
+ * Worker thread implementation for Hanzogui extraction
  * Used by both piscina (async) and synckit (sync for babel)
  */
 
@@ -8,7 +8,7 @@ import { createExtractor } from './extractor/createExtractor'
 import type { ExtractedResponse } from './extractor/extractToClassNames'
 import { extractToClassNames as extractToClassNamesImpl } from './extractor/extractToClassNames'
 import { extractToNative as extractToNativeImpl } from './extractor/extractToNative'
-import type { GuiOptions } from './types'
+import type { HanzoguiOptions } from './types'
 
 // Create extractors lazily to avoid loading unused ones
 let webExtractor: ReturnType<typeof createExtractor> | null = null
@@ -35,7 +35,7 @@ export interface ExtractToClassNamesTask {
   type: 'extractToClassNames'
   source: string
   sourcePath: string
-  options: GuiOptions
+  options: HanzoguiOptions
   shouldPrintDebug: boolean | 'verbose'
 }
 
@@ -43,7 +43,7 @@ export interface ExtractToNativeTask {
   type: 'extractToNative'
   sourceFileName: string
   sourceCode: string
-  options: GuiOptions
+  options: HanzoguiOptions
 }
 
 export interface ClearCacheTask {
@@ -68,14 +68,14 @@ export async function runTask(task: WorkerTask): Promise<WorkerResult> {
       // only skip if both extraction AND debug attrs are disabled (fully disabled)
       const isFullyDisabled =
         task.options.disableExtraction && task.options.disableDebugAttr
-      if (!isFullyDisabled && !task.options['_disableLoadGui']) {
+      if (!isFullyDisabled && !task.options['_disableLoadHanzogui']) {
         const cacheKey = JSON.stringify({
           config: task.options.config,
           components: task.options.components,
         })
 
         if (!configCache.has(cacheKey)) {
-          configCache.set(cacheKey, getWebExtractor().loadGui(task.options))
+          configCache.set(cacheKey, getWebExtractor().loadHanzogui(task.options))
         }
 
         await configCache.get(cacheKey)
@@ -100,7 +100,7 @@ export async function runTask(task: WorkerTask): Promise<WorkerResult> {
       })
 
       if (!configCache.has(cacheKey)) {
-        configCache.set(cacheKey, getNativeExtractor().loadGui(task.options))
+        configCache.set(cacheKey, getNativeExtractor().loadHanzogui(task.options))
       }
 
       await configCache.get(cacheKey)

package/types/check-dep-versions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-dep-versions.d.ts","sourceRoot":"","sources":["../src/check-dep-versions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAkpBH,+CAA+C;AAC/C,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,OAAO,CAAA;IACtB,QAAQ,EAAE,SAAS;QACjB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,SAAS;YAAE,YAAY,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAC9C,EAAE,CAAA;CACJ,CAAA;AAED,qBAAa,IAAI;IACf,4GAA4G;IAC5G,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAE3C;;;;;;;;;;OAUG;gBACS,IAAI,EAAE,MAAM;IAKjB,iBAAiB,IAAI,MAAM;IAI3B,eAAe,IAAI,SAAS,UAAU,EAAE;IAMxC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAc9C,IAAW,0BAA0B,IAAI,OAAO,CAE/C;CACF"}
+{"version":3,"file":"check-dep-versions.d.ts","sourceRoot":"","sources":["../src/check-dep-versions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA8oBH,+CAA+C;AAC/C,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,OAAO,CAAA;IACtB,QAAQ,EAAE,SAAS;QACjB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,SAAS;YAAE,YAAY,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAC9C,EAAE,CAAA;CACJ,CAAA;AAED,qBAAa,IAAI;IACf,4GAA4G;IAC5G,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAE3C;;;;;;;;;;OAUG;gBACS,IAAI,EAAE,MAAM;IAKjB,iBAAiB,IAAI,MAAM;IAI3B,eAAe,IAAI,SAAS,UAAU,EAAE;IAMxC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAc9C,IAAW,0BAA0B,IAAI,OAAO,CAE/C;CACF"}

package/types/checkDeps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkDeps.d.ts","sourceRoot":"","sources":["../src/checkDeps.ts"],"names":[],"mappings":"AAIA,oBAAY,eAAe;IACzB,YAAY,iBAAiB;IAC7B,eAAe,oBAAoB;IACnC,oBAAoB,yBAAyB;IAC7C,gBAAgB,qBAAqB;IACrC,WAAW,gBAAgB;CAC5B;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,CAAC,EAAE,SAAS,GAAG,eAAe,EAAE,EAAE,CAAA;IACzC,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACxC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC,CAAA;AAiUD,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,iBA8B3C"}
+{"version":3,"file":"checkDeps.d.ts","sourceRoot":"","sources":["../src/checkDeps.ts"],"names":[],"mappings":"AAIA,oBAAY,eAAe;IACzB,YAAY,iBAAiB;IAC7B,eAAe,oBAAoB;IACnC,oBAAoB,yBAAyB;IAC7C,gBAAgB,qBAAqB;IACrC,WAAW,gBAAgB;CAC5B;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,CAAC,EAAE,SAAS,GAAG,eAAe,EAAE,EAAE,CAAA;IACzC,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACxC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC,CAAA;AA+TD,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,iBA8B3C"}

package/types/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gBAAgB,CAAA;AAG1C,eAAO,MAAM,SAAS,MAAM,CAAA;AAG5B,eAAO,MAAM,QAAQ,KAAoD,CAAA;AAEzE,eAAO,MAAM,WAAW,eAA8B,CAAA;AAEtD,eAAO,MAAM,YAAY,qBACiD,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gBAAgB,CAAA;AAG1C,eAAO,MAAM,SAAS,MAAM,CAAA;AAG5B,eAAO,MAAM,QAAQ,KAAmD,CAAA;AAExE,eAAO,MAAM,WAAW,eAA8B,CAAA;AAEtD,eAAO,MAAM,YAAY,qBAC+C,CAAA"}

package/types/exports.d.ts

@@ -7,8 +7,8 @@ export * from './extractor/extractToClassNames';
 export * from './extractor/concatClassName';
 export * from './extractor/extractToNative';
 export * from './extractor/extractHelpers';
-export * from './extractor/loadGui';
-export * from './extractor/watchGuiConfig';
+export * from './extractor/loadHanzogui';
+export * from './extractor/watchHanzoguiConfig';
 export * from './extractor/createLogger';
 export * from './registerRequire';
 export { detectModuleFormat, clearFormatCache } from './extractor/detectModuleFormat';

package/types/exports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../src/exports.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,cAAc,aAAa,CAAA;AAC3B,cAAc,iCAAiC,CAAA;AAC/C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA;AACnC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACrF,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../src/exports.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,cAAc,aAAa,CAAA;AAC3B,cAAc,iCAAiC,CAAA;AAC/C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,0BAA0B,CAAA;AACxC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACrF,cAAc,oBAAoB,CAAA"}

package/types/extractor/bundle.d.ts

@@ -1,5 +1,5 @@
 import esbuild from 'esbuild';
-import type { GuiPlatform } from '../types';
+import type { HanzoguiPlatform } from '../types';
 export declare const esbuildLoaderConfig: {
     readonly '.js': "jsx";
     readonly '.png': "dataurl";
@@ -34,7 +34,7 @@ type Props = Omit<Partial<esbuild.BuildOptions>, 'entryPoints'> & {
     entryPoints: string[];
     resolvePlatformSpecificEntries?: boolean;
 };
-export declare function esbundleGuiConfig(props: Props, platform: GuiPlatform, aliases?: Record<string, string>): Promise<esbuild.BuildResult<{
+export declare function esbundleHanzoguiConfig(props: Props, platform: HanzoguiPlatform, aliases?: Record<string, string>): Promise<esbuild.BuildResult<{
     outfile: string;
     bundle?: boolean;
     splitting?: boolean;

package/types/extractor/bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/extractor/bundle.ts"],"names":[],"mappings":"AACA,OAAO,OAAO,MAAM,SAAS,CAAA;AAE7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAO3C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;CAwBtB,CAAA;AAQV,eAAO,MAAM,uBAAuB,QAAqD,CAAA;AAEzF;;GAEG;AAEH,KAAK,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,GAAG;IAChE,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,8BAA8B,CAAC,EAAE,OAAO,CAAA;CACzC,CAAA;AA+MD,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,WAAW,EACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBjC"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../src/extractor/bundle.ts"],"names":[],"mappings":"AACA,OAAO,OAAO,MAAM,SAAS,CAAA;AAE7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAOhD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;CAwBtB,CAAA;AAQV,eAAO,MAAM,uBAAuB,QAAqD,CAAA;AAEzF;;GAEG;AAEH,KAAK,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,GAAG;IAChE,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,8BAA8B,CAAC,EAAE,OAAO,CAAA;CACzC,CAAA;AA6MD,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBjC"}