bundo-appgen 0.0.10 → 0.0.12

package/lib/bin/bin.mjs

@@ -1,4 +1,26 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/_bin/_main/_helpers/config/cache-paths/index.mts
+var exports_cache_paths = {};
+__export(exports_cache_paths, {
+  assetCatalogsTrackerFile: () => assetCatalogsTrackerFile,
+  dirCache: () => dirCache,
+  stringCatalogsTrackerFile: () => stringCatalogsTrackerFile
+});
 
 // src/_bin/bin.mts
 import yargs from "yargs";
@@ -41,9 +63,32 @@ var GlobalVars;
 })(GlobalVars ||= {});
 
 // src/_bin/_main/main.mts
-import * as node_fs14 from "node:fs";
-import * as node_path17 from "node:path";
+import * as node_fs18 from "node:fs";
+import * as node_path24 from "node:path";
+
+// src/_bin/_main/_helpers/config/cache-paths/asset-catalogs-tracker-file.mts
+import * as node_path2 from "node:path";
+
+// src/_bin/_main/_helpers/config/cache-paths/dir-cache.mts
+import * as node_fs from "node:fs";
+import * as node_path from "node:path";
+function dirCache() {
+  const path = node_path.join(node_path.dirname(GlobalVars.configFilePath.get()), ".bundo.rn");
+  if (!node_fs.existsSync(path)) {
+    node_fs.mkdirSync(path);
+  }
+  return path;
+}
 
