@tamagui/cli 1.101.0 → 1.101.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/cli",
-  "version": "1.101.0",
+  "version": "1.101.1",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "main": "dist",
@@ -23,11 +23,11 @@
     "clean:build": "tamagui-build clean:build"
   },
   "dependencies": {
-    "@tamagui/create-theme": "1.101.0",
-    "@tamagui/generate-themes": "1.101.0",
-    "@tamagui/static": "1.101.0",
-    "@tamagui/types": "1.101.0",
-    "@tamagui/vite-plugin": "1.101.0",
+    "@tamagui/create-theme": "1.101.1",
+    "@tamagui/generate-themes": "1.101.1",
+    "@tamagui/static": "1.101.1",
+    "@tamagui/types": "1.101.1",
+    "@tamagui/vite-plugin": "1.101.1",
     "@vitejs/plugin-react-swc": "^3.6.0",
     "arg": "^5.0.2",
     "chalk": "^4.1.2",
@@ -49,14 +49,14 @@
     "opener": "^1.5.2",
     "prompts": "2.1.0",
     "ts-morph": "^15.1.0",
-    "typescript": "^5.4.5",
+    "typescript": "^5.5.2",
     "url": "^0.11.0",
     "vite": "6.0.0-alpha.17",
     "vite-plugin-entry-shaking": "^0.4.3",
     "vite-tsconfig-paths": "^4.3.2"
   },
   "devDependencies": {
-    "@tamagui/build": "1.101.0",
+    "@tamagui/build": "1.101.1",
     "@types/chokidar": "^2.1.3",
     "@types/marked": "^5.0.0"
   }

package/types/build.d.ts

