codeplay-common 1.0.0

package/files/.env.storeid1

@@ -0,0 +1 @@
+VITE_STORE_ID=1

package/files/.env.storeid2

@@ -0,0 +1 @@
+VITE_STORE_ID=2

package/files/.env.storeid7

@@ -0,0 +1 @@
+VITE_STORE_ID=7

package/files/add-splash-screen-1.0.js

@@ -0,0 +1,77 @@
+const fs = require("fs");
+const path = require("path");
+
+// Define file paths
+const projectFolder = path.resolve(".");
+const sourceSplashIcon = path.join(projectFolder, "resources", "splash_icon.png");
+const destinationSplashIcon = path.join(
+  projectFolder,
+  "android",
+  "app",
+  "src",
+  "main",
+  "res",
+  "drawable-nodpi",
+  "splash_icon.png"
+);
+const sourceSplashXML = path.join(projectFolder, "splashxml", "codeplay_splashScreen.xml");
+const destinationSplashXML = path.join(
+  projectFolder,
+  "android",
+  "app",
+  "src",
+  "main",
+  "res",
+  "values",
+  "codeplay_splashScreen.xml"
+);
+const androidManifestPath = path.join(
+  projectFolder,
+  "android",
+  "app",
+  "src",
+  "main",
+  "AndroidManifest.xml"
+);
+
+// Helper function to copy files
+function copyFile(source, destination) {
+  if (!fs.existsSync(source)) {
+    throw new Error(`Source file not found: ${source}`);
+  }
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.copyFileSync(source, destination);
+  console.log(`Copied: ${source} -> ${destination}`);
+}
+
+// Helper function to update AndroidManifest.xml
+function updateAndroidManifest() {
+  if (!fs.existsSync(androidManifestPath)) {
+    throw new Error(`AndroidManifest.xml not found: ${androidManifestPath}`);
+  }
+
+  let manifestContent = fs.readFileSync(androidManifestPath, "utf-8");
+
+  // Replace the android:theme attribute in the <activity> tag
+  manifestContent = manifestContent.replace(
+    /<activity[^>]*android:theme="[^"]*"/,
+    (match) => {
+      return match.replace(/android:theme="[^"]*"/, 'android:theme="@style/Theme.Codeplay.SplashScreen"');
+    }
+  );
+
+  fs.writeFileSync(androidManifestPath, manifestContent, "utf-8");
+  console.log(`Updated AndroidManifest.xml with new theme.`);
+}
+
+// Perform the tasks
+try {
+  console.log("Starting splash screen setup...");
+  copyFile(sourceSplashIcon, destinationSplashIcon);
+  copyFile(sourceSplashXML, destinationSplashXML);
+  updateAndroidManifest();
+  console.log("Splash screen setup completed.");
+} catch (error) {
+  console.error(`Error: ${error.message}`);
+  process.exit(1);
+}

package/files/codeplayBeforeBuild-1.0.js

