@tamagui/cli 1.116.0 → 1.116.2

package/dist/add.js

@@ -0,0 +1,91 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var add_exports = {};
+__export(add_exports, {
+  generatedPackageTypes: () => generatedPackageTypes,
+  installGeneratedPackage: () => installGeneratedPackage
+});
+module.exports = __toCommonJS(add_exports);
+var import_node_child_process = require("node:child_process"), import_node_fs = require("node:fs"), import_promises = require("node:fs/promises"), import_node_os = require("node:os"), import_node_path = __toESM(require("node:path")), import_chalk = __toESM(require("chalk")), import_change_case = require("change-case"), import_fs_extra = require("fs-extra"), import_marked = require("marked"), import_marked_terminal = __toESM(require("marked-terminal")), import_opener = __toESM(require("opener")), import_prompts = __toESM(require("prompts"));
+import_marked.marked.setOptions({
+  renderer: new import_marked_terminal.default()
+});
+const home = (0, import_node_os.homedir)(), tamaguiDir = import_node_path.default.join(home, ".tamagui"), generatedPackageTypes = ["font", "icon"], installGeneratedPackage = async (type, packagesPath) => {
+  if (packagesPath = packagesPath || import_node_path.default.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 ${import_chalk.default.blueBright(tamaguiDir)}...`), await (0, import_fs_extra.ensureDir)(tamaguiDir);
+  const tempDir = import_node_path.default.join(tamaguiDir, repoName);
+  (0, import_node_fs.existsSync)(tempDir) && (0, import_node_fs.rmSync)(tempDir, { recursive: !0 });
+  try {
+    process.chdir(tamaguiDir);
+    try {
+      console.info("Attempting to clone with SSH"), (0, import_node_child_process.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"), (0, import_node_child_process.execSync)(
+        `git clone -n --depth=1 --branch generated --filter=tree:0 https://github.com/tamagui/${repoName}`
+      );
+    }
+    process.chdir(tempDir), (0, import_node_child_process.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(
+        import_chalk.default.yellow(
+          `You don't have access to Tamagui ${type === "font" ? "fonts" : "icons"}. Check \u{1F961} Tamagui Takeout (https://tamagui.dev/takeout) for more info.`
+        )
+      ), (0, import_opener.default)("https://tamagui.dev/takeout"), process.exit(0)), error;
+  }
+  const meta = JSON.parse(
+    await (0, import_promises.readFile)(import_node_path.default.join(tamaguiDir, repoName, "meta", "data.json")).then(
+      (r) => r.toString()
+    )
+  );
+  console.info(
+    import_chalk.default.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 (0, import_prompts.default)({
+    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/${(0, import_change_case.pascalCase)(slug)})` : `${data.name}: ${data.total} icons, ${data.license.title} license (${data.author.url})`,
+      value: slug
+    }))
+  }), packageName = `${type}-${result.packageName}`, packageDir = import_node_path.default.join(tempDir, "packages", packageName);
+  process.chdir(tempDir), (0, import_node_child_process.execSync)(
+    [`git sparse-checkout set --no-cone packages/${packageName}`, "git checkout"].join(
+      " && "
+    )
+  );
+  const finalDir = import_node_path.default.join(packagesPath, packageName);
+  await (0, import_fs_extra.ensureDir)(packagesPath), await (0, import_fs_extra.copy)(packageDir, finalDir), console.info(), console.info(import_chalk.default.green(`Created the package under ${finalDir}`)), console.info();
+  const readmePath = import_node_path.default.join(finalDir, "README.md");
+  (0, import_node_fs.existsSync)(readmePath) && console.info(import_marked.marked.parse((0, import_fs_extra.readFileSync)(readmePath).toString()));
+};
+//# sourceMappingURL=add.js.map

package/dist/build.js

@@ -0,0 +1,75 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var build_exports = {};
+__export(build_exports, {
+  build: () => build
+});
+module.exports = __toCommonJS(build_exports);
+var import_node_path = require("node:path"), import_static = require("@tamagui/static"), import_chokidar = __toESM(require("chokidar")), import_fs_extra = require("fs-extra"), import_micromatch = __toESM(require("micromatch"));
+const build = async (options) => {
+  const sourceDir = options.dir ?? ".", promises = [], buildOptions = (0, import_static.loadTamaguiBuildConfigSync)(options.tamaguiOptions), platform = options.target ?? "web";
+  process.env.TAMAGUI_TARGET = platform;
+  const tamaguiOptions = {
+    ...buildOptions,
+    platform
+  };
+  await (0, import_static.loadTamagui)(tamaguiOptions), await new Promise((res) => {
+    import_chokidar.default.watch(`${sourceDir}/**/*.tsx`, {
+      // persistent: true,
+    }).on("add", (relativePath) => {
+      if (options.exclude && import_micromatch.default.contains(relativePath, options.exclude) || options.include && !import_micromatch.default.contains(relativePath, options.include))
+        return;
+      const sourcePath = (0, import_node_path.resolve)(process.cwd(), relativePath);
+      console.info(` [tamagui] optimizing ${sourcePath}`), promises.push(
+        (async () => {
+          options.debug && (process.env.NODE_ENV ||= "development");
+          const source = await (0, import_fs_extra.readFile)(sourcePath, "utf-8");
+          if (platform === "web") {
+            const extractor = (0, import_static.createExtractor)({
+              platform
+            }), out2 = await (0, import_static.extractToClassNames)({
+              extractor,
+              source,
+              sourcePath,
+              options: buildOptions,
+              shouldPrintDebug: options.debug || !1
+            });
+            if (!out2)
+              return;
+            const cssName = "_" + (0, import_node_path.basename)(sourcePath, (0, import_node_path.extname)(sourcePath)), stylePath = (0, import_node_path.join)((0, import_node_path.dirname)(sourcePath), cssName + ".css"), code = `import "./${cssName}.css"
+${out2.js}`;
+            await Promise.all([
+              (0, import_fs_extra.writeFile)(sourcePath, code, "utf-8"),
+              (0, import_fs_extra.writeFile)(stylePath, out2.styles, "utf-8")
+            ]);
+          }
+          const out = (0, import_static.extractToNative)(sourcePath, source, tamaguiOptions);
+          await (0, import_fs_extra.writeFile)(sourcePath, out.code, "utf-8");
+        })()
+      );
+    }).on("ready", () => {
+      res();
+    });
+  }), await Promise.all(promises);
+};
+//# sourceMappingURL=build.js.map

package/dist/cli.js

@@ -0,0 +1,199 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+));
+var import_arg = __toESM(require("arg")), import_chalk = __toESM(require("chalk")), import_add = require("./add"), import_utils = require("./utils"), import_static = require("@tamagui/static");
+["exit", "SIGINT"].forEach((_) => {
+  process.on(_, () => {
+    (0, import_utils.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 } = (0, import_arg.default)(this.flags), options = await (0, import_utils.getOptions)({
+        debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1,
+        loadTamaguiOptions: !0
+      });
+      await (0, import_static.checkDeps)(options.paths.root);
+    }
+  },
+  generate: {
+    description: "Builds your entire tamagui configuration and outputs any CSS.",
+    shorthands: [],
+    flags: {
+      "--help": Boolean,
+      "--debug": Boolean,
+      "--verbose": Boolean
+    },
+    async run() {
+      const { _, ...flags2 } = (0, import_arg.default)(this.flags), options = await (0, import_utils.getOptions)({
+        debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1,
+        loadTamaguiOptions: !0
+      });
+      process.env.TAMAGUI_KEEP_THEMES = "1", await (0, import_static.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 } = (0, import_arg.default)(this.flags), options = await (0, import_utils.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: ${import_add.generatedPackageTypes.join(
+      ", "
+    )}`,
+    flags: {
+      "--help": Boolean,
+      "--debug": Boolean,
+      "--verbose": Boolean
+    },
+    async run() {
+      const { _, ...flags2 } = (0, import_arg.default)(this.flags), { installGeneratedPackage } = require("./add"), [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,
+      "--target": String,
+      "--include": String,
+      "--exclude": String
+    },
+    async run() {
+      const { _, ...flags2 } = (0, import_arg.default)(this.flags), [_command, dir] = _, imported = await import("./build"), options = await (0, import_utils.getOptions)({
+        debug: flags2["--debug"] ? flags2["--verbose"] ? "verbose" : !0 : !1
+      });
+      await imported.default.build({
+        ...options,
+        dir,
+        include: flags2["--include"],
+        target: flags2["--target"] || "web",
+        exclude: flags2["--exclude"]
+      });
+    }
+  },
+  // update: {
+  //   shorthands: [],
+  //   description: `Update all tamagui packages within a monorepo`,
+  //   flags: {},
+  //   async run() {
+  //     const { update } = await import('./update')
+  //     await update()
+  //   },
+  // },
+  "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 } = (0, import_arg.default)(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
+} = (0, import_arg.default)(
+  {
+    "--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(import_chalk.default.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 } = (0, import_arg.default)(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);
+}
+//# sourceMappingURL=cli.js.map

package/dist/generate.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var generate_exports = {};
+__export(generate_exports, {
+  generateTypes: () => generateTypes,
+  getTypes: () => getTypes
+});
+module.exports = __toCommonJS(generate_exports);
+var import_fs_extra = __toESM(require("fs-extra")), import_ts_morph = require("ts-morph"), import_utils = require("./utils");
+async function generateTypes(options) {
+  const types = await getTypes(options);
+  await import_fs_extra.default.writeJSON(options.paths.types, types, {
+    spaces: 2
+  });
+}
+async function getTypes(options) {
+  const tamagui = await (0, import_utils.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 import_ts_morph.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()
+      ])
+    ]))
+  );
+}
+//# sourceMappingURL=generate.js.map

