codeplay-common 4.0.5 → 4.0.8

package/files/buildCodeplay/codeplayBeforeBuild-6.2.js

@@ -272,9 +272,61 @@ function compareWithBeta(installedVersion, minVersion, isBeta) {
 
 
 
+const ensureAnalyticsFlagsInConfig = (config) => {
+  const analyticsFlagKey = 'ANALYTICS_ENABLED';
+  const legacyAnalyticsFlagKey = ['ANALY', 'STICS_ENABLED'].join('');
+  let updated = false;
+
+  if (!config.android) {
+    config.android = {};
+    updated = true;
+  }
+
+  if (!config.ios) {
+    config.ios = {};
+    updated = true;
+  }
+
+  const syncPlatformFlag = (platformName, platformConfig) => {
+    const existingValue = platformConfig[analyticsFlagKey];
+    const legacyValue = platformConfig[legacyAnalyticsFlagKey];
+    let nextValue = false;
+
+    if (typeof existingValue === 'boolean') {
+      nextValue = existingValue;
+    } else if (typeof legacyValue === 'boolean') {
+      nextValue = legacyValue;
+    } else if (existingValue !== undefined) {
+      console.warn(`⚠️ ${platformName}.ANALYTICS_ENABLED should be true or false. Automatically setting it to false.`);
+    }
+
+    if (platformConfig[analyticsFlagKey] !== nextValue) {
+      platformConfig[analyticsFlagKey] = nextValue;
+      updated = true;
+      console.warn(`⚠️ ${platformName}.ANALYTICS_ENABLED added/updated as ${nextValue}.`);
+    }
+
+    if (legacyAnalyticsFlagKey in platformConfig) {
+      delete platformConfig[legacyAnalyticsFlagKey];
+      updated = true;
+      console.warn(`⚠️ ${platformName}.ANALYTICS_ENABLED spelling corrected.`);
+    }
+
+    if (nextValue === false) {
+      console.warn(`⚠️ Google Analytics is disabled for ${platformName}. Mostly recommended to enable it when IAP is available.`);
+    }
+  };
+
+  syncPlatformFlag('android', config.android);
+  syncPlatformFlag('ios', config.ios);
+
+  return updated;
+};
+
 const checkAppUniqueId=()=>{
 
   const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const analyticsFlagsUpdated = ensureAnalyticsFlagsInConfig(config);
 
   const appUniqueId = config.android?.APP_UNIQUE_ID;
   const RESIZEABLE_ACTIVITY = config.android?.RESIZEABLE_ACTIVITY;
@@ -313,14 +365,22 @@ const checkAppUniqueId=()=>{
     logErrorMessage+='❌ APP_UNIQUE_ID must be an integer. Example: 1, 2, 3, etc.';
   }
 
-
-
   if(logErrorMessage!="")
   {
+    if (analyticsFlagsUpdated) {
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log('✅ capacitor.config.json analytics flags synced.');
+    }
+
     console.error(logErrorMessage);
     process.exit(1)
   }
 
+  if (analyticsFlagsUpdated) {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log('✅ capacitor.config.json analytics flags synced.');
+  }
+
 
   console.log(`✅ APP_UNIQUE_ID is valid: ${appUniqueId}`);
 
@@ -2520,6 +2580,623 @@ const syncAdmobAliasInViteConfig = () => {
 };
 
 
+const getViteConfigPath = () => {
+  const possibleFiles = [
+    "vite.config.mjs",
+    "vite.config.js"
+  ];
+
+  return possibleFiles
+    .map(file => path.join(process.cwd(), file))
+    .find(filePath => fs.existsSync(filePath));
+};
+
+const getLatestIapDir = () => {
+  const adsDir = path.join(process.cwd(), "src", "js", "Ads");
+
+  if (!fs.existsSync(adsDir)) return null;
+
+  const iapDirs = fs.readdirSync(adsDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory() && /^IAP-\d+(\.\d+)*$/.test(entry.name))
+    .map(entry => entry.name)
+    .sort((a, b) => {
+      const versionA = a.match(/(\d+(?:\.\d+)*)/)[1].split(".").map(Number);
+      const versionB = b.match(/(\d+(?:\.\d+)*)/)[1].split(".").map(Number);
+
+      for (let i = 0; i < Math.max(versionA.length, versionB.length); i++) {
+        const diff = (versionB[i] || 0) - (versionA[i] || 0);
+        if (diff !== 0) return diff;
+      }
+
+      return 0;
+    });
+
+  return iapDirs.length > 0 ? path.join(adsDir, iapDirs[0]) : null;
+};
+
+const getAnalyticsConfig = () => {
+  const config = fs.existsSync(configPath)
+    ? JSON.parse(fs.readFileSync(configPath, "utf8"))
+    : {};
+
+  const analyticsFlagKey = "ANALYTICS_ENABLED";
+  const androidEnabled = config.android?.[analyticsFlagKey] ?? false;
+  const iosEnabled = config.ios?.[analyticsFlagKey] ?? false;
+
+  return {
+    androidEnabled: androidEnabled === true,
+    iosEnabled: iosEnabled === true,
+    enabled: androidEnabled === true || iosEnabled === true
+  };
+};
+
+const isPackageAvailable = (packageName) => {
+  if (!fs.existsSync(packageJsonPath)) return false;
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+  return Boolean(
+    packageJson.dependencies?.[packageName] ||
+    packageJson.devDependencies?.[packageName] ||
+    fs.existsSync(path.join(process.cwd(), "node_modules", packageName, "package.json"))
+  );
+};
+
+const sourceImportsPackage = (packageName, ignoredFilePath) => {
+  const sourceDir = path.join(process.cwd(), "src");
+  if (!fs.existsSync(sourceDir)) return false;
+
+  const escapedPackage = packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const importRegex = new RegExp(`(?:from\\s*['"]${escapedPackage}(?:/[^'"]*)?['"]|import\\s*['"]${escapedPackage}(?:/[^'"]*)?['"]|import\\s*\\(\\s*['"]${escapedPackage}(?:/[^'"]*)?['"]\\s*\\)|require\\s*\\(\\s*['"]${escapedPackage}(?:/[^'"]*)?['"]\\s*\\))`);
+
+  const scan = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (ignoredFilePath && path.resolve(fullPath) === path.resolve(ignoredFilePath)) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        if (scan(fullPath)) return true;
+        continue;
+      }
+
+      if (!/\.(js|mjs|cjs|ts|tsx|jsx|f7)$/.test(entry.name)) continue;
+
+      const content = fs.readFileSync(fullPath, "utf8");
+      if (importRegex.test(content)) return true;
+    }
+
+    return false;
+  };
+
+  return scan(sourceDir);
+};
+
+const runNpmCommand = (command) => {
+  console.log(`🚀 ${command}`);
+  execSync(command, { stdio: "inherit" });
+};
+
+const syncSystemBarsSafeAreaMigration = () => {
+  if (isPackageAvailable("@capacitor-community/safe-area")) {
+    runNpmCommand("npm uninstall @capacitor-community/safe-area");
+  } else {
+    console.log("ℹ️ @capacitor-community/safe-area is not installed.");
+  }
+
+  if (!fs.existsSync(configPath)) {
+    console.warn("⚠️ capacitor.config.json not found. Skipping SystemBars config sync.");
+    return;
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  if (!config.plugins) config.plugins = {};
+  if (!config.plugins.SystemBars) config.plugins.SystemBars = {};
+
+  if (config.plugins.SystemBars.insetsHandling !== "css") {
+    config.plugins.SystemBars.insetsHandling = "css";
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    console.log('✅ capacitor.config.json SystemBars.insetsHandling set to "css".');
+  } else {
+    console.log('ℹ️ capacitor.config.json SystemBars.insetsHandling already "css".');
+  }
+};
+
+const ensureFirebaseAnalyticsWrapper = (analyticsEnabled) => {
+  const analyticsDir = getLatestIapDir();
+  const legacyAnalyticsDir = path.join(process.cwd(), "src", "js", "analytics");
+  const legacyAnalyticsFile = path.join(legacyAnalyticsDir, "firebase-analytics.js");
+
+  if (!analyticsDir) {
+    console.warn("⚠️ No IAP-x.x folder found. Skipping Firebase analytics wrapper sync.");
+    return null;
+  }
+
+  const analyticsFile = path.join(analyticsDir, "firebase-analytics.js");
+
+  if (!fs.existsSync(analyticsDir)) {
+    fs.mkdirSync(analyticsDir, { recursive: true });
+  }
+
+  const activeWrapper = `import { Capacitor, registerPlugin } from '@capacitor/core';
+
+const FirebaseAnalytics = registerPlugin('FirebaseAnalytics');
+
+const isEnabledValue = (value) => value === true || value === 'true';
+
+const canUseNativeAnalytics = () => {
+    if (!Capacitor.isNativePlatform()) return false;
+
+    const platform = Capacitor.getPlatform();
+
+    if (platform === 'android') {
+        return isEnabledValue(import.meta.env.VITE_ANDROID_ANALYTICS_ENABLED);
+    }
+
+    if (platform === 'ios') {
+        return isEnabledValue(import.meta.env.VITE_IOS_ANALYTICS_ENABLED);
+    }
+
+    return false;
+};
+
+const cleanParams = (params = {}) => {
+    return Object.entries(params).reduce((result, [key, value]) => {
+        if (value === undefined || value === null || value === '') return result;
+        if (typeof value === 'number' && Number.isNaN(value)) return result;
+
+        result[key] = value;
+        return result;
+    }, {});
+};
+
+const trackEvent = async (name, params = {}) => {
+    if (!canUseNativeAnalytics()) return;
+
+    try {
+        await FirebaseAnalytics.logEvent({
+            name,
+            params: cleanParams(params),
+        });
+    } catch (err) {
+        console.warn(\`Firebase analytics event failed: \${name}\`, err);
+    }
+};
+
+export const trackSubscriptionScreenViewed = (params) => {
+    trackEvent('subscription_screen_view', params);
+};
+
+export const trackSubscriptionCheckoutStarted = (params) => {
+    trackEvent('subscription_checkout_start', params);
+};
+
+export const trackSubscriptionPurchased = (params) => {
+    trackEvent('subscription_purchase', params);
+};
+
+export const trackConsumablePurchased = (params) => {
+    trackEvent('consumable_purchase', params);
+};
+`;
+
+  const noopWrapper = `const trackEvent = () => {};
+
+export const trackSubscriptionScreenViewed = trackEvent;
+export const trackSubscriptionCheckoutStarted = trackEvent;
+export const trackSubscriptionPurchased = trackEvent;
+export const trackConsumablePurchased = trackEvent;
+`;
+
+  const nextContent = analyticsEnabled ? activeWrapper : noopWrapper;
+  const currentContent = fs.existsSync(analyticsFile) ? fs.readFileSync(analyticsFile, "utf8") : "";
+
+  if (currentContent !== nextContent) {
+    fs.writeFileSync(analyticsFile, nextContent, "utf8");
+    console.log(`✅ Firebase analytics wrapper ${analyticsEnabled ? "enabled" : "disabled"}: ${path.relative(process.cwd(), analyticsFile)}`);
+  } else {
+    console.log(`ℹ️ Firebase analytics wrapper already ${analyticsEnabled ? "enabled" : "disabled"}.`);
+  }
+
+  if (fs.existsSync(legacyAnalyticsFile)) {
+    fs.unlinkSync(legacyAnalyticsFile);
+    console.log("✅ Removed old Firebase analytics wrapper: src/js/analytics/firebase-analytics.js");
+  }
+
+  if (fs.existsSync(legacyAnalyticsDir) && fs.readdirSync(legacyAnalyticsDir).length === 0) {
+    fs.rmdirSync(legacyAnalyticsDir);
+  }
+
+  return analyticsFile;
+};
+
+const syncFirebaseAnalyticsPackages = () => {
+  const analyticsConfig = getAnalyticsConfig();
+
+  if (analyticsConfig.enabled) {
+    if (!isPackageAvailable("@capacitor-firebase/analytics") || !isPackageAvailable("firebase")) {
+      runNpmCommand("npm install @capacitor-firebase/analytics firebase");
+    } else {
+      console.log("ℹ️ Firebase Analytics packages already installed.");
+    }
+
+    ensureFirebaseAnalyticsWrapper(true);
+    return;
+  }
+
+  const analyticsFile = ensureFirebaseAnalyticsWrapper(false);
+
+  if (isPackageAvailable("@capacitor-firebase/analytics")) {
+    runNpmCommand("npm uninstall @capacitor-firebase/analytics");
+  } else {
+    console.log("ℹ️ @capacitor-firebase/analytics is not installed.");
+  }
+
+  if (isPackageAvailable("firebase")) {
+    if (sourceImportsPackage("firebase", analyticsFile)) {
+      console.log("ℹ️ Keeping firebase package because other source files import it.");
+    } else {
+      runNpmCommand("npm uninstall firebase");
+    }
+  }
+};
+
+const syncFirebaseAnalyticsPodfile = () => {
+  const podfilePath = path.join(process.cwd(), "ios", "App", "Podfile");
+  if (!fs.existsSync(podfilePath)) return;
+
+  const { iosEnabled } = getAnalyticsConfig();
+  const basePodLine = "  pod 'CapacitorFirebaseAnalytics', :path => '../../node_modules/@capacitor-firebase/analytics'";
+  const analyticsPodLine = "  pod 'CapacitorFirebaseAnalytics/Analytics', :path => '../../node_modules/@capacitor-firebase/analytics'";
+
+  let content = fs.readFileSync(podfilePath, "utf8");
+  let nextContent = content;
+
+  if (iosEnabled) {
+    if (!nextContent.includes(basePodLine)) {
+      nextContent = nextContent.replace(
+        /(pod 'CapacitorCommunitySafeArea'[^\n]*\r?\n)/,
+        `$1${basePodLine}\n`
+      );
+    }
+
+    if (!nextContent.includes(analyticsPodLine)) {
+      nextContent = nextContent.replace(
+        /(# Add your Pods here\r?\n)/,
+        `$1${analyticsPodLine}\n`
+      );
+    }
+  } else {
+    nextContent = nextContent
+      .split(/\r?\n/)
+      .filter(line => !line.includes("CapacitorFirebaseAnalytics"))
+      .join("\n");
+  }
+
+  if (nextContent !== content) {
+    fs.writeFileSync(podfilePath, nextContent, "utf8");
+    console.log(`✅ iOS Firebase Analytics Podfile entries ${iosEnabled ? "enabled" : "removed"}.`);
+  } else {
+    console.log(`ℹ️ iOS Firebase Analytics Podfile entries already ${iosEnabled ? "enabled" : "disabled"}.`);
+  }
+};
+
+const ensureImportOrRequire = (content, moduleName, esmLine, cjsLine) => {
+  const escaped = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (new RegExp(`from\\s*['"]${escaped}['"]|require\\s*\\(\\s*['"]${escaped}['"]\\s*\\)`).test(content)) {
+    return content;
+  }
+
+  const isCommonJs = /module\.exports|require\s*\(/.test(content);
+  const line = isCommonJs ? cjsLine : esmLine;
+
+  return `${line}\n${content}`;
+};
+
+const ensureViteDefineEntry = (viteContent, key, valueExpression) => {
+  const entry = `      '${key}': JSON.stringify(${valueExpression}),`;
+
+  if (viteContent.includes(`'${key}'`) || viteContent.includes(`"${key}"`)) {
+    return viteContent;
+  }
+
+  if (/define\s*:\s*{/.test(viteContent)) {
+    return viteContent.replace(/define\s*:\s*{\s*/, match => `${match}\n${entry}\n`);
+  }
+
+  const defineBlock = `    define: {
+      '${key}': JSON.stringify(${valueExpression}),
+    },`;
+
+  if (/\n\s*publicDir\s*:\s*[^,\n]+,?/.test(viteContent)) {
+    return viteContent.replace(
+      /(\n\s*publicDir\s*:\s*[^,\n]+,?)/,
+      `$1\n${defineBlock}`
+    );
+  }
+
+  return viteContent.replace(
+    /(return\s+{)/,
+    `$1\n${defineBlock}`
+  );
+};
+
+const ensurePrivacyAndAnalyticsViteConfig = () => {
+  const viteConfigPath = getViteConfigPath();
+
+  if (!viteConfigPath) {
+    console.warn("⚠️ No vite config found. Skipping privacy/analytics Vite sync.");
+    return;
+  }
+
+  let viteContent = fs.readFileSync(viteConfigPath, "utf8");
+  const originalContent = viteContent;
+
+  viteContent = ensureImportOrRequire(
+    viteContent,
+    "fs",
+    "import fs from 'fs';",
+    "const fs = require('fs');"
+  );
+
+  viteContent = ensureImportOrRequire(
+    viteContent,
+    "path",
+    "import path from 'path';",
+    "const path = require('path');"
+  );
+
+  if (!/\bcapacitorConfig\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(\r?\nexport\s+default|\r?\nmodule\.exports)/,
+      `\nconst capacitorConfig = JSON.parse(fs.readFileSync(path.resolve(__dirname, './capacitor.config.json'), 'utf8'));\n$1`
+    );
+  }
+
+  if (!/\bAPP_UNIQUE_ID\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(const capacitorConfig = JSON\.parse\(fs\.readFileSync\(path\.resolve\(__dirname,\s*['"]\.\/capacitor\.config\.json['"]\),\s*['"]utf8['"]\)\);\r?\n)/,
+      `$1const APP_UNIQUE_ID = capacitorConfig.android?.APP_UNIQUE_ID ?? '';\n`
+    );
+  }
+
+  if (!/\bANDROID_ANALYTICS_ENABLED\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(const APP_UNIQUE_ID = capacitorConfig\.android\?\.APP_UNIQUE_ID \?\? ['"]['"];\r?\n)/,
+      `$1const ANDROID_ANALYTICS_ENABLED = capacitorConfig.android?.ANALYTICS_ENABLED ?? false;\n`
+    );
+  }
+
+  if (!/\bIOS_ANALYTICS_ENABLED\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(const ANDROID_ANALYTICS_ENABLED = capacitorConfig\.android\?\.ANALYTICS_ENABLED \?\? false;\r?\n)/,
+      `$1const IOS_ANALYTICS_ENABLED = capacitorConfig.ios?.ANALYTICS_ENABLED ?? false;\n`
+    );
+  }
+
+  if (!/\bIAP_DESIGN\b/.test(viteContent)) {
+    viteContent = viteContent.replace(
+      /(const IOS_ANALYTICS_ENABLED = capacitorConfig\.ios\?\.ANALYTICS_ENABLED \?\? false;\r?\n)/,
+      `$1const IAP_DESIGN = capacitorConfig["IAP-Design"] ?? 'default';\n`
+    );
+  }
+
+  viteContent = viteContent
+    .replace(
+      /const ANDROID_ANALYTICS_ENABLED = capacitorConfig\.android\?\.ANALY[ST]ICS_ENABLED \?\? capacitorConfig\.android\?\.ANALYTICS_ENABLED \?\? false;/g,
+      "const ANDROID_ANALYTICS_ENABLED = capacitorConfig.android?.ANALYTICS_ENABLED ?? false;"
+    )
+    .replace(
+      /const IOS_ANALYTICS_ENABLED = capacitorConfig\.ios\?\.ANALY[ST]ICS_ENABLED \?\? capacitorConfig\.ios\?\.ANALYTICS_ENABLED \?\? false;/g,
+      "const IOS_ANALYTICS_ENABLED = capacitorConfig.ios?.ANALYTICS_ENABLED ?? false;"
+    );
+
+  viteContent = ensureViteDefineEntry(viteContent, "import.meta.env.VITE_APP_UNIQUE_ID", "APP_UNIQUE_ID");
+  viteContent = ensureViteDefineEntry(viteContent, "import.meta.env.VITE_ANDROID_ANALYTICS_ENABLED", "ANDROID_ANALYTICS_ENABLED");
+  viteContent = ensureViteDefineEntry(viteContent, "import.meta.env.VITE_IOS_ANALYTICS_ENABLED", "IOS_ANALYTICS_ENABLED");
+  viteContent = ensureViteDefineEntry(viteContent, "import.meta.env.VITE_IAP_DESIGN", "IAP_DESIGN");
+
+  if (viteContent !== originalContent) {
+    fs.writeFileSync(viteConfigPath, viteContent, "utf8");
+    console.log("✅ vite.config.(m)js privacy/analytics settings synced.");
+  } else {
+    console.log("ℹ️ vite.config.(m)js privacy/analytics settings already synced.");
+  }
+};
+
+const syncFirebaseAnalyticsSetup = () => {
+  syncFirebaseAnalyticsPackages();
+  syncFirebaseAnalyticsPodfile();
+  ensurePrivacyAndAnalyticsViteConfig();
+};
+
+const getAdmobIapConfigPath = () => {
+  const possiblePaths = [
+    path.join(process.cwd(), 'src', 'js', 'Ads', 'admob-ad-configuration-nextgen.json'),
+    path.join(process.cwd(), 'src', 'js', 'Ads', 'admob-ad-configuration.json')
+  ];
+
+  return possiblePaths.find(fileExists);
+};
+
+const getAdmobIapConfig = () => {
+  const admobIapConfigPath = getAdmobIapConfigPath();
+
+  if (!admobIapConfigPath) {
+    console.warn("⚠️ No AdMob configuration JSON found. Skipping RevenueCat IAP package sync.");
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(admobIapConfigPath, "utf8"));
+  } catch (err) {
+    console.error(`❌ Failed to read ${path.relative(process.cwd(), admobIapConfigPath)}`, err);
+    process.exit(1);
+  }
+};
+
+const isAnyIapStoreEnabled = (iapConfig) => {
+  return Boolean(
+    iapConfig?.playstore === true ||
+    iapConfig?.samsung === true ||
+    iapConfig?.amazon === true ||
+    iapConfig?.ios === true
+  );
+};
+
+const ensureIapDesignInCapacitorConfig = (iapConfig) => {
+  if (!isAnyIapStoreEnabled(iapConfig)) return;
+
+  if (!fs.existsSync(configPath)) {
+    console.warn("⚠️ capacitor.config.json not found. Skipping IAP-Design sync.");
+    return;
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+
+  if (Object.prototype.hasOwnProperty.call(config, "IAP-Design")) {
+    console.log("ℹ️ capacitor.config.json IAP-Design already configured.");
+    return;
+  }
+
+  config["IAP-Design"] = "default";
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log('✅ Added "IAP-Design": "default" to capacitor.config.json.');
+};
+
+const getCurrentStoreId = () => {
+  const envStoreId = Number(process.env.VITE_STORE_ID);
+  if (Number.isInteger(envStoreId) && envStoreId > 0) return envStoreId;
+
+  const viteConfigPath = getViteConfigPath();
+  if (!viteConfigPath) return 1;
+
+  const viteConfigContent = fs.readFileSync(viteConfigPath, "utf8");
+  const commonAliasMatch = viteConfigContent.match(/['"]@common['"]:\s*path\.resolve\(__dirname,\s*['"]([^'"]+)['"]\)/);
+
+  if (!commonAliasMatch) return 1;
+
+  const commonFilePath = path.resolve(path.dirname(viteConfigPath), commonAliasMatch[1]);
+  if (!fs.existsSync(commonFilePath)) return 1;
+
+  const commonFileContent = fs.readFileSync(commonFilePath, "utf8");
+  const storeIdMatch = commonFileContent.match(/export\s+let\s+_storeid\s*=\s*import\.meta\.env\.VITE_STORE_ID\s*\|\|\s*(\d+)\s*;/);
+
+  return storeIdMatch ? Number(storeIdMatch[1]) : 1;
+};
+
+const getRevenueCatStoreState = (iapConfig) => {
+  const storeId = getCurrentStoreId();
+  const configuration = iapConfig.configuration || {};
+  const storeMap = {
+    1: {
+      name: "PlayStore",
+      enabled: iapConfig.playstore === true,
+      apiKeyName: "IAP.configuration.playstore",
+      apiKey: configuration.playstore,
+      usesGoogleBilling: true
+    },
+    6: {
+      name: "iOSStore",
+      enabled: iapConfig.ios === true,
+      apiKeyName: "IAP.configuration.ios",
+      apiKey: configuration.ios,
+      usesGoogleBilling: false
+    },
+    7: {
+      name: "AmazonStore",
+      enabled: iapConfig.amazon === true,
+      apiKeyName: "IAP.configuration.amazon",
+      apiKey: configuration.amazon,
+      usesGoogleBilling: false
+    }
+  };
+
+  return {
+    storeId,
+    store: storeMap[storeId] || null
+  };
+};
+
+const ensureAndroidPermission = (permission, enabled) => {
+  if (!fs.existsSync(androidManifestPath)) return false;
+
+  let manifestContent = fs.readFileSync(androidManifestPath, "utf8");
+  const permissionLine = `    <uses-permission android:name="${permission}" />`;
+  const permissionRegex = new RegExp(`^\\s*<uses-permission\\s+android:name="${permission.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}"\\s*/?>\\s*\\r?\\n?`, "m");
+
+  if (enabled) {
+    if (permissionRegex.test(manifestContent)) return false;
+
+    manifestContent = manifestContent.replace(
+      /<\/manifest>\s*$/,
+      `${permissionLine}\n</manifest>`
+    );
+    fs.writeFileSync(androidManifestPath, manifestContent, "utf8");
+    console.log(`✅ Added Android permission: ${permission}`);
+    return true;
+  }
+
+  if (!permissionRegex.test(manifestContent)) return false;
+
+  manifestContent = manifestContent.replace(permissionRegex, "");
+  fs.writeFileSync(androidManifestPath, manifestContent, "utf8");
+  console.log(`✅ Removed Android permission: ${permission}`);
+  return true;
+};
+
+const syncRevenueCatIapSetup = () => {
+  const admobConfig = getAdmobIapConfig();
+  const iapConfig = admobConfig?.IAP;
+
+  if (!iapConfig) {
+    console.log("ℹ️ IAP configuration not found. Skipping RevenueCat package sync.");
+    return;
+  }
+
+  ensureIapDesignInCapacitorConfig(iapConfig);
+
+  const revenueCatEnabled =
+    iapConfig.playstore === true ||
+    iapConfig.ios === true ||
+    iapConfig.amazon === true;
+  const { storeId, store } = getRevenueCatStoreState(iapConfig);
+  const revenueCatEnabledForCurrentStore = store?.enabled === true;
+
+  if (revenueCatEnabledForCurrentStore && !store.apiKey) {
+    console.error(`❌ RevenueCat IAP is enabled for ${store.name} but ${store.apiKeyName} is missing.`);
+    process.exit(1);
+  }
+
+  let packageChanged = false;
+
+  if (revenueCatEnabledForCurrentStore) {
+    if (!isPackageAvailable("@revenuecat/purchases-capacitor")) {
+      runNpmCommand("npm install @revenuecat/purchases-capacitor");
+      packageChanged = true;
+    } else {
+      console.log(`ℹ️ RevenueCat package already installed for ${store.name}.`);
+    }
+  } else if (isPackageAvailable("@revenuecat/purchases-capacitor")) {
+    runNpmCommand("npm uninstall @revenuecat/purchases-capacitor");
+    packageChanged = true;
+  } else {
+    console.log(`ℹ️ RevenueCat package is not required for store id ${storeId}.`);
+  }
+
+  ensureAndroidPermission("com.android.vending.BILLING", store?.usesGoogleBilling === true && revenueCatEnabledForCurrentStore);
+
+  if (iapConfig.samsung === true && revenueCatEnabled) {
+    console.warn("⚠️ Samsung IAP uses cordova-plugin-samsungiap; PlayStore/Amazon/iOS use RevenueCat.");
+  }
+
+  if (packageChanged) {
+    runNpmCommand("npx cap sync");
+  }
+};
+
 
 
 
@@ -2692,11 +3369,14 @@ ensureGitignoreEntry('buildCodeplay/');
 
 
 // Run the validation
-(async () => {
-
-  await loadPluginVersions();   // 🔥 NEW
-
-  await checkPlugins();
+(async () => {
+
+  await loadPluginVersions();   // 🔥 NEW
+
+  syncSystemBarsSafeAreaMigration();
+  await checkPlugins();
+  syncRevenueCatIapSetup();
+  syncFirebaseAnalyticsSetup();
   checkAndupdateDropInViteConfig();
   syncAdmobAliasInViteConfig();
   checkAdmobConfigurationProperty()
@@ -2790,45 +3470,45 @@ const filePath = path.join(
   "../node_modules/@capacitor/android/capacitor/src/main/java/com/getcapacitor/plugin/SystemBars.java"
 );
 
-// 🔍 OLD BLOCK (anchor)
-const OLD_BLOCK = `if (shouldPassthroughInsets) {
-                // We need to correct for a possible shown IME
-                v.setPadding(0, 0, 0, keyboardVisible ? imeInsets.bottom : 0);
+const SYSTEM_BARS_PATCH_MARKER = "CODEPLAY_KEYBOARD_INSET_FIX";
+
+function getSystemBarsPatchedBlock(originalBlock, content) {
+  const isCapacitor842OrNewer = content.includes("private String insetsHandling = INSETS_HANDLING_CSS;");
+  const safeAreaCondition = isCapacitor842OrNewer
+    ? "INSETS_HANDLING_CSS.equals(insetsHandling)"
+    : "Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && hasViewportCover && insetHandlingEnabled";
+
+  return `if (shouldPassthroughInsets) {
+                /* ${SYSTEM_BARS_PATCH_MARKER}
+${originalBlock.split("\n").map(line => "                   " + line).join("\n")}
+                */
+
+                // Codeplay fix: avoid adding IME height as WebView parent padding.
+                v.setPadding(0, 0, 0, 0);
 
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && hasViewportCover && insetHandlingEnabled) {
+                if (${safeAreaCondition}) {
                     Insets safeAreaInsets = calcSafeAreaInsets(insets);
                     injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
                 }
 
-                return new WindowInsetsCompat.Builder(insets)
-                    .setInsets(
-                        WindowInsetsCompat.Type.systemBars() | WindowInsetsCompat.Type.displayCutout(),
-                        Insets.of(
-                            systemBarsInsets.left,
-                            systemBarsInsets.top,
-                            systemBarsInsets.right,
-                            getBottomInset(systemBarsInsets, keyboardVisible)
-                        )
-                    )
-                    .build();
+                return insets; // WebView handles keyboard and safe-area sizing.
             }`;
+}
 
-// ✅ NEW BLOCK
-const NEW_BLOCK = `if (shouldPassthroughInsets) {
-    /* 🔴 ORIGINAL CODE (COMMENTED FOR SAFETY)
-${OLD_BLOCK.split("\n").map(line => "    " + line).join("\n")}
-    */
-
-    // ✅ NEW LOGIC (CUSTOM FIX)
-    v.setPadding(0, 0, 0, 0);
+function findShouldPassthroughInsetsBlock(content) {
+  const start = content.indexOf("            if (shouldPassthroughInsets) {");
+  if (start === -1) return null;
 
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM && hasViewportCover && insetHandlingEnabled) {
-        Insets safeAreaInsets = calcSafeAreaInsets(insets);
-        injectSafeAreaCSS(safeAreaInsets.top, safeAreaInsets.right, safeAreaInsets.bottom, safeAreaInsets.left);
-    }
+  const endMarker = "\n\n            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM)";
+  const end = content.indexOf(endMarker, start);
+  if (end === -1) return null;
 
-    return insets; // WebView handles everything
-}`;
+  return {
+    start,
+    end,
+    text: content.slice(start, end)
+  };
+}
 
 // 🚨 ERROR MESSAGE
 const ERROR_MSG = `
@@ -2857,30 +3537,38 @@ function patchFile() {
     process.exit(1);
   }
 
+  const capacitorConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+  if (capacitorConfig.plugins?.SystemBars?.insetsHandling === "disable") {
+    console.log('ℹ️ SystemBars.insetsHandling is "disable"; skipping SystemBars.java keyboard inset patch.');
+    return;
+  }
+
   let content = fs.readFileSync(filePath, "utf8");
 
   // ✅ Already patched?
-  if (content.includes("🔴 ORIGINAL CODE (COMMENTED FOR SAFETY)")) {
+  if (content.includes(SYSTEM_BARS_PATCH_MARKER) || content.includes("🔴 ORIGINAL CODE (COMMENTED FOR SAFETY)")) {
     console.log("✅ Already SystemBars.java patched. Skipping...");
     return;
   }
 
-  // 🔍 Check old block exists
-  if (!content.includes(OLD_BLOCK)) {
+  const block = findShouldPassthroughInsetsBlock(content);
+  if (!block) {
     console.error(ERROR_MSG);
     process.exit(1);
   }
 
   // 🔁 Replace
-  const updated = content.replace(OLD_BLOCK, NEW_BLOCK);
+  const updated =
+    content.slice(0, block.start) +
+    getSystemBarsPatchedBlock(block.text, content) +
+    content.slice(block.end);
 
   fs.writeFileSync(filePath, updated, "utf8");
 
-  console.log("✅ SystemBars.java patched (comment + new logic)!");
+  console.log("✅ SystemBars.java patched with Codeplay keyboard inset fix!");
 }
 
 //patchFile();
-//console.log("SystemBars.java Not Patched, due to upgrade from @capacitor/android:8.4.2. We need to validate if any problem related to the systembar issue. Note: For this we have disable the 'patchFile()' method");
 
 //##################################  SystemBars.java update for "@capacitor/android": "^8.3.0" plugin END ###############################