moving things around for stats & better understanding

Author: jycouet

apps/svelte.dev/scripts/sync-packages/index.ts

@@ -1,4 +1,5 @@
 import { PACKAGES_META } from '../../src/lib/packages-meta';
+import type { PackageKey, PackageNpm, PackageGithub } from '../../src/lib/server/content';
 import { execSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -15,7 +16,9 @@ let logsAtTheEnd: {
 		| 'low_downloads'
 		| 'low_github_stars'
 		| 'new_json_file'
-		| 'deleted_unused_json_file';
+		| 'deleted_unused_json_file'
+		| 'outdated'
+		| 'deprecated';
 	pkg: string;
 	extra: string;
 }[] = [];
@@ -92,7 +95,9 @@ function theEnd(val: number) {
 			low_downloads: 'Low Downloads',
 			low_github_stars: 'Low Stars',
 			new_json_file: 'NEW JSON',
-			deleted_unused_json_file: 'DEL JSON'
+			deleted_unused_json_file: 'DEL JSON',
+			outdated: 'Outdated',
+			deprecated: 'Deprecated'
 		};
 		console.log(
 			`  - ${logsAtTheEnd.map((l) => `${typePrints[l.type].padEnd(15)} | ${l.pkg.padEnd(35)} | ${l.extra}`).join('\n  - ')}`
@@ -101,13 +106,15 @@ function theEnd(val: number) {
 	process.exit(val);
 }
 
-async function fetchData(pkg: string) {
+async function fetchData(pkg: string): Promise<PackageKey & PackageNpm & PackageGithub> {
 	const [npmInfo, npmDlInfo] = await Promise.all([
 		fetch(`https://registry.npmjs.org/${pkg}`).then((r) => r.json()),
 		fetch(`https://api.npmjs.org/downloads/point/last-week/${pkg}`).then((r) => r.json())
 	]);
 	// delete npmInfo.readme;
 	// delete npmInfo.versions;
+	// console.log(`npmInfo`, npmInfo);
+
 	const description = npmInfo.description;
 	const raw_repo_url = npmInfo.repository?.url ?? '';
 	const repo_url = raw_repo_url?.replace(/^git\+/, '').replace(/\.git$/, '');
@@ -123,6 +130,7 @@ async function fetchData(pkg: string) {
 	const downloads = npmDlInfo.downloads;
 	const version = npmInfo['dist-tags'].latest;
 	const updated = npmInfo.time[version];
+	const deprecated_reason = npmInfo.versions[version].deprecated;
 
 	let github_stars: number | undefined = undefined;
 	if (git_org && git_repo && !skipGithubStars) {
@@ -143,8 +151,9 @@ async function fetchData(pkg: string) {
 		repo_url,
 		authors,
 		homepage,
-		downloads,
 		version,
+		deprecated_reason,
+		downloads,
 		updated,
 		// runes: false,
 		github_stars
@@ -187,6 +196,14 @@ async function refreshJson(fullPath: string) {
 		});
 	}
 
+	if (data.updated && PACKAGES_META.is_outdated(data.updated)) {
+		logsAtTheEnd.push({ type: 'outdated', pkg: data.name, extra: `${data.updated}` });
+	}
+
+	if (data.deprecated_reason) {
+		logsAtTheEnd.push({ type: 'deprecated', pkg: data.name, extra: `${data.deprecated_reason}` });
+	}
+
 	writeButPretty(fullPath, JSON.stringify(data, null, 2));
 }
 

apps/svelte.dev/src/lib/packages-meta.ts

@@ -253,8 +253,268 @@ function is_official(pkg: string): boolean {
 	return false;
 }
 
+function is_outdated(iso: string): boolean {
+	// 2 years
+	return +new Date() - +new Date(iso) > 2 * 365 * 24 * 60 * 60 * 1000;
+}
+
+/**
+ * Checks if a semver range supports Svelte versions 3.x, 4.x, and 5.x
+ */
+function supports_svelte_versions(version_range: string): {
+	3: boolean;
+	4: boolean;
+	5: boolean;
+} {
+	if (!version_range) return { 3: false, 4: false, 5: false };
+
+	// Initialize result object
+	const result = { 3: false, 4: false, 5: false };
+
+	// Handle version range with OR operators first before any other processing
+	if (version_range.includes('||')) {
+		const ranges = version_range.split('||').map((r) => r.trim());
+
+		// Check each range and combine results with OR logic
+		for (const range of ranges) {
+			const range_result = supports_svelte_versions(range);
+			result[3] = result[3] || range_result[3];
+			result[4] = result[4] || range_result[4];
+			result[5] = result[5] || range_result[5];
+		}
+
+		return result;
+	}
+
+	// Handle exact version with equals sign
+	if (version_range.startsWith('=')) {
+		const exact_version = version_range.substring(1);
+		return supports_svelte_versions(exact_version);
+	}
+
+	// Handle hyphen ranges directly (not part of a complex expression)
+	if (version_range.includes(' - ')) {
+		// Split by hyphen and trim whitespace
+		const parts = version_range.split('-').map((p) => p.trim());
+		// Handle "x - y" format correctly
+		if (parts.length === 2) {
+			const start = parseFloat(parts[0]);
+			const end = parseFloat(parts[1]);
+
+			result[3] = start <= 3 && end >= 3;
+			result[4] = start <= 4 && end >= 4;
+			result[5] = start <= 5 && end >= 5;
+
+			return result;
+		}
+	}
+
+	// Handle complex version ranges with both upper and lower bounds in the same expression
+	// Examples: ">=1.0.0 <=4.9.9", ">=3.0.0 <6.0.0", ">3.0.0-rc.1 <3.1.0"
+	if (
+		version_range.includes(' ') &&
+		(version_range.includes('<') ||
+			version_range.includes('<=') ||
+			version_range.includes('>=') ||
+			version_range.includes('>'))
+	) {
+		// Process for complex range with multiple constraints
+		let includes_version_3 = true;
+		let includes_version_4 = true;
+		let includes_version_5 = true;
+
+		// Split by spaces to get individual constraints
+		const constraints = version_range
+			.split(' ')
+			.filter(
+				(c) => c.startsWith('<') || c.startsWith('<=') || c.startsWith('>') || c.startsWith('>=')
+			);
+
+		// If we couldn't parse any valid constraints, return false
+		if (constraints.length === 0) {
+			return { 3: false, 4: false, 5: false };
+		}
+
+		// Special case handling for pre-release specific ranges (e.g., ">3.0.0-rc.1 <3.1.0")
+		if (constraints.some((c) => c.includes('-'))) {
+			// Identify if this is a narrow range for a specific major version
+			let major_version = null;
+
+			for (const constraint of constraints) {
+				const match = constraint.match(/[<>=]+\s*(\d+)/);
+				if (match) {
+					const version = parseInt(match[1]);
+					if (major_version === null) {
+						major_version = version;
+					} else if (major_version !== version) {
+						major_version = null; // Different major versions, not a narrow range
+						break;
+					}
+				}
+			}
+
+			// If we identified a specific major version for this pre-release constraint
+			if (major_version !== null) {
+				result[3] = major_version === 3;
+				result[4] = major_version === 4;
+				result[5] = major_version === 5;
+				return result;
+			}
+		}
+
+		for (const constraint of constraints) {
+			if (constraint.startsWith('>=')) {
+				const version_number = parseFloat(constraint.substring(2));
+				// Check lower bounds for each version
+				if (version_number > 3) includes_version_3 = false;
+				if (version_number > 4) includes_version_4 = false;
+				if (version_number > 5) includes_version_5 = false;
+			} else if (constraint.startsWith('>')) {
+				const version_number = parseFloat(constraint.substring(1));
+				// Check lower bounds for each version
+				if (version_number >= 3) includes_version_3 = false;
+				if (version_number >= 4) includes_version_4 = false;
+				if (version_number >= 5) includes_version_5 = false;
+			} else if (constraint.startsWith('<=')) {
+				const version_number = parseFloat(constraint.substring(2));
+				// Check upper bounds for each version
+				if (version_number < 3) includes_version_3 = false;
+				if (version_number < 4) includes_version_4 = false;
+				if (version_number < 5) includes_version_5 = false;
+			} else if (constraint.startsWith('<')) {
+				const version_number = parseFloat(constraint.substring(1));
+				// Check upper bounds for each version
+				if (version_number <= 3) includes_version_3 = false;
+				if (version_number <= 4) includes_version_4 = false;
+				if (version_number <= 5) includes_version_5 = false;
+			}
+		}
+
+		result[3] = includes_version_3;
+		result[4] = includes_version_4;
+		result[5] = includes_version_5;
+
+		return result;
+	}
+
+	// Handle exact major version format
+	if (/^[0-9]+$/.test(version_range)) {
+		const version = parseInt(version_range);
+		result[3] = version === 3;
+		result[4] = version === 4;
+		result[5] = version === 5;
+		return result;
+	}
+
+	// Handle caret ranges
+	if (version_range.startsWith('^')) {
+		const major_version = parseInt(version_range.substring(1).split('.')[0]);
+		result[3] = major_version === 3;
+		result[4] = major_version === 4;
+		result[5] = major_version === 5;
+		return result;
+	}
+
+	// Handle pre-release versions directly (e.g., 5.0.0-next.42)
+	if (/^([0-9]+)\.([0-9]+)\.([0-9]+)-/.test(version_range)) {
+		const match = version_range.match(/^([0-9]+)\./);
+		if (match) {
+			// Extract major version from the pre-release
+			const major_version = parseInt(match[1]);
+			result[3] = major_version === 3;
+			result[4] = major_version === 4;
+			result[5] = major_version === 5;
+			return result;
+		}
+	}
+
+	// Handle tilde ranges
+	if (version_range.startsWith('~')) {
+		const major_version = parseInt(version_range.substring(1).split('.')[0]);
+		result[3] = major_version === 3;
+		result[4] = major_version === 4;
+		result[5] = major_version === 5;
+		return result;
+	}
+
+	// Handle wildcard (*) by itself, which means any version
+	if (version_range === '*') {
+		return { 3: true, 4: true, 5: true };
+	}
+
+	// Handle * and x ranges (e.g., "3.x", "4.*")
+	if (/^([0-9]+)\.(x|\*)/.test(version_range)) {
+		const match = version_range.match(/^([0-9]+)\./);
+		if (match) {
+			const major_version = parseInt(match[1]);
+			result[3] = major_version === 3;
+			result[4] = major_version === 4;
+			result[5] = major_version === 5;
+			return result;
+		}
+	}
+
+	// Handle >= ranges
+	if (version_range.startsWith('>=')) {
+		const version_number = parseFloat(version_range.substring(2));
+		result[3] = version_number <= 3;
+		result[4] = version_number <= 4;
+		result[5] = version_number <= 5;
+		return result;
+	}
+
+	// Handle > ranges
+	if (version_range.startsWith('>')) {
+		const version_number = parseFloat(version_range.substring(1));
+		result[3] = version_number < 3;
+		result[4] = version_number < 4;
+		result[5] = version_number < 5;
+		return result;
+	}
+
+	// Handle <= ranges
+	if (version_range.startsWith('<=')) {
+		const version_number = parseFloat(version_range.substring(2));
+		result[3] = version_number >= 3;
+		result[4] = version_number >= 4;
+		result[5] = version_number >= 5;
+		return result;
+	}
+
+	// Handle < ranges
+	if (version_range.startsWith('<')) {
+		const version_number = parseFloat(version_range.substring(1));
+		result[3] = version_number > 3;
+		result[4] = version_number > 4;
+		result[5] = version_number > 5;
+		return result;
+	}
+
+	// Handle exact versions (like 3.0.0, 4.1.2, etc.)
+	if (/^[0-9]+\.[0-9]+\.[0-9]+$/.test(version_range)) {
+		const major_version = parseInt(version_range.split('.')[0]);
+		result[3] = major_version === 3;
+		result[4] = major_version === 4;
+		result[5] = major_version === 5;
+		return result;
+	}
+
+	// Handle x-ranges (3.x.x, 4.x, etc.)
+	if (version_range.includes('.x') || version_range.includes('.*')) {
+		const major_version = parseInt(version_range.split('.')[0]);
+		result[3] = major_version === 3;
+		result[4] = major_version === 4;
+		result[5] = major_version === 5;
+		return result;
+	}
+
+	return result;
+}
+
 export const PACKAGES_META = {
 	is_official,
+	is_outdated,
+	supports_svelte_versions,
 	FEATURED,
 	SV_ADD,
 	SV_ADD_CMD