codeplay-common 4.9.7 → 4.9.9

package/files/buildCodeplay/sync-admob-nextgen.js

@@ -0,0 +1,217 @@
+// AdMob packages version the folder; filenames inside it stay stable.
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const PACKAGE_PATTERN = /^admob-nextgen-(\d+(?:\.\d+)*)$/;
+const REQUIRED_FILES = ['admob-emi-nextgen.js', 'app-open-state.js'];
+const SERVER = 'https://htmlcodeplay.com/code-play-plugin/';
+
+function compareVersions(a, b) {
+  const left = String(a).split('.').map(Number);
+  const right = String(b).split('.').map(Number);
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const difference = (left[i] || 0) - (right[i] || 0);
+    if (difference) return difference;
+  }
+  return 0;
+}
+
+function isComplete(directory) {
+  return REQUIRED_FILES.every(file => fs.existsSync(path.join(directory, file))
+    && fs.statSync(path.join(directory, file)).isFile()
+    && fs.statSync(path.join(directory, file)).size > 0);
+}
+
+function findLatestPackage(adsDirectory) {
+  if (!fs.existsSync(adsDirectory)) return null;
+  return fs.readdirSync(adsDirectory).filter(name => PACKAGE_PATTERN.test(name)
+    && isComplete(path.join(adsDirectory, name)))
+    .sort((a, b) => compareVersions(b.match(PACKAGE_PATTERN)[1], a.match(PACKAGE_PATTERN)[1]))[0] || null;
+}
+
+function request(url, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { timeout: 10000 }, response => {
+      if ([301, 302, 303, 307, 308].includes(response.statusCode) && response.headers.location) {
+        response.resume();
+        if (redirects >= 3) return reject(new Error('Too many AdMob download redirects.'));
+        const target = new URL(response.headers.location, url);
+        if (target.protocol !== 'https:') return reject(new Error('AdMob downloads require HTTPS.'));
+        resolve(request(target.href, redirects + 1));
+        return;
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`AdMob download returned HTTP ${response.statusCode}.`));
+        return;
+      }
+      const chunks = [];
+      response.on('data', chunk => chunks.push(chunk));
+      response.on('error', reject);
+      response.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+    req.on('timeout', () => req.destroy(new Error('AdMob download timed out.')));
+    req.on('error', reject);
+  });
+}
+
+function extractPackage(buffer, destination, packageName, AdmZip = require('adm-zip')) {
+  const zip = new AdmZip(buffer);
+  const entries = zip.getEntries();
+  const wrapped = entries.some(entry => entry.entryName === `${packageName}/admob-emi-nextgen.js`);
+  for (const entry of entries) {
+    let name = entry.entryName;
+    if (name.includes('\\') || name.startsWith('/') || name.split('/').includes('..')
+      || /^[a-z]:/i.test(name) || ((entry.header.attr >>> 16) & 0xf000) === 0xa000) {
+      throw new Error(`Unsafe AdMob ZIP entry: ${name}`);
+    }
+    if (wrapped) {
+      if (name === `${packageName}/`) continue;
+      if (!name.startsWith(`${packageName}/`)) throw new Error('Mixed AdMob ZIP roots.');
+      name = name.slice(packageName.length + 1);
+    }
+    if (!name) continue;
+    const target = path.resolve(destination, name);
+    if (!target.startsWith(path.resolve(destination) + path.sep)) throw new Error('Invalid AdMob ZIP path.');
+    if (entry.isDirectory) fs.mkdirSync(target, { recursive: true });
+    else {
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, entry.getData());
+    }
+  }
+  if (!isComplete(destination)) throw new Error('AdMob ZIP must contain the controller and app-open-state.js.');
+}
+
+function sourceFiles(directory) {
+  if (!fs.existsSync(directory)) return [];
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+    if (['node_modules', '.git', 'android', 'ios', 'www', 'agent-temp'].includes(entry.name)) return [];
+    const fullPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) return sourceFiles(fullPath);
+    return entry.isFile() && /\.(?:js|mjs|cjs|ts|f7|vue|jsx|tsx)$/.test(entry.name) ? [fullPath] : [];
+  });
+}
+
+function syncImports(projectRoot, packageName) {
+  const adsDirectory = path.join(projectRoot, 'src', 'js', 'Ads');
+  const targetDirectory = path.join(adsDirectory, packageName);
+  if (!isComplete(targetDirectory)) throw new Error('Cannot migrate imports to an incomplete AdMob package.');
+  const files = sourceFiles(path.join(projectRoot, 'src'));
+  for (const name of ['vite.config.js', 'vite.config.mjs', 'vite.config.ts']) {
+    const file = path.join(projectRoot, name);
+    if (fs.existsSync(file)) files.push(file);
+  }
+  const updates = [];
+  for (const file of files) {
+    const original = fs.readFileSync(file, 'utf8');
+    const next = original.replace(/(['"`])([^'"`\r\n]+)\1/g, (match, quote, specifier) => {
+      if (!/admob-(?:emi-nextgen|app-open-state|nextgen)-/.test(specifier)) return match;
+      if (specifier.includes('${')) throw new Error(`Computed AdMob import needs migration before cleanup: ${file}`);
+      const suffixIndex = specifier.search(/[?#]/);
+      const suffix = suffixIndex < 0 ? '' : specifier.slice(suffixIndex);
+      specifier = suffixIndex < 0 ? specifier : specifier.slice(0, suffixIndex);
+      let resolved;
+      if (specifier.startsWith('@/')) resolved = path.resolve(projectRoot, 'src', specifier.slice(2));
+      else if (specifier.startsWith('./') || specifier.startsWith('../')) resolved = path.resolve(path.dirname(file), specifier);
+      else return match;
+      const relative = path.relative(adsDirectory, resolved).split(path.sep).join('/');
+      let name;
+      if (/^admob-emi-nextgen-\d+(?:\.\d+)*\.js$/.test(relative)) name = REQUIRED_FILES[0];
+      else if (/^admob-app-open-state-\d+(?:\.\d+)*\.js$/.test(relative)) name = REQUIRED_FILES[1];
+      else {
+        const folderFile = relative.match(/^admob-nextgen-\d+(?:\.\d+)*\/(.+)$/);
+        if (!folderFile) return match;
+        name = folderFile[1];
+      }
+      const target = path.join(targetDirectory, name);
+      if (!fs.existsSync(target)) throw new Error(`AdMob import target missing: ${target}`);
+      let replacement = specifier.startsWith('@/')
+        ? `@/js/Ads/${packageName}/${name}`
+        : path.relative(path.dirname(file), target).split(path.sep).join('/');
+      if (!specifier.startsWith('@/') && !replacement.startsWith('.')) replacement = './' + replacement;
+      return quote + replacement + suffix + quote;
+    });
+    if (next !== original) updates.push({ file, next });
+  }
+  // Plan every replacement before writing or removing any legacy source.
+  for (const { file, next } of updates) fs.writeFileSync(file, next, 'utf8');
+  return updates.map(update => path.relative(projectRoot, update.file));
+}
+
+function syncPackageDependencies(projectRoot, packageName) {
+  const adsDirectory = path.join(projectRoot, 'src', 'js', 'Ads');
+  const controller = path.join(adsDirectory, packageName, REQUIRED_FILES[0]);
+  const iapFolders = fs.readdirSync(adsDirectory).filter(name => /^IAP-\d+(?:\.\d+)*$/.test(name)
+    && fs.existsSync(path.join(adsDirectory, name, 'firebase-analytics.js')))
+    .sort((a, b) => compareVersions(b.slice(4), a.slice(4)));
+  const original = fs.readFileSync(controller, 'utf8');
+  let next = original.replace(/(['"])\.\.?\/admob-ad-configuration-nextgen\.json\1/g,
+    (match, quote) => `${quote}../admob-ad-configuration-nextgen.json${quote}`);
+  if (iapFolders.length) next = next.replace(/(['"])\.\.?\/IAP-\d+(?:\.\d+)*\/firebase-analytics\.js\1/g,
+    (match, quote) => `${quote}../${iapFolders[0]}/firebase-analytics.js${quote}`);
+  if (next !== original) fs.writeFileSync(controller, next, 'utf8');
+}
+
+async function syncAdmobNextgen(options = {}) {
+  const projectRoot = path.resolve(options.projectRoot || process.cwd());
+  const adsDirectory = path.join(projectRoot, 'src', 'js', 'Ads');
+  if (!fs.existsSync(adsDirectory)) return null;
+  const log = options.log || console.log;
+  const fetch = options.request || request;
+  let latest = findLatestPackage(adsDirectory);
+  let versions = options.versions;
+  if (versions === undefined) {
+    try { versions = JSON.parse((await fetch(SERVER + 'versions.json')).toString('utf8')); }
+    catch (error) { log(`AdMob: server unavailable; retaining the installed package. ${error.message}`); }
+  }
+  // New manifests use admob-nextgen. Accept the previous key only at folder versions >= 4.0.
+  const advertisedVersion = String(versions?.['admob-nextgen'] || versions?.['admob-emi-nextgen'] || '');
+  // Match versions.json's minimum-folder rule while older live manifests still advertise a JS release.
+  const remoteVersion = /^\d+(?:\.\d+)*$/.test(advertisedVersion) && compareVersions(advertisedVersion, '4.0') >= 0
+    ? advertisedVersion : '4.0';
+  const candidates = [];
+  if (/^\d+(?:\.\d+)*$/.test(remoteVersion) && compareVersions(remoteVersion, '4.0') >= 0) {
+    candidates.push({ version: remoteVersion });
+  }
+  for (const candidate of candidates) {
+    if (latest && compareVersions(latest.match(PACKAGE_PATTERN)[1], candidate.version) >= 0) break;
+    const name = `admob-nextgen-${candidate.version}`;
+    const temporaryRoot = path.join(projectRoot, 'agent-temp', 'admob-package-sync');
+    fs.mkdirSync(temporaryRoot, { recursive: true });
+    const staging = fs.mkdtempSync(path.join(temporaryRoot, 'package-'));
+    try {
+      const buffer = await fetch(SERVER + name + '.zip');
+      extractPackage(buffer, staging, name, options.AdmZip);
+      const destination = path.join(adsDirectory, name);
+      if (fs.existsSync(destination)) throw new Error(`Incomplete AdMob package already exists: ${destination}`);
+      fs.renameSync(staging, destination);
+      latest = name;
+      log(`AdMob: installed ${name}.`);
+    } catch (error) {
+      log(`AdMob: could not install ${name}: ${error.message}`);
+    } finally {
+      fs.rmSync(staging, { recursive: true, force: true });
+    }
+  }
+  if (!latest) throw new Error('No complete AdMob folder package is available. Check admob-nextgen in the live versions.json and its ZIP on htmlcodeplay.com; existing files were preserved.');
+  syncPackageDependencies(projectRoot, latest);
+  const changed = syncImports(projectRoot, latest);
+  // Remove only this plugin's superseded files after the new imports are in place.
+  for (const entry of fs.readdirSync(adsDirectory, { withFileTypes: true })) {
+    if (entry.isFile() && /^admob-(?:emi-nextgen|app-open-state)-\d+(?:\.\d+)*\.js$/.test(entry.name)) {
+      fs.unlinkSync(path.join(adsDirectory, entry.name));
+    } else if (entry.isDirectory() && PACKAGE_PATTERN.test(entry.name) && entry.name !== latest) {
+      fs.rmSync(path.join(adsDirectory, entry.name), { recursive: true });
+    }
+  }
+  log(`AdMob: ${latest} ready; migrated ${changed.length} file(s).`);
+  return latest;
+}
+
+module.exports = { syncAdmobNextgen, syncImports, findLatestPackage, compareVersions, extractPackage };
+
+if (require.main === module) syncAdmobNextgen().catch(error => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/files/buildCodeplay/versions.json

@@ -3,7 +3,7 @@
 {"name":"backbutton","pattern":"backbutton-(\\d+\\.\\d+)\\.js$","minVersion":"2.1","baseDir":"js","mandatoryUpdate":true},
 {"name":"common-js","pattern":"common-(\\d+\\.\\d+)(?:-beta-(\\d+))?\\.js$","minVersion":"6.7","baseDir":"js","mandatoryUpdate":true},
 
-{"name":"admob-emi-nextgen","pattern":"Ads[\\\\/]admob-emi-nextgen-(\\d+\\.\\d+)\\.js$","minVersion":"2.5","baseDir":"js","mandatoryUpdate":true},
+{"name":"admob-nextgen","pattern":"admob-nextgen-(\\d+(?:\\.\\d+)*)$","minVersion":"4.0","baseDir":"js/Ads","mandatoryUpdate":true,"isFolder":true},
 {"name":"video-player","pattern":"video-player-(\\d+\\.\\d+)\\.js$","minVersion":"1.6","baseDir":"js","mandatoryUpdate":true},
 {"name":"image-cropper","pattern":"image-cropper-(\\d+\\.\\d+)\\.js$","minVersion":"1.1","baseDir":"js","mandatoryUpdate":true},
 {"name":"beautify","pattern":"beautify-(\\d+\\.\\d+)\\.js$","minVersion":"1.1","baseDir":"js","mandatoryUpdate":true},

package/files/finalrelease

@@ -103,24 +103,24 @@ function checkProductionAdmobAlias() {
     const viteConfigContent = stripJavaScriptComments(readFileSync(viteConfigPath, 'utf8'));
     const aliasPattern = /(['"])@admob\1\s*:\s*path\.resolve\(\s*__dirname\s*,\s*(['"])([^'"\r\n]+)\2\s*\)/g;
     const activeAliases = [...viteConfigContent.matchAll(aliasPattern)].map(match => match[3]);
-    const productionAliasPattern = /^\.\/src\/js\/Ads\/admob-emi-nextgen-\d+(?:\.\d+)+\.js$/;
+    const productionAliasPattern = /^\.\/src\/js\/Ads\/(?:admob-nextgen-\d+(?:\.\d+)+\/admob-emi-nextgen|admob-emi-nextgen-\d+(?:\.\d+)+)\.js$/;
 
     if (activeAliases.length === 0) {
         console.error('❌ FINAL RELEASE BLOCKED: The production @admob alias is commented out or missing in the Vite config.');
-        console.error("   Enable: '@admob': path.resolve(__dirname, './src/js/Ads/admob-emi-nextgen-x.x.js')");
+        console.error("   Enable: '@admob': path.resolve(__dirname, './src/js/Ads/admob-nextgen-x.x/admob-emi-nextgen.js')");
         process.exit(1);
     }
 
     if (activeAliases.length > 1) {
         console.error('❌ FINAL RELEASE BLOCKED: Multiple active @admob aliases were found in the Vite config.');
-        console.error('   Keep exactly one active production admob-emi-nextgen-x.x.js alias.');
+        console.error('   Keep exactly one active production @admob alias.');
         process.exit(1);
     }
 
     const activeAlias = activeAliases[0];
     if (!productionAliasPattern.test(activeAlias)) {
         console.error(`❌ FINAL RELEASE BLOCKED: @admob currently points to '${activeAlias}'.`);
-        console.error("   It must point to './src/js/Ads/admob-emi-nextgen-x.x.js', not a test AdMob file.");
+        console.error("   It must point to './src/js/Ads/admob-nextgen-x.x/admob-emi-nextgen.js', not a test AdMob file.");
         process.exit(1);
     }
 
@@ -464,19 +464,13 @@ const checkIsTestingInAdmob=()=>{
 const checkIsAdsDisableByReturnStatement=()=>{
     
     
-    const adsFolder = join('src', 'js', 'Ads');
-    const filePattern = /^admob-emi-nextgen-(\d+\.)+\d+\.js$/;
-    
-    // Step 1: Find the admob file
-    const files = readdirSync(adsFolder);
-    const admobFile = files.find(f => filePattern.test(f));
-    
-    if (!admobFile) {
-      console.log('❌ No Admob nextgen file found.');
-      process.exit(1);
-    }
-    
-    const filePath = join(adsFolder, admobFile);
+    // Inspect the controller selected by the validated production alias.
+    const viteFile = ['vite.config.mjs', 'vite.config.js']
+      .map(file => resolve(__dirname, file)).find(file => existsSync(file));
+    const config = stripJavaScriptComments(readFileSync(viteFile, 'utf8'));
+    const alias = config.match(/(['"])@admob\1\s*:\s*path\.resolve\(\s*__dirname\s*,\s*(['"])([^'"\r\n]+)\2\s*\)/);
+    const filePath = resolve(__dirname, alias[3]);
+    const admobFile = alias[3];
     const content = readFileSync(filePath, 'utf-8');
     
     // Step 2: Extract the adsOnDeviceReady function body

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "codeplay-common",
-  "version": "4.9.7",
+  "version": "4.9.9",
   "description": "Common build scripts and files",
   "scripts": {
 	"postinstall": "node scripts/sync-files.js",
 	"preinstall": "node scripts/uninstall.js"
   },
+  "dependencies": {
+    "adm-zip": "^0.6.1"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/merbin2012/codeplay-common.git"

package/scripts/sync-files.js

@@ -108,3 +108,11 @@ packageJson.scripts["build:storeid8"] = "vite build --mode storeid8";
 // Save changes
 fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf8");
 process.stdout.write("✅ package.json updated!\n");
+
+// Migrate AdMob packages and imports during installation, without running native builds.
+require(path.join(projectRoot, 'buildCodeplay', 'sync-admob-nextgen.js'))
+  .syncAdmobNextgen({ projectRoot, AdmZip: require('adm-zip') })
+  .catch(error => {
+    process.stderr.write('AdMob migration failed: ' + error.message + '\n');
+    process.exitCode = 1;
+  });