@@ -0,0 +1,139 @@
+const fs = require('fs');
+const path = require('path');
+const plist = require('plist');
+
+const configPath = path.join(process.cwd(), 'capacitor.config.json');
+const androidPlatformPath = path.join(process.cwd(), 'android');
+const iosPlatformPath = path.join(process.cwd(), 'ios');
+const pluginPath = path.join(process.cwd(), 'node_modules', 'emi-indo-cordova-plugin-admob', 'plugin.xml');
+const infoPlistPath = path.join(process.cwd(), 'ios', 'App', 'App', 'Info.plist');
+
+function fileExists(filePath) {
+  return fs.existsSync(filePath);
+}
+
+function getAdMobConfig() {
+  if (!fileExists(configPath)) {
+    throw new Error('capacitor.config.json not found. Ensure this is a Capacitor project.');
+  }
+
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  const admobConfig = config.plugins?.AdMob;
+
+  if (!admobConfig || !admobConfig.APP_ID_ANDROID || !admobConfig.APP_ID_IOS) {
+    throw new Error('AdMob configuration is missing in capacitor.config.json. Ensure APP_ID_ANDROID and APP_ID_IOS are defined.');
+  }
+
+  return {
+    APP_ID_ANDROID: admobConfig.APP_ID_ANDROID,
+    APP_ID_IOS: admobConfig.APP_ID_IOS,
+    USE_LITE_ADS: admobConfig.USE_LITE_ADS === "lite",
+  };
+}
+
+function updatePluginXml(admobConfig) {
+  if (!fileExists(pluginPath)) {
+    console.error('plugin.xml not found. Ensure the plugin is installed.');
+    return;
+  }
+
+  let pluginContent = fs.readFileSync(pluginPath, 'utf8');
+
+  pluginContent = pluginContent
+    .replace(/<preference name="APP_ID_ANDROID" default=".*?" \/>/, `<preference name="APP_ID_ANDROID" default="${admobConfig.APP_ID_ANDROID}" />`)
+    .replace(/<preference name="APP_ID_IOS" default=".*?" \/>/, `<preference name="APP_ID_IOS" default="${admobConfig.APP_ID_IOS}" />`);
+
+
+  fs.writeFileSync(pluginPath, pluginContent, 'utf8');
+  console.log('AdMob IDs successfully updated in plugin.xml');
+}
+
+function updateInfoPlist(admobConfig) {
+  if (!fileExists(infoPlistPath)) {
+    console.error('Info.plist not found. Ensure you have built the iOS project.');
+    return;
+  }
+
+  const plistContent = fs.readFileSync(infoPlistPath, 'utf8');
+  const plistData = plist.parse(plistContent);
+
+  plistData.GADApplicationIdentifier = admobConfig.APP_ID_IOS;
+  plistData.NSUserTrackingUsageDescription = 'This identifier will be used to deliver personalized ads to you.';
+  plistData.GADDelayAppMeasurementInit = true;
+
+  // https://developers.google.com/admob/ios/quick-start
+  plistData.SKAdNetworkItems = [
+    { SKAdNetworkIdentifier: 'cstr6suwn9.skadnetwork' }, // Google
+    { SKAdNetworkIdentifier: '4fzdc2evr5.skadnetwork' }, // Aarki
+    { SKAdNetworkIdentifier: '2fnua5tdw4.skadnetwork' }, // Adform
+    { SKAdNetworkIdentifier: 'ydx93a7ass.skadnetwork' }, // Adikteev
+    { SKAdNetworkIdentifier: 'p78axxw29g.skadnetwork' }, // Amazon
+    { SKAdNetworkIdentifier: 'v72qych5uu.skadnetwork' }, // Appier
+    { SKAdNetworkIdentifier: 'ludvb6z3bs.skadnetwork' }, // Applovin
+    { SKAdNetworkIdentifier: 'cp8zw746q7.skadnetwork' }, // Arpeely
+    { SKAdNetworkIdentifier: '3sh42y64q3.skadnetwork' }, // Basis
+    { SKAdNetworkIdentifier: 'c6k4g5qg8m.skadnetwork' }, // Beeswax.io
+    { SKAdNetworkIdentifier: 's39g8k73mm.skadnetwork' }, // Bidease
+    { SKAdNetworkIdentifier: '3qy4746246.skadnetwork' }, // Bigabid
+    { SKAdNetworkIdentifier: 'hs6bdukanm.skadnetwork' }, // Criteo
+    { SKAdNetworkIdentifier: 'mlmmfzh3r3.skadnetwork' }, // Digital Turbine DSP
+    { SKAdNetworkIdentifier: 'v4nxqhlyqp.skadnetwork' }, // i-mobile
+    { SKAdNetworkIdentifier: 'wzmmz9fp6w.skadnetwork' }, // InMobi
+    { SKAdNetworkIdentifier: 'su67r6k2v3.skadnetwork' }, // ironSource Ads
+    { SKAdNetworkIdentifier: 'yclnxrl5pm.skadnetwork' }, // Jampp
+    { SKAdNetworkIdentifier: '7ug5zh24hu.skadnetwork' }, // Liftoff
+    { SKAdNetworkIdentifier: 'gta9lk7p23.skadnetwork' }, // Liftoff Monetize
+    { SKAdNetworkIdentifier: 'vutu7akeur.skadnetwork' }, // LINE
+    { SKAdNetworkIdentifier: 'y5ghdn5j9k.skadnetwork' }, // Mediaforce
+    { SKAdNetworkIdentifier: 'v9wttpbfk9.skadnetwork' }, // Meta (1 of 2)
+    { SKAdNetworkIdentifier: 'n38lu8286q.skadnetwork' }, // Meta (2 of 2)
+    { SKAdNetworkIdentifier: '47vhws6wlr.skadnetwork' }, // MicroAd
+    { SKAdNetworkIdentifier: 'kbd757ywx3.skadnetwork' }, // Mintegral / Mobvista
+    { SKAdNetworkIdentifier: '9t245vhmpl.skadnetwork' }, // Moloco
+    { SKAdNetworkIdentifier: 'a2p9lx4jpn.skadnetwork' }, // Opera
+    { SKAdNetworkIdentifier: '22mmun2rn5.skadnetwork' }, // Pangle
+    { SKAdNetworkIdentifier: '4468km3ulz.skadnetwork' }, // Realtime Technologies GmbH
+    { SKAdNetworkIdentifier: '2u9pt9hc89.skadnetwork' }, // Remerge
+    { SKAdNetworkIdentifier: '8s468mfl3y.skadnetwork' }, // RTB House
+    { SKAdNetworkIdentifier: 'ppxm28t8ap.skadnetwork' }, // Smadex
+    { SKAdNetworkIdentifier: 'uw77j35x4d.skadnetwork' }, // The Trade Desk
+    { SKAdNetworkIdentifier: 'pwa73g5rt2.skadnetwork' }, // Tremor
+    { SKAdNetworkIdentifier: '578prtvx9j.skadnetwork' }, // Unicorn
+    { SKAdNetworkIdentifier: '4dzt52r2t5.skadnetwork' }, // Unity Ads
+    { SKAdNetworkIdentifier: 'tl55sbb4fm.skadnetwork' }, // Verve
+    { SKAdNetworkIdentifier: 'e5fvkxwrpn.skadnetwork' }, // Yahoo!
+    { SKAdNetworkIdentifier: '8c4e2ghe7u.skadnetwork' }, // Yahoo! Japan Ads
+    { SKAdNetworkIdentifier: '3rd42ekr43.skadnetwork' }, // YouAppi
+    { SKAdNetworkIdentifier: '3qcr597p9d.skadnetwork' }, // Zucks
+];
+
+  const updatedPlistContent = plist.build(plistData);
+  fs.writeFileSync(infoPlistPath, updatedPlistContent, 'utf8');
+  console.log('AdMob IDs and additional configurations successfully updated in Info.plist');
+}
+
+try {
+  if (!fileExists(configPath)) {
+    throw new Error('capacitor.config.json not found. Skipping setup.');
+  }
+
+  if (!fileExists(androidPlatformPath) && !fileExists(iosPlatformPath)) {
+    throw new Error('Neither Android nor iOS platforms are found. Ensure platforms are added to your Capacitor project.');
+  }
+
+  const admobConfig = getAdMobConfig();
+
+  if (fileExists(androidPlatformPath)) {
+    updatePluginXml(admobConfig);
+  }
+
+  if (fileExists(iosPlatformPath)) {
+    updateInfoPlist(admobConfig);
+  }
+} catch (error) {
+  console.error(error.message);
+}
+
+
+  
+  

package/files/finalrelease13

