Implementation of svelte.dev/packages only with no package search

Author: benmccann

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

@@ -0,0 +1,26 @@
+const OFFICIAL = [
+	/^@sveltejs\//,
+	'prettier-plugin-svelte',
+	'svelte',
+	'svelte2tsx',
+	'eslint-plugin-svelte',
+	'sv',
+	'svelte-loader',
+	'rollup-plugin-svelte'
+];
+function is_official(pkg: string): boolean {
+	for (const official of OFFICIAL) {
+		if (official instanceof RegExp) {
+			if (official.test(pkg)) return true;
+			continue;
+		}
+
+		if (official === pkg) return true;
+	}
+
+	return false;
+}
+
+export const PACKAGES_META = {
+	is_official
+};

apps/svelte.dev/src/lib/server/content.ts

@@ -1,4 +1,5 @@
 import { read } from '$app/server';
+import { PACKAGES_META } from '$lib/packages-meta';
 import type { Document, DocumentSummary } from '@sveltejs/site-kit';
 import { create_index } from '@sveltejs/site-kit/server/content';
 
@@ -17,6 +18,15 @@ const assets = import.meta.glob<string>(
 	}
 );
 
+const registry_docs = import.meta.glob<string>(
+	'../../../src/lib/server/generated/registry/*.json',
+	{
+		eager: true,
+		query: '?raw',
+		import: 'default'
+	}
+);
+
 // https://github.com/vitejs/vite/issues/17453
 export const index = await create_index(documents, assets, '../../../content', read);
 
@@ -142,3 +152,332 @@ export function create_summary(document: Document): DocumentSummary {
 export const docs = create_docs();
 
 export const examples = index.examples.children;
+
+/**
+ * Represents a Svelte package in the registry
+ */
+export interface Package {
+	/** Package name */
+	name: string;
+
+	version: string;
+
+	/** Package description (HTML formatted) */
+	description?: string;
+
+	/** Repository URL (typically GitHub) */
+	repo_url?: string;
+
+	/** Author username */
+	authors?: string[];
+
+	/** Homepage URL */
+	homepage?: string;
+
+	/** Weekly download count */
+	downloads?: number;
+
+	/** Last update timestamp */
+	updated: string;
+
+	/** Number of GitHub stars */
+	github_stars?: number;
+
+	outdated?: boolean;
+
+	deprecated?: boolean;
+
+	svelte: {
+		3: boolean;
+		4: boolean;
+		5: boolean;
+	};
+
+	/** @deprecated DO NOT USE ON FRONTEND */
+	svelte_range?: string;
+	/** @deprecated DO NOT USE ON FRONTEND */
+	kit_range?: string;
+	/** @deprecated DO NOT USE ON FRONTEND */
+	last_rune_check_version?: string;
+
+	runes: boolean;
+
+	/** Tags for categorizing the package */
+	tags: string[];
+
+	official?: boolean;
+
+	typescript: boolean;
+}
+
+/**
+ * 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;
+}
+
+function create_registry() {
+	let output: Package[] = [];
+
+	for (const frontmatter of Object.values(registry_docs)) {
+		const json = JSON.parse(frontmatter);
+		json.description = json.description;
+		json.outdated = +new Date() - +new Date(json.updated) > 2 * 365 * 24 * 60 * 60 * 1000;
+		json.official = json.official ?? PACKAGES_META.is_official(json.name);
+		json.ts_support = json.typescript?.types_source;
+		json.svelte = supports_svelte_versions(json.svelte_range);
+
+		output.push(json as unknown as Package);
+	}
+
+	return output;
+}
+
+export const registry = create_registry();

apps/svelte.dev/src/lib/server/generated/registry/ai-sdk-svelte.json

@@ -0,0 +1,16 @@
+{
+	"name": "@ai-sdk/svelte",
+	"description": "Provide Svelte UI components for AI SDK.",
+	"repo_url": "https://github.com/vercel/ai",
+	"authors": ["jaredpalmer", "vercel-release-bot"],
+	"homepage": "https://sdk.vercel.ai/docs",
+	"downloads": 343180,
+	"updated": "2025-04-14T07:12:31.855Z",
+	"tags": ["ui"],
+	"runes": true,
+	"github_stars": 13390,
+	"typescript": true,
+	"version": "2.1.9",
+	"svelte_range": "^5.0.0",
+	"last_rune_check_version": "2.1.9"
+}