@tamagui/cli 1.0.1-rc.1.4

package/dist/esm/test.js

@@ -0,0 +1,9 @@
+const test = async (options) => {
+  const { dev } = await import("./dev.js");
+  void dev(options);
+  console.log("run tests");
+};
+export {
+  test
+};
+//# sourceMappingURL=test.js.map

package/dist/esm/test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/test.ts"],
+  "sourcesContent": ["/* eslint-disable no-console */\nimport { ResolvedOptions } from './types.js'\n\nexport const test = async (options: ResolvedOptions) => {\n  const { dev } = await import('./dev.js')\n\n  // failing on startup \"Tamagui error bundling components require() of ES Module\"\n\n  void dev(options)\n\n  console.log('run tests')\n}\n"],
+  "mappings": "AAGO,MAAM,OAAO,OAAO,YAA6B;AACtD,QAAM,EAAE,IAAI,IAAI,MAAM,OAAO;AAI7B,OAAK,IAAI,OAAO;AAEhB,UAAQ,IAAI,WAAW;AACzB;",
+  "names": []
+}

package/dist/esm/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/esm/utils.js

@@ -0,0 +1,77 @@
+import { join } from "path";
+import { loadTamagui as loadTamaguiStatic } from "@tamagui/static";
+import chalk from "chalk";
+import fs, { pathExists, readJSON } from "fs-extra";
+async function getOptions({
+  root = process.cwd(),
+  tsconfigPath = "tsconfig.json",
+  tamaguiOptions,
+  host,
+  debug
+} = {}) {
+  const tsConfigFilePath = join(root, tsconfigPath);
+  ensure(await fs.pathExists(tsConfigFilePath), `No tsconfig found: ${tsConfigFilePath}`);
+  const dotDir = join(root, ".tamagui");
+  const pkgJson = await readJSON(join(root, "package.json"));
+  return {
+    mode: process.env.NODE_ENV === "production" ? "production" : "development",
+    root,
+    host,
+    pkgJson,
+    debug,
+    tsconfigPath,
+    tamaguiOptions: {
+      components: ["tamagui"],
+      config: await getDefaultTamaguiConfigPath(),
+      ...tamaguiOptions
+    },
+    paths: {
+      dotDir,
+      conf: join(dotDir, "tamagui.config.json"),
+      types: join(dotDir, "types.json")
+    }
+  };
+}
+function ensure(condition, message) {
+  if (!condition) {
+    console.error(chalk.red.bold("Error:"), chalk.yellow(`${message}`));
+    process.exit(1);
+  }
+}
+const defaultPaths = ["tamagui.config.ts", join("src", "tamagui.config.ts")];
+let cachedPath = "";
+async function getDefaultTamaguiConfigPath() {
+  if (cachedPath)
+    return cachedPath;
+  const existing = (await Promise.all(defaultPaths.map((path) => pathExists(path)))).findIndex(
+    (x) => !!x
+  );
+  const found = defaultPaths[existing];
+  if (!found) {
+    throw new Error(`No found tamagui.config.ts`);
+  }
+  cachedPath = found;
+  return found;
+}
+let cached = null;
+const loadTamagui = async (opts) => {
+  return cached ??= await loadTamaguiStatic({
+    config: await getDefaultTamaguiConfigPath(),
+    components: ["tamagui"],
+    ...opts
+  });
+};
+function closeEvent(server) {
+  return new Promise((resolve) => {
+    server.ws.on("close", () => {
+      return resolve();
+    });
+  });
+}
+export {
+  closeEvent,
+  ensure,
+  getOptions,
+  loadTamagui
+};
+//# sourceMappingURL=utils.js.map