@@ -0,0 +1,493 @@
+const fs = require('fs');
+const path = require('path');
+const child_process = require('child_process');
+const readline = require('readline');
+
+// Define a mapping between store IDs and store names
+const storeNames = {
+    "1": "PlayStore",
+    "2": "SamsungStore",
+    "7": "AmazonStore"
+};
+
+const androidManifestPath = path.join("android", "app", "src", "main", "AndroidManifest.xml");
+
+
+
+const admobConfigPath = path.join('src', 'js','Ads', 'admob-ad-configuration.json');
+let admobConfig;
+try {
+    admobConfig = JSON.parse(fs.readFileSync(admobConfigPath, 'utf8'));
+} catch (err) {
+    console.error("Failed to read admob-ad-configuration.json", err);
+    process.exit(1);
+}
+
+
+
+
+const checkCommonFileStoreId=()=>{
+    const possibleConfigFiles = ['vite.config.mjs', 'vite.config.js'];
+    let viteConfigPath;
+    for (const configFile of possibleConfigFiles) {
+        const fullPath = path.resolve( configFile);
+        if (fs.existsSync(fullPath)) {
+            viteConfigPath = fullPath;
+            break;
+        }
+    }
+    
+    if (!viteConfigPath) {
+        console.error('Error: No vite.config.mjs or vite.config.js file found.');
+        process.exit(1);
+    }
+    
+        try {
+            // Read vite config file
+            const viteConfigContent = fs.readFileSync(viteConfigPath, 'utf-8');
+            
+            // Extract @common alias path
+            const aliasPattern = /'@common':\s*path\.resolve\(__dirname,\s*'(.+?)'\)/;
+            const match = viteConfigContent.match(aliasPattern);
+            
+            if (!match) {
+                console.error(`Error: @common alias not found in ${viteConfigPath}`);
+                process.exit(1);
+            }
+            
+            const commonFilePath = match[1];
+            const resolvedCommonPath = path.resolve(__dirname, commonFilePath);
+            
+            // Read the common file content
+            if (!fs.existsSync(resolvedCommonPath)) {
+                console.error(`Error: Resolved common file does not exist: ${resolvedCommonPath}`);
+                process.exit(1);
+            }
+            
+            const commonFileContent = fs.readFileSync(resolvedCommonPath, 'utf-8');
+            
+            // Check for the _storeid export line
+            const storeIdPattern = /export\s+let\s+_storeid\s*=\s*import\.meta\.env\.VITE_STORE_ID\s*\|\|\s*1\s*;/;
+            if (!storeIdPattern.test(commonFileContent)) {
+                console.error(`Error: _storeid value is wrong in ${commonFilePath}`);
+                process.exit(1);
+            }
+    
+            console.log(commonFilePath,'Success - No problem found');
+        } catch (error) {
+            console.error('Error:', error);
+            process.exit(1);
+        }
+
+}
+
+const checkIsTestingInAdmob=()=>{
+    
+    if (admobConfig.config && admobConfig.config.isTesting === true) {
+        console.error(`Problem found while generating the AAB file. Please change "isTesting: true" to "isTesting: false" in the "admob-ad-configuration.json" file.`);
+        process.exit(1); // Exit with an error code to halt the process
+    } else {
+        console.log('No problem found. "isTesting" is either already false or not defined.');
+    }
+}
+
+const addPermission_AD_ID=()=>{
+
+    const admobPluginXmlPath = path.join('node_modules', 'emi-indo-cordova-plugin-admob', 'plugin.xml');
+    
+
+    fs.access(admobPluginXmlPath, fs.constants.F_OK, (err) => {
+        if (err) {
+            isAdmobFound = false;
+        } else {
+            isAdmobFound = true;
+        }
+    });
+    
+    
+    if (isAdmobFound) {
+        // Check if AndroidManifest.xml exists
+        if (fs.existsSync(androidManifestPath)) {
+            // Read the content of AndroidManifest.xml
+            let manifestContent = fs.readFileSync(androidManifestPath, 'utf8');
+    
+            // Check if the ad_id permission already exists
+            const adIdPermission = '<uses-permission android:name="com.google.android.gms.permission.AD_ID" />';
+            if (!manifestContent.includes(adIdPermission)) {
+                console.log("ad_id permission not found. Adding to AndroidManifest.xml.");
+    
+                // Add the ad_id permission before the closing </manifest> tag
+                manifestContent = manifestContent.replace('</manifest>', `    ${adIdPermission}\n</manifest>`);
+    
+                // Write the updated manifest content back to AndroidManifest.xml
+                fs.writeFileSync(androidManifestPath, manifestContent, 'utf8');
+                console.log("ad_id permission added successfully.");
+            } else {
+                console.log("ad_id permission already exists in AndroidManifest.xml.");
+            }
+        } else {
+            console.error("AndroidManifest.xml not found at the specified path.");
+        }
+    } else {
+        console.log("\x1b[33m%s\x1b[0m", "No admob found, so permission.AD_ID is not added");
+    }
+}
+
+
+checkCommonFileStoreId();
+checkIsTestingInAdmob();
+
+
+let isAdmobFound = true;
+addPermission_AD_ID()
+
+
+
+const { playstore, samsung, amazon } = admobConfig.IAP;
+console.log(`IAP Configurations - PlayStore: ${playstore}, Samsung: ${samsung}, Amazon: ${amazon}`);
+
+
+
+
+
+
+// Get the store ID from the command line arguments
+const storeIdArg = process.argv[2]; // Get the store ID from the command line
+const storeIds = storeIdArg ? [storeIdArg] : ["1", "2", "7"]; // If a specific ID is provided, use it; otherwise, use all store IDs
+
+// Store the original minSdkVersion globally
+let originalMinSdkVersion;
+
+// Remove any existing AAB files before starting the build process
+const aabDirectory = path.join("android", "app", "build", "outputs", "bundle", "release");
+if (fs.existsSync(aabDirectory)) {
+    const files = fs.readdirSync(aabDirectory).filter(file => file.endsWith('.aab'));
+    files.forEach(file => {
+        const filePath = path.join(aabDirectory, file);
+        fs.unlinkSync(filePath);
+        console.log(`Deleted existing AAB file: ${file}`);
+    });
+}
+
+const aabOutputDir = path.join("AAB");
+if (!fs.existsSync(aabOutputDir)) {
+    fs.mkdirSync(aabOutputDir);
+    console.log(`Created directory: ${aabOutputDir}`);
+}
+
+if (fs.existsSync(aabOutputDir)) {
+    const files = fs.readdirSync(aabOutputDir).filter(file => file.endsWith('.aab'));
+    files.forEach(file => {
+        const filePath = path.join(aabOutputDir, file);
+        fs.unlinkSync(filePath);
+        console.log(`Deleted existing AAB file: ${file}`);
+    });
+}
+
+
+// Extract version code and version name from build.gradle
+const gradleFilePath = path.join("android", "app", "build.gradle");
+const gradleContent = fs.readFileSync(gradleFilePath, 'utf8');
+
+const versionCodeMatch = gradleContent.match(/versionCode\s+(\d+)/);
+const versionNameMatch = gradleContent.match(/versionName\s+"([^"]+)"/);
+
+const versionCode = versionCodeMatch ? versionCodeMatch[1] : '';
+const versionName = versionNameMatch ? versionNameMatch[1] : '';
+
+// Display the current versionCode and versionName
+console.log(`Current versionCode: ${versionCode}`);
+console.log(`Current versionName: ${versionName}`);
+
+// Create an interface for user input
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+// Ask for new versionCode
+rl.question('Enter new versionCode (press enter to keep current): ', (newVersionCode) => {
+    const finalVersionCode = newVersionCode || versionCode; // Use existing if no input
+
+    // Ask for new versionName
+    rl.question('Enter new versionName (press enter to keep current): ', (newVersionName) => {
+        const finalVersionName = newVersionName || versionName; // Use existing if no input
+
+        // Log the final version details
+        console.log(`Final versionCode: ${finalVersionCode}`);
+        console.log(`Final versionName: ${finalVersionName}`);
+
+        // Update build.gradle with the new version details
+        let updatedGradleContent = gradleContent
+            .replace(/versionCode\s+\d+/, `versionCode ${finalVersionCode}`)
+            .replace(/versionName\s+"[^"]+"/, `versionName "${finalVersionName}"`);
+
+        // Check if resConfigs "en" already exists
+        const resConfigsLine = '        resConfigs "en"';
+        if (!updatedGradleContent.includes(resConfigsLine)) {
+            // Add resConfigs "en" below versionName
+            updatedGradleContent = updatedGradleContent.replace(/versionName\s+"[^"]+"/, `versionName "${finalVersionName}"\n${resConfigsLine}`);
+        } else {
+            console.log('resConfigs "en" already exists in build.gradle.');
+        }
+
+        // Write the updated gradle content back to build.gradle
+        fs.writeFileSync(gradleFilePath, updatedGradleContent, 'utf8');
+        console.log(`Updated build.gradle with versionCode: ${finalVersionCode}, versionName: ${finalVersionName}, and resConfigs "en"`);
+
+        storeIds.forEach((id) => {
+            console.log(`Building for Store ID ${id}`);
+
+            // Set the environment variable for store ID
+            process.env.VITE_STORE_ID = id;
+
+            // Conditionally set the new file name
+            let newFileName;
+            const storeName = storeNames[id];
+            
+            managePackages(storeName);
+
+            if (storeName === "SamsungStore") {
+                // For SamsungStore, rename to versionCode value only
+                newFileName = `${finalVersionCode}.aab`;
+            } else {
+                // For other stores, use the standard naming format
+                newFileName = `app-release-signed-${storeName}-b${finalVersionCode}-v${finalVersionName}.aab`;
+            }
+
+            const checkFullPath = path.join("AAB", newFileName); // Update to point to the new AAB directory
+
+            // Modify minSdkVersion in variables.gradle for SamsungStore
+            const variablesGradleFilePath = path.join("android", "variables.gradle");
+            let variablesGradleContent = fs.readFileSync(variablesGradleFilePath, 'utf8');
+
+            // Extract the current minSdkVersion
+            const minSdkVersionMatch = variablesGradleContent.match(/minSdkVersion\s*=\s*(\d+)/);
+            const currentMinSdkVersion = minSdkVersionMatch ? parseInt(minSdkVersionMatch[1], 10) : null;
+
+            // Store the original minSdkVersion (only on the first iteration)
+            if (!originalMinSdkVersion) {
+                originalMinSdkVersion = currentMinSdkVersion;
+            }
+            try {
+                // Modify the minSdkVersion based on the store
+                if (storeName === "SamsungStore" || storeName === "PlayStore") {
+                    if (currentMinSdkVersion !== 24) {
+                        variablesGradleContent = variablesGradleContent.replace(/minSdkVersion\s*=\s*\d+/, 'minSdkVersion = 24');
+                        console.log('minSdkVersion updated to 24 for SamsungStore & PlayStore');
+                        fs.writeFileSync(variablesGradleFilePath, variablesGradleContent);
+                    }
+                } else {
+                    // For PlayStore and AmazonStore, ensure minSdkVersion is originalMinSdkVersion
+                    if (currentMinSdkVersion !== originalMinSdkVersion) {
+                        variablesGradleContent = variablesGradleContent.replace(/minSdkVersion\s*=\s*\d+/, `minSdkVersion = ${originalMinSdkVersion}`);
+                        console.log(`minSdkVersion reverted to ${originalMinSdkVersion} for ${storeName}`);
+                        fs.writeFileSync(variablesGradleFilePath, variablesGradleContent);
+                    }
+                }
+
+                // Run the Node.js script to modify plugin.xml
+                if (isAdmobFound) {
+                    child_process.execSync('node modify-plugin-xml.js', { stdio: 'inherit' });
+                } else {
+                    console.log("\x1b[33m%s\x1b[0m", "Seems to Pro Version [No ads found]");
+                }
+
+                // Run the Vite build
+                child_process.execSync(`npm run build:storeid${id}`, { stdio: 'inherit' });
+
+                
+
+                // Copy the built files to the appropriate folder
+                const src = path.join("www", "*");
+                const dest = path.join("android", "app", "src", "main", "assets", "public");
+
+                // Use 'xcopy' command for Windows
+                child_process.execSync(`xcopy ${src} ${dest} /E /I /Y`, { stdio: 'inherit' });
+
+                // Build Android AAB file
+                //child_process.execSync('cd android && ./gradlew bundleRelease', { stdio: 'inherit' });
+
+
+                // Build Android AAB file with Capacitor
+                child_process.execSync('npx cap sync android', { stdio: 'inherit' });
+                child_process.execSync('npx cap build android --androidreleasetype=AAB', { stdio: 'inherit' });
+
+
+                // Rename the output AAB file
+                const oldFilePath = path.join(aabDirectory, "app-release-signed.aab");
+                if (fs.existsSync(oldFilePath)) {
+                    fs.renameSync(oldFilePath, checkFullPath);
+                    console.log(`Renamed output AAB file to: ${newFileName}`);
+                } else {
+                    console.error("AAB file not found after build.");
+                }
+
+            } catch (error) {
+                console.error(`Error during build for Store ID ${id}:`, error);
+            }
+        });
+
+        rl.close(); // Close the readline interface after all operations
+    });
+});
+
+
+
+
+
+function managePackages(store) {
+    console.log(`IAP Configurations - PlayStore: ${playstore}, Samsung: ${samsung}, Amazon: ${amazon}`);
+
+    let install = "";
+    let uninstall = "";
+
+
+
+    let manifestContent = fs.readFileSync(androidManifestPath, 'utf-8');
+    
+    const permissionsToRemove = [
+        'com.android.vending.BILLING',
+        'com.samsung.android.iap.permission.BILLING'
+    ];
+    
+    
+    permissionsToRemove.forEach(permission => {
+        const permissionRegex = new RegExp(`^\\s*<uses-permission\\s+android:name="${permission}"\\s*/?>\\s*[\r\n]?`, 'm');
+        if (permissionRegex.test(manifestContent)) {
+            manifestContent = manifestContent.replace(permissionRegex, '');
+            console.log(`Removed <uses-permission android:name="${permission}" /> from AndroidManifest.xml`);
+        }
+    });
+    
+    // Write the updated content back to the file
+    fs.writeFileSync(androidManifestPath, manifestContent, 'utf-8');
+
+
+
+    if ((playstore && store === "PlayStore") || (amazon && store === "AmazonStore")) {
+        install = '@revenuecat/purchases-capacitor';
+        uninstall = 'cordova-plugin-samsungiap';
+
+        // Update AndroidManifest.xml for PlayStore
+        if(playstore)
+            updateAndroidManifest(store, 
+                '<uses-permission android:name="com.android.vending.BILLING" />');
+
+    } else if (samsung && store === "SamsungStore") {
+        install = 'cordova-plugin-samsungiap';
+        uninstall = '@revenuecat/purchases-capacitor';
+
+        // Update AndroidManifest.xml for SamsungStore
+        updateAndroidManifest(store, 
+            '<uses-permission android:name="com.samsung.android.iap.permission.BILLING" />');
+
+    } else {
+        console.log("No valid store specified or no configurations found. Both plugins will be uninstalled.");
+        try {
+            child_process.execSync(`npm uninstall cordova-plugin-samsungiap`, { stdio: 'inherit' });
+            child_process.execSync(`npm uninstall @revenuecat/purchases-capacitor`, { stdio: 'inherit' });
+            console.log(`Both plugins uninstalled successfully.`);
+        } catch (err) {
+            console.error("Error uninstalling plugins:", err);
+        }
+        return;
+    }
+
+    console.log(`Installing ${install} and uninstalling ${uninstall} for ${store}...`);
+    try {
+        if (install) {
+            child_process.execSync(`npm install ${install}`, { stdio: 'inherit' });
+        }
+        if (uninstall) {
+            child_process.execSync(`npm uninstall ${uninstall}`, { stdio: 'inherit' });
+        }
+        console.log(`${install} installed and ${uninstall} uninstalled successfully.`);
+    } catch (err) {
+        console.error(`Error managing packages for ${store}:`, err);
+    }
+}
+
+
+
+function updateAndroidManifest(store, addPermission) {
+    try {
+        if (!fs.existsSync(androidManifestPath)) {
+            console.error("AndroidManifest.xml file not found!");
+            return;
+        }
+
+        // Read the content of the AndroidManifest.xml
+        let manifestContent = fs.readFileSync(androidManifestPath, 'utf-8');
+
+        // Normalize line endings to `\n` for consistent processing
+        manifestContent = manifestContent.replace(/\r\n/g, '\n');
+
+        // Check if the permission is already present
+        if (manifestContent.includes(addPermission.trim())) {
+            console.log(`${addPermission} is already in the AndroidManifest.xml. Skipping addition.`);
+            return; // Skip if the permission is already present
+        }
+
+        // Insert the permission before the closing </manifest> tag
+        const closingTag = '</manifest>';
+        const formattedPermission = `    ${addPermission.trim()}\n`;
+        if (manifestContent.includes(closingTag)) {
+            manifestContent = manifestContent.replace(
+                closingTag,
+                `${formattedPermission}${closingTag}`
+            );
+            console.log(`Added ${addPermission} before </manifest> tag.`);
+        } else {
+            console.warn(`</manifest> tag not found. Adding ${addPermission} at the end of the file.`);
+            manifestContent += `\n${formattedPermission}`;
+        }
+
+        // Normalize line endings back to `\r\n` and write the updated content
+        manifestContent = manifestContent.replace(/\n/g, '\r\n');
+        fs.writeFileSync(androidManifestPath, manifestContent, 'utf-8');
+        console.log(`AndroidManifest.xml updated successfully for ${store}`);
+    } catch (err) {
+        console.error(`Error updating AndroidManifest.xml for ${store}:`, err);
+    }
+}
+
+
+
+/* function updateAndroidManifest1(store, addPermission) {
+    try {
+        if (!fs.existsSync(androidManifestPath)) {
+            console.error("AndroidManifest.xml file not found!");
+            return;
+        }
+
+        let manifestContent = fs.readFileSync(androidManifestPath, 'utf-8');
+
+
+
+        // Add the required permission if not already present
+        if (!manifestContent.includes(addPermission)) {
+            const manifestLines = manifestContent.split('\n');
+            const insertIndex = manifestLines.findIndex(line => line.trim().startsWith('<application'));
+            if (insertIndex > -1) {
+                manifestLines.splice(insertIndex, 0, `    ${addPermission}`);
+                manifestContent = manifestLines.join('\n');
+                console.log(`Added ${addPermission} to AndroidManifest.xml`);
+            }
+        }
+
+        // Write the updated content back to the file
+        fs.writeFileSync(androidManifestPath, manifestContent, 'utf-8');
+        console.log(`AndroidManifest.xml updated successfully for ${store}`);
+    } catch (err) {
+        console.error(`Error updating AndroidManifest.xml for ${store}:`, err);
+    }
+} */
+
+
+
+
+
+
+
+