@@ -1,6 +1,6 @@
 import type { CLIResolvedOptions } from '@tamagui/types';
 export declare const build: (options: CLIResolvedOptions & {
-    target?: 'web' | 'native';
+    target?: "web" | "native";
     dir?: string;
     include?: string;
     exclude?: string;

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAKzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAIxE,wBAAsB,UAAU,CAAC,EAC/B,IAAoB,EACpB,YAA8B,EAC9B,cAAc,EACd,IAAI,EACJ,KAAK,EACL,kBAAkB,GACnB,GAAE,OAAO,CAAC,cAAc,CAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAuC5D;AAED,wBAAgB,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,QAKzD;AAiBD,eAAO,MAAM,WAAW,SAChB,QAAQ,cAAc,CAAC,KAC5B,QAAQ,kBAAkB,GAAG,IAAI,CAUnC,CAAA;AAID,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,IAAI,QAE7C;AAED,wBAAgB,UAAU,SAEzB"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAKzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAIxE,wBAAsB,UAAU,CAAC,EAC/B,IAAoB,EACpB,YAA8B,EAC9B,cAAc,EACd,IAAI,EACJ,KAAK,EACL,kBAAkB,GACnB,GAAE,OAAO,CAAC,cAAc,CAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAuC5D;AAED,wBAAgB,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,QAKzD;AAiBD,eAAO,MAAM,WAAW,SAChB,OAAO,CAAC,cAAc,CAAC,KAC5B,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAUnC,CAAA;AAID,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,IAAI,QAE7C;AAED,wBAAgB,UAAU,SAEzB"}

package/dist/add.mjs

@@ -1,64 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync, rmSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import path from "node:path";
-import chalk from "chalk";
-import { pascalCase } from "change-case";
-import FSExtra from "fs-extra";
-import { marked } from "marked";
-import TerminalRenderer from "marked-terminal";
-import open from "opener";
-import prompts from "prompts";
-const {
-  copy,
-  ensureDir,
-  readFileSync
-} = FSExtra;
-marked.setOptions({
-  headerIds: !1,
-  mangle: !1,
-  renderer: new TerminalRenderer()
-});
-const home = homedir(),
-  tamaguiDir = path.join(home, ".tamagui"),
-  generatedPackageTypes = ["font", "icon"],
-  installGeneratedPackage = async (type, packagesPath) => {
-    if (packagesPath = packagesPath || path.join(process.cwd(), "packages"), !generatedPackageTypes.includes(type)) throw new Error(`${type ? `Type "${type}" is Not supported.` : "No type provided."} Supported types: ${generatedPackageTypes.join(", ")}`);
-    const repoName = type === "font" ? "tamagui-google-fonts" : "tamagui-iconify";
-    console.info(`Setting up ${chalk.blueBright(tamaguiDir)}...`), await ensureDir(tamaguiDir);
-    const tempDir = path.join(tamaguiDir, repoName);
-    existsSync(tempDir) && rmSync(tempDir, {
-      recursive: !0
-    });
-    try {
-      process.chdir(tamaguiDir);
-      try {
-        console.info("Attempting to clone with SSH"), execSync(`git clone -n --depth=1  --branch generated --filter=tree:0 git@github.com:tamagui/${repoName}.git`);
-      } catch {
-        console.info("SSH failed - Attempting to c  lone with HTTPS"), execSync(`git clone -n --depth=1 --branch generated --filter=tree:0 https://github.com/tamagui/${repoName}`);
-      }
-      process.chdir(tempDir), execSync(["git sparse-checkout set --no-cone meta", "git checkout"].join(" && "));
-    } catch (error) {
-      if (error instanceof Error) throw error?.stderr.includes("Repository not found") && (console.info(chalk.yellow(`You don't have access to Tamagui ${type === "font" ? "fonts" : "icons"}. Check \u{1F961} Tamagui Takeout (https://tamagui.dev/takeout) for more info.`)), open("https://tamagui.dev/takeout"), process.exit(0)), error;
-    }
-    const meta = JSON.parse(await readFile(path.join(tamaguiDir, repoName, "meta", "data.json")).then(r => r.toString()));
-    console.info(chalk.gray("Use \u21E7/\u21E9 to navigate. Use tab to cycle the result. Use Page Up/Page Down (on Mac: fn + \u21E7 / \u21E9) to change page. Hit enter to select the highlighted item below the prompt."));
-    const result = await prompts({
-        name: "packageName",
-        type: "autocomplete",
-        message: type === "icon" ? "Pick an icon pack:" : type === "font" ? "Pick a font:" : "Pick one:",
-        choices: Object.entries(meta).map(([slug, data]) => ({
-          title: type === "font" ? `${slug}: ${data.weights.length} weights, ${data.styles.length} styles, ${data.subsets.length} subsets (https://fonts.google.com/specimen/${pascalCase(slug)})` : `${data.name}: ${data.total} icons, ${data.license.title} license (${data.author.url})`,
-          value: slug
-        }))
-      }),
-      packageName = `${type}-${result.packageName}`,
-      packageDir = path.join(tempDir, "packages", packageName);
-    process.chdir(tempDir), execSync([`git sparse-checkout set --no-cone packages/${packageName}`, "git checkout"].join(" && "));
-    const finalDir = path.join(packagesPath, packageName);
-    await ensureDir(packagesPath), await copy(packageDir, finalDir), console.info(), console.info(chalk.green(`Created the package under ${finalDir}`)), console.info();
-    const readmePath = path.join(finalDir, "README.md");
-    existsSync(readmePath) && console.info(marked.parse(readFileSync(readmePath).toString()));
-  };
-export { generatedPackageTypes, installGeneratedPackage };

package/dist/build.mjs

@@ -1,37 +0,0 @@
-import { resolve } from "node:path";
-import { createExtractor, extractToClassNames, loadTamaguiBuildConfigSync } from "@tamagui/static";
-import chokidar from "chokidar";
-import { readFile } from "fs-extra";
-import MicroMatch from "micromatch";
-const build = async options => {
-  const sourceDir = options.dir ?? ".",
-    promises = [],
-    targets = ["web"],
-    buildOptions = loadTamaguiBuildConfigSync(options.tamaguiOptions);
-  await new Promise(res => {
-    chokidar.watch(sourceDir, {
-      // persistent: true,
-    }).on("add", relativePath => {
-      if (options.exclude && MicroMatch.contains(relativePath, options.exclude) || options.include && !MicroMatch.contains(relativePath, options.include)) return;
-      const sourcePath = resolve(process.cwd(), relativePath);
-      promises.push((async () => {
-        await Promise.all(targets.map(async target => {
-          process.env.TAMAGUI_TARGET = target, options.debug && (process.env.NODE_ENV ||= "development");
-          const source = await readFile(sourcePath, "utf-8"),
-            extractor = createExtractor(),
-            out = await extractToClassNames({
-              extractor,
-              source,
-              sourcePath,
-              options: buildOptions,
-              shouldPrintDebug: options.debug || !1
-            });
-          console.log("go", out);
-        }));
-      })());
-    }).on("ready", () => {
-      res();
-    });
-  }), await Promise.all(promises);
-};
-export { build };

package/dist/cli.mjs

@@ -1,250 +0,0 @@
-import arg from "arg";
-import chalk from "chalk";
-import { generatedPackageTypes } from "./add.js";
-import { disposeAll, getOptions } from "./utils.mjs";
-import { loadTamagui, checkDeps } from "@tamagui/static";
-["exit", "SIGINT"].forEach(_ => {
-  process.on(_, () => {
-    disposeAll(), process.exit();
-  });
-});
-const COMMAND_MAP = {
-    check: {
-      description: "Checks your dependencies for inconsistent versions.",
-      shorthands: [],
-      flags: {
-        "--help": Boolean,
-        "--debug": Boolean,
-        "--verbose": Boolean
-      },
-      async run() {
-        const {
-            _,
-            ...flags2
-          } = arg(this.flags),
-          options = await getOptions({
-            debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1,
-            loadTamaguiOptions: !0
-          }),
-          instance = await checkDeps(options.paths.root, {
-            depType: ["dependencies", "devDependencies"]
-          }),
-          isNonTamaguiNamedDep = {
-            "react-native-web-lite": !0,
-            "react-native-web-internals": !0
-          };
-        for (const dep of instance.getDependencies()) !dep.name.includes("tamagui") && !isNonTamaguiNamedDep[dep.name] || dep.isMismatching && console.warn(`-------------------------------------------------------------------------------------------------
-
-\u26A0\uFE0F  [tamagui] Mis-matching dependency version found in: ${dep.name}
-
-      This will cause errors in your app. To fix, make sure all tamagui dependencies
-      in your repo are on on the same version.
-          
-      Other versions used in the repo: ${dep.versions.map(version => version.version).join(", ")}
-
--------------------------------------------------------------------------------------------------`);
-      }
-    },
-    generate: {
-      description: "Builds your entire tamagui configuration and outputs any CSS.",
-      shorthands: [],
-      flags: {
-        "--help": Boolean,
-        "--debug": Boolean,
-        "--verbose": Boolean
-      },
-      async run() {
-        const {
-            _,
-            ...flags2
-          } = arg(this.flags),
-          options = await getOptions({
-            debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1,
-            loadTamaguiOptions: !0
-          });
-        process.env.TAMAGUI_KEEP_THEMES = "1", await loadTamagui({
-          ...options.tamaguiOptions,
-          platform: "web"
-        });
-      }
-    },
-    "generate-themes": {
-      shorthands: ["gt"],
-      description: "Use to pre-build your themes",
-      flags: {
-        "--help": Boolean,
-        "--debug": Boolean,
-        "--verbose": Boolean
-      },
-      async run() {
-        const {
-            _,
-            ...flags2
-          } = arg(this.flags),
-          options = await getOptions({
-            debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1
-          }),
-          [_cmd, inPath, outPath] = _;
-        if (!inPath || !outPath) throw new Error(`Must supply both input and output paths, missing one (inPath: ${inPath}, outPath: ${outPath})`);
-        const {
-          generateThemes,
-          writeGeneratedThemes
-        } = require("@tamagui/generate-themes");
-        try {
-          const generated = await generateThemes(inPath);
-          await writeGeneratedThemes(options.paths.dotDir, outPath, generated);
-        } catch (err) {
-          console.error(`Error generating themes: ${err}`);
-          return;
-        }
-        console.info(`Successfully generated themes to ${outPath}`);
-      }
-    },
-    add: {
-      shorthands: ["a"],
-      description: `Use to add fonts and icons to your monorepo. Supported types: ${generatedPackageTypes.join(", ")}`,
-      flags: {
-        "--help": Boolean,
-        "--debug": Boolean,
-        "--verbose": Boolean
-      },
-      async run() {
-        const {
-            _,
-            ...flags2
-          } = arg(this.flags),
-          {
-            installGeneratedPackage
-          } = require("./add.js"),
-          [cmd, type, path] = _;
-        await installGeneratedPackage(type, path);
-      }
-    },
-    build: {
-      shorthands: ["b"],
-      description: "Use to pre-build a Tamagui component directory",
-      flags: {
-        "--help": Boolean,
-        "--debug": Boolean,
-        "--verbose": Boolean,
-        "--include": String,
-        "--exclude": String
-      },
-      async run() {
-        const {
-            _,
-            ...flags2
-          } = arg(this.flags),
-          [dir] = _,
-          {
-            build
-          } = await import("./build.js"),
-          options = await getOptions({
-            debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1
-          });
-        await build({
-          ...options,
-          dir,
-          include: flags2["--include"],
-          exclude: flags2["--exclude"]
-        });
-      }
-    },
-    // update: {
-    //   shorthands: [],
-    //   description: `Update all tamagui packages within a monorepo`,
-    //   flags: {},
-    //   async run() {
-    //     const { update } = await import('./update')
-    //     await update()
-    //   },
-    // },
-    studio: {
-      shorthands: ["s"],
-      description: "Studio",
-      flags: {
-        "--help": Boolean,
-        "--debug": Boolean,
-        "--verbose": Boolean,
-        "--remote": Boolean,
-        "--build": Boolean
-      },
-      async run() {
-        const {
-            _,
-            ...flags2
-          } = arg(this.flags),
-          {
-            studio
-          } = require("./studio"),
-          options = await getOptions({
-            debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1
-          });
-        await studio(options, flags2["--remote"], flags2["--build"]);
-      }
-    },
-    "update-template": {
-      shorthands: ["ut"],
-      description: "Used to update your git repo with the source template. (e.g. Takeout)",
-      flags: {
-        "--help": Boolean,
-        "--template-repo": String,
-        "--ignored-patterns": String
-      },
-      async run() {
-        const {
-            _,
-            ...flags2
-          } = arg(this.flags),
-          {
-            updateTemplate
-          } = require("./update-template");
-        if (!flags2["--template-repo"]) throw new Error("--template-repo is required");
-        await updateTemplate(flags2["--template-repo"], flags2["--ignored-patterns"]?.split(" "));
-      }
-    }
-  },
-  commandEntries = Object.keys(COMMAND_MAP).flatMap(command2 => {
-    const definition2 = COMMAND_MAP[command2];
-    return [command2, ...definition2.shorthands].map(cmd => [cmd, definition2]);
-  }),
-  commands = Object.fromEntries(commandEntries),
-  {
-    _: [command],
-    ...flags
-  } = arg({
-    "--help": Boolean,
-    "--version": Boolean
-  }, {
-    permissive: !0
-  });
-flags["--version"] && (console.info(require("../package.json").version), process.exit(0));
-!command && flags["--help"] && (console.info(`$ tamagui
-
-commands:
-
-${Object.keys(COMMAND_MAP).map(key => `  ${key}`).join(`
-`)}`), process.exit(0));
-command in commands || (console.error(), console.warn(chalk.yellow(`Not a valid command: ${command}`)), process.exit(1));
-const definition = commands[command];
-main();
-async function main() {
-  flags["--help"] && (console.info(`
-$ tamagui ${command}: ${definition.description}
-`), console.info(`Flags: ${Object.entries(definition.flags).map(([k, v]) => `${k} (${v.name})`)}`), process.exit(0));
-  const {
-    _,
-    ...cmdFlags
-  } = arg(definition.flags);
-  cmdFlags["--help"] && (console.info(`$ tamagui ${_}
-
-    Flags: ${JSON.stringify(cmdFlags, null, 2)}
-
-`), process.exit(0));
-  try {
-    await definition.run();
-  } catch (err) {
-    console.error(`Error running command: ${err.message}`);
-  }
-  process.exit(0);
-}

package/dist/generate.mjs

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-import fs from "fs-extra";
-import { Project } from "ts-morph";
-import { loadTamagui } from "./utils.mjs";
-async function generateTypes(options) {
-  const types = await getTypes(options);
-  await fs.writeJSON(options.paths.types, types, {
-    spaces: 2
-  });
-}
-async function getTypes(options) {
-  const tamagui = await loadTamagui(options.tamaguiOptions);
-  if (!tamagui) throw new Error("No tamagui config");
-  const nameToPaths = tamagui.nameToPaths || [],
-    uniqueViewExportingPaths = new Set(Object.keys(nameToPaths).map(name => `${[...nameToPaths[name]][0]}.ts*`)),
-    files = new Project({
-      compilerOptions: {
-        noEmit: !1,
-        declaration: !0,
-        emitDeclarationOnly: !0
-      },
-      skipAddingFilesFromTsConfig: !0,
-      tsConfigFilePath: options.tsconfigPath
-    }).addSourceFilesAtPaths([...uniqueViewExportingPaths]);
-  return Object.fromEntries(files.flatMap(x => [...x.getExportedDeclarations()].map(([k, v]) => [k, v[0].getType().getApparentType().getProperties().map(prop => [prop.getEscapedName(), prop.getValueDeclaration()?.getType().getText()])])));
-}
-export { generateTypes, getTypes };

package/dist/index.mjs

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-require("./cli");

package/dist/studio.mjs

@@ -1,108 +0,0 @@
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { watchTamaguiConfig } from "@tamagui/static";
-import viteReactPlugin from "@vitejs/plugin-react-swc";
-import chalk from "chalk";
-import express from "express";
-import fs, { ensureDir } from "fs-extra";
-import { createProxyMiddleware } from "http-proxy-middleware";
-import { build, createServer } from "vite";
-import viteInspect from "vite-plugin-inspect";
-import viteTsConfigPaths from "vite-tsconfig-paths";
-const resolve = "url" in import.meta ? createRequire(import.meta.url).resolve : require.resolve,
-  studio = async (options, isRemote = !1, isBuild = !1) => {
-    const {
-      tamaguiExtractPlugin,
-      tamaguiPlugin
-    } = await import("@tamagui/vite-plugin");
-    await ensureDir(options.paths.dotDir);
-    const configWatchPromise = watchTamaguiConfig(options.tamaguiOptions);
-    let localServerPromise = new Promise(() => {});
-    if (isRemote) console.log("Open ", chalk.green("https://studio.tamagui.dev"), " to load studio");else {
-      process.env.VITE_IS_LOCAL = "1", process.stdout.on("error", err => {
-        err.code == "EPIPE" && process.exit(0);
-      });
-      const {
-          default: getPort
-        } = await import("get-port"),
-        {
-          paths
-        } = options,
-        root = dirname(dirname(resolve("@tamagui/studio"))),
-        [serverPort, vitePort] = await Promise.all([getPort({
-          port: 1421
-        }), getPort({
-          port: 1422
-        })]),
-        targets = [resolve("@tamagui/lucide-icons").replace("/dist/cjs/index.js", ""), resolve("@tamagui/demos").replace("/dist/cjs/index.js", "")],
-        viteConfig = {
-          root,
-          server: {
-            host: options.host,
-            port: vitePort,
-            hmr: !0,
-            cors: !0
-          },
-          build: {
-            rollupOptions: {}
-          },
-          plugins: [viteReactPlugin({
-            tsDecorators: !0
-          }), tamaguiPlugin({
-            components: ["tamagui"]
-          }), tamaguiExtractPlugin({
-            config: "./src/tamagui.config.ts",
-            disableExtraction: !0,
-            components: ["tamagui"]
-          }), viteTsConfigPaths(),
-          // await entryShakingPlugin({
-          //   targets,
-          // }),
-          viteInspect()],
-          define: {
-            "process.env.TAMAGUI_KEEP_THEMES": "true",
-            global: "window"
-          }
-        };
-      if (isBuild) return await build(viteConfig);
-      const server = await createServer(viteConfig);
-      await server.listen();
-      const info = server.httpServer?.address(),
-        app = express();
-      app.disable("x-powered-by"), app.use(express.static(paths.dotDir, {
-        maxAge: "2h"
-      })), app.get("/conf.json", async (req, res) => {
-        const conf = await fs.readJSON(paths.conf);
-        res.status(200).json(conf);
-      }), app.get("/pingz", async (req, res) => {
-        res.status(200).json({
-          hi: !0
-        });
-      }), app.get("/api/tamagui.config.json", async (req, res) => {
-        try {
-          res.status(200).json(await fs.readJSON(paths.conf));
-        } catch (err) {
-          res.status(500).json({
-            error: `${err.message}`
-          });
-        }
-      }), app.get("/api/tamagui.themes.json", async (req, res) => {
-        try {
-          res.status(200).json(await fs.readJSON(join(paths.dotDir, "theme-builder.json")));
-        } catch (err) {
-          res.status(500).json({
-            error: `${err.message}`
-          });
-        }
-      });
-      const target = `http://${info.address}:${vitePort}`;
-      app.use("/", createProxyMiddleware({
-        target,
-        ws: !0
-      }));
-      const appServer = app.listen(serverPort);
-      localServerPromise = new Promise(res => appServer.on("close", res)), console.log("Listening on", chalk.green(`http://localhost:${serverPort}`));
-    }
-    await Promise.allSettled([configWatchPromise, localServerPromise]);
-  };
-export { studio };

package/dist/update-template.mjs

@@ -1,23 +0,0 @@
-import chalk from "chalk";
-import { execSync } from "child_process";
-function updateTemplate(templateUrl, ignoredPatterns = []) {
-  const remoteName = `${templateUrl.split("/").pop()?.split(".")[0] || "template"}-template`,
-    addRemoteCommand = `git remote add ${remoteName} ${templateUrl}`,
-    rmRemoteCommand = `git remote remove ${remoteName}`;
-  try {
-    execSync(addRemoteCommand);
-  } catch (error) {
-    if (error instanceof Error && error.toString().includes("already exists")) execSync(rmRemoteCommand), execSync(addRemoteCommand);else throw error;
-  }
-  execSync("git fetch --all");
-  try {
-    execSync("git merge takeout-template/main --allow-unrelated-histories");
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("unresolved conflict")) console.info(tamaguiLog("We've merged the latest changes. Please resolve the conflicts and commit the merge."));else throw error;
-  }
-  execSync(`git reset HEAD ${ignoredPatterns.join(" ")}`);
-}
-function tamaguiLog(message) {
-  return `${chalk.green("[Tamagui]")} ${message}`;
-}
-export { updateTemplate };