package/dist/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+require("./cli");
+//# sourceMappingURL=index.js.map

package/dist/update-template.js

@@ -0,0 +1,57 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var update_template_exports = {};
+__export(update_template_exports, {
+  updateTemplate: () => updateTemplate
+});
+module.exports = __toCommonJS(update_template_exports);
+var import_chalk = __toESM(require("chalk")), import_child_process = require("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 {
+    (0, import_child_process.execSync)(addRemoteCommand);
+  } catch (error) {
+    if (error instanceof Error && error.toString().includes("already exists"))
+      (0, import_child_process.execSync)(rmRemoteCommand), (0, import_child_process.execSync)(addRemoteCommand);
+    else
+      throw error;
+  }
+  (0, import_child_process.execSync)("git fetch --all");
+  try {
+    (0, import_child_process.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;
+  }
+  (0, import_child_process.execSync)(`git reset HEAD ${ignoredPatterns.join(" ")}`);
+}
+function tamaguiLog(message) {
+  return `${import_chalk.default.green("[Tamagui]")} ${message}`;
+}
+//# sourceMappingURL=update-template.js.map

package/dist/update.js

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var update_exports = {};
+__export(update_exports, {
+  update: () => update
+});
+module.exports = __toCommonJS(update_exports);
+const update = async () => {
+};
+//# sourceMappingURL=update.js.map