package/files/iap-install-1.js

@@ -0,0 +1,146 @@
+const fs = require('fs');
+const path = require('path');
+
+
+
+const androidManifestPath = path.join("android", "app", "src", "main", "AndroidManifest.xml");
+
+// Find the vite config file
+const possibleConfigFiles = ['vite.config.mjs', 'vite.config.js'];
+let viteConfigPath;
+
+for (const configFile of possibleConfigFiles) {
+    const fullPath = path.resolve(configFile);
+    if (fs.existsSync(fullPath)) {
+        viteConfigPath = fullPath;
+        break;
+    }
+}
+
+if (!viteConfigPath) {
+    console.error('Error: No vite.config.mjs or vite.config.js file found.');
+    process.exit(1);
+}
+
+try {
+    // Read vite config file
+    const viteConfigContent = fs.readFileSync(viteConfigPath, 'utf-8');
+
+    // Extract @common alias path
+    const aliasPattern = /'@common':\s*path\.resolve\(__dirname,\s*'(.+?)'\)/;
+    const match = viteConfigContent.match(aliasPattern);
+
+    if (!match) {
+        console.error(`Error: @common alias not found in ${viteConfigPath}`);
+        process.exit(1);
+    }
+
+    const commonFilePath = match[1];
+    const resolvedCommonPath = path.resolve(__dirname, commonFilePath);
+
+    // Read the common file content
+    if (!fs.existsSync(resolvedCommonPath)) {
+        console.error(`Error: Resolved common file does not exist: ${resolvedCommonPath}`);
+        process.exit(1);
+    }
+
+    const commonFileContent = fs.readFileSync(resolvedCommonPath, 'utf-8');
+
+    // Extract _storeid value
+    const storeIdPattern = /export\s+let\s+_storeid\s*=\s*(?:import\.meta\.env\.VITE_STORE_ID\|\|)?(\d+)/;
+    const storeMatch = commonFileContent.match(storeIdPattern);
+
+    if (!storeMatch) {
+        console.error(`Error: _storeid not found in ${resolvedCommonPath}`);
+        process.exit(1);
+    }
+
+    const _storeid = parseInt(storeMatch[1], 10);
+
+    // Determine the store name based on _storeid
+
+
+
+    let storeName = "";
+    if (_storeid === 1) {
+        storeName = "PlayStore";
+    } else if (_storeid === 2) {
+        storeName = "SamsungStore";
+    } else if (_storeid === 7) {
+        storeName = "AmazonStore";
+    }
+    else {
+        console.error(`Error: Unsupported _storeid value: ${_storeid}`);
+        process.exit(1);
+    }
+
+    // Call managePackages with the determined store name
+    managePackages(storeName);
+
+    console.log(commonFilePath, `Success - _storeid found: ${_storeid}, Store: ${storeName}`);
+} catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+}
+
+function managePackages(store) {
+    console.log(`Managing packages for store: ${store}`);
+
+    let install = "";
+    let uninstall = "";
+
+    //let androidManifestPath = "path/to/AndroidManifest.xml"; // Update this path
+
+    
+    let manifestContent = fs.readFileSync(androidManifestPath, 'utf-8');
+
+    const permissionsToRemove = [
+        'com.android.vending.BILLING',
+        'com.samsung.android.iap.permission.BILLING'
+    ];
+
+    permissionsToRemove.forEach(permission => {
+        const permissionRegex = new RegExp(`^\\s*<uses-permission\\s+android:name="${permission}"\\s*/?>\\s*[\r\n]?`, 'm');
+        if (permissionRegex.test(manifestContent)) {
+            manifestContent = manifestContent.replace(permissionRegex, '');
+            console.log(`Removed <uses-permission android:name="${permission}" /> from AndroidManifest.xml`);
+        }
+    });
+
+    // Write the updated content back to the file
+    fs.writeFileSync(androidManifestPath, manifestContent, 'utf-8');
+
+    if (store === "PlayStore") {
+        install = '@revenuecat/purchases-capacitor';
+        uninstall = 'cordova-plugin-samsungiap';
+    } else if (store === "AmazonStore") {
+        install = '@revenuecat/purchases-capacitor';
+        uninstall = 'cordova-plugin-samsungiap';
+    } else if (store === "SamsungStore") {
+        install = 'cordova-plugin-samsungiap';
+        uninstall = '@revenuecat/purchases-capacitor';
+    } else {
+        console.log("No valid store specified. Uninstalling both plugins.");
+        try {
+            require('child_process').execSync(`npm uninstall cordova-plugin-samsungiap`, { stdio: 'inherit' });
+            require('child_process').execSync(`npm uninstall @revenuecat/purchases-capacitor`, { stdio: 'inherit' });
+            console.log("Both plugins uninstalled successfully.");
+        } catch (err) {
+            console.error("Error uninstalling plugins:", err);
+        }
+        return;
+    }
+
+    console.log(`Installing ${install} and uninstalling ${uninstall} for ${store}...`);
+    try {
+        if (install) {
+            require('child_process').execSync(`npm install ${install}`, { stdio: 'inherit' });
+        }
+        if (uninstall) {
+            require('child_process').execSync(`npm uninstall ${uninstall}`, { stdio: 'inherit' });
+        }
+        console.log(`${install} installed and ${uninstall} uninstalled successfully.`);
+    } catch (err) {
+        console.error(`Error managing packages for ${store}:`, err);
+    }
+}

