@hanzogui/static 7.0.0 → 7.3.0

package/src/extractor/regenerateConfig.ts

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

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

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

package/src/getPragmaOptions.ts

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

package/src/helpers/requireGuiCore.ts

@@ -0,0 +1,28 @@
+// this allows us to swap between core native and web in the same process:
+
+import type { GuiPlatform } from '../types'
+
+export function requireGuiCore(
+  platform: GuiPlatform,
+  ogRequire: Function = require
+): typeof import('@hanzogui/core') {
+  if (!platform) {
+    throw new Error(`No platform given to requireGuiCore`)
+  }
+
+  // avoid tree shaking out themes
+  const og1 = process.env.GUI_IS_SERVER
+  const og2 = process.env.GUI_KEEP_THEMES
+  process.env.GUI_IS_SERVER ||= '1'
+  process.env.GUI_KEEP_THEMES ||= '1'
+
+  const exported = ogRequire(
+    platform === 'native' ? '@hanzogui/core/native' : '@hanzogui/core'
+  )
+
+  // restore back
+  process.env.GUI_IS_SERVER = og1
+  process.env.GUI_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 { requireHanzoguiCore } from './helpers/requireHanzoguiCore'
-import type { HanzoguiPlatform } from './types'
+import { requireGuiCore } from './helpers/requireGuiCore'
+import type { GuiPlatform } from './types'
 
 const nameToPaths = {}
 
@@ -54,7 +54,7 @@ function getStaticExtractionStub(path: string) {
 }
 
 export function registerRequire(
-  platform: HanzoguiPlatform,
+  platform: GuiPlatform,
   { proxyWormImports } = {
     proxyWormImports: false,
   }
@@ -62,7 +62,7 @@ export function registerRequire(
   // already registered
   if (isRegistered) {
     return {
-      hanzoguiRequire: require,
+      guiRequire: require,
       unregister: () => {},
     }
   }
@@ -77,7 +77,7 @@ export function registerRequire(
     hookMatcher: (filename) => {
       if (
         filename.includes('@hanzogui') ||
-        /\/hanzogui\/code\/(core|ui|packages)\//.test(filename)
+        /\/gui\/code\/(core|ui|packages)\//.test(filename)
       ) {
         return false
       }
@@ -104,20 +104,20 @@ export function registerRequire(
 
   isRegistered = true
 
-  Module.prototype.require = hanzoguiRequire
+  Module.prototype.require = guiRequire
 
-  function hanzoguiRequire(this: any, path: string) {
+  function guiRequire(this: any, path: string) {
     const staticExtractionStub = getStaticExtractionStub(path)
     if (staticExtractionStub) {
       return staticExtractionStub
     }
 
-    if (path === 'hanzogui' && platform === 'native') {
-      return og.apply(this, ['hanzogui/native'])
+    if (path === 'gui' && platform === 'native') {
+      return og.apply(this, ['gui/native'])
     }
 
     if (path === '@hanzogui/core') {
-      return requireHanzoguiCore(platform, (path) => {
+      return requireGuiCore(platform, (path) => {
         return og.apply(this, [path])
       })
     }
@@ -155,25 +155,25 @@ export function registerRequire(
     }
 
     if (!whitelisted[path]) {
-      if (proxyWormImports && !path.includes('.hanzogui-dynamic-eval')) {
-        // allow hanzogui and its sub-packages through - they re-export components
+      if (proxyWormImports && !path.includes('.gui-dynamic-eval')) {
+        // allow gui and its sub-packages through - they re-export components
         // with staticConfig needed for dynamic eval optimization.
-        // also allow requires FROM within hanzogui packages (relative imports like ./Separator.cjs)
+        // also allow requires FROM within gui packages (relative imports like ./Separator.cjs)
         const callerFile = this?.filename || this?.id || ''
-        const isFromHanzoguiPkg =
-          callerFile.includes('@hanzogui') || callerFile.includes('node_modules/hanzogui/')
+        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('/.hanzogui/')
+          callerFile.includes('/.gui/')
 
         if (
-          path === 'hanzogui' ||
+          path === 'gui' ||
           path.startsWith('@hanzogui/') ||
-          isFromHanzoguiPkg ||
+          isFromGuiPkg ||
           isFromStaticLoader
         ) {
           return og.apply(this, [path])
@@ -210,15 +210,15 @@ export function registerRequire(
       return out
     } catch (err: any) {
       if (
-        !process.env.TAMAGUI_ENABLE_WARN_DYNAMIC_LOAD &&
-        path.includes('hanzogui-dynamic-eval')
+        !process.env.GUI_ENABLE_WARN_DYNAMIC_LOAD &&
+        path.includes('gui-dynamic-eval')
       ) {
         // ok, dynamic eval fails
         return
       }
       if (allowedIgnores[path] || IGNORES === 'true') {
         // ignore
-      } else if (!process.env.TAMAGUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG) {
+      } else if (!process.env.GUI_SHOW_FULL_BUNDLE_ERRORS && !process.env.DEBUG) {
         if (hasWarnedForModules.has(path)) {
           // ignore
         } else {
@@ -231,7 +231,7 @@ export function registerRequire(
          */
 
         console.warn(
-          `  [hanzogui] skipped "${path}" (set TAMAGUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`
+          `  [gui] skipped "${path}" (set GUI_IGNORE_BUNDLE_ERRORS="${path}" to silence)`
         )
       }
 
@@ -240,11 +240,11 @@ export function registerRequire(
   }
 
   return {
-    hanzoguiRequire,
+    guiRequire,
     unregister: () => {
       if (hasWarnedForModules.size) {
         console.info(
-          `  [hanzogui] skipped loading ${hasWarnedForModules.size} module, see: https://hanzogui.dev/docs/intro/errors#warning-001`
+          `  [gui] skipped loading ${hasWarnedForModules.size} module, see: https://gui.dev/docs/intro/errors#warning-001`
         )
         hasWarnedForModules.clear()
       }
@@ -256,9 +256,9 @@ export function registerRequire(
   }
 }
 
-const IGNORES = process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS
+const IGNORES = process.env.GUI_IGNORE_BUNDLE_ERRORS
 const extraIgnores =
-  IGNORES === 'true' ? [] : process.env.TAMAGUI_IGNORE_BUNDLE_ERRORS?.split(',')
+  IGNORES === 'true' ? [] : process.env.GUI_IGNORE_BUNDLE_ERRORS?.split(',')
 
 const knownIgnorableModules = {
   '@gorhom/bottom-sheet': true,
@@ -266,7 +266,7 @@ const knownIgnorableModules = {
   solito: true,
   'expo-linear-gradient': true,
   '@expo/vector-icons': true,
-  'hanzogui/linear-gradient': true,
+  'gui/linear-gradient': true,
   // animation libraries not needed for static extraction
   '@emotion/is-prop-valid': true,
   'framer-motion': true,

package/src/server.ts

@@ -1,8 +1,8 @@
-import type { HanzoguiOptions } from './types'
+import type { GuiOptions } from './types'
 
 import net from 'node:net'
 
-export async function startServer(options: HanzoguiOptions) {
+export async function startServer(options: GuiOptions) {
   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, HanzoguiConfig } from '@hanzogui/core'
+import type { PseudoStyles, StaticConfig, GuiConfig } from '@hanzogui/core'
 import type { StyleObject } from '@hanzogui/helpers'
-import type { HanzoguiOptions } from '@hanzogui/types'
+import type { GuiOptions } from '@hanzogui/types'
 import type { ViewStyle } from 'react-native'
 
 import type { LoadedComponents } from './extractor/bundleConfig'
 
-export type HanzoguiPlatform = 'native' | 'web'
+export type GuiPlatform = 'native' | 'web'
 
-export type { HanzoguiOptions, HanzoguiBuildOptions } from '@hanzogui/types'
+export type { GuiOptions, GuiBuildOptions } from '@hanzogui/types'
 
 export type { StyleObject } from '@hanzogui/helpers'
 
@@ -33,7 +33,7 @@ export interface Logger {
 
 export type ExtractorOptions = {
   logger?: Logger
-  platform?: HanzoguiPlatform
+  platform?: GuiPlatform
 }
 
 export type ExtractedAttrAttr = {
@@ -58,7 +58,7 @@ export type ExtractedTernaryAttr = {
 export type ExtractedAttr = ExtractedAttrAttr | ExtractedTernaryAttr | ExtractedAttrStyle
 
 export type ExtractTagProps = {
-  parserProps: HanzoguiOptionsWithFileInfo
+  parserProps: GuiOptionsWithFileInfo
   attrs: ExtractedAttr[]
   node: t.JSXOpeningElement
   attemptEval: (exprNode: t.Node, evalFn?: ((node: t.Node) => any) | undefined) => any
@@ -70,19 +70,19 @@ export type ExtractTagProps = {
   filePath: string
   completeProps: Record<string, any>
   staticConfig: StaticConfig
-  config: HanzoguiConfig
+  config: GuiConfig
 }
 
-export type HanzoguiOptionsWithFileInfo = HanzoguiOptions & {
+export type GuiOptionsWithFileInfo = GuiOptions & {
   sourcePath?: string
   allLoadedComponents: LoadedComponents[]
 }
 
 export type ExtractorParseProps = Omit<
-  HanzoguiOptionsWithFileInfo,
+  GuiOptionsWithFileInfo,
   'allLoadedComponents'
 > & {
-  platform: HanzoguiPlatform
+  platform: GuiPlatform
   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 Hanzogui extraction
+ * Worker thread implementation for Gui 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 { HanzoguiOptions } from './types'
+import type { GuiOptions } 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: HanzoguiOptions
+  options: GuiOptions
   shouldPrintDebug: boolean | 'verbose'
 }
 
@@ -43,7 +43,7 @@ export interface ExtractToNativeTask {
   type: 'extractToNative'
   sourceFileName: string
   sourceCode: string
-  options: HanzoguiOptions
+  options: GuiOptions
 }
 
 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['_disableLoadHanzogui']) {
+      if (!isFullyDisabled && !task.options['_disableLoadGui']) {
         const cacheKey = JSON.stringify({
           config: task.options.config,
           components: task.options.components,
         })
 
         if (!configCache.has(cacheKey)) {
-          configCache.set(cacheKey, getWebExtractor().loadHanzogui(task.options))
+          configCache.set(cacheKey, getWebExtractor().loadGui(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().loadHanzogui(task.options))
+        configCache.set(cacheKey, getNativeExtractor().loadGui(task.options))
       }
 
       await configCache.get(cacheKey)

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,KAAmD,CAAA;AAExE,eAAO,MAAM,WAAW,eAA8B,CAAA;AAEtD,eAAO,MAAM,YAAY,qBAC+C,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,KAA8C,CAAA;AAEnE,eAAO,MAAM,WAAW,eAA8B,CAAA;AAEtD,eAAO,MAAM,YAAY,qBAC0C,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/loadHanzogui';
-export * from './extractor/watchHanzoguiConfig';
+export * from './extractor/loadGui';
+export * from './extractor/watchGuiConfig';
 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,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"}
+{"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"}

package/types/extractor/bundle.d.ts

@@ -1,5 +1,5 @@
 import esbuild from 'esbuild';
-import type { HanzoguiPlatform } from '../types';
+import type { GuiPlatform } 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 esbundleHanzoguiConfig(props: Props, platform: HanzoguiPlatform, aliases?: Record<string, string>): Promise<esbuild.BuildResult<{
+export declare function esbundleGuiConfig(props: Props, platform: GuiPlatform, 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,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"}
+{"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;AA6MD,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,WAAW,EACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBjC"}

package/types/extractor/bundleConfig.d.ts

@@ -1,6 +1,6 @@
-import { type StaticConfig, type HanzoguiInternalConfig } from '@hanzogui/web';
+import { type StaticConfig, type GuiInternalConfig } from '@hanzogui/web';
 import esbuild from 'esbuild';
-import type { HanzoguiOptions } from '../types';
+import type { GuiOptions } from '../types';
 type NameToPaths = {
     [key: string]: Set<string>;
 };
@@ -10,9 +10,9 @@ export type LoadedComponents = {
         staticConfig: StaticConfig;
     }>;
 };
-export type HanzoguiProjectInfo = {
+export type GuiProjectInfo = {
     components?: LoadedComponents[];
-    hanzoguiConfig?: HanzoguiInternalConfig | null;
+    guiConfig?: GuiInternalConfig | null;
     nameToPaths?: NameToPaths;
     cached?: boolean;
 };
@@ -37,13 +37,13 @@ export declare const esbuildOptionsWithPlugins: {
 };
 export type BundledConfig = Exclude<Awaited<ReturnType<typeof bundleConfig>>, undefined>;
 export declare function hasBundledConfigChanged(): boolean;
-export declare const getLoadedConfig: () => HanzoguiInternalConfig | null;
-export declare function getBundledConfig(props: HanzoguiOptions, rebuild?: boolean): Promise<any>;
-export declare function bundleConfig(props: HanzoguiOptions): Promise<any>;
-export declare function writeHanzoguiCSS(outputCSS: string, config: HanzoguiInternalConfig): Promise<void>;
-export declare function loadComponents(props: HanzoguiOptions, forceExports?: boolean): Promise<LoadedComponents[]>;
-export declare function loadComponentsSync(props: HanzoguiOptions, forceExports?: boolean): LoadedComponents[];
-export declare function loadComponentsInner(props: HanzoguiOptions, forceExports?: boolean): Promise<null | LoadedComponents[]>;
-export declare function loadComponentsInnerSync(props: HanzoguiOptions, forceExports?: boolean): null | LoadedComponents[];
+export declare const getLoadedConfig: () => GuiInternalConfig | null;
+export declare function getBundledConfig(props: GuiOptions, rebuild?: boolean): Promise<any>;
+export declare function bundleConfig(props: GuiOptions): Promise<any>;
+export declare function writeGuiCSS(outputCSS: string, config: GuiInternalConfig): Promise<void>;
+export declare function loadComponents(props: GuiOptions, forceExports?: boolean): Promise<LoadedComponents[]>;
+export declare function loadComponentsSync(props: GuiOptions, forceExports?: boolean): LoadedComponents[];
+export declare function loadComponentsInner(props: GuiOptions, forceExports?: boolean): Promise<null | LoadedComponents[]>;
+export declare function loadComponentsInnerSync(props: GuiOptions, forceExports?: boolean): null | LoadedComponents[];
 export {};
 //# sourceMappingURL=bundleConfig.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bundleConfig.d.ts","sourceRoot":"","sources":["../../src/extractor/bundleConfig.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,sBAAsB,EAAE,MAAM,eAAe,CAAA;AAC9E,OAAO,OAAO,MAAM,SAAS,CAAA;AAI7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAyE/C,KAAK,WAAW,GAAG;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAChB,MAAM,EACN;QACE,YAAY,EAAE,YAAY,CAAA;KAC3B,CACF,CAAA;CACF,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAA;IAC/B,cAAc,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAA;IAC9C,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAgGD,eAAO,MAAM,cAAc;;;;;;;;CAEK,CAAA;AAGhC,eAAO,MAAM,yBAAyB;;;;;;;;;CAGN,CAAA;AAEhC,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;AAQxF,wBAAgB,uBAAuB,YAMtC;AAID,eAAO,MAAM,eAAe,qCAAqB,CAAA;AAEjD,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,eAAe,EAAE,OAAO,UAAQ,gBAS7E;AAgBD,wBAAsB,YAAY,CAAC,KAAK,EAAE,eAAe,gBAmPxD;AAED,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,sBAAsB,iBAmBvF;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,eAAe,EAAE,YAAY,UAAQ,+BAIhF;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,eAAe,EAAE,YAAY,UAAQ,sBAI9E;AAqBD,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,eAAe,EACtB,YAAY,UAAQ,GACnB,OAAO,CAAC,IAAI,GAAG,gBAAgB,EAAE,CAAC,CAyJpC;AAGD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,eAAe,EACtB,YAAY,UAAQ,GACnB,IAAI,GAAG,gBAAgB,EAAE,CAyI3B"}
+{"version":3,"file":"bundleConfig.d.ts","sourceRoot":"","sources":["../../src/extractor/bundleConfig.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACzE,OAAO,OAAO,MAAM,SAAS,CAAA;AAI7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAyE1C,KAAK,WAAW,GAAG;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAChB,MAAM,EACN;QACE,YAAY,EAAE,YAAY,CAAA;KAC3B,CACF,CAAA;CACF,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAA;IAC/B,SAAS,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAA;IACpC,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,CAAA;AAgGD,eAAO,MAAM,cAAc;;;;;;;;CAEK,CAAA;AAGhC,eAAO,MAAM,yBAAyB;;;;;;;;;CAGN,CAAA;AAEhC,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,EAAE,SAAS,CAAC,CAAA;AAQxF,wBAAgB,uBAAuB,YAMtC;AAID,eAAO,MAAM,eAAe,gCAAqB,CAAA;AAEjD,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,UAAQ,gBASxE;AAgBD,wBAAsB,YAAY,CAAC,KAAK,EAAE,UAAU,gBAmPnD;AAED,wBAAsB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,iBAmB7E;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,UAAQ,+BAI3E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,YAAY,UAAQ,sBAIzE;AAqBD,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,UAAU,EACjB,YAAY,UAAQ,GACnB,OAAO,CAAC,IAAI,GAAG,gBAAgB,EAAE,CAAC,CAyJpC;AAGD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,UAAU,EACjB,YAAY,UAAQ,GACnB,IAAI,GAAG,gBAAgB,EAAE,CAyI3B"}