chore: improve publish scripts

MartianGreed · MartianGreed · commit 2ac7b98d4c20 · 2025-08-14T11:06:15.000+02:00
diff --git a/biome.json b/biome.json
@@ -6,6 +6,7 @@
         "includes": [
             "packages/**/*.{ts,tsx,js,jsx,mjs,cjs,json}",
             "examples/**/*.{ts,tsx,js,jsx,mjs,cjs,json}",
+            "scripts/**/*.{ts,tsx}",
             "*.{ts,tsx,js,jsx,mjs,cjs,json}",
             "!**/*/target/**",
             "!**/*/dist/**",
diff --git a/scripts/prepare-publish.ts b/scripts/prepare-publish.ts
@@ -1,10 +1,10 @@
 #!/usr/bin/env bun
 
-import fs from 'fs';
-import path from 'path';
+import fs from "fs";
+import path from "path";
 
-const rootDir = path.resolve(import.meta.dir, '..');
-const BACKUP_DIR = path.join(rootDir, '.package-backups');
+const rootDir = path.resolve(import.meta.dir, "..");
+const BACKUP_DIR = path.join(rootDir, ".package-backups");
 
 interface PackageJson {
     name: string;
@@ -28,139 +28,182 @@ interface RootPackageJson extends PackageJson {
 }
 
 function readJSON<T = any>(filePath: string): T {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
 }
 
 function writeJSON(filePath: string, data: any): void {
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 4) + '\n');
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 4) + "\n");
 }
 
 function getWorkspacePackages(): Map<string, WorkspacePackageInfo> {
     const packages = new Map<string, WorkspacePackageInfo>();
-    const packagesDir = path.join(rootDir, 'packages');
-    
-    const dirs = fs.readdirSync(packagesDir)
-        .filter(dir => fs.statSync(path.join(packagesDir, dir)).isDirectory());
-    
+    const packagesDir = path.join(rootDir, "packages");
+
+    const dirs = fs
+        .readdirSync(packagesDir)
+        .filter((dir) =>
+            fs.statSync(path.join(packagesDir, dir)).isDirectory()
+        );
+
     for (const dir of dirs) {
-        const pkgPath = path.join(packagesDir, dir, 'package.json');
+        const pkgPath = path.join(packagesDir, dir, "package.json");
         if (fs.existsSync(pkgPath)) {
             const pkg = readJSON<PackageJson>(pkgPath);
             packages.set(pkg.name, {
                 version: pkg.version,
-                path: pkgPath
+                path: pkgPath,
             });
         }
     }
-    
+
     return packages;
 }
 
 function getCatalogVersions(): Record<string, string> {
-    const rootPkg = readJSON<RootPackageJson>(path.join(rootDir, 'package.json'));
+    const rootPkg = readJSON<RootPackageJson>(
+        path.join(rootDir, "package.json")
+    );
     return rootPkg.workspaces?.catalog || {};
 }
 