package/files/ionic.config.json

@@ -0,0 +1,7 @@
+{
+  "name": "merbin-test-app",
+  "integrations": {
+    "capacitor": {}
+  },
+  "type": "custom"
+}

package/files/modify-plugin-xml.js

@@ -0,0 +1,36 @@
+const fs = require('fs');
+const path = require('path');
+
+// Path to the plugin.xml file
+const pluginXmlPath = path.join('node_modules', 'emi-indo-cordova-plugin-admob', 'plugin.xml');
+
+// Get the store ID from the environment variable
+const storeId = process.env.VITE_STORE_ID || '1';
+
+// Determine the framework to use based on storeId
+const framework = storeId === '7'
+  ? '<framework src="com.google.android.gms:play-services-ads:$PLAY_SERVICES_VERSION" />'
+  : '<framework src="com.google.android.gms:play-services-ads-lite:$PLAY_SERVICES_VERSION" />';
+
+// Read and modify the plugin.xml file
+fs.readFile(pluginXmlPath, 'utf8', (err, data) => {
+  if (err) {
+    console.error('Error reading plugin.xml:', err);
+    process.exit(1);
+  }
+
+  // Replace the existing framework line with the selected one
+  const modifiedData = data.replace(
+    /<framework src="com.google.android.gms:play-services-ads.*" \/>\n/,
+    `${framework}\n`
+  );
+
+  // Write the modified content back to plugin.xml
+  fs.writeFile(pluginXmlPath, modifiedData, 'utf8', (err) => {
+    if (err) {
+      console.error('Error writing plugin.xml:', err);
+      process.exit(1);
+    }
+    console.log('plugin.xml updated successfully.');
+  });
+});

