bundo-appgen 0.0.1-beta.7

package/lib/bin/bin.mjs

@@ -0,0 +1,1141 @@
+#!/usr/bin/env node
+
+// src/_bin/bin.mts
+import yargs from "yargs";
+import * as YargsHelper from "yargs/helpers";
+
+// src/_bin/_global-vars/_global-vars.mts
+var prefixName = `__bundo_appgen_${Math.random()}_`;
+var postfixSetCount = "_setcount";
+var postfixSetCountMax = "_setcountmax";
+function globalVars(name, initialValue, maxSetCount) {
+  globalThis[prefixName + name] = initialValue;
+  globalThis[prefixName + name + postfixSetCount] = 0;
+  globalThis[prefixName + name + postfixSetCountMax] = maxSetCount ?? 1;
+  return {
+    get() {
+      return globalThis[prefixName + name];
+    },
+    set(value) {
+      globalThis[prefixName + name + postfixSetCount] += 1;
+      if (globalThis[prefixName + name + postfixSetCount] > globalThis[prefixName + name + postfixSetCountMax]) {
+        throw new Error("Exceeded amount of modifying.");
+      }
+      globalThis[prefixName + name] = value;
+    }
+  };
+}
+
+// src/_bin/_global-vars/index.mts
+var GlobalVars;
+((GlobalVars) => {
+  GlobalVars.appConfig = globalVars("app_config", {});
+  GlobalVars.argv = globalVars("argv", {
+    clean: false,
+    forceCrossPlatform: false,
+    path: "",
+    xcodegenPath: ""
+  });
+  GlobalVars.appgenRoot = globalVars("appgen_root", "");
+  GlobalVars.configFilePath = globalVars("config_file_path", "");
+})(GlobalVars ||= {});
+
+// src/_bin/_main/main.mts
+import * as node_fs14 from "node:fs";
+import * as node_path17 from "node:path";
+
+// src/_bin/_main/_helpers/config/get-name.mts
+function getName(config, platform) {
+  if (platform == "macos") {
+    return config.macos?.name || config.name;
+  }
+  return config.name;
+}
+// src/_bin/_main/_helpers/config/get-project-name.mts
+var cache;
+function getProjectName(...params) {
+  if (cache) {
+    return cache;
+  }
+  const name = getName(...params);
+  if (!name) {
+    return;
+  }
+  cache = name.replace(/[^a-zA-Z0-9]/g, "");
+  return cache;
+}
+// src/_bin/_main/_helpers/platform/compatibility-error.mts
+var CompatibilityError = new Error(`
+Cannot run bundo.rn appgen CLI in non compatible platform or JavaScript development runtime.
+
+bundo.rn CLIs are compatible for
+Platforms: macOS, Windows, Linux
+Development Runtime: Bun, Node.js
+	`);
+// src/_bin/_main/_helpers/platform/is-compatible.mts
+function isCompatible() {
+  const supportdRNPlatforms = [
+    "darwin",
+    "win32"
+  ], osCompatible = supportdRNPlatforms.indexOf(process.platform) > -1;
+  if (!osCompatible) {
+    return GlobalVars.argv.get().forceCrossPlatform;
+  }
+  return false;
+}
+
+// src/_bin/_main/_helpers/platform/get-data.mts
+var cache2;
+function getData() {
+  if (cache2) {
+    return cache2;
+  }
+  if (!isCompatible()) {
+    throw CompatibilityError;
+  }
+  const isBun = typeof Bun !== "undefined" || !!process.versions.bun;
+  let developmentRuntime;
+  if (isBun) {
+    developmentRuntime = {
+      type: "bun",
+      version: process.versions.bun
+    };
+  } else {
+    developmentRuntime = {
+      type: "node",
+      version: process.versions.node
+    };
+  }
+  cache2 = {
+    developmentRuntime
+  };
+  return cache2;
+}
+// src/_bin/_main/_check-config-validity.mts
+function checkConfigValidity(config) {
+  if (!config.macos) {
+    throw new Error("No platforms configuration.");
+  }
+  const isCrossPlatform = GlobalVars.argv.get().forceCrossPlatform;
+  if (isCrossPlatform) {
+    checkMacosConfig(config);
+  } else if (process.platform == "darwin") {
+    checkMacosConfig(config);
+  } else if (process.platform == "win32") {}
+  if (config.plugins) {
+    if (Array.isArray(config.plugins)) {
+      config.plugins.forEach((plugin) => {
+        let isValid = true;
+        if (Array.isArray(plugin) && plugin.length) {
+          isValid = typeof plugin[0] === "string";
+          if (plugin.length > 2) {
+            isValid = false;
+          } else if (plugin[1]) {
+            isValid = typeof plugin[1] === "object" && plugin[1].constructor === Object;
+          }
+        } else if (typeof plugin === "string" && !plugin.length) {
+          isValid = false;
+        }
+        if (!isValid) {
+          throw new Error("Plugin item needs to be an string of the plugin name, or an array of the plugin name and its parameter.");
+        }
+      });
+    } else {
+      throw new Error("Expected an Array in the plugin registry.");
+    }
+  }
+}
+
+class OSFieldError extends Error {
+  constructor(prop, os) {
+    super(`\`${prop}\` is required for ${os} app.`);
+  }
+}
+function checkMacosConfig(config) {
+  if (!getName(config, "macos")) {
+    throw new Error("`name` or `macos.name` is required in the config.");
+  }
+  if (!config.macos) {
+    throw new Error(`Missing macos property in the config.`);
+  }
+  if (!config.macos.buildVersion) {
+    throw new OSFieldError("buildVersion", "macos");
+  }
+  if (!config.macos.bundleIdentifier) {
+    throw new OSFieldError("bundleIdentifier", "macos");
+  }
+  if (!config.macos.version) {
+    throw new OSFieldError("version", "macos");
+  }
+}
+
+// src/_bin/_main/_evaluate-plugin-registry.mts
+import * as node_fs from "node:fs";
+import * as node_module from "node:module";
+import * as node_path from "node:path";
+function evaluatePluginRegistry(plugins) {
+  if (!plugins?.length) {
+    return;
+  }
+  const registry = [];
+  for (const plugin of plugins) {
+    let nameOrPath, parameter = undefined;
+    if (typeof plugin === "string" && plugin) {
+      nameOrPath = plugin;
+    } else if (Array.isArray(plugin) && plugin.length && typeof plugin[0] === "string" && plugin[0]) {
+      nameOrPath = plugin[0];
+      if (plugin[1]) {
+        if (typeof plugin[1] === "object" && plugin[1].constructor === Object) {
+          parameter = plugin[1];
+        } else {
+          throw new Error(`The plugin parameter is only supported in plain object. Caused by "${nameOrPath}".`);
+        }
+      }
+    } else {
+      throw new Error("The plugin registry is not a valid schema in the config.");
+    }
+    const mainPathFromNodeModule = getPluginMainPathFromNodeModules(nameOrPath);
+    if (mainPathFromNodeModule) {
+      registry.push({
+        name: nameOrPath,
+        mainPath: mainPathFromNodeModule,
+        parameter
+      });
+      continue;
+    }
+    const filePath = node_path.join(node_path.dirname(GlobalVars.configFilePath.get()), nameOrPath);
+    if (node_fs.existsSync(filePath)) {
+      const lstat = node_fs.lstatSync(filePath);
+      if (lstat.isFile()) {
+        registry.push({
+          name: nameOrPath,
+          mainPath: filePath,
+          parameter
+        });
+        continue;
+      } else {
+        throw new Error(`${filePath} is not a file.`);
+      }
+    }
+    throw new Error(`"${nameOrPath}" plugin cannot be found.`);
+  }
+  return registry;
+}
+function getPluginMainPathFromNodeModules(name) {
+  let modulePath;
+  let isDirectory = true;
+  try {
+    const __require = node_module.createRequire(node_path.join(process.cwd(), "package.json"));
+    const nodeModulePaths = __require.resolve.paths("bundo-appgen");
+    if (nodeModulePaths?.length) {
+      for (const nodeModulePath of nodeModulePaths) {
+        const __modulePath = node_path.join(nodeModulePath, name);
+        if (node_fs.existsSync(__modulePath)) {
+          const modulePathStat = node_fs.lstatSync(__modulePath);
+          if (modulePathStat.isFile()) {
+            isDirectory = false;
+          }
+          if (modulePathStat.isSymbolicLink()) {
+            modulePath = node_fs.realpathSync(__modulePath);
+          } else {
+            modulePath = __modulePath;
+          }
+          break;
+        }
+      }
+    }
+    if (!modulePath) {
+      return;
+    }
+  } catch {
+    return;
+  }
+  if (!isDirectory) {
+    return modulePath;
+  }
+  let mainPath;
+  for (const pluginMainFileExt of pluginMainFileExts) {
+    const path = node_path.join(modulePath, `bundo.plugin.${pluginMainFileExt}`);
+    if (node_fs.existsSync(path)) {
+      const lstat = node_fs.lstatSync(path);
+      if (lstat.isSymbolicLink()) {
+        mainPath = node_fs.realpathSync(path);
+      } else {
+        mainPath = path;
+      }
+      break;
+    }
+  }
+  return mainPath;
+}
+var pluginMainFileExts = [
+  "mjs",
+  "js"
+];
+
+// src/_bin/_main/_exec-plugin-runner/exec-plugin-runner.mts
+import * as node_path3 from "node:path";
+
+// src/_bin/_main/_exec-plugin-runner/_spawn-plugin-sandbox-runner.mts
+import * as node_childProcess from "node:child_process";
+import * as node_fs2 from "node:fs";
+import * as node_module2 from "node:module";
+import * as node_path2 from "node:path";
+async function spawnPluginSandboxRunner(registry, permissions, metadata) {
+  const requireModule = node_module2.createRequire(process.cwd()), messageID = Math.random().toString();
+  return new Promise((resolve) => {
+    const nodeArgs = [
+      "--permission"
+    ];
+    permissions["--allow-fs-read"]?.forEach((path) => {
+      nodeArgs.push(`--allow-fs-read=${path}`);
+    });
+    permissions["--allow-fs-write"]?.forEach((path) => {
+      nodeArgs.push(`--allow-fs-write=${path}`);
+    });
+    if (permissions["--allow-net"]) {
+      nodeArgs.push("--allow-net");
+    }
+    requireModule.resolve.paths("bundo-appgen")?.forEach((nodeModulePath) => {
+      if (nodeModulePath.slice(-"/node".length) != "/node") {
+        nodeArgs.push(`--allow-fs-read=${nodeModulePath}`);
+      }
+    });
+    registry.forEach((plugin) => {
+      const pluginDirectory = node_path2.dirname(plugin.mainPath);
+      const lstat = node_fs2.lstatSync(pluginDirectory);
+      if (lstat.isSymbolicLink()) {
+        nodeArgs.push(`--allow-fs-read=${node_fs2.realpathSync(pluginDirectory)}`);
+      }
+      nodeArgs.push(`--allow-fs-read=${pluginDirectory}`);
+    });
+    nodeArgs.push(node_path2.join(GlobalVars.appgenRoot.get(), "lib", "bin", "plugin-sandbox-runner.mjs"));
+    nodeArgs.push(`--json=${JSON.stringify({
+      projectDirectory: metadata.projectDirectory,
+      projectName: metadata.projectName,
+      evaluatedPluginRegistry: registry,
+      messageID
+    })}`);
+    const pluginRunner = node_childProcess.spawn("node", nodeArgs, {
+      stdio: [
+        "pipe",
+        "pipe",
+        "inherit",
+        "ipc"
+      ]
+    });
+    let message;
+    pluginRunner.on("message", (clientMessage) => {
+      if (typeof clientMessage === "string") {
+        message = clientMessage;
+      }
+    });
+    pluginRunner.on("exit", (code) => {
+      if (code == 0) {
+        if (message) {
+          const json = JSON.parse(message);
+          if (json.messageID === messageID && json.macos && typeof json.macos === "object") {
+            delete json.messageID;
+            resolve(json);
+          } else {
+            throw new Error("Plugin Sandbox Runner was not sending a valid result.");
+          }
+        } else {
+          throw new Error("Plugin Sandbox Runner was not sending a valid result.");
+        }
+      } else {
+        throw new Error(`Plugin Sandbox Runner exited with ${code} code`);
+      }
+    });
+  });
+}
+
+// src/_bin/_main/_exec-plugin-runner/exec-plugin-runner.mts
+async function execPluginRunner(registry, options) {
+  if (!registry?.length) {
+    return;
+  }
+  const projectDirectory = node_path3.dirname(GlobalVars.configFilePath.get()), projectName = getProjectName(GlobalVars.appConfig.get(), "macos");
+  if (options?.mode === "restricted") {
+    console.log(`Executing ${registry.length} plugin${registry.length == 1 ? "" : "s"}`);
+    return await spawnPluginSandboxRunner(registry, {
+      "--allow-fs-read": [
+        node_path3.join(projectDirectory, "macos", projectName, "AppDelegate.swift"),
+        node_path3.join(projectDirectory, "macos", "Podfile")
+      ],
+      "--allow-fs-write": null,
+      "--allow-net": false
+    }, {
+      projectDirectory,
+      projectName
+    });
+  } else {
+    console.log(`Executing ${registry.length} less restrictive plugin${registry.length == 1 ? "" : "s"}`);
+    const projectDirectoryMacos = node_path3.join(projectDirectory, "macos");
+    return await spawnPluginSandboxRunner(registry, {
+      "--allow-fs-read": [
+        projectDirectoryMacos
+      ],
+      "--allow-fs-write": [
+        projectDirectoryMacos
+      ],
+      "--allow-net": true
+    }, {
+      projectDirectory,
+      projectName
+    });
+  }
+}
+// src/_bin/_main/_get-config.mts
+import * as node_module3 from "node:module";
+import * as node_path4 from "node:path";
+var __filename = "/home/runner/work/bundo.rn/bundo.rn/packages/bundo-appgen/src/_bin/_main/_get-config.mts";
+async function getConfig(configFilePath) {
+  const ext = node_path4.extname(configFilePath);
+  if (ext == ".ts" || ext == ".mts") {
+    if (typeof Bun !== "undefined" || process.versions.bun) {
+      return import(configFilePath).then((c) => c.default);
+    }
+    console.log("Resolving your TypeScript file config…");
+    try {
+      return import("tsx/cjs/api").then(async (tsx) => {
+        const result = await tsx.require(configFilePath, __filename);
+        return result.default;
+      });
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "ERR_MODULE_NOT_FOUND") {
+        throw new Error(`
+For TypeScript config file, please install \`tsx\` as your dev dependency,
+or you can use Bun, or just use the JavaScript config file.
+`);
+      }
+      throw err;
+    }
+  }
+  if (ext == ".mjs") {
+    return import(configFilePath).then((c) => c.default);
+  }
+  const requireModule = node_module3.createRequire(configFilePath);
+  return requireModule(configFilePath);
+}
+
+// src/_bin/_main/_init-template/init-template.mts
+import * as node_fs9 from "node:fs";
+import * as node_path11 from "node:path";
+
+// src/_bin/_main/_init-template/_init-apple/init-apple.mts
+import * as node_fs8 from "node:fs";
+import * as node_path10 from "node:path";
+
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_init-appiconsets.mts
+import * as node_fs3 from "node:fs";
+import * as node_path5 from "node:path";
+
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_metadata-check/appearances.mts
+function appearances(value) {
+  if (!Array.isArray(value) || value.length != 1 || !value[0] || typeof value[0] != "object") {
+    return false;
+  }
+  const it = value[0];
+  return !!__appearance[it.appearance] && !!__value[it.value];
+}
+var __appearance = {
+  contrast: 1,
+  luminosity: 1
+};
+var __value = {
+  dark: 1,
+  light: 1
+};
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_metadata-check/idiom.mts
+function idiom(value) {
+  return !!value && !!__idiom[value];
+}
+var __idiom = {
+  "ios-marketing": 1,
+  "watch-marketing": 1,
+  appLauncher: 1,
+  companionSettings: 1,
+  ipad: 1,
+  iphone: 1,
+  mac: 1,
+  notificationCenter: 1,
+  quickLook: 1,
+  tv: 1,
+  universal: 1,
+  watch: 1
+};
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_metadata-check/image/compression-type.mts
+function compressionType(value) {
+  return !!value && !!__compressionType[value];
+}
+var __compressionType = {
+  "gpu-optimized-best": 1,
+  "gpu-optimized-smallest": 1,
+  automatic: 1,
+  lossless: 1,
+  lossy: 1
+};
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_metadata-check/image/display-gamut.mts
+function displayGamut(value) {
+  return !!value && !!displayGamuts[value];
+}
+var displayGamuts = {
+  "display-P3": 1,
+  sRGB: 1
+};
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_metadata-check/image/language-direction.mts
+function languageDirection(value) {
+  return !!value && !!__languageDirection[value];
+}
+var __languageDirection = {
+  "left-to-right": 1,
+  "right-to-left": 1
+};
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_init-appiconsets.mts
+function initAppiconsets(appiconsets, metadata) {
+  if (!appiconsets?.length) {
+    return;
+  }
+  const projectDirectory = node_path5.dirname(GlobalVars.configFilePath.get());
+  const targetDirectory = node_path5.join(projectDirectory, "macos", metadata.projectName, "Assets.xcassets");
+  let appiconset_index = -1;
+  for (const appiconset of appiconsets) {
+    if (!appiconset.images.length) {
+      break;
+    }
+    appiconset_index++;
+    const _appiconset_directory = node_path5.join(targetDirectory, `${appiconset.name}.appiconset`);
+    if (!node_fs3.existsSync(_appiconset_directory)) {
+      node_fs3.mkdirSync(_appiconset_directory);
+    }
+    const contentsJson = {
+      images: [],
+      info: {
+        version: 1,
+        author: metadata.bundleIdentifier
+      }
+    };
+    let image_index = -1;
+    for (const { path: imagePath, ...image } of appiconset.images) {
+      image_index++;
+      const imageFilePath = node_path5.resolve(projectDirectory, imagePath), imageMetadata = {
+        appearances: image.appearances?.[0] ? [{
+          appearance: image.appearances[0].appearance,
+          value: image.appearances[0].value
+        }] : undefined,
+        "display-gamut": image["display-gamut"] || undefined,
+        filename: node_path5.basename(imageFilePath),
+        size: image.size,
+        idiom: image.idiom || "universal",
+        scale: image.scale || "1x"
+      };
+      {
+        const traceStr = `\`appiconsets[${appiconset_index}].images[${image_index}]\``;
+        if (!imagePath) {
+          throw new Error(`Not a valid image path in the ${traceStr}.`);
+        }
+        if (image.appearances?.length && !appearances(image.appearances)) {
+          throw new Error(`Not a valid appearances in the ${traceStr}.`);
+        }
+        if (image["display-gamut"] && !displayGamut(image["display-gamut"])) {
+          throw new Error(`Not a valid image "display-gamut" in the ${traceStr}.`);
+        }
+        if (!mapImageSize[image.size]) {
+          throw new Error(`Not a valid image size in the ${traceStr}.`);
+        }
+        if (image["idiom"] && !idiom(image.idiom)) {
+          throw new Error(`Not a valid idiom in the ${traceStr}.`);
+        }
+        if (!node_fs3.existsSync(imageFilePath)) {
+          throw new Error(`Cannot find ${imagePath} relatively from your project directory.`);
+        }
+        const imageExtname = node_path5.extname(imageFilePath);
+        if (imageExtname !== ".png") {
+          throw new Error(`${imageExtname} file is not supported in Asset Catalogs.`);
+        }
+        if (contentsJson.images.length) {
+          for (const existingImageMetadata of contentsJson.images) {
+            const isSimilar = JSON.stringify(existingImageMetadata) === JSON.stringify(imageMetadata);
+            if (isSimilar) {
+              throw new Error("Cannot use multiple images with same variant.");
+            }
+          }
+        }
+      }
+      node_fs3.copyFileSync(imageFilePath, node_path5.join(_appiconset_directory, imageMetadata.filename));
+      contentsJson.images.push({ ...imageMetadata });
+    }
+    node_fs3.writeFileSync(node_path5.join(_appiconset_directory, "Contents.json"), JSON.stringify(contentsJson, null, 2), "utf8");
+  }
+}
+var mapImageSize = {
+  "16x16": 1,
+  "20x20": 1,
+  "24x24": 1,
+  "27.5x27.5": 1,
+  "29x29": 1,
+  "32x32": 1,
+  "40x40": 1,
+  "44x44": 1,
+  "60x60": 1,
+  "76x76": 1,
+  "83.5x83.5": 1,
+  "86x86": 1,
+  "98x98": 1,
+  "128x128": 1,
+  "256x256": 1,
+  "512x512": 1,
+  "1024x1024": 1
+};
+
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_init-imagesets.mts
+import * as node_fs4 from "node:fs";
+import * as node_path6 from "node:path";
+function initImagesets(imagesets, metadata) {
+  if (!imagesets?.length) {
+    return;
+  }
+  const projectDirectory = node_path6.dirname(GlobalVars.configFilePath.get());
+  let targetDirectory = node_path6.join(projectDirectory, "macos", metadata.projectName, "Assets.xcassets");
+  if (metadata.namespace) {
+    targetDirectory = node_path6.join(targetDirectory, metadata.namespace);
+    node_fs4.mkdirSync(targetDirectory, {
+      recursive: true
+    });
+    node_fs4.writeFileSync(node_path6.join(targetDirectory, "Contents.json"), JSON.stringify({
+      info: {
+        version: 1,
+        author: metadata.bundleIdentifier
+      },
+      properties: {
+        "provides-namespace": true
+      }
+    }, null, 2), "utf8");
+  }
+  let imageset_index = -1;
+  for (const imageset of imagesets) {
+    if (!imageset.images.length) {
+      break;
+    }
+    imageset_index++;
+    const _imageset_directory = node_path6.join(targetDirectory, `${imageset.name}.imageset`);
+    if (!node_fs4.existsSync(_imageset_directory)) {
+      node_fs4.mkdirSync(_imageset_directory);
+    }
+    const existingImageFilenames = [];
+    const contentsJson = {
+      images: [],
+      info: {
+        version: 1,
+        author: metadata.bundleIdentifier
+      }
+    };
+    let image_index = -1;
+    for (const { path: imagePath, ...image } of imageset.images) {
+      image_index++;
+      if (!imagePath) {
+        throw new Error("Not a valid image metadata object in the `imagesets[number].images[number]`");
+      }
+      const imageFilePath = node_path6.resolve(projectDirectory, imagePath), imageMetadata = {
+        appearances: image.appearances?.[0] ? [{
+          appearance: image.appearances[0].appearance,
+          value: image.appearances[0].value
+        }] : undefined,
+        "compression-type": image["compression-type"] || undefined,
+        "display-gamut": image["display-gamut"] || undefined,
+        filename: node_path6.basename(imageFilePath),
+        idiom: image.idiom || "universal",
+        languageDirection: image.languageDirection,
+        scale: image.scale || "1x"
+      };
+      {
+        const traceStr = `\`appiconsets[${imageset_index}].images[${image_index}]\``;
+        if (!imagePath) {
+          throw new Error(`Not a valid image path in the ${traceStr}.`);
+        }
+        if (image.appearances?.length && !appearances(image.appearances)) {
+          throw new Error(`Not a valid appearances in the ${traceStr}.`);
+        }
+        if (image["compression-type"] && !compressionType(image["compression-type"])) {
+          throw new Error(`Not a valid image compression-type in the ${traceStr}.`);
+        }
+        if (image["display-gamut"] && !displayGamut(image["display-gamut"])) {
+          throw new Error(`Not a valid image "display-gamut" in the ${traceStr}.`);
+        }
+        if (image["idiom"] && !idiom(image.idiom)) {
+          throw new Error(`Not a valid idiom in the ${traceStr}.`);
+        }
+        if (image.languageDirection && !languageDirection(image.languageDirection)) {
+          throw new Error(`Not a valid image language direction in the ${traceStr}.`);
+        }
+        if (!node_fs4.existsSync(imageFilePath)) {
+          throw new Error(`Cannot find ${imagePath} relatively from your project directory.`);
+        }
+        const imageExtname = node_path6.extname(imageFilePath);
+        if (supportedImageExts.indexOf(imageExtname) == -1) {
+          throw new Error(`${imageExtname} file is not supported in Asset Catalogs.`);
+        }
+        if (existingImageFilenames.indexOf(imageMetadata.filename) > -1) {
+          throw new Error("Cannot use the same image file for different variant.");
+        }
+        if (contentsJson.images.length) {
+          for (const existingImageMetadata of contentsJson.images) {
+            const isSimilar = JSON.stringify(existingImageMetadata) === JSON.stringify(imageMetadata);
+            if (isSimilar) {
+              throw new Error("Cannot use multiple images with same variant.");
+            }
+          }
+        }
+      }
+      node_fs4.copyFileSync(imageFilePath, node_path6.join(_imageset_directory, imageMetadata.filename));
+      contentsJson.images.push({ ...imageMetadata });
+    }
+    node_fs4.writeFileSync(node_path6.join(_imageset_directory, "Contents.json"), JSON.stringify(contentsJson, null, 2), "utf8");
+  }
+}
+var supportedImageExts = [
+  ".heic",
+  ".heif",
+  ".jpg",
+  ".jpeg",
+  ".png"
+];
+
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/create-asset-catalogs.mts
+function createAssetCatalogs(assetCatalogs, metadata) {
+  if (!assetCatalogs) {
+    return;
+  }
+  for (const _key of Object.keys(assetCatalogs)) {
+    const key = _key;
+    if (key == "imagesets") {
+      initImagesets(assetCatalogs.imagesets, metadata);
+    } else if (key == "appiconsets") {
+      initAppiconsets(assetCatalogs.appiconsets, metadata);
+    } else {
+      const namespacedCatalogs = assetCatalogs[key];
+      if (namespacedCatalogs && Object.keys(namespacedCatalogs).length) {
+        createAssetCatalogs(namespacedCatalogs, {
+          ...metadata,
+          namespace: key
+        });
+      }
+    }
+  }
+}
+// src/_bin/_main/_init-template/_init-apple/_create-string-catalogs/create-string-catalog.mts
+import * as node_fs5 from "node:fs";
+import * as node_path7 from "node:path";
+function createStringCatalogs(stringCatalogs, locales = ["en"], metadata) {
+  const config = GlobalVars.appConfig.get(), nativeProjectDir = node_path7.join(node_path7.dirname(GlobalVars.configFilePath.get()), metadata.platform, getProjectName(config, metadata.platform)), catalogs = stringCatalogs ? Object.entries(stringCatalogs) : null;
+  if (catalogs?.length) {
+    for (const [catalogName, data] of catalogs) {
+      const json = {
+        sourceLanguage: locales[0],
+        strings: {},
+        version: "1.2"
+      }, keys = Object.keys(data);
+      for (const key of keys) {
+        const localizedValue = data[key];
+        if (!localizedValue) {
+          throw new Error(`String catalog of ${catalogName} has invalid configuration.`);
+        }
+        const localesOfValue = Object.keys(localizedValue);
+        {
+          for (const localeOfValue of localesOfValue) {
+            if (locales.indexOf(localeOfValue) == -1) {
+              throw new Error(`"${localeOfValue}" was not found from your \`locales\` config. Add "${localeOfValue}" to the \`locales\` array.`);
+            }
+          }
+        }
+        localesOfValue.forEach((locale) => {
+          const value = localizedValue[locale];
+          if (!value) {
+            throw new Error(`\`stringCatalogs.${key}.${locale}\` is empty.`);
+          }
+          if (!json.strings[key]) {
+            json.strings[key] = {
+              extractionState: "manual",
+              localizations: {
+                [locale]: {
+                  stringUnit: {
+                    state: "translated",
+                    value
+                  }
+                }
+              }
+            };
+          } else {
+            json.strings[key].localizations[locale] = {
+              stringUnit: {
+                state: "translated",
+                value
+              }
+            };
+          }
+        });
+      }
+      node_fs5.writeFileSync(node_path7.join(nativeProjectDir, `${catalogName}.xcstrings`), JSON.stringify(json, null, 2), "utf8");
+    }
+  }
+}
+
+// src/_bin/_main/_init-template/_init-apple/_mod-files/_app-delegate-swift.mts
+import * as node_fs6 from "node:fs";
+import * as node_path8 from "node:path";
+function appDelegateSwift(platform) {
+  const appConfig = GlobalVars.appConfig.get(), projectName = getProjectName(appConfig, platform), appName = getName(appConfig, platform), appDelegateSwiftFilePath = node_path8.join(node_path8.dirname(GlobalVars.configFilePath.get()), platform, getProjectName(GlobalVars.appConfig.get(), platform), "AppDelegate.swift");
+  let appDelegateSwiftText = node_fs6.readFileSync(appDelegateSwiftFilePath, "utf8");
+  appDelegateSwiftText = appDelegateSwiftText.replace(/Window\("HelloWorld"/, `Window("${appName}"`);
+  appDelegateSwiftText = appDelegateSwiftText.replace(/factory.rootViewFactory.view\(withModuleName: "HelloWorld"/, `factory.rootViewFactory.view(withModuleName: "${projectName}"`);
+  node_fs6.writeFileSync(appDelegateSwiftFilePath, appDelegateSwiftText, "utf8");
+}
+
+// src/_bin/_main/_init-template/_init-apple/_mod-files/_podfile.mts
+import * as node_fs7 from "node:fs";
+import * as node_path9 from "node:path";
+function podfile(platform) {
+  const projectName = getProjectName(GlobalVars.appConfig.get(), platform), podfilePath = node_path9.join(node_path9.dirname(GlobalVars.configFilePath.get()), platform, "Podfile");
+  let podfileText = node_fs7.readFileSync(podfilePath, "utf8");
+  podfileText = podfileText.replace(/(target) 'HelloWorld' (do)/, `$1 '${projectName}' $2`);
+  node_fs7.writeFileSync(podfilePath, podfileText, "utf8");
+}
+
+// src/_bin/_main/_init-template/_init-apple/_mod-files/mod-files.mts
+function modFiles(platform) {
+  appDelegateSwift(platform);
+  podfile(platform);
+}
+// src/_bin/_main/_init-template/_init-apple/init-apple.mts
+function initApple(platform) {
+  const config = GlobalVars.appConfig.get(), projectDirectory = node_path10.dirname(GlobalVars.configFilePath.get()), nativeProjectDirectory = node_path10.join(projectDirectory, platform), templateDir = node_path10.join(GlobalVars.appgenRoot.get(), "template", platform), projectName = getProjectName(config, platform);
+  if (!node_fs8.existsSync(nativeProjectDirectory)) {
+    node_fs8.cpSync(templateDir, nativeProjectDirectory, { recursive: true });
+    node_fs8.renameSync(node_path10.join(nativeProjectDirectory, "HelloWorld"), node_path10.join(nativeProjectDirectory, projectName));
+    modFiles(platform);
+  }
+  const appleData = config[platform];
+  createAssetCatalogs(appleData.assetCatalogs, {
+    bundleIdentifier: appleData.bundleIdentifier,
+    platform,
+    projectName
+  });
+  createStringCatalogs(appleData.stringCatalogs, appleData.locales, {
+    platform
+  });
+}
+// src/_bin/_main/_init-template/init-template.mts
+function initTemplate() {
+  try {
+    if (process.platform == "darwin") {
+      initApple("macos");
+    } else if (process.platform == "win32") {} else {
+      initApple("macos");
+    }
+  } catch (err) {
+    const projectDirectory = node_path11.dirname(GlobalVars.configFilePath.get()), projectMacosDir = node_path11.join(projectDirectory, "macos");
+    if (node_fs9.existsSync(projectMacosDir)) {
+      node_fs9.rmSync(projectMacosDir, { recursive: true, force: true });
+    }
+    throw err;
+  }
+}
+// src/_bin/_main/_mod-plugin/mod-plugin.mts
+import * as node_fs10 from "node:fs";
+import * as node_path12 from "node:path";
+function modPlugin(contextResult) {
+  const config = GlobalVars.appConfig.get(), projectDirectory = node_path12.dirname(GlobalVars.configFilePath.get());
+  {
+    const projectName = getProjectName(config, "macos"), nativeProjectDir = node_path12.join(projectDirectory, "macos");
+    node_fs10.writeFileSync(node_path12.join(nativeProjectDir, projectName, "AppDelegate.swift"), contextResult.macos.files.Project["AppDelegate.swift"], "utf8");
+    node_fs10.writeFileSync(node_path12.join(nativeProjectDir, "Podfile"), contextResult.macos.files.Podfile, "utf8");
+  }
+}
+// src/_bin/_main/_xcodegen/xcodegen.mts
+import * as node_childProcess2 from "node:child_process";
+import * as node_path16 from "node:path";
+
+// src/_bin/_main/_xcodegen/_create-project-spec/create-project-spec.mts
+import * as node_fs12 from "node:fs";
+import * as node_module4 from "node:module";
+import * as node_path14 from "node:path";
+
+// src/_bin/_main/_xcodegen/_create-project-spec/_init-resources.mts
+import * as node_fs11 from "node:fs";
+import * as node_path13 from "node:path";
+function initResources(resources, metadata) {
+  if (!resources?.length) {
+    return null;
+  }
+  const projectDirectory = node_path13.dirname(GlobalVars.configFilePath.get()), resourcesDirectory = node_path13.join(projectDirectory, metadata.platform, "Resources"), data = [];
+  node_fs11.rmSync(resourcesDirectory, { recursive: true, force: true });
+  node_fs11.mkdirSync(resourcesDirectory);
+  try {
+    for (const resource of resources) {
+      let path = node_path13.resolve(projectDirectory, resource);
+      if (!node_fs11.existsSync(path)) {
+        throw new Error(`The ${path} was not found.`);
+      }
+      const lstat = node_fs11.lstatSync(path);
+      if (lstat.isSymbolicLink()) {
+        path = node_fs11.realpathSync(path);
+      }
+      console.log(`\x1B[32mCopying resource\x1B[0m \x1B[36m${path}\x1B[0m`);
+      node_fs11.cpSync(path, node_path13.join(resourcesDirectory, node_path13.basename(path)), {
+        recursive: true,
+        force: true
+      });
+      data.push({
+        basename: node_path13.basename(path),
+        isDirectory: lstat.isDirectory()
+      });
+    }
+  } catch (err) {
+    node_fs11.rmSync(resourcesDirectory, { force: true, recursive: true });
+    throw err;
+  }
+  return data;
+}
+
+// src/_bin/_main/_xcodegen/_create-project-spec/create-project-spec.mts
+function createProjectSpec(platform, overrideConfig) {
+  const projectDirectory = node_path14.dirname(GlobalVars.configFilePath.get()), nativeProjectDir = node_path14.join(projectDirectory, platform);
+  if (!node_fs12.existsSync(projectDirectory)) {
+    throw new Error(`An unexpected happened. ${projectDirectory} was not found.`);
+  }
+  const config = GlobalVars.appConfig.get();
+  if (config.macos?.appicon && (!config.macos.assetCatalogs?.appiconsets?.length || !config.macos.assetCatalogs.appiconsets.some((set) => set.name == config.macos?.appicon))) {
+    throw new Error(`No appicon with the name "${config.macos.appicon}" was found in the appiconsets in Asset Catalogs.`);
+  }
+  if (platform == "macos" && !config.macos) {
+    throw new Error(`${platform} configuration was not found.`);
+  }
+  const requireFromNativeDirectory = node_module4.createRequire(nativeProjectDir), reactNativeXcodeScriptRelativePath = node_path14.relative(nativeProjectDir, platform == "macos" ? requireFromNativeDirectory.resolve("react-native-macos/scripts/react-native-xcode.sh") : requireFromNativeDirectory.resolve("react-native/scripts/react-native-xcode.sh")), appleData = {
+    ...config[platform],
+    infoPlist: {
+      ...overrideConfig?.infoPlist,
+      ...config[platform].infoPlist
+    }
+  }, projectName = getProjectName(config, platform), resourcesData = initResources(config.macos?.resources, {
+    platform
+  }), json = {
+    name: projectName,
+    targets: {
+      [projectName]: {
+        type: "application",
+        platform: platform == "macos" ? "macOS" : "iOS",
+        deploymentTarget: appleData.minimumDeployment || "15.6",
+        sources: [
+          {
+            path: projectName,
+            type: "syncedFolder"
+          },
+          ...resourcesData?.map((resource) => {
+            return {
+              path: "Resources",
+              buildPhase: {
+                copyFiles: {
+                  destination: "resources",
+                  subpath: resource.isDirectory ? resource.basename : undefined
+                }
+              }
+            };
+          }) ?? []
+        ],
+        info: {
+          path: `${projectName}/Info.plist`,
+          properties: {
+            CFBundleDisplayName: getName(config, platform),
+            CFBundleShortVersionString: "$(MARKETING_VERSION)",
+            CFBundleVersion: "$(CURRENT_PROJECT_VERSION)",
+            NSAppTransportSecurity: {
+              NSAllowsArbitraryLoads: true,
+              NSExceptionDomains: {
+                localhost: {
+                  NSExceptionAllowsInsecureHTTPLoads: true
+                }
+              }
+            },
+            NSPrincipalClass: "NSApplication",
+            NSSupportsAutomaticTermination: true,
+            NSSupportsSuddenTermination: true,
+            ...appleData.infoPlist
+          }
+        },
+        postBuildScripts: [
+          {
+            name: "Bundle React Native code and images",
+            script: `export NODE_BINARY=node
+${reactNativeXcodeScriptRelativePath}`
+          }
+        ],
+        scheme: {},
+        settings: {
+          ASSETCATALOG_COMPILER_APPICON_NAME: appleData.appicon
+        }
+      }
+    },
+    settings: {
+      base: {
+        ASSETCATALOG_COMPILER_INCLUDE_ALL_APPICON_ASSETS: true,
+        CODE_SIGN_STYLE: "Automatic",
+        CURRENT_PROJECT_VERSION: appleData.buildVersion || "1",
+        GENERATE_INFOPLIST_FILE: true,
+        LD_RUNPATH_SEARCH_PATHS: "$(inherited) @executable_path/Frameworks",
+        MARKETING_VERSION: appleData.version || "1.0.0",
+        OTHER_LDFLAGS: "$(inherited) -ObjC -lc++",
+        PRODUCT_BUNDLE_IDENTIFIER: appleData.bundleIdentifier
+      }
+    },
+    options: {
+      useBaseInternationalization: false
+    }
+  };
+  node_fs12.writeFileSync(node_path14.join(nativeProjectDir, "project.json"), JSON.stringify(json, null, 2), "utf8");
+}
+// src/_bin/_main/_xcodegen/_mod-known-regions/mod-known-regions.mts
+import * as node_fs13 from "node:fs";
+import * as node_path15 from "node:path";
+function modKnownRegions(platform) {
+  const config = GlobalVars.appConfig.get(), appleData = config[platform];
+  if (!appleData?.locales?.length) {
+    return;
+  }
+  const projectName = getProjectName(config, platform), pbxprojPath = node_path15.join(node_path15.dirname(GlobalVars.configFilePath.get()), platform, `${projectName}.xcodeproj`, "project.pbxproj");
+  let file = node_fs13.readFileSync(pbxprojPath, "utf8");
+  let strReplacer = "knownRegions = (";
+  appleData.locales.forEach((locale) => {
+    strReplacer += `
+$2${locale},`;
+  });
+  strReplacer += "$3";
+  file = file.replace(/knownRegions = \((\n(\t+)\w+,)+(\n\t+\);)/, strReplacer);
+  node_fs13.writeFileSync(pbxprojPath, file, "utf8");
+}
+
+// src/_bin/_main/_xcodegen/xcodegen.mts
+function xcodegen(platform, overrideConfig) {
+  createProjectSpec(platform, overrideConfig);
+  const xcodegenPath = GlobalVars.argv.get().xcodegenPath, nativeProjectDir = node_path16.join(node_path16.dirname(GlobalVars.configFilePath.get()), platform);
+  node_childProcess2.execSync(`${xcodegenPath} --spec project.json`, {
+    cwd: nativeProjectDir,
+    stdio: "inherit"
+  });
+  modKnownRegions(platform);
+  node_childProcess2.execSync(`pod install`, {
+    cwd: nativeProjectDir,
+    stdio: "inherit"
+  });
+}
+// src/_bin/_main/main.mts
+async function main() {
+  getData();
+  let configFilePath = "";
+  const argv = GlobalVars.argv.get();
+  if (argv.path) {
+    const isValidExt = isValidConfigFileExt(argv.path);
+    if (!isValidExt) {
+      throw new Error(`App config file only compatible with ${configFileExts.join(" | ")}`);
+    }
+    const targetConfigFilePath = node_path17.resolve(process.cwd(), argv.path);
+    if (!node_fs14.existsSync(targetConfigFilePath)) {
+      throw new Error(`${targetConfigFilePath} file doesn't exist.`);
+    }
+    configFilePath = node_path17.resolve(process.cwd(), argv.path);
+  } else {
+    for (let i = 0;i < configFileExts.length; i++) {
+      const targetConfigFilePath = node_path17.join(process.cwd(), `bundo.config.${configFileExts[i]}`);
+      if (node_fs14.existsSync(targetConfigFilePath)) {
+        configFilePath = targetConfigFilePath;
+        break;
+      } else if (i == configFileExts.length - 1) {
+        throw new Error("Cannot found bundo config file.");
+      }
+    }
+  }
+  GlobalVars.configFilePath.set(configFilePath);
+  console.log("Retrieving config");
+  const config = await getConfig(configFilePath);
+  console.log("Validating config");
+  checkConfigValidity(config);
+  GlobalVars.appConfig.set(config);
+  console.log("Evaluating the plugin registry if any");
+  const pluginRegistry = evaluatePluginRegistry(config.plugins);
+  const unrestrictedPluginRegistry = evaluatePluginRegistry(config.lessRestrictivePlugins);
+  initTemplate();
+  const pluginSandboxedContextResult = await execPluginRunner(pluginRegistry, {
+    mode: "restricted"
+  });
+  const pluginContextResult = await execPluginRunner(unrestrictedPluginRegistry, {
+    mode: "lessRestrictive"
+  });
+  if (pluginSandboxedContextResult) {
+    modPlugin(pluginSandboxedContextResult);
+  }
+  if (pluginContextResult) {
+    modPlugin(pluginContextResult);
+  }
+  xcodegen("macos", {
+    infoPlist: {
+      ...pluginSandboxedContextResult?.macos.infoPlist,
+      ...pluginContextResult?.macos.infoPlist
+    }
+  });
+}
+var configFileExts = [
+  "ts",
+  "mts",
+  "mjs",
+  "js"
+];
+function isValidConfigFileExt(filePath) {
+  const ext = node_path17.extname(filePath);
+  if (!ext) {
+    return false;
+  }
+  return configFileExts.indexOf(ext.slice(1)) > -1;
+}
+// src/_bin/bin.mts
+async function bin(bundoAppgenRoot) {
+  GlobalVars.appgenRoot.set(bundoAppgenRoot);
+  try {
+    const argv = yargs(YargsHelper.hideBin(process.argv)).options({
+      clean: {
+        type: "boolean",
+        description: "Perform clean app generation."
+      },
+      "force-cross-platform": {
+        type: "boolean",
+        description: "Experimentally force the script to init native app in non compatible OS."
+      },
+      path: {
+        alias: "p",
+        type: "string",
+        description: "Use specific configuration file target."
+      },
+      "xcodegen-path": {
+        type: "string",
+        description: "Use specific XcodeGen binary."
+      }
+    }).parseSync();
+    GlobalVars.argv.set({
+      clean: !!argv.clean,
+      forceCrossPlatform: !!argv["force-cross-platform"],
+      path: argv.path || "",
+      xcodegenPath: argv["xcodegen-path"] || "xcodegen"
+    });
+    await main();
+  } catch (err) {
+    if (err instanceof Error && err.message) {
+      console.error("\x1B[31mError\x1B[0m: " + err.message);
+      process.exitCode = 1;
+    } else {
+      console.error("Unknown error. Please report it to https://github.com/RakaDoank/bundo.rn", { cause: err });
+      process.exitCode = 1;
+    }
+  }
+}
+export {
+  bin
+};