+// src/_bin/_main/_helpers/config/cache-paths/asset-catalogs-tracker-file.mts
+function assetCatalogsTrackerFile() {
+  return node_path2.join(dirCache(), "asset-catalogs.json");
+}
+// src/_bin/_main/_helpers/config/cache-paths/string-catalogs-tracker-file.mts
+import * as node_path3 from "node:path";
+function stringCatalogsTrackerFile() {
+  return node_path3.join(dirCache(), "string-catalogs.json");
+}
 // src/_bin/_main/_helpers/config/get-name.mts
 function getName(config, platform) {
   if (platform == "macos") {
@@ -52,17 +97,20 @@ function getName(config, platform) {
   return config.name;
 }
 // src/_bin/_main/_helpers/config/get-project-name.mts
-var cache;
+var cacheMacos;
 function getProjectName(...params) {
-  if (cache) {
-    return cache;
+  if (params[1] == "macos" && cacheMacos) {
+    return cacheMacos;
   }
   const name = getName(...params);
   if (!name) {
     return;
   }
-  cache = name.replace(/[^a-zA-Z0-9]/g, "");
-  return cache;
+  if (params[1] == "macos") {
+    cacheMacos = name.replace(/[^a-zA-Z0-9]/g, "");
+    return cacheMacos;
+  }
+  return;
 }
 // src/_bin/_main/_helpers/platform/compatibility-error.mts
 var CompatibilityError = new Error(`
@@ -85,10 +133,10 @@ function isCompatible() {
 }
 
 // src/_bin/_main/_helpers/platform/get-data.mts
-var cache2;
+var cache;
 function getData() {
-  if (cache2) {
-    return cache2;
+  if (cache) {
+    return cache;
   }
   if (!isCompatible()) {
     throw CompatibilityError;
@@ -106,10 +154,10 @@ function getData() {
       version: process.versions.node
     };
   }
-  cache2 = {
+  cache = {
     developmentRuntime
   };
-  return cache2;
+  return cache;
 }
 // src/_bin/_main/_check-config-validity.mts
 function checkConfigValidity(config) {
@@ -121,7 +169,9 @@ function checkConfigValidity(config) {
     checkMacosConfig(config);
   } else if (process.platform == "darwin") {
     checkMacosConfig(config);
-  } else if (process.platform == "win32") {}
+  } else {
+    throw new Error(`Cannot support appgen for macOS in ${process.platform} platform.`);
+  }
   if (config.plugins) {
     if (Array.isArray(config.plugins)) {
       config.plugins.forEach((plugin) => {
@@ -170,9 +220,9 @@ function checkMacosConfig(config) {
 }
 
 // src/_bin/_main/_evaluate-plugin-registry.mts
-import * as node_fs from "node:fs";
+import * as node_fs2 from "node:fs";
 import * as node_module from "node:module";
-import * as node_path from "node:path";
+import * as node_path4 from "node:path";
 function evaluatePluginRegistry(plugins) {
   if (!plugins?.length) {
     return;
@@ -203,9 +253,9 @@ function evaluatePluginRegistry(plugins) {
       });
       continue;
     }
-    const filePath = node_path.join(node_path.dirname(GlobalVars.configFilePath.get()), nameOrPath);
-    if (node_fs.existsSync(filePath)) {
-      const lstat = node_fs.lstatSync(filePath);
+    const filePath = node_path4.join(node_path4.dirname(GlobalVars.configFilePath.get()), nameOrPath);
+    if (node_fs2.existsSync(filePath)) {
+      const lstat = node_fs2.lstatSync(filePath);
       if (lstat.isFile()) {
         registry.push({
           name: nameOrPath,
@@ -225,18 +275,18 @@ function getPluginMainPathFromNodeModules(name) {
   let modulePath;
   let isDirectory = true;
   try {
-    const __require = node_module.createRequire(node_path.join(process.cwd(), "package.json"));
+    const __require = node_module.createRequire(node_path4.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);
+        const __modulePath = node_path4.join(nodeModulePath, name);
+        if (node_fs2.existsSync(__modulePath)) {
+          const modulePathStat = node_fs2.lstatSync(__modulePath);
           if (modulePathStat.isFile()) {
             isDirectory = false;
           }
           if (modulePathStat.isSymbolicLink()) {
-            modulePath = node_fs.realpathSync(__modulePath);
+            modulePath = node_fs2.realpathSync(__modulePath);
           } else {
             modulePath = __modulePath;
           }
@@ -255,11 +305,11 @@ function getPluginMainPathFromNodeModules(name) {
   }
   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);
+    const path = node_path4.join(modulePath, `bundo.plugin.${pluginMainFileExt}`);
+    if (node_fs2.existsSync(path)) {
+      const lstat = node_fs2.lstatSync(path);
       if (lstat.isSymbolicLink()) {
-        mainPath = node_fs.realpathSync(path);
+        mainPath = node_fs2.realpathSync(path);
       } else {
         mainPath = path;
       }
@@ -274,13 +324,13 @@ var pluginMainFileExts = [
 ];
 
 // src/_bin/_main/_exec-plugin-runner/exec-plugin-runner.mts
-import * as node_path3 from "node:path";
+import * as node_path6 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_fs3 from "node:fs";
 import * as node_module2 from "node:module";
-import * as node_path2 from "node:path";
+import * as node_path5 from "node:path";
 async function spawnPluginSandboxRunner(registry, permissions, metadata) {
   const requireModule = node_module2.createRequire(process.cwd()), messageID = Math.random().toString();
   return new Promise((resolve) => {
@@ -302,15 +352,15 @@ async function spawnPluginSandboxRunner(registry, permissions, metadata) {
       }
     });
     registry.forEach((plugin) => {
-      const pluginDirectory = node_path2.dirname(plugin.mainPath);
-      const lstat = node_fs2.lstatSync(pluginDirectory);
+      const pluginDirectory = node_path5.dirname(plugin.mainPath);
+      const lstat = node_fs3.lstatSync(pluginDirectory);
       if (lstat.isSymbolicLink()) {
-        nodeArgs.push(`--allow-fs-read=${node_fs2.realpathSync(pluginDirectory)}`);
+        nodeArgs.push(`--allow-fs-read=${node_fs3.realpathSync(pluginDirectory)}`);
       } else {
         nodeArgs.push(`--allow-fs-read=${pluginDirectory}`);
       }
     });
-    nodeArgs.push(node_path2.join(GlobalVars.appgenRoot.get(), "lib", "bin", "plugin-sandbox-runner.mjs"));
+    nodeArgs.push(node_path5.join(GlobalVars.appgenRoot.get(), "lib", "bin", "plugin-sandbox-runner.mjs"));
     nodeArgs.push(`--json=${JSON.stringify({
       projectDirectory: metadata.projectDirectory,
       projectName: metadata.projectName,
@@ -356,13 +406,13 @@ async function execPluginRunner(registry, options) {
   if (!registry?.length) {
     return;
   }
-  const projectDirectory = node_path3.dirname(GlobalVars.configFilePath.get()), projectName = getProjectName(GlobalVars.appConfig.get(), "macos");
+  const projectDirectory = node_path6.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")
+        node_path6.join(projectDirectory, "macos", projectName, "AppDelegate.swift"),
+        node_path6.join(projectDirectory, "macos", "Podfile")
       ],
       "--allow-fs-write": null,
       "--allow-net": false
@@ -372,7 +422,7 @@ async function execPluginRunner(registry, options) {
     });
   } else {
     console.log(`Executing ${registry.length} less restrictive plugin${registry.length == 1 ? "" : "s"}`);
-    const projectDirectoryMacos = node_path3.join(projectDirectory, "macos");
+    const projectDirectoryMacos = node_path6.join(projectDirectory, "macos");
     return await spawnPluginSandboxRunner(registry, {
       "--allow-fs-read": [
         projectDirectoryMacos
@@ -389,10 +439,10 @@ async function execPluginRunner(registry, options) {
 }
 // src/_bin/_main/_get-config.mts
 import * as node_module3 from "node:module";
-import * as node_path4 from "node:path";
+import * as node_path7 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);
+  const ext = node_path7.extname(configFilePath);
   if (ext == ".ts" || ext == ".mts") {
     if (typeof Bun !== "undefined" || process.versions.bun) {
       return import(configFilePath).then((c) => c.default);
@@ -421,16 +471,27 @@ or you can use Bun, or just use the JavaScript config file.
 }
 
 // src/_bin/_main/_init-template/init-template.mts
-import * as node_fs9 from "node:fs";
-import * as node_path11 from "node:path";
+import * as node_fs13 from "node:fs";
+import * as node_path18 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";
+import * as node_fs12 from "node:fs";
+import * as node_path17 from "node:path";
+
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/create-asset-catalogs.mts
+import * as node_fs6 from "node:fs";
+import * as node_path11 from "node:path";
+
+// src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_get-xcassets-path.mts
+import * as node_path8 from "node:path";
+function getXcassetsPath(platform) {
+  const projectDirectory = node_path8.dirname(GlobalVars.configFilePath.get()), projectName = getProjectName(GlobalVars.appConfig.get(), platform);
+  return node_path8.join(projectDirectory, platform, projectName, "Assets.xcassets");
+}
 
 // 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";
+import * as node_fs4 from "node:fs";
+import * as node_path9 from "node:path";
 
 // src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/_metadata-check/appearances.mts
 function appearances(value) {
@@ -498,17 +559,17 @@ 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");
+  const createdCatalogs = [], projectDirectory = node_path9.dirname(GlobalVars.configFilePath.get());
+  const xcassetsPath = getXcassetsPath(metadata.platform);
   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 _appiconset_directory = node_path9.join(xcassetsPath, `${appiconset.name}.appiconset`);
+    if (!node_fs4.existsSync(_appiconset_directory)) {
+      node_fs4.mkdirSync(_appiconset_directory);
     }
     const contentsJson = {
       images: [],
@@ -520,13 +581,13 @@ function initAppiconsets(appiconsets, metadata) {
     let image_index = -1;
     for (const { path: imagePath, ...image } of appiconset.images) {
       image_index++;
-      const imageFilePath = node_path5.resolve(projectDirectory, imagePath), imageMetadata = {
+      const imageFilePath = node_path9.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),
+        filename: node_path9.basename(imageFilePath),
         size: image.size,
         idiom: image.idiom || "universal",
         scale: image.scale || "1x"
@@ -548,10 +609,10 @@ function initAppiconsets(appiconsets, metadata) {
         if (image["idiom"] && !idiom(image.idiom)) {
           throw new Error(`Not a valid idiom in the ${traceStr}.`);
         }
-        if (!node_fs3.existsSync(imageFilePath)) {
+        if (!node_fs4.existsSync(imageFilePath)) {
           throw new Error(`Cannot find ${imagePath} relatively from your project directory.`);
         }
-        const imageExtname = node_path5.extname(imageFilePath);
+        const imageExtname = node_path9.extname(imageFilePath);
         if (imageExtname !== ".png") {
           throw new Error(`${imageExtname} file is not supported in Asset Catalogs.`);
         }
@@ -564,11 +625,13 @@ function initAppiconsets(appiconsets, metadata) {
           }
         }
       }
-      node_fs3.copyFileSync(imageFilePath, node_path5.join(_appiconset_directory, imageMetadata.filename));
+      node_fs4.copyFileSync(imageFilePath, node_path9.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");
+    node_fs4.writeFileSync(node_path9.join(_appiconset_directory, "Contents.json"), JSON.stringify(contentsJson, null, 2), "utf8");
+    createdCatalogs.push(appiconset.name);
   }
+  return createdCatalogs;
 }
 var mapImageSize = {
   "16x16": 1,
@@ -591,20 +654,20 @@ var mapImageSize = {
 };
 
 // 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";
+import * as node_fs5 from "node:fs";
+import * as node_path10 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");
+  const createdCatalogs = [], projectDirectory = node_path10.dirname(GlobalVars.configFilePath.get());
+  let xcassetsPath = getXcassetsPath(metadata.platform);
   if (metadata.namespace) {
-    targetDirectory = node_path6.join(targetDirectory, metadata.namespace);
-    node_fs4.mkdirSync(targetDirectory, {
+    xcassetsPath = node_path10.join(xcassetsPath, metadata.namespace);
+    node_fs5.mkdirSync(xcassetsPath, {
       recursive: true
     });
-    node_fs4.writeFileSync(node_path6.join(targetDirectory, "Contents.json"), JSON.stringify({
+    node_fs5.writeFileSync(node_path10.join(xcassetsPath, "Contents.json"), JSON.stringify({
       info: {
         version: 1,
         author: metadata.bundleIdentifier
@@ -620,9 +683,9 @@ function initImagesets(imagesets, metadata) {
       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 _imageset_directory = node_path10.join(xcassetsPath, `${imageset.name}.imageset`);
+    if (!node_fs5.existsSync(_imageset_directory)) {
+      node_fs5.mkdirSync(_imageset_directory);
     }
     const existingImageFilenames = [];
     const contentsJson = {
@@ -638,14 +701,14 @@ function initImagesets(imagesets, metadata) {
       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 = {
+      const imageFilePath = node_path10.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),
+        filename: node_path10.basename(imageFilePath),
         idiom: image.idiom || "universal",
         languageDirection: image.languageDirection,
         scale: image.scale || "1x"
@@ -670,10 +733,10 @@ function initImagesets(imagesets, metadata) {
         if (image.languageDirection && !languageDirection(image.languageDirection)) {
           throw new Error(`Not a valid image language direction in the ${traceStr}.`);
         }
-        if (!node_fs4.existsSync(imageFilePath)) {
+        if (!node_fs5.existsSync(imageFilePath)) {
           throw new Error(`Cannot find ${imagePath} relatively from your project directory.`);
         }
-        const imageExtname = node_path6.extname(imageFilePath);
+        const imageExtname = node_path10.extname(imageFilePath);
         if (supportedImageExts.indexOf(imageExtname) == -1) {
           throw new Error(`${imageExtname} file is not supported in Asset Catalogs.`);
         }
@@ -689,11 +752,17 @@ function initImagesets(imagesets, metadata) {
           }
         }
       }
-      node_fs4.copyFileSync(imageFilePath, node_path6.join(_imageset_directory, imageMetadata.filename));
+      node_fs5.copyFileSync(imageFilePath, node_path10.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");
+    node_fs5.writeFileSync(node_path10.join(_imageset_directory, "Contents.json"), JSON.stringify(contentsJson, null, 2), "utf8");
+    if (metadata.namespace) {
+      createdCatalogs.push(`${metadata.namespace}/${imageset.name}`);
+    } else {
+      createdCatalogs.push(imageset.name);
+    }
   }
+  return createdCatalogs;
 }
 var supportedImageExts = [
   ".heic",
@@ -705,122 +774,388 @@ var supportedImageExts = [
 
 // src/_bin/_main/_init-template/_init-apple/_create-asset-catalogs/create-asset-catalogs.mts
 function createAssetCatalogs(assetCatalogs, metadata) {
+  const xcassetsPath = getXcassetsPath(metadata.platform), assetCatalogsTrackerFilePath = exports_cache_paths.assetCatalogsTrackerFile();
+  let catalogsTracker = {
+    appiconsets: undefined,
+    imagesets: undefined
+  };
+  function removeAllCatalogs() {
+    if (node_fs6.existsSync(xcassetsPath)) {
+      node_fs6.rmSync(xcassetsPath, {
+        recursive: true,
+        force: true
+      });
+      node_fs6.cpSync(node_path11.join(GlobalVars.appgenRoot.get(), "template", metadata.platform, "HelloWorld", "Assets.xcassets"), xcassetsPath, {
+        recursive: true,
+        force: true
+      });
+    }
+    if (node_fs6.existsSync(assetCatalogsTrackerFilePath)) {
+      node_fs6.rmSync(assetCatalogsTrackerFilePath);
+    }
+  }
   if (!assetCatalogs) {
+    removeAllCatalogs();
     return;
   }
+  try {
+    if (node_fs6.existsSync(assetCatalogsTrackerFilePath)) {
+      catalogsTracker = JSON.parse(node_fs6.readFileSync(assetCatalogsTrackerFilePath, "utf8"));
+    }
+  } catch {
+    removeAllCatalogs();
+  }
+  const newCatalogsTracker = createCatalogs(assetCatalogs, {
+    bundleIdentifier: metadata.bundleIdentifier,
+    platform: metadata.platform,
+    namespace: metadata.namespace
+  });
+  catalogsTracker.appiconsets?.forEach((existingCatalog) => {
+    if (newCatalogsTracker.appiconsets?.indexOf(existingCatalog) === -1) {
+      const existingPath = node_path11.join(xcassetsPath, existingCatalog + ".appiconset");
+      if (node_fs6.existsSync(existingPath)) {
+        node_fs6.rmSync(existingPath, {
+          recursive: true,
+          force: true
+        });
+      }
+    }
+  });
+  catalogsTracker.imagesets?.forEach((existingCatalog) => {
+    if (newCatalogsTracker.imagesets?.indexOf(existingCatalog) === -1) {
+      const existingCatalogBasename = existingCatalog.split("/")[0];
+      if (!existingCatalogBasename) {
+        return;
+      }
+      const existingPath = node_path11.join(xcassetsPath, existingCatalogBasename);
+      if (node_fs6.existsSync(existingPath)) {
+        node_fs6.rmSync(existingPath, {
+          recursive: true,
+          force: true
+        });
+      } else {
+        const imagesetDir = node_path11.join(existingCatalogBasename, ".imageset");
+        if (node_fs6.existsSync(imagesetDir)) {
+          node_fs6.rmSync(imagesetDir, {
+            recursive: true,
+            force: true
+          });
+        }
+      }
+    }
+  });
+  node_fs6.writeFileSync(assetCatalogsTrackerFilePath, JSON.stringify(newCatalogsTracker, null, 2), "utf8");
+}
+function createCatalogs(assetCatalogs, metadata, nextTracker) {
+  const tracker = nextTracker ?? {
+    appiconsets: undefined,
+    imagesets: undefined
+  };
+  if (!assetCatalogs) {
+    return tracker;
+  }
+  let isRecursived = false;
   for (const _key of Object.keys(assetCatalogs)) {
     const key = _key;
     if (key == "imagesets") {
-      initImagesets(assetCatalogs.imagesets, metadata);
+      const trackedCatalogs = initImagesets(assetCatalogs.imagesets, metadata);
+      if (trackedCatalogs?.length) {
+        if (!tracker.imagesets?.length) {
+          tracker.imagesets = trackedCatalogs;
+        } else {
+          tracker.imagesets = [
+            ...tracker.imagesets,
+            ...trackedCatalogs
+          ];
+        }
+      }
     } else if (key == "appiconsets") {
-      initAppiconsets(assetCatalogs.appiconsets, metadata);
+      if (!isRecursived) {
+        const trackedCatalogs = initAppiconsets(assetCatalogs.appiconsets, metadata);
+        if (trackedCatalogs?.length) {
+          if (!tracker.appiconsets?.length) {
+            tracker.appiconsets = trackedCatalogs;
+          } else {
+            tracker.appiconsets = [
+              ...tracker.appiconsets,
+              ...trackedCatalogs
+            ];
+          }
+        }
+      }
     } else {
       const namespacedCatalogs = assetCatalogs[key];
       if (namespacedCatalogs && Object.keys(namespacedCatalogs).length) {
-        createAssetCatalogs(namespacedCatalogs, {
+        isRecursived = true;
+        createCatalogs(namespacedCatalogs, {
           ...metadata,
-          namespace: key
-        });
+          namespace: metadata.namespace ? `${metadata.namespace}/${key}` : key
+        }, tracker);
       }
     }
   }
+  return tracker;
 }
 // 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";
+import * as node_fs7 from "node:fs";
+import * as node_path12 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 config = GlobalVars.appConfig.get(), targetProjectDir = node_path12.join(node_path12.dirname(GlobalVars.configFilePath.get()), metadata.platform, getProjectName(config, metadata.platform)), catalogs = stringCatalogs ? Object.entries(stringCatalogs) : null, stringCatalogsTrackerFilePath = exports_cache_paths.stringCatalogsTrackerFile();
+  let catalogsTracker = {
+    catalogs: undefined
+  };
+  if (!catalogs?.length) {
+    if (node_fs7.existsSync(stringCatalogsTrackerFilePath)) {
+      node_fs7.rmSync(stringCatalogsTrackerFilePath);
+    }
+    return;
+  }
+  try {
+    catalogsTracker = node_fs7.existsSync(stringCatalogsTrackerFilePath) ? JSON.parse(node_fs7.readFileSync(stringCatalogsTrackerFilePath, "utf8")) : { catalogs: undefined };
+  } catch {}
+  if (catalogsTracker.catalogs?.length) {
+    catalogsTracker.catalogs.slice().forEach((existingCatalog, index) => {
+      if (!stringCatalogs?.[existingCatalog]) {
+        const existingPath = getCatalogFilePath({
+          targetProjectDirectory: targetProjectDir,
+          catalogName: existingCatalog
+        });
+        if (node_fs7.existsSync(existingPath)) {
+          node_fs7.rmSync(existingPath, {
+            force: true
+          });
         }
-        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.`);
-            }
+        catalogsTracker.catalogs?.splice(index, 1);
+      }
+    });
+  }
+  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
-                  }
+      }
+      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");
+            }
+          };
+        } else {
+          json.strings[key].localizations[locale] = {
+            stringUnit: {
+              state: "translated",
+              value
+            }
+          };
+        }
+      });
+    }
+    node_fs7.writeFileSync(getCatalogFilePath({
+      targetProjectDirectory: targetProjectDir,
+      catalogName
+    }), JSON.stringify(json, null, 2), "utf8");
+    if (!catalogsTracker.catalogs?.length) {
+      catalogsTracker.catalogs = [];
+    }
+    if (catalogsTracker.catalogs.indexOf(catalogName) == -1) {
+      catalogsTracker.catalogs.push(catalogName);
     }
   }
+  node_fs7.writeFileSync(stringCatalogsTrackerFilePath, JSON.stringify(catalogsTracker, null, 2), "utf8");
+}
+function getCatalogFilePath(data) {
+  return node_path12.join(data.targetProjectDirectory, `${data.catalogName}.xcstrings`);
 }
 
 // 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";
+import * as node_fs8 from "node:fs";
+import * as node_path13 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");
+  const appConfig = GlobalVars.appConfig.get(), projectName = getProjectName(appConfig, platform), appName = getName(appConfig, platform), appDelegateSwiftFilePath = node_path13.join(node_path13.dirname(GlobalVars.configFilePath.get()), platform, projectName, "AppDelegate.swift");
+  let appDelegateSwiftText = node_fs8.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");
+  node_fs8.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";
+// src/_bin/_main/_init-template/_init-apple/_mod-files/_podfile/podfile.mts
+import * as node_fs10 from "node:fs";
+import * as node_path15 from "node:path";
+
+// src/_bin/_main/_init-template/_init-apple/_mod-files/_podfile/_pod-dependencies.mts
+import * as node_fs9 from "node:fs";
+import * as node_path14 from "node:path";
+function podDependencies(platform) {
+  const dependencies = GlobalVars.appConfig.get()[platform]?.Podfile?.dependencies, nativeProjectDir = node_path14.join(node_path14.dirname(GlobalVars.configFilePath.get()), platform);
+  const podDependenciesFilePath = node_path14.join(nativeProjectDir, "pod_dependencies.rb");
+  let podDependenciesFile = "def pod_dependencies";
+  dependencies?.forEach((dependency) => {
+    let tx = `
+  pod '${dependency.name}'`;
+    if (dependency.type == "cocoapods") {
+      if (dependency.version) {
+        tx += `, '${dependency.version}'`;
+      }
+    } else if (dependency.type == "git") {
+      if (!dependency.url || typeof dependency.url != "string") {
+        throw new Error('"gitUrl" is empty or not a valid string for a pod spec source.');
+      }
+      tx += `, :git => '${dependency.url}'`;
+      if (dependency.revision) {
+        if (dependency.revision.type !== "branch" && dependency.revision.type !== "commit" && dependency.revision.type !== "tag") {
+          throw new Error('Expected "branch", or "commit", or "tag" for the revision type.');
+        }
+        if (typeof dependency.revision.ref != "string" || !dependency.revision.ref) {
+          throw new Error("Revision ref is empty or not a valid string.");
+        }
+        tx += `, :${dependency.revision.type} => '${dependency.revision.ref}'`;
+      }
+    } else if (dependency.type == "local") {
+      if (!dependency.path || typeof dependency.path != "string") {
+        throw new Error('"path" is empty or not a valid string for a local pod.');
+      }
+      tx += `, :path => '${dependency.path}'`;
+    }
+    podDependenciesFile += tx;
+  });
+  podDependenciesFile += `
+end
+`;
+  node_fs9.writeFileSync(podDependenciesFilePath, podDependenciesFile, "utf8");
+}
+
+// src/_bin/_main/_init-template/_init-apple/_mod-files/_podfile/podfile.mts
 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");
+  const projectName = getProjectName(GlobalVars.appConfig.get(), platform), nativeProjectDir = node_path15.join(node_path15.dirname(GlobalVars.configFilePath.get()), platform), podfilePath = node_path15.join(nativeProjectDir, "Podfile");
+  let podfileText = node_fs10.readFileSync(podfilePath, "utf8");
   podfileText = podfileText.replace(/(target) 'HelloWorld' (do)/, `$1 '${projectName}' $2`);
-  node_fs7.writeFileSync(podfilePath, podfileText, "utf8");
+  node_fs10.writeFileSync(podfilePath, podfileText, "utf8");
+  podDependencies(platform);
+}
+// src/_bin/_main/_init-template/_init-apple/_mod-files/_privacy-manifest.mts
+import * as node_fs11 from "node:fs";
+import * as node_path16 from "node:path";
+function privacyManifest(platform) {
+  const manifest = GlobalVars.appConfig.get()[platform]?.privacyManifest;
+  if (!manifest) {
+    return;
+  }
+  const nativeProjectDir = node_path16.join(node_path16.dirname(GlobalVars.configFilePath.get()), platform), privacyInfoFilePath = node_path16.join(nativeProjectDir, "PrivacyInfo.xcprivacy");
+  let privacyInfoFile = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>`;
+  for (const [key, plist] of Object.entries(manifest)) {
+    privacyInfoFile += getDictionaryItem(key, plist);
+  }
+  privacyInfoFile += `
+</dict>
+</plist>`;
+  node_fs11.writeFileSync(privacyInfoFilePath, privacyInfoFile, "utf8");
+}
+function getDictionaryItem(key, plist, startIndentAmount = 1) {
+  const indent = Array(startIndentAmount).fill("\t").join("");
+  let tx = `
+${indent}<key>${key}</key>`;
+  if (typeof plist == "boolean") {
+    if (plist) {
+      tx += `
+${indent}<true/>`;
+    } else {
+      tx += `
+${indent}<false/>`;
+    }
+  } else if (typeof plist == "string") {
+    if (!plist) {
+      throw new Error("A plist item is empty or not a valid string.");
+    }
+    tx += `
+${indent}<string>${plist}</string>`;
+  } else if (Array.isArray(plist)) {
+    if (plist.length) {
+      tx += `
+${indent}<array>`;
+      plist.forEach((value, index) => {
+        if (typeof value == "string") {
+          if (!value) {
+            throw new Error(`${key}[${index}] is empty or not a valid string.`);
+          }
+          tx += `
+${indent}	<string>${value}</string>`;
+        } else if (typeof value == "object" && value) {
+          tx += `
+${indent}<dict>`;
+          for (const [key2, plist2] of Object.entries(value)) {
+            tx += getDictionaryItem(key2, plist2, startIndentAmount + 1);
+          }
+          tx += `
+${indent}</dict>`;
+        }
+      });
+      tx += `
+${indent}</array>`;
+    } else {
+      tx += `
+<array/>`;
+    }
+  } else if (typeof plist == "object" && plist) {
+    tx += `
+${indent}<dict>`;
+    for (const [key2, plist2] of Object.entries(plist)) {
+      tx += getDictionaryItem(key2, plist2, startIndentAmount + 1);
+    }
+    tx += `
+${indent}</dict>`;
+  }
+  return tx;
 }
 
 // src/_bin/_main/_init-template/_init-apple/_mod-files/mod-files.mts
 function modFiles(platform) {
   appDelegateSwift(platform);
   podfile(platform);
+  privacyManifest(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 config = GlobalVars.appConfig.get(), appleData = config[platform];
+  if (!appleData) {
+    throw new Error(`"${platform}" config is empty.`);
+  }
+  const projectDirectory = node_path17.dirname(GlobalVars.configFilePath.get()), nativeProjectDirectory = node_path17.join(projectDirectory, platform), templateDir = node_path17.join(GlobalVars.appgenRoot.get(), "template", platform), projectName = getProjectName(config, platform);
+  if (!node_fs12.existsSync(nativeProjectDirectory)) {
+    node_fs12.cpSync(templateDir, nativeProjectDirectory, { recursive: true });
+    node_fs12.renameSync(node_path17.join(nativeProjectDirectory, "HelloWorld"), node_path17.join(nativeProjectDirectory, projectName));
   }
-  const appleData = config[platform];
+  modFiles(platform);
   createAssetCatalogs(appleData.assetCatalogs, {
     bundleIdentifier: appleData.bundleIdentifier,
-    platform,
-    projectName
+    platform
   });
   createStringCatalogs(appleData.stringCatalogs, appleData.locales, {
     platform
@@ -835,74 +1170,78 @@ function initTemplate() {
       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 });
+    const projectDirectory = node_path18.dirname(GlobalVars.configFilePath.get()), projectMacosDir = node_path18.join(projectDirectory, "macos");
+    if (node_fs13.existsSync(projectMacosDir)) {
+      node_fs13.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";
+import * as node_fs14 from "node:fs";
+import * as node_path19 from "node:path";
 function modPlugin(contextResult) {
-  const config = GlobalVars.appConfig.get(), projectDirectory = node_path12.dirname(GlobalVars.configFilePath.get());
+  const config = GlobalVars.appConfig.get(), projectDirectory = node_path19.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");
+    const projectName = getProjectName(config, "macos"), nativeProjectDir = node_path19.join(projectDirectory, "macos");
+    node_fs14.writeFileSync(node_path19.join(nativeProjectDir, projectName, "AppDelegate.swift"), contextResult.macos.files.Project["AppDelegate.swift"], "utf8");
+    node_fs14.writeFileSync(node_path19.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";
+import * as node_path23 from "node:path";
 
 // src/_bin/_main/_xcodegen/_create-project-spec/create-project-spec.mts
-import * as node_fs12 from "node:fs";
+import * as node_fs16 from "node:fs";
 import * as node_module4 from "node:module";
-import * as node_path14 from "node:path";
+import * as node_path21 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";
+import * as node_fs15 from "node:fs";
+import * as node_path20 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);
+  const projectDirectory = node_path20.dirname(GlobalVars.configFilePath.get()), resourcesDirectory = node_path20.join(projectDirectory, metadata.platform, "Resources"), basenameFiles = [], subpaths = [];
+  node_fs15.rmSync(resourcesDirectory, { recursive: true, force: true });
+  node_fs15.mkdirSync(resourcesDirectory);
   try {
     for (const resource of resources) {
-      let path = node_path13.resolve(projectDirectory, resource);
-      if (!node_fs11.existsSync(path)) {
+      let path = node_path20.resolve(projectDirectory, resource);
+      if (!node_fs15.existsSync(path)) {
         throw new Error(`The ${path} was not found.`);
       }
-      const lstat = node_fs11.lstatSync(path);
+      const lstat = node_fs15.lstatSync(path);
       if (lstat.isSymbolicLink()) {
-        path = node_fs11.realpathSync(path);
+        path = node_fs15.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)), {
+      node_fs15.cpSync(path, node_path20.join(resourcesDirectory, node_path20.basename(path)), {
         recursive: true,
         force: true
       });
-      data.push({
-        basename: node_path13.basename(path),
-        isDirectory: lstat.isDirectory()
-      });
+      if (lstat.isDirectory()) {
+        subpaths.push(node_path20.basename(path));
+      } else {
+        basenameFiles.push(node_path20.basename(path));
+      }
     }
   } catch (err) {
-    node_fs11.rmSync(resourcesDirectory, { force: true, recursive: true });
+    node_fs15.rmSync(resourcesDirectory, { force: true, recursive: true });
     throw err;
   }
-  return data;
+  return {
+    basenameFiles,
+    subpaths
+  };
 }
 
 // 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)) {
+  const projectDirectory = node_path21.dirname(GlobalVars.configFilePath.get()), nativeProjectDir = node_path21.join(projectDirectory, platform);
+  if (!node_fs16.existsSync(projectDirectory)) {
     throw new Error(`An unexpected happened. ${projectDirectory} was not found.`);
   }
   const config = GlobalVars.appConfig.get();
@@ -912,13 +1251,20 @@ function createProjectSpec(platform, overrideConfig) {
   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 = {
+  const projectName = getProjectName(config, platform);
+  {
+    const entitlementsFilePath = node_path21.join(nativeProjectDir, projectName, `${projectName}.entitlements`);
+    if (node_fs16.existsSync(entitlementsFilePath)) {
+      node_fs16.rmSync(entitlementsFilePath);
+    }
+  }
+  const requireFromNativeDirectory = node_module4.createRequire(nativeProjectDir), reactNativeXcodeScriptRelativePath = node_path21.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, {
+  }, resourcesData = initResources(config.macos?.resources, {
     platform
   }), json = {
     name: projectName,
@@ -932,13 +1278,23 @@ function createProjectSpec(platform, overrideConfig) {
             path: projectName,
             type: "syncedFolder"
           },
-          ...resourcesData?.map((resource) => {
+          ...resourcesData?.basenameFiles.length ? [{
+            path: "Resources",
+            excludes: resourcesData.subpaths,
+            buildPhase: {
+              copyFiles: {
+                destination: "resources"
+              }
+            }
+          }] : [],
+          ...resourcesData?.subpaths?.map((subpath) => {
             return {
               path: "Resources",
+              excludes: resourcesData.basenameFiles,
               buildPhase: {
                 copyFiles: {
                   destination: "resources",
-                  subpath: resource.isDirectory ? resource.basename : undefined
+                  subpath
                 }
               }
             };
@@ -964,6 +1320,10 @@ function createProjectSpec(platform, overrideConfig) {
             ...appleData.infoPlist
           }
         },
+        entitlements: appleData.entitlements ? {
+          path: `${projectName}/${projectName}.entitlements`,
+          properties: appleData.entitlements
+        } : undefined,
         postBuildScripts: [
           {
             name: "Bundle React Native code and images",
@@ -971,7 +1331,6 @@ function createProjectSpec(platform, overrideConfig) {
 ${reactNativeXcodeScriptRelativePath}`
           }
         ],
-        scheme: {},
         settings: {
           ASSETCATALOG_COMPILER_APPICON_NAME: appleData.appicon
         }
@@ -996,18 +1355,18 @@ ${reactNativeXcodeScriptRelativePath}`
       useBaseInternationalization: false
     }
   };
-  node_fs12.writeFileSync(node_path14.join(nativeProjectDir, "project.json"), JSON.stringify(json, null, 2), "utf8");
+  node_fs16.writeFileSync(node_path21.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";
+import * as node_fs17 from "node:fs";
+import * as node_path22 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");
+  const projectName = getProjectName(config, platform), pbxprojPath = node_path22.join(node_path22.dirname(GlobalVars.configFilePath.get()), platform, `${projectName}.xcodeproj`, "project.pbxproj");
+  let file = node_fs17.readFileSync(pbxprojPath, "utf8");
   let strReplacer = "knownRegions = (";
   appleData.locales.forEach((locale) => {
     strReplacer += `
@@ -1015,13 +1374,13 @@ $2${locale},`;
   });
   strReplacer += "$3";
   file = file.replace(/knownRegions = \((\n(\t+)\w+,)+(\n\t+\);)/, strReplacer);
-  node_fs13.writeFileSync(pbxprojPath, file, "utf8");
+  node_fs17.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);
+  const xcodegenPath = GlobalVars.argv.get().xcodegenPath, nativeProjectDir = node_path23.join(node_path23.dirname(GlobalVars.configFilePath.get()), platform);
   node_childProcess2.execSync(`${xcodegenPath} --spec project.json`, {
     cwd: nativeProjectDir,
     stdio: "inherit"
@@ -1042,15 +1401,15 @@ async function main() {
     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)) {
+    const targetConfigFilePath = node_path24.resolve(process.cwd(), argv.path);
+    if (!node_fs18.existsSync(targetConfigFilePath)) {
       throw new Error(`${targetConfigFilePath} file doesn't exist.`);
     }
-    configFilePath = node_path17.resolve(process.cwd(), argv.path);
+    configFilePath = node_path24.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)) {
+      const targetConfigFilePath = node_path24.join(process.cwd(), `bundo.config.${configFileExts[i]}`);
+      if (node_fs18.existsSync(targetConfigFilePath)) {
         configFilePath = targetConfigFilePath;
         break;
       } else if (i == configFileExts.length - 1) {
@@ -1095,7 +1454,7 @@ var configFileExts = [
   "js"
 ];
 function isValidConfigFileExt(filePath) {
-  const ext = node_path17.extname(filePath);
+  const ext = node_path24.extname(filePath);
   if (!ext) {
     return false;
   }