-function resolveWorkspaceVersion(depName: string, workspacePackages: Map<string, WorkspacePackageInfo>): string | null {
+function resolveWorkspaceVersion(
+    depName: string,
+    workspacePackages: Map<string, WorkspacePackageInfo>
+): string | null {
     const pkg = workspacePackages.get(depName);
     return pkg ? pkg.version : null;
 }
 
-function resolveCatalogVersion(depName: string, catalogVersions: Record<string, string>): string | null {
+function resolveCatalogVersion(
+    depName: string,
+    catalogVersions: Record<string, string>
+): string | null {
     return catalogVersions[depName] || null;
 }
 
 function backupPackageJson(filePath: string): void {
     if (!fs.existsSync(BACKUP_DIR)) {
         fs.mkdirSync(BACKUP_DIR, { recursive: true });
     }
-    
+
     const relativePath = path.relative(rootDir, filePath);
     const backupPath = path.join(BACKUP_DIR, relativePath);
     const backupDir = path.dirname(backupPath);
-    
+
     if (!fs.existsSync(backupDir)) {
         fs.mkdirSync(backupDir, { recursive: true });
     }
-    
+
     fs.copyFileSync(filePath, backupPath);
 }
+function handleDependency<T>(
+    type: string,
+    deps: Record<string, string>,
+    name: string,
+    version: string,
+    catalogVersions: T,
+    resolverFn: (name: string, version: T) => string | null
+): { modified: boolean; deps: Record<string, string> } {
+    if (version !== type) {
+        return { modified: false, deps };
+    }
+    const resolvedVersion = resolverFn(name, catalogVersions);
+    if (!resolvedVersion) {
+        console.warn(`  ! Could not resolve ${type} version for ${name}`);
+        return { modified: false, deps };
+    }
+    deps[name] = resolvedVersion;
+    console.log(`  ✓ Resolved ${name}: ${type} → ${resolvedVersion}`);
+    return { modified: true, deps };
+}
 
 function processPackageJson(
-    pkgPath: string, 
-    workspacePackages: Map<string, WorkspacePackageInfo>, 
+    pkgPath: string,
+    workspacePackages: Map<string, WorkspacePackageInfo>,
     catalogVersions: Record<string, string>
 ): boolean {
     const pkg = readJSON<PackageJson>(pkgPath);
     let modified = false;
-    
+
     backupPackageJson(pkgPath);
-    
+
     const processDeps = (deps?: Record<string, string>) => {
         if (!deps) return;
-        
+
         for (const [name, version] of Object.entries(deps)) {
-            if (version === 'workspace:*') {
-                const resolvedVersion = resolveWorkspaceVersion(name, workspacePackages);
-                if (resolvedVersion) {
-                    deps[name] = `^${resolvedVersion}`;
-                    modified = true;
-                    console.log(`  ✓ Resolved ${name}: workspace:* → ^${resolvedVersion}`);
-                } else {
-                    console.warn(`  ⚠ Could not resolve workspace version for ${name}`);
-                }
-            } else if (version === 'catalog:') {
-                const resolvedVersion = resolveCatalogVersion(name, catalogVersions);
-                if (resolvedVersion) {
-                    deps[name] = resolvedVersion;
-                    modified = true;
-                    console.log(`  ✓ Resolved ${name}: catalog: → ${resolvedVersion}`);
-                } else {
-                    console.warn(`  ⚠ Could not resolve catalog version for ${name}`);
-                }
+            const workspaceDep = handleDependency(
+                "workspace:*",
+                deps!,
+                name,
+                version,
+                workspacePackages,
+                resolveWorkspaceVersion
+            );
+            deps = workspaceDep.deps;
+            if (workspaceDep.modified) {
+                modified = true;
+                continue;
+            }
+            const catalogDep = handleDependency(
+                "catalog:",
+                deps!,
+                name,
+                version,
+                catalogVersions,
+                resolveCatalogVersion
+            );
+            deps = catalogDep.deps;
+            if (catalogDep.modified) {
+                modified = true;
+                continue;
             }
         }
     };
-    
+
     processDeps(pkg.dependencies);
     processDeps(pkg.devDependencies);
     processDeps(pkg.peerDependencies);
     processDeps(pkg.optionalDependencies);
-    
+
     if (modified) {
         writeJSON(pkgPath, pkg);
         console.log(`  ✅ Updated ${path.relative(rootDir, pkgPath)}`);
     }
-    
+
     return modified;
 }
 
 function main(): void {
-    console.log('🔧 Preparing packages for publishing...\n');
-    
+    console.log("🔧 Preparing packages for publishing...\n");
+
     const workspacePackages = getWorkspacePackages();
     const catalogVersions = getCatalogVersions();
-    
+
     console.log(`📦 Found ${workspacePackages.size} workspace packages`);
-    console.log(`📚 Found ${Object.keys(catalogVersions).length} catalog entries\n`);
-    
+    console.log(
+        `📚 Found ${Object.keys(catalogVersions).length} catalog entries\n`
+    );
+
     let packagesModified = 0;
-    
+
     for (const [name, info] of workspacePackages) {
         console.log(`Processing ${name}...`);
         if (processPackageJson(info.path, workspacePackages, catalogVersions)) {
             packagesModified++;
         }
-        console.log('');
+        console.log("");
     }
-    
+
     console.log(`✅ Prepared ${packagesModified} packages for publishing`);
     console.log(`📁 Backups saved to ${path.relative(rootDir, BACKUP_DIR)}`);
 }
 
 try {
     main();
 } catch (error) {
-    console.error('❌ Error preparing packages:', error instanceof Error ? error.message : error);
+    console.error(
+        "❌ Error preparing packages:",
+        error instanceof Error ? error.message : error
+    );
     process.exit(1);
-}
+}
diff --git a/scripts/restore-packages.ts b/scripts/restore-packages.ts
@@ -1,33 +1,36 @@
 #!/usr/bin/env bun
 
-import fs from 'fs';
-import path from 'path';
+import fs from "fs";
+import path from "path";
 
-const rootDir = path.resolve(import.meta.dir, '..');
-const BACKUP_DIR = path.join(rootDir, '.package-backups');
+const rootDir = path.resolve(import.meta.dir, "..");
+const BACKUP_DIR = path.join(rootDir, ".package-backups");
 
 function restorePackages(): void {
     if (!fs.existsSync(BACKUP_DIR)) {
-        console.log('ℹ️  No backup directory found. Nothing to restore.');
+        console.log("i  No backup directory found. Nothing to restore.");
         return;
     }
-    
-    console.log('🔄 Restoring original package.json files...\n');
-    
+
+    console.log("🔄 Restoring original package.json files...\n");
+
     let restoredCount = 0;
-    
-    function restoreFiles(dir: string, baseBackupPath: string = BACKUP_DIR): void {
+
+    function restoreFiles(
+        dir: string,
+        baseBackupPath: string = BACKUP_DIR
+    ): void {
         const entries = fs.readdirSync(dir, { withFileTypes: true });
-        
+
         for (const entry of entries) {
             const backupPath = path.join(dir, entry.name);
-            
+
             if (entry.isDirectory()) {
                 restoreFiles(backupPath, baseBackupPath);
-            } else if (entry.name === 'package.json') {
+            } else if (entry.name === "package.json") {
                 const relativePath = path.relative(baseBackupPath, backupPath);
                 const originalPath = path.join(rootDir, relativePath);
-                
+
                 if (fs.existsSync(originalPath)) {
                     fs.copyFileSync(backupPath, originalPath);
                     console.log(`  ✓ Restored ${relativePath}`);
@@ -36,35 +39,39 @@ function restorePackages(): void {
             }
         }
     }
-    
+
     restoreFiles(BACKUP_DIR);
-    
+
     console.log(`\n✅ Restored ${restoredCount} package.json files`);
 }
 
 function cleanupBackups(): void {
-    if (fs.existsSync(BACKUP_DIR)) {
-        fs.rmSync(BACKUP_DIR, { recursive: true, force: true });
-        console.log(`🧹 Cleaned up backup directory`);
+    if (!fs.existsSync(BACKUP_DIR)) {
+        return;
     }
+    fs.rmSync(BACKUP_DIR, { recursive: true, force: true });
+    console.log(`🧹 Cleaned up backup directory`);
 }
 
 function main(): void {
     const args = process.argv.slice(2);
-    const shouldCleanup = args.includes('--cleanup');
-    
+    const shouldCleanup = args.includes("--cleanup");
+
     try {
         restorePackages();
-        
-        if (shouldCleanup) {
-            cleanupBackups();
-        } else {
-            console.log('\nℹ️  Run with --cleanup flag to remove backup directory');
+        if (!shouldCleanup) {
+            console.log(
+                "\n  Run with --cleanup flag to remove backup directory"
+            );
         }
+        cleanupBackups();
     } catch (error) {
-        console.error('❌ Error restoring packages:', error instanceof Error ? error.message : error);
+        console.error(
+            "❌ Error restoring packages:",
+            error instanceof Error ? error.message : error
+        );
         process.exit(1);
     }
 }
 
-main();
+main();