package/files/setSplashAnimation-1.0.js

@@ -0,0 +1,167 @@
+const fs = require('fs');
+const readline = require('readline');
+const path = require('path');
+
+// Define the root directory of the project (adjust if needed)
+const projectRoot = path.join('android/app/src/main');
+
+// Animation options
+const animations = [
+  { id: 1, name: 'Ripple Effect', code: `.scaleX(1.2f).scaleY(1.2f).alpha(0.3f)` },  //Okay super
+  { id: 2, name: 'Pop Out', code: `.scaleX(1.2f).scaleY(1.2f).alpha(0f)` },  //Okay super
+  { id: 3, name: 'Super Zoom', code: `.scaleX(1.5f).scaleY(1.5f).alpha(1f)` }, //Okay super
+  
+
+  { id: 4, name: 'Flip and Fade', code: `.scaleX(0f).scaleY(0f).rotation(180f).alpha(0f)` }, //Okay
+  { id: 5, name: 'Wipe Away', code: `.translationX(splashScreenView.getWidth()).alpha(0f)` }, //Okay
+  { id: 6, name: 'Bounce in Spiral', code: `.scaleX(0.5f).scaleY(0.5f).alpha(0.5f).rotation(360f)` },  //Okay
+  { id: 7, name: 'Fade and Slide', code: `.alpha(0f).translationY(splashScreenView.getHeight())` },  //Okay
+  { id: 8, name: 'Zoom Out with Bounce', code: `.scaleX(0f).scaleY(0f).alpha(0f).translationY(splashScreenView.getHeight())` },  //Okay
+  { id: 9, name: 'Twist', code: `.rotation(720f).alpha(0f)` }, //Okay
+  { id: 10, name: 'Rotate Back', code: `.rotation(-360f).alpha(1f)` },  //Okay
+  { id: 11, name: 'Stretch In', code: `.scaleX(1.5f).scaleY(1.5f).alpha(1f)` }, //Okay
+  { id: 12, name: 'Fade and Scale', code: `.alpha(0f).scaleX(0f).scaleY(0f)` }, //Okay
+  { id: 13, name: 'Slide Left and Fade', code: `.translationX(-splashScreenView.getWidth()).alpha(0f)` }, //Okay
+
+
+  { id: 14, name: 'Fade Out', code: `.alpha(0f)` },
+  { id: 15, name: 'Slide Down', code: `.translationY(splashScreenView.getHeight())` },
+  { id: 16, name: 'Zoom Out', code: `.scaleX(0f).scaleY(0f).alpha(0f)` },
+  { id: 17, name: 'Rotate Out', code: `.rotation(360f).alpha(0f)` },
+  { id: 18, name: 'Slide Up', code: `.translationY(-splashScreenView.getHeight()).alpha(0f)` },
+  { id: 19, name: 'Bounce Effect', code: `.translationY(splashScreenView.getHeight())` },
+  { id: 20, name: 'Flip Out', code: `.scaleX(0f).alpha(0f)` },
+  { id: 21, name: 'Diagonal Slide and Fade Out', code: `.translationX(splashScreenView.getWidth()).translationY(splashScreenView.getHeight()).alpha(0f)` },
+  { id: 22, name: 'Scale Down with Bounce', code: `.scaleX(0f).scaleY(0f)` },
+  { id: 23, name: 'Slide Left', code: `.translationX(-splashScreenView.getWidth()).alpha(0f)` },
+  { id: 24, name: 'Slide Right', code: `.translationX(splashScreenView.getWidth()).alpha(0f)` },
+  { id: 25, name: 'Scale Up', code: `.scaleX(1f).scaleY(1f).alpha(1f)` },
+  { id: 26, name: 'Rotate In', code: `.rotation(180f).alpha(1f)` },
+  { id: 27, name: 'Bounce Up', code: `.translationY(-100f).setInterpolator(new BounceInterpolator())` },
+  { id: 28, name: 'Flip Horizontal', code: `.scaleX(-1f).alpha(1f)` },
+  { id: 29, name: 'Zoom In', code: `.scaleX(1f).scaleY(1f).alpha(1f)` },
+  { id: 30, name: 'Wobble', code: `.translationX(10f).translationX(-10f).translationX(10f)` },
+  { id: 31, name: 'Vertical Shake', code: `.translationY(10f).translationY(-10f).translationY(10f)` },
+  { id: 32, name: 'Bounce Down', code: `.translationY(100f).setInterpolator(new BounceInterpolator())` },
+  { id: 33, name: 'Swing', code: `.rotation(15f).translationX(-10f).rotation(-15f).translationX(10f)` },
+  { id: 34, name: 'Elastic Bounce', code: `.translationX(30f).translationX(-30f).translationX(15f).translationX(-15f)` },
+  { id: 35, name: 'Pulse', code: `.scaleX(1.1f).scaleY(1.1f).alpha(1f).setRepeatMode(ValueAnimator.REVERSE).setRepeatCount(ValueAnimator.INFINITE)` },
+  { id: 36, name: 'Skew', code: `.setRotationX(30f).setRotationY(30f).alpha(0.5f)` },
+  { id: 37, name: 'Vibrate', code: `.translationX(5f).translationX(-5f).translationX(5f).translationX(-5f)` },
+  { id: 38, name: 'Speed Out', code: `.alpha(0f).setDuration(300)` },
+  { id: 39, name: 'Wave', code: `.translationX(20f).translationX(-20f).translationX(20f).translationX(-20f)` },
+  { id: 40, name: 'Swing Bounce', code: `.rotation(15f).translationX(10f).translationX(-10f)` },
+];
+
+
+// Function to find the package name from capacitor.config.json
+function findPackageName() {
+  const configPath = path.join('capacitor.config.json');
+  if (!fs.existsSync(configPath)) {
+    console.error('capacitor.config.json not found. Ensure this is a valid Capacitor project.');
+    process.exit(1);
+  }
+
+  const configContent = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  return configContent.appId;
+}
+
+// Function to construct the MainActivity.java path
+function constructMainActivityPath(packageName) {
+  const packagePath = packageName.replace(/\./g, '/'); // Convert package name to path
+  const mainActivityPath = path.join('android', 'app', 'src', 'main', 'java', packagePath, 'MainActivity.java');
+  
+  console.log('MainActivity path:', mainActivityPath);  // Output for debugging
+  return mainActivityPath;
+}
+
+// Find package name and MainActivity.java path
+const packageName = findPackageName();
+if (!packageName) {
+  console.error('Failed to extract the package name from capacitor.config.json.');
+  process.exit(1);
+}
+
+const mainActivityPath = constructMainActivityPath(packageName);
+
+// Display animation options
+/* const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+}); */
+
+console.log('Select an animation type for the splash screen:');
+animations.forEach((animation) => {
+  console.log(`${animation.id}. ${animation.name}`);
+});
+
+// Prompt user for animation selection
+//rl.question('Enter the number of the animation type: ', (answer) => {
+
+  const answer=1;
+
+  const selectedAnimation = animations.find((anim) => anim.id === parseInt(answer, 10));
+
+  if (!selectedAnimation) {
+    console.log('Invalid selection. Please run the script again.');
+    //rl.close();
+    return;
+  }
+
+  console.log(`Selected: ${selectedAnimation.name}`);
+
+  // Read the MainActivity.java file
+  fs.readFile(mainActivityPath, 'utf8', (err, data) => {
+    if (err) {
+      console.error(`Error reading MainActivity.java: ${err.message}`);
+      //rl.close();
+      return;
+    }
+
+    // New logic for removing existing code and adding new splash screen animation code
+    const newMainActivityCode =
+`package ${findPackageName()};
+
+import android.os.Build;
+import android.os.Bundle;
+import com.getcapacitor.BridgeActivity;
+
+
+    public class MainActivity extends BridgeActivity {
+        @Override
+        protected void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            // Handle custom splash screen exit animation
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                getSplashScreen().setOnExitAnimationListener(splashScreenView -> {
+                    // Add your custom animation here (e.g., fade out)
+                    splashScreenView.setAlpha(1f);
+                    splashScreenView.animate()
+                            ${selectedAnimation.code} // Apply selected animation
+                            .setDuration(1000) // Animation duration (1000ms)
+                            .withEndAction(splashScreenView::remove) // Remove splash screen
+                            .start();
+                });
+            }
+        }
+    }
+    `;
+
+    // Write the new MainActivity.java content
+    writeMainActivity(newMainActivityCode);
+  });
+
+  //rl.close();
+//});
+
+// Write updated data to MainActivity.java
+function writeMainActivity(updatedData) {
+  fs.writeFile(mainActivityPath, updatedData, 'utf8', (err) => {
+    if (err) {
+      console.error(`Error writing to MainActivity.java: ${err.message}`);
+      return;
+    }
+    console.log('MainActivity.java updated successfully!');
+  });
+}