package/dist/esm/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils.ts"],
+  "sourcesContent": ["import { join } from 'path'\n\nimport type { TamaguiOptions, TamaguiProjectInfo } from '@tamagui/static'\nimport { loadTamagui as loadTamaguiStatic } from '@tamagui/static'\nimport chalk from 'chalk'\nimport fs, { pathExists, readJSON } from 'fs-extra'\nimport { ViteDevServer } from 'vite'\n\nimport { ResolvedOptions, UserOptions } from './types.js'\n\nexport async function getOptions({\n  root = process.cwd(),\n  tsconfigPath = 'tsconfig.json',\n  tamaguiOptions,\n  host,\n  debug,\n}: Partial<UserOptions> = {}): Promise<ResolvedOptions> {\n  const tsConfigFilePath = join(root, tsconfigPath)\n  ensure(await fs.pathExists(tsConfigFilePath), `No tsconfig found: ${tsConfigFilePath}`)\n  const dotDir = join(root, '.tamagui')\n  const pkgJson = await readJSON(join(root, 'package.json'))\n\n  return {\n    mode: process.env.NODE_ENV === 'production' ? 'production' : 'development',\n    root,\n    host,\n    pkgJson,\n    debug,\n    tsconfigPath,\n    tamaguiOptions: {\n      components: ['tamagui'],\n      config: await getDefaultTamaguiConfigPath(),\n      ...tamaguiOptions,\n    },\n    paths: {\n      dotDir,\n      conf: join(dotDir, 'tamagui.config.json'),\n      types: join(dotDir, 'types.json'),\n    },\n  }\n}\n\nexport function ensure(condition: boolean, message: string) {\n  if (!condition) {\n    console.error(chalk.red.bold('Error:'), chalk.yellow(`${message}`))\n    process.exit(1)\n  }\n}\n\nconst defaultPaths = ['tamagui.config.ts', join('src', 'tamagui.config.ts')]\nlet cachedPath = ''\nasync function getDefaultTamaguiConfigPath() {\n  if (cachedPath) return cachedPath\n  const existing = (await Promise.all(defaultPaths.map((path) => pathExists(path)))).findIndex(\n    (x) => !!x\n  )\n  const found = defaultPaths[existing]\n  if (!found) {\n    throw new Error(`No found tamagui.config.ts`)\n  }\n  cachedPath = found\n  return found\n}\n\nlet cached: TamaguiProjectInfo | null = null\nexport const loadTamagui = async (opts: Partial<TamaguiOptions>): Promise<TamaguiProjectInfo> => {\n  return (cached ??= await loadTamaguiStatic({\n    config: await getDefaultTamaguiConfigPath(),\n    components: ['tamagui'],\n    ...opts,\n  }))\n}\n\nexport function closeEvent(server: ViteDevServer): Promise<void> {\n  return new Promise((resolve) => {\n    server.ws.on('close', () => {\n      return resolve()\n    })\n  })\n}\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAGrB,SAAS,eAAe,yBAAyB;AACjD,OAAO,WAAW;AAClB,OAAO,MAAM,YAAY,gBAAgB;AAKzC,eAAsB,WAAW;AAAA,EAC/B,OAAO,QAAQ,IAAI;AAAA,EACnB,eAAe;AAAA,EACf;AAAA,EACA;AAAA,EACA;AACF,IAA0B,CAAC,GAA6B;AACtD,QAAM,mBAAmB,KAAK,MAAM,YAAY;AAChD,SAAO,MAAM,GAAG,WAAW,gBAAgB,GAAG,sBAAsB,kBAAkB;AACtF,QAAM,SAAS,KAAK,MAAM,UAAU;AACpC,QAAM,UAAU,MAAM,SAAS,KAAK,MAAM,cAAc,CAAC;AAEzD,SAAO;AAAA,IACL,MAAM,QAAQ,IAAI,aAAa,eAAe,eAAe;AAAA,IAC7D;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,gBAAgB;AAAA,MACd,YAAY,CAAC,SAAS;AAAA,MACtB,QAAQ,MAAM,4BAA4B;AAAA,MAC1C,GAAG;AAAA,IACL;AAAA,IACA,OAAO;AAAA,MACL;AAAA,MACA,MAAM,KAAK,QAAQ,qBAAqB;AAAA,MACxC,OAAO,KAAK,QAAQ,YAAY;AAAA,IAClC;AAAA,EACF;AACF;AAEO,SAAS,OAAO,WAAoB,SAAiB;AAC1D,MAAI,CAAC,WAAW;AACd,YAAQ,MAAM,MAAM,IAAI,KAAK,QAAQ,GAAG,MAAM,OAAO,GAAG,SAAS,CAAC;AAClE,YAAQ,KAAK,CAAC;AAAA,EAChB;AACF;AAEA,MAAM,eAAe,CAAC,qBAAqB,KAAK,OAAO,mBAAmB,CAAC;AAC3E,IAAI,aAAa;AACjB,eAAe,8BAA8B;AAC3C,MAAI;AAAY,WAAO;AACvB,QAAM,YAAY,MAAM,QAAQ,IAAI,aAAa,IAAI,CAAC,SAAS,WAAW,IAAI,CAAC,CAAC,GAAG;AAAA,IACjF,CAAC,MAAM,CAAC,CAAC;AAAA,EACX;AACA,QAAM,QAAQ,aAAa;AAC3B,MAAI,CAAC,OAAO;AACV,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAC9C;AACA,eAAa;AACb,SAAO;AACT;AAEA,IAAI,SAAoC;AACjC,MAAM,cAAc,OAAO,SAA+D;AAC/F,SAAQ,WAAW,MAAM,kBAAkB;AAAA,IACzC,QAAQ,MAAM,4BAA4B;AAAA,IAC1C,YAAY,CAAC,SAAS;AAAA,IACtB,GAAG;AAAA,EACL,CAAC;AACH;AAEO,SAAS,WAAW,QAAsC;AAC/D,SAAO,IAAI,QAAQ,CAAC,YAAY;AAC9B,WAAO,GAAG,GAAG,SAAS,MAAM;AAC1B,aAAO,QAAQ;AAAA,IACjB,CAAC;AAAA,EACH,CAAC;AACH;",
+  "names": []
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@tamagui/cli",
+  "version": "1.0.1-rc.1.4",
+  "source": "src/index.ts",
+  "types": "./types/index.d.ts",
+  "module": "dist/esm",
+  "main": "dist/cjs",
+  "bin": {
+    "tama": "./dist/cjs/index.js",
+    "tamagui": "./dist/cjs/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "types",
+    "dist"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tamagui-build",
+    "watch": "tamagui-build --watch",
+    "clean": "tamagui-build clean",
+    "clean:build": "tamagui-build clean:build"
+  },
+  "dependencies": {
+    "@tamagui/build": "^1.0.1-rc.1.4",
+    "@tamagui/static": "^1.0.1-rc.1.4",
+    "@tamagui/vite-plugin": "^1.0.1-rc.1.4",
+    "@types/compression": "^1.7.2",
+    "@types/morgan": "^1.9.3",
+    "arg": "^5.0.2",
+    "chalk": "^4.1.2",
+    "chokidar": "^3.5.2",
+    "compression": "^1.7.4",
+    "esbuild": "^0.15.11",
+    "execa": "^5.0.0",
+    "express": "^4.18.1",
+    "express-http-proxy": "^1.6.3",
+    "fast-glob": "^3.2.11",
+    "fs-extra": "^10.1.0",
+    "get-port": "^6.1.2",
+    "graphology": "^0.24.1",
+    "lodash.debounce": "^4.0.8",
+    "morgan": "^1.10.0",
+    "ts-morph": "^15.1.0",
+    "typescript": "^4.7.4",
+    "url": "^0.11.0",
+    "vite": "4.0.0-beta.0",
+    "zx": "^7.1.1"
+  },
+  "devDependencies": {
+    "@takeout/studio": "^1.0.1-rc.1.4"
+  }
+}

