@penskemediacorp/larva 1.74.0 → 1.75.1

package/bin/install-hooks.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+/**
+ * Git Hooks Installation Script
+ *
+ * Copies pre-push hook from larva package to .git/hooks/ for all team members.
+ * Runs automatically via npm postinstall script.
+ *
+ * Source: node_modules/@penskemediacorp/larva/bin/pre-push
+ * Target: root/.git/hooks/pre-push (local, not tracked)
+ */
+
+const fs = require( 'fs' );
+const path = require( 'path' );
+const { execSync } = require( 'child_process' );
+
+const colors = {
+	reset: '\x1b[0m',
+	green: '\x1b[32m',
+	yellow: '\x1b[33m',
+	cyan: '\x1b[36m',
+};
+
+function log( message, color = 'reset' ) {
+	console.log( `${ colors[ color ] }${ message }${ colors.reset }` );
+}
+
+function findGitRoot() {
+	// Try multiple strategies to find the correct git root
+
+	// Strategy 1: Check if INIT_CWD is set (npm sets this to original directory)
+	if ( process.env.INIT_CWD ) {
+		try {
+			const gitRoot = execSync( 'git rev-parse --show-toplevel', {
+				encoding: 'utf8',
+				cwd: process.env.INIT_CWD,
+			} ).trim();
+			return gitRoot;
+		} catch ( e ) {
+			// Fall through to next strategy
+		}
+	}
+
+	// Strategy 2: Walk up from node_modules to find .git
+	let currentDir = __dirname;
+	while ( currentDir !== path.parse( currentDir ).root ) {
+		// Go up until we find node_modules
+		if ( currentDir.includes( 'node_modules' ) ) {
+			// Go up from node_modules/@penskemediacorp/larva to the project root
+			const parts = currentDir.split( path.sep );
+			const nodeModulesIndex = parts.lastIndexOf( 'node_modules' );
+			if ( nodeModulesIndex > 0 ) {
+				const projectRoot = parts.slice( 0, nodeModulesIndex ).join( path.sep );
+				const gitDir = path.join( projectRoot, '.git' );
+				if ( fs.existsSync( gitDir ) ) {
+					return projectRoot;
+				}
+			}
+		}
+
+		currentDir = path.dirname( currentDir );
+	}
+
+	// Strategy 3: Use current working directory as fallback
+	try {
+		return execSync( 'git rev-parse --show-toplevel', {
+			encoding: 'utf8',
+			cwd: process.cwd(),
+		} ).trim();
+	} catch ( e ) {
+		throw new Error( 'Could not find git repository' );
+	}
+}
+
+function installHooks() {
+	try {
+		// Find the correct git root
+		const gitRoot = findGitRoot();
+
+		// Source hook is in bin folder (same directory as this script)
+		const sourceHookPath = path.join( __dirname, 'pre-push' );
+		const targetHookPath = path.join( gitRoot, '.git', 'hooks', 'pre-push' );
+
+		if (!fs.existsSync(sourceHookPath)) {
+			log( '⚠️  Larva pre-push hook not found', 'yellow' );
+			log( `Looking in: ${ sourceHookPath }`, 'yellow' );
+			return false;
+		}
+
+		// Create .git/hooks directory if needed
+		const hooksDir = path.dirname( targetHookPath );
+		if ( ! fs.existsSync( hooksDir ) ) {
+			fs.mkdirSync( hooksDir, { recursive: true } );
+		}
+
+		// Copy the hook
+		fs.copyFileSync( sourceHookPath, targetHookPath );
+
+		// Make executable
+		if ( process.platform !== 'win32' ) {
+			fs.chmodSync( targetHookPath, '755' );
+		}
+
+		log( '✓ Larva pre-push hook installed successfully!', 'green' );
+		log( `  Git root: ${ gitRoot }`, 'cyan' );
+		log( `  Source: ${ sourceHookPath }`, 'cyan' );
+		log( `  Target: ${ targetHookPath }`, 'cyan' );
+		return true;
+	} catch ( error ) {
+		log( `⚠️  Could not install Larva hook: ${ error.message }`, 'yellow' );
+		return false;
+	}
+}
+
+// Run if called directly
+if ( require.main === module ) {
+	log( '\n📦 Installing Larva Git hooks...', 'cyan' );
+	installHooks();
+	log( '' );
+}
+
+module.exports = { installHooks };