package/dist/utils.js

@@ -0,0 +1,94 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  disposeAll: () => disposeAll,
+  ensure: () => ensure,
+  getOptions: () => getOptions,
+  loadTamagui: () => loadTamagui,
+  registerDispose: () => registerDispose
+});
+module.exports = __toCommonJS(utils_exports);
+var import_static = require("@tamagui/static"), import_chalk = __toESM(require("chalk")), import_fs_extra = __toESM(require("fs-extra")), import_node_path = require("node:path");
+async function getOptions({
+  root = process.cwd(),
+  tsconfigPath = "tsconfig.json",
+  tamaguiOptions,
+  host,
+  debug,
+  loadTamaguiOptions
+} = {}) {
+  const tsConfigFilePath = (0, import_node_path.join)(root, tsconfigPath);
+  ensure(await import_fs_extra.default.pathExists(tsConfigFilePath), `No tsconfig found: ${tsConfigFilePath}`);
+  const dotDir = (0, import_node_path.join)(root, ".tamagui");
+  let pkgJson = {}, config = "";
+  try {
+    config = await getDefaultTamaguiConfigPath(), pkgJson = await (0, import_fs_extra.readJSON)((0, import_node_path.join)(root, "package.json"));
+  } catch {
+  }
+  const filledOptions = {
+    platform: "native",
+    components: ["tamagui"],
+    config,
+    ...tamaguiOptions
+  }, finalOptions = loadTamaguiOptions ? (0, import_static.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: (0, import_node_path.join)(dotDir, "tamagui.config.json"),
+      types: (0, import_node_path.join)(dotDir, "types.json")
+    }
+  };
+}
+function ensure(condition, message) {
+  condition || (console.error(import_chalk.default.red.bold("Error:"), import_chalk.default.yellow(`${message}`)), process.exit(1));
+}
+const defaultPaths = ["tamagui.config.ts", (0, import_node_path.join)("src", "tamagui.config.ts")];
+let cachedPath = "";
+async function getDefaultTamaguiConfigPath() {
+  if (cachedPath) return cachedPath;
+  const existing = (await Promise.all(defaultPaths.map((path) => (0, import_fs_extra.pathExists)(path)))).findIndex((x) => !!x), found = defaultPaths[existing];
+  if (!found)
+    throw new Error("No found tamagui.config.ts");
+  return cachedPath = found, found;
+}
+const loadTamagui = async (opts) => await (0, import_static.loadTamagui)({
+  components: ["tamagui"],
+  ...opts,
+  config: opts.config ?? await getDefaultTamaguiConfigPath()
+}), disposers = /* @__PURE__ */ new Set();
+function registerDispose(cb) {
+  disposers.add(cb);
+}
+function disposeAll() {
+  disposers.forEach((cb) => cb());
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/cli",
-  "version": "1.116.0",
+  "version": "1.116.2",
   "source": "src/index.ts",
   "types": "./types/index.d.ts",
   "main": "dist/index.cjs",
@@ -23,11 +23,11 @@
     "clean:build": "tamagui-build clean:build"
   },
   "dependencies": {
-    "@tamagui/create-theme": "1.116.0",
-    "@tamagui/generate-themes": "1.116.0",
-    "@tamagui/static": "1.116.0",
-    "@tamagui/types": "1.116.0",
-    "@tamagui/vite-plugin": "1.116.0",
+    "@tamagui/create-theme": "1.116.2",
+    "@tamagui/generate-themes": "1.116.2",
+    "@tamagui/static": "1.116.2",
+    "@tamagui/types": "1.116.2",
+    "@tamagui/vite-plugin": "1.116.2",
     "arg": "^5.0.2",
     "chalk": "^4.1.2",
     "change-case": "^4.1.2",
@@ -54,7 +54,7 @@
     "vite-plugin-entry-shaking": "^0.4.3"
   },
   "devDependencies": {
-    "@tamagui/build": "1.116.0",
+    "@tamagui/build": "1.116.2",
     "@types/chokidar": "^2.1.3",
     "@types/marked": "^5.0.0"
   }