package/src/build.ts

@@ -0,0 +1,63 @@
+import { basename, dirname, join, resolve } from 'path'
+
+import { createExtractor, extractToClassNames, loadTamagui } from '@tamagui/static'
+import chokidar from 'chokidar'
+import { readFile } from 'fs-extra'
+
+import { ResolvedOptions } from './types.js'
+
+export const build = async (options: ResolvedOptions) => {
+  // const tamagui = await loadTamagui(options.tamaguiOptions)
+
+  const entry = options.pkgJson.source
+  if (!entry) {
+    throw new Error(`Must add "source" to package.json pointing to your source directory`)
+  }
+  const sourceDir = dirname(entry)
+  const promises: Promise<void>[] = []
+  const targets = ['web']
+
+  await new Promise<void>((res) => {
+    chokidar
+      // prevent infinite loop but cause race condition if you just build directly
+      .watch(sourceDir, {
+        // persistent: true,
+      })
+      .on('add', (relativePath) => {
+        const sourcePath = resolve(process.cwd(), relativePath)
+
+        // testing..
+        if (!sourcePath.endsWith('Layouts.tsx')) return
+
+        promises.push(
+          (async () => {
+            await Promise.all(
+              targets.map(async (target) => {
+                process.env.TAMAGUI_TARGET = target
+                if (options.debug) {
+                  process.env.NODE_ENV ||= 'development'
+                }
+                console.log('go', sourcePath)
+                const source = await readFile(sourcePath, 'utf-8')
+                const extractor = createExtractor()
+                const out = await extractToClassNames({
+                  extractor,
+                  source,
+                  sourcePath,
+                  options: options.tamaguiOptions,
+                  shouldPrintDebug: options.debug || false,
+                })
+
+                console.log('gotem', out?.js)
+              })
+            )
+          })()
+        )
+      })
+      .on('ready', () => {
+        res()
+      })
+  })
+
+  await Promise.all(promises)
+}