package/bin/pre-push

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-Push Git Hook - Larva Version Checker
+ *
+ * Automatically checks if @penskemediacorp/larva is up-to-date before allowing git push.
+ * Blocks push if update is available, unless --force flag is used.
+ *
+ * Installation: Auto-installed via npm postinstall script
+ * Override: Use --force, -f, or --no-verify flags
+ */
+
+const { execSync } = require( 'child_process' );
+const fs = require( 'fs' );
+const path = require( 'path' );
+const os = require( 'os' );
+
+// Cache configuration
+const CACHE_FILE = path.join(os.tmpdir(), 'larva-version-cache.json');
+const CACHE_DURATION = 1000 * 60 * 60 * 24; // 1 Day.
+
+// ANSI color codes
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  bold: '\x1b[1m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function getCurrentLarvaVersion() {
+  try {
+	// Get git root directory
+	const gitRoot = execSync('git rev-parse --show-toplevel', {
+	  encoding: 'utf8'
+	}).trim();
+
+	// Look for package.json in assets folder
+	const packageJsonPath = path.join(gitRoot, 'assets', 'package.json');
+
+	if (!fs.existsSync(packageJsonPath)) {
+	  return null;
+	}
+
+	const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+	const larvaVersion = packageJson.dependencies?.['@penskemediacorp/larva'] ||
+						packageJson.devDependencies?.['@penskemediacorp/larva'];
+
+	if (!larvaVersion) {
+	  return null;
+	}
+
+	// Remove all semver operators and pre-release tags
+	return larvaVersion.replace(/^[\^~>=<]+/, '').split('-')[0].split('+')[0];
+  } catch (error) {
+	log(`Error reading package.json: ${error.message}`, 'red');
+	return null;
+  }
+}
+
+function getLatestLarvaVersion() {
+
+	// Check cache first
+	if ( fs.existsSync( CACHE_FILE ) ) {
+		try {
+			const cache = JSON.parse( fs.readFileSync( CACHE_FILE, 'utf8' ) );
+			const now = Date.now();
+
+			// Return cached version if still valid
+			if ( cache.timestamp && cache.version && ( now - cache.timestamp ) < CACHE_DURATION ) {
+				return cache.version;
+			}
+		} catch ( error ) {
+			// Invalid cache file, continue to fetch
+		}
+	}
+
+  try {
+	const result = execSync('npm view @penskemediacorp/larva version', {
+	  encoding: 'utf8',
+	  stdio: ['pipe', 'pipe', 'pipe'],
+	  timeout: 5000  // 5 second timeout
+	});
+
+	const version = result.trim();
+
+	// Save to cache
+	try {
+		fs.writeFileSync( CACHE_FILE, JSON.stringify( {
+		version: version,
+		timestamp: Date.now()
+		} ), 'utf8' );
+	} catch ( error ) {
+		// Cache write failure is non-critical, ignore
+	}
+
+	return version;
+  } catch (error) {
+	// Check if it's a timeout error.
+	if ( error.killed ) {
+		log( 'Warning: npm registry request timed out', 'yellow' );
+	} else {
+		log( 'Warning: Could not fetch latest @penskemediacorp/larva version from npm', 'yellow' );
+	}
+	return null;
+  }
+}
+
+function compareVersions(current, latest) {
+  const currentParts = current.split('.').map(Number);
+  const latestParts = latest.split('.').map(Number);
+
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+	const curr = currentParts[i] || 0;
+	const lat = latestParts[i] || 0;
+
+	if (lat > curr) return 1;  // Update available
+	if (lat < curr) return -1; // Current is newer
+  }
+
+  return 0; // Same version
+}
+
+function checkForceFlag() {
+	const args = process.argv.slice(2);
+	if (args.includes('--force') || args.includes('-f')) {
+		return true;
+	}
+
+	try {
+		let psCommand;
+
+		if (process.platform === 'win32') {
+			// Try PowerShell first (works on Windows 10/11)
+			psCommand = `powershell -Command "Get-WmiObject Win32_Process -Filter \\"ProcessId=${process.ppid}\\" | Select-Object -ExpandProperty CommandLine"`;
+		} else {
+			// Unix-like systems
+			psCommand = `ps -o command= -p ${process.ppid}`;
+		}
+
+		const parentCommand = execSync(psCommand, {
+			encoding: 'utf8',
+			stdio: ['pipe', 'pipe', 'pipe'],
+			timeout: 2000 // Add timeout
+		}).trim();
+
+		if (parentCommand.includes('--force') || parentCommand.match(/\s-[a-z]*f[a-z]*\s/)) {
+			return true;
+		}
+	} catch (error) {
+		// Silently fail - parent process inspection failed
+	}
+
+	return false;
+}
+
+function main() {
+  log('\n🔍 Checking @penskemediacorp/larva version...', 'cyan');
+
+  const currentVersion = getCurrentLarvaVersion();
+
+  if (!currentVersion) {
+	log('✓ No @penskemediacorp/larva dependency found in this project', 'green');
+	process.exit(0);
+  }
+
+  log(`Current version: ${currentVersion}`, 'cyan');
+
+  const latestVersion = getLatestLarvaVersion();
+
+  if (!latestVersion) {
+	log('⚠ Could not verify latest version, proceeding with push...', 'yellow');
+	process.exit(0);
+  }
+
+  log(`Latest version: ${latestVersion}`, 'cyan');
+
+  const comparison = compareVersions(currentVersion, latestVersion);
+
+  if (comparison > 0) {
+	// Update available (latest is greater than current)
+	const forceFlag = checkForceFlag();
+
+	log('\n' + '='.repeat(60), 'yellow');
+	log('⚠️  UPDATE AVAILABLE FOR @penskemediacorp/larva', 'yellow');
+	log('='.repeat(60), 'yellow');
+	log(`Current: ${currentVersion}`, 'red');
+	log(`Latest:  ${latestVersion}`, 'green');
+	log('\nPlease update @penskemediacorp/larva before pushing:', 'yellow');
+	log('  npm install @penskemediacorp/larva@latest', 'cyan');
+	log('='.repeat(60) + '\n', 'yellow');
+
+	if (forceFlag) {
+	  log('⚠️  Force flag detected - allowing push with outdated version', 'yellow');
+	  log('Please update @penskemediacorp/larva as soon as possible!\n', 'yellow');
+	  process.exit(0);
+	} else {
+		log('❌ Push blocked. Please update @penskemediacorp/larva before pushing.\n', 'red');
+		log('To override this check:', 'yellow');
+		log('  git push --force           # Try force push', 'cyan');
+		log('  git push --no-verify       # Skip hook entirely\n', 'cyan');
+		process.exit(1);
+	}
+  } else {
+	log('✓ @penskemediacorp/larva is up to date!\n', 'green');
+	process.exit(0);
+}
+}
+
+main();