package/dist/update.mjs

@@ -1,2 +0,0 @@
-const update = async () => {};
-export { update };

package/dist/utils.mjs

@@ -1,72 +0,0 @@
-import { join } from "path";
-import { loadTamaguiBuildConfigSync, 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,
-  loadTamaguiOptions
-} = {}) {
-  const tsConfigFilePath = join(root, tsconfigPath);
-  ensure(await fs.pathExists(tsConfigFilePath), `No tsconfig found: ${tsConfigFilePath}`);
-  const dotDir = join(root, ".tamagui");
-  let pkgJson = {},
-    config = "";
-  try {
-    config = await getDefaultTamaguiConfigPath(), pkgJson = await readJSON(join(root, "package.json"));
-  } catch {}
-  const filledOptions = {
-      platform: "native",
-      components: ["tamagui"],
-      config,
-      ...tamaguiOptions
-    },
-    finalOptions = loadTamaguiOptions ? loadTamaguiBuildConfigSync(filledOptions) : filledOptions;
-  return {
-    mode: process.env.NODE_ENV === "production" ? "production" : "development",
-    root,
-    host: host || "127.0.0.1",
-    pkgJson,
-    debug,
-    tsconfigPath,
-    tamaguiOptions: finalOptions,
-    paths: {
-      root,
-      dotDir,
-      conf: join(dotDir, "tamagui.config.json"),
-      types: join(dotDir, "types.json")
-    }
-  };
-}
-function ensure(condition, message) {
-  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),
-    found = defaultPaths[existing];
-  if (!found) throw new Error("No found tamagui.config.ts");
-  return cachedPath = found, found;
-}
-let cached = null;
-const loadTamagui = async opts => {
-    const loaded = await loadTamaguiStatic({
-      config: await getDefaultTamaguiConfigPath(),
-      components: ["tamagui"],
-      ...opts
-    });
-    return loaded && (cached = loaded), loaded;
-  },
-  disposers = /* @__PURE__ */new Set();
-function registerDispose(cb) {
-  disposers.add(cb);
-}
-function disposeAll() {
-  disposers.forEach(cb => cb());
-}
-export { disposeAll, ensure, getOptions, loadTamagui, registerDispose };