package/src/cli.ts

@@ -0,0 +1,153 @@
+/* eslint-disable no-console */
+import arg from 'arg'
+import chalk from 'chalk'
+
+import { getOptions } from './utils.js'
+
+const commandMap = {
+  build: {
+    shorthands: ['b'],
+    description: `Use to pre-build a Tamagui component directory`,
+    flags: {
+      '--help': Boolean,
+      '--debug': Boolean,
+      '--verbose': Boolean,
+    },
+    async run() {
+      const { _, ...flags } = arg(this.flags)
+      const { build } = await import('./build.js')
+      const options = await getOptions({
+        debug: flags['--debug'] ? (flags['--verbose'] ? 'verbose' : true) : false,
+      })
+      await build(options)
+    },
+  },
+}
+
+type CommandDefinitions = typeof commandMap
+type CommandKey = keyof typeof commandMap
+type CommandDefinition = CommandDefinitions[CommandKey]
+
+const commandEntries = Object.keys(commandMap).flatMap((command) => {
+  const definition = commandMap[command as CommandKey]
+  const entries = [command, ...definition.shorthands].map((cmd) => {
+    return [cmd, definition] as const
+  })
+  return entries
+})
+
+const commands = Object.fromEntries(commandEntries) as any as Record<CommandKey, CommandDefinition>
+
+const {
+  _: [command],
+  ...flags
+} = arg(
+  {
+    '--help': Boolean,
+    '--version': Boolean,
+  },
+  {
+    permissive: true,
+  }
+)
+
+if (flags['--version']) {
+  console.log(require('../package.json').version)
+  process.exit(0)
+}
+
+if (!command && flags['--help']) {
+  console.log(`$ tamagui
+
+commands:
+
+${Object.keys(commandMap)
+  .map((key) => {
+    return `  ${key}`
+  })
+  .join('\n')}`)
+  process.exit(0)
+}
+
+if (!(command in commands)) {
+  console.error()
+  console.warn(chalk.yellow(`Not a valid command: ${command}`))
+  process.exit(1)
+}
+
+const definition = commands[command] as CommandDefinition
+
+main()
+
+async function main() {
+  if (flags['--help']) {
+    console.log(`\n$ tamagui ${command}: ${definition.description}\n`)
+    console.log(`Flags: ${Object.entries(definition.flags).map(([k, v]) => `${k} (${v.name})`)}`)
+    process.exit(0)
+  }
+
+  await definition.run()
+  process.exit(0)
+}
+
+// async function main() {
+//   const options = await getOptions({
+//     host: flags['--host'],
+//   })
+
+//   switch (command) {
+//     // build
+//     case 'b':
+//     case 'build': {
+//       const { build } = await import('./build.js')
+//       break
+//     }
+
+//     // generate
+//     case 'generate':
+//     case 'gen': {
+//       const { generateTamaguiConfig: generateTamgauiConfig } = await import(
+//         './tamaguiConfigUtils.js'
+//       )
+//       const { generateTypes } = await import('./generate.js')
+
+//       if (props[0] === 'types') {
+//         await generateTypes(options)
+//         return
+//       }
+//       if (props[0] === 'config') {
+//         await generateTamgauiConfig(options)
+//         return
+//       }
+
+//       await Promise.all([
+//         // all
+//         generateTypes(options),
+//         generateTamgauiConfig(options),
+//       ])
+//       break
+//     }
+
+//     // studio
+//     case 'studio': {
+//       const { studio } = await import('./studio.js')
+//       await studio(options)
+//       break
+//     }
+
+//     // for now, dev === serve, eventually serve can be just prod mode
+//     case 'dev': {
+//       const { dev } = await import('./dev.js')
+//       await dev(options)
+//       break
+//     }
+
+//     default: {
+//       if (!command || flags['--help']) {
+//       }
+//       // eslint-disable-next-line no-console
+//       console.warn(chalk.yellow(`No command found ${command}`))
+//       process.exit(1)
+//     }
+//   }
+// }