package/files/splashxml/codeplay_splashScreen.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="splashscreen_background">#FFFFFF</color>
+
+    <style name="Theme.Codeplay.SplashScreen" parent="Theme.SplashScreen.IconBackground">
+        <item name="windowSplashScreenBackground">@color/splashscreen_background</item>
+        <item name="windowSplashScreenAnimatedIcon">@drawable/splash_icon</item>
+        <item name="windowSplashScreenAnimationDuration">10000</item>
+        <item name="postSplashScreenTheme">@style/Theme.AppCompat.NoActionBar</item>
+    </style>
+</resources>

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "codeplay-common",
+  "version": "1.0.0",
+  "description": "Common build scripts and files",
+  "main": "index.js",
+  "scripts": {
+    "postinstall": "node scripts/sync-files.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/merbin2012/codeplay-common.git"
+  },
+  "author": "Codeplay Technologies",
+  "license": "MIT"
+}

package/scripts/sync-files.js

@@ -0,0 +1,67 @@
+const fs = require("fs");
+const path = require("path");
+
+const projectRoot = process.cwd(); // Project root where this package is installed
+const commonBuildPath = path.join(__dirname, "../files"); // Path to "Common Build File" folder
+const packageJsonPath = path.join(projectRoot, "package.json");
+
+// Ensure package.json exists
+if (!fs.existsSync(packageJsonPath)) {
+    console.error("❌ Error: package.json not found in project.");
+    process.exit(1);
+}
+
+// Function to get the latest versioned file dynamically
+function getLatestFile(prefix) {
+    const files = fs.readdirSync(commonBuildPath);
+    const matchingFiles = files.filter(file => file.startsWith(prefix));
+
+    if (matchingFiles.length === 0) {
+        console.warn(`⚠️ Warning: No file found for ${prefix}`);
+        return null;
+    }
+
+    // Sort files by version and pick the latest one
+    matchingFiles.sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+    return matchingFiles[0];
+}
+
+// Copy all files from "files" folder to the project root
+fs.readdirSync(commonBuildPath).forEach(file => {
+    fs.copyFileSync(path.join(commonBuildPath, file), path.join(projectRoot, file));
+    console.log(`✅ Copied: ${file}`);
+});
+
+// Get the latest versions
+const latestSplashScreen = getLatestFile("add-splash-screen-");
+const latestSplashAnimation = getLatestFile("setSplashAnimation-");
+const latestCodeplayBuild = getLatestFile("codeplayBeforeBuild-");
+
+// Read and update package.json
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+// Update only the versioned script names in package.json
+if (latestSplashScreen) {
+    packageJson.scripts["capacitor:sync:after"] = packageJson.scripts["capacitor:sync:after"].replace(
+        /add-splash-screen-\d+\.\d+\.js/,
+        latestSplashScreen
+    );
+}
+
+if (latestSplashAnimation) {
+    packageJson.scripts["capacitor:sync:after"] = packageJson.scripts["capacitor:sync:after"].replace(
+        /setSplashAnimation-\d+\.\d+\.js/,
+        latestSplashAnimation
+    );
+}
+
+if (latestCodeplayBuild) {
+    packageJson.scripts["build"] = packageJson.scripts["build"].replace(
+        /codeplayBeforeBuild-\d+\.\d+\.js/,
+        latestCodeplayBuild
+    );
+}
+
+// Write updated package.json
+fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf8");
+console.log("✅ package.json updated successfully!");