package/src/dev.ts

@@ -0,0 +1,60 @@
+import { AddressInfo } from 'net'
+
+import chalk from 'chalk'
+import express from 'express'
+import proxy from 'express-http-proxy'
+import fs from 'fs-extra'
+import morgan from 'morgan'
+import { createServer } from 'vite'
+
+import { watchTamaguiConfig } from './tamaguiConfigUtils.js'
+import { ResolvedOptions } from './types.js'
+import { closeEvent } from './utils.js'
+
+export const dev = async (options: ResolvedOptions) => {
+  const { default: getPort } = await import('get-port')
+  const { root, mode, paths } = options
+  const server = await createServer({
+    root,
+    server: {
+      open: true,
+      host: options.host,
+    },
+  })
+
+  // these can be lazy loaded (eventually should put in own process)
+  await Promise.all([
+    server.listen(),
+    //
+    watchTamaguiConfig(options),
+    // generateTypes(options),
+  ])
+
+  const info = server.httpServer?.address() as AddressInfo
+
+  const port = await getPort({
+    port: info.port + 1,
+  })
+
+  const app = express()
+
+  app.disable('x-powered-by')
+  app.use(express.static(paths.dotDir, { maxAge: '2h' }))
+  app.use(morgan('tiny'))
+
+  // studio specific - move out eventually to studioPlugin
+
+  app.get('/conf', async (req, res) => {
+    const conf = await fs.readJSON(paths.conf)
+    res.status(200).json(conf)
+  })
+
+  app.use('/', proxy(`${info.address}:${info.port}`))
+
+  app.listen(port)
+
+  console.log(`Listening on`, chalk.green(`http://localhost:${port}`))
+  server.printUrls()
+
+  await closeEvent(server)
+}

package/src/generate.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import fs from 'fs-extra'
+import { Project } from 'ts-morph'
+
+import { ResolvedOptions } from './types.js'
+import { loadTamagui } from './utils.js'
+
+export async function generateTypes(options: ResolvedOptions) {
+  const types = await getTypes(options)
+  await fs.writeJSON(options.paths.types, types, {
+    spaces: 2,
+  })
+}
+
+export async function getTypes(options: ResolvedOptions) {
+  const tamagui = await loadTamagui(options.tamaguiOptions)
+
+  const uniqueViewExportingPaths = new Set(
+    Object.keys(tamagui.nameToPaths).map((name) => {
+      return `${[...tamagui.nameToPaths[name]][0]}.ts*`
+    })
+  )
+
+  const project = new Project({
+    compilerOptions: {
+      noEmit: false,
+      declaration: true,
+      emitDeclarationOnly: true,
+    },
+    skipAddingFilesFromTsConfig: true,
+    tsConfigFilePath: options.tsconfigPath,
+  })
+
+  const files = project.addSourceFilesAtPaths([...uniqueViewExportingPaths])
+
+  return Object.fromEntries(
+    files.flatMap((x) => {
+      return [...x.getExportedDeclarations()].map(([k, v]) => {
+        return [
+          k,
+          v[0]
+            .getType()
+            .getApparentType()
+            .getProperties()
+            .map((prop) => {
+              return [prop.getEscapedName(), prop.getValueDeclaration()?.getType().getText()]
+            }),
+        ]
+      })
+    })
+  )
+
+  // console.log(
+  //   'project',
+  //   files.map((x) => x.getFilePath()),
+  //   files.map((x) => {
+  //     return x.getExportedDeclarations()
+  //   }),
+  //   Object.fromEntries(
+  //     files.flatMap((x) => {
+  //       return [...x.getExportedDeclarations()].map(([k, v]) => {
+  //         return [k, v[0].getType().getApparentType().getText()]
+  //       })
+  //     })
+  //   ),
+
+  //   // files.map((f) => f.getExportSymbols())
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import './cli.js'

package/src/studio.ts

@@ -0,0 +1,69 @@
+import { createRequire } from 'module'
+import { AddressInfo } from 'net'
+import { dirname } from 'path'
+
+import { tamaguiPlugin } from '@tamagui/vite-plugin'
+import chalk from 'chalk'
+import express from 'express'
+import proxy from 'express-http-proxy'
+import fs from 'fs-extra'
+import morgan from 'morgan'
+import { createServer } from 'vite'
+
+import { watchTamaguiConfig } from './tamaguiConfigUtils.js'
+import { ResolvedOptions } from './types.js'
+import { closeEvent } from './utils.js'
+
+const resolve = 'url' in import.meta ? createRequire(import.meta.url).resolve : require.resolve
+
+export const studio = async (options: ResolvedOptions) => {
+  const { default: getPort } = await import('get-port')
+  const { paths } = options
+  const root = dirname(resolve('@takeout/studio/entry'))
+  const server = await createServer({
+    root,
+    server: {
+      // open: true,
+      host: options.host,
+    },
+    plugins: [
+      tamaguiPlugin({
+        components: ['tamagui'],
+      }),
+    ],
+  })
+
+  // these can be lazy loaded (eventually should put in own process)
+  await Promise.all([
+    server.listen(),
+    //
+    watchTamaguiConfig(options),
+    // generateTypes(options),
+  ])
+
+  const info = server.httpServer?.address() as AddressInfo
+  console.log('devServerInfo', info)
+
+  const port = await getPort({
+    port: info.port + 1,
+  })
+
+  const app = express()
+
+  app.disable('x-powered-by')
+  app.use(express.static(paths.dotDir, { maxAge: '2h' }))
+  app.use(morgan('tiny'))
+
+  app.get('/conf', async (req, res) => {
+    const conf = await fs.readJSON(paths.conf)
+    res.status(200).json(conf)
+  })
+
+  app.use('/', proxy(`${info.address}:${info.port}`))
+
+  app.listen(port)
+
+  console.log(`Listening on`, chalk.green(`http://localhost:${port}`))
+
+  await closeEvent(server)
+}

package/src/tamaguiConfigUtils.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+import { getVariableValue } from '@tamagui/core-node'
+import esbuild from 'esbuild'
+import fs, { ensureDir } from 'fs-extra'
+
+import { ResolvedOptions } from './types.js'
+import { loadTamagui } from './utils.js'
+
+export async function generateTamaguiConfig(options: ResolvedOptions) {
+  await ensureDir(options.paths.dotDir)
+  const config = await getTamaguiConfig(options)
+  const { components, nameToPaths } = config
+  const { themes, tokens } = config.tamaguiConfig
+
+  // reduce down to usable, smaller json
+
+  // slim themes, add name
+  for (const key in themes) {
+    const theme = themes[key]
+    // @ts-ignore
+    theme.id = key
+    for (const tkey in theme) {
+      theme[tkey] = getVariableValue(theme[tkey])
+    }
+  }
+
+  // flatten variables
+  for (const key in tokens) {
+    const token = tokens[key]
+    for (const tkey in token) {
+      token[tkey] = getVariableValue(token[tkey])
+    }
+  }
+
+  // remove bulky stuff in components
+  for (const key in components) {
+    const component = components[key]
+    for (const _ in component.nameToInfo) {
+      delete component.nameToInfo[_].staticConfig['validStyles']
+    }
+  }
+
+  // set to array
+  for (const key in nameToPaths) {
+    // @ts-ignore
+    nameToPaths[key] = [...nameToPaths[key]]
+  }
+
+  // cleanup other stuff
+  // @ts-ignore
+  delete config.tamaguiConfig['Provider']
+  // @ts-ignore
+  delete config.tamaguiConfig['fontsParsed']
+  // @ts-ignore
+  delete config.tamaguiConfig['getCSS']
+  // @ts-ignore
+  delete config.tamaguiConfig['tokensParsed']
+  // @ts-ignore
+  delete config.tamaguiConfig['themeConfig']
+
+  await fs.writeJSON(options.paths.conf, config, {
+    spaces: 2,
+  })
+}
+
+async function getTamaguiConfig(options: ResolvedOptions) {
+  return loadTamagui(options.tamaguiOptions)
+}
+
+export async function watchTamaguiConfig(options: ResolvedOptions) {
+  if (!options.tamaguiOptions.config) return
+  await generateTamaguiConfig(options)
+  await esbuild.build({
+    entryPoints: [options.tamaguiOptions.config],
+    sourcemap: false,
+    // dont output just use esbuild as a watcher
+    write: false,
+    watch: {
+      onRebuild(err, result) {
+        generateTamaguiConfig(options)
+      },
+    },
+  })
+}