@mxpicture/build-api 0.2.18 → 0.2.20

package/dist/deps/FixWorkspaceDeps.js

@@ -1,4 +1,4 @@
-import { logInfo, logSuccess } from "../logger/Logger.js";
+import { logError, logInfo, logSuccess } from "../logger/Logger.js";
 import { DepsReplacementMode, } from "../types/types.deps.js";
 import { buildMapEntries, readPackageEntries, writePackageEntries, } from "../workspace/workspace.pkg.js";
 export const runFixDeps = async (p) => instanceFixDeps(p).run();
@@ -40,7 +40,7 @@ export class IFixWorkspaceDeps {
                 });
             }
             catch (err) {
-                console.error(`\nError processing ${consumingPkg.content.name}:`, err);
+                logError(`\nError processing ${consumingPkg.content.name}:`, err);
                 throw err;
             }
         }
@@ -86,7 +86,7 @@ export class FixWorkspaceDepsVersion extends IFixWorkspaceDeps {
             return null;
         const actualVersion = p.versionMap.get(p.pkg);
         if (!actualVersion) {
-            console.error(`  ERROR: Could not find version for workspace dependency ${p.pkg}`);
+            logError(`  ERROR: Could not find version for workspace dependency ${p.pkg}`);
             throw new Error(`Cannot resolve workspace dependency: ${p.pkg}`);
         }
         return `^${actualVersion}`;
@@ -109,7 +109,7 @@ export class FixWorkspaceDepsFile extends IFixWorkspaceDeps {
         const mapEntry = p.mapEntries.find((mapEntry) => mapEntry.fromPkg.content.name === p.consumingPkg.content.name &&
             mapEntry.toPkg.content.name === p.pkg);
         if (!mapEntry) {
-            console.error(`  ERROR: Could not find version for workspace dependency ${p.pkg}`);
+            logError(`  ERROR: Could not find version for workspace dependency ${p.pkg}`);
             throw new Error(`Cannot resolve workspace dependency: ${p.pkg}`);
         }
         return `file:${mapEntry.relPath}`;

package/dist/npmPublish/NpmPublisher.js

@@ -16,9 +16,9 @@ export class NpmPublisher {
         const results = await Promise.allSettled(packageDirs.map((d) => this.runPackage(d)));
         const failures = results.filter((r) => r.status === "rejected");
         if (failures.length > 0) {
-            console.error(`\n❌ ${failures.length} package(s) failed to publish:`);
+            logError(`\n❌ ${failures.length} package(s) failed to publish:`);
             failures.forEach((failure) => {
-                console.error(failure.reason);
+                logError(failure.reason);
             });
             process.exit(1);
         }

package/dist/pkg/UpdatePackages.d.ts

@@ -0,0 +1,19 @@
+import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
+import { PackageEntry, UpdatePackagesParams } from "../types/types.package.js";
+export declare const runUpdatePackages: (params: UpdatePackagesParams) => Promise<void>;
+export declare class UpdatePackages {
+    protected readonly paths: WorkspacePaths;
+    protected readonly pattern: string;
+    protected patternWoSlash: string;
+    constructor(paths: WorkspacePaths, pattern: string);
+    run(): Promise<void>;
+    protected exec(command: string): Promise<string>;
+    protected getPackages(): Promise<Set<string>>;
+    protected filterPackages(wsPackages: PackageEntry[], results: Set<string>): void;
+    protected filterPackage(wsPackage: PackageEntry, results: Set<string>): void;
+    protected filterPackageDep(deps: Record<string, string> | undefined, results: Set<string>): void;
+    protected updatePackages(packages: Set<string>): Promise<void>;
+    protected deduplicate(): Promise<void>;
+    protected rmOldVersions(): Promise<void>;
+    protected verifyPackages(): Promise<void>;
+}

package/dist/pkg/UpdatePackages.js

@@ -0,0 +1,148 @@
+import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
+import { readPackageEntries } from "../workspace/workspace.pkg.js";
+import { logInfo, logSuccess } from "../logger/Logger.js";
+import { execAsync } from "../common/common.fs.js";
+import micromatch from "micromatch";
+export const runUpdatePackages = async (params) => new UpdatePackages(WorkspacePaths.instance(params.repoRoot, params.workspacesName), params.pattern).run();
+export class UpdatePackages {
+    paths;
+    pattern;
+    patternWoSlash;
+    constructor(paths, pattern) {
+        this.paths = paths;
+        this.pattern = pattern;
+        this.patternWoSlash = pattern.replaceAll("/", "+");
+    }
+    async run() {
+        logInfo(`🚀 Starting ${this.pattern} packages update process...\n`);
+        // Step 1: Find all packages
+        const packages = await this.getPackages();
+        logInfo(`📦 Found ${this.pattern} packages:`);
+        for (const pkg of packages)
+            logInfo(`   - ${pkg}`);
+        if (packages.size === 0)
+            return logSuccess(`✅ No ${this.pattern} packages found.`);
+        // Step 2: Update packages in all workspaces recursively
+        await this.updatePackages(packages);
+        // Step 3: Deduplicate dependencies
+        await this.deduplicate();
+        // Step 4: Remove old versions from node_modules
+        await this.rmOldVersions();
+        // Step 5: Verify all packages are at the same version
+        await this.verifyPackages();
+    }
+    async exec(command) {
+        console.log(`\n▶ ${command}`);
+        try {
+            return (await execAsync(command, {
+                cwd: this.paths.repoRoot,
+                encoding: "utf-8",
+            })).stdout;
+        }
+        catch (error) {
+            console.error(`Error executing: ${command}`);
+            throw error;
+        }
+    }
+    async getPackages() {
+        const wsPackages = await readPackageEntries(this.paths.repoRoot);
+        const packageNames = new Set();
+        this.filterPackages(wsPackages, packageNames);
+        return packageNames;
+    }
+    filterPackages(wsPackages, results) {
+        for (const wsPackage of wsPackages)
+            this.filterPackage(wsPackage, results);
+    }
+    filterPackage(wsPackage, results) {
+        this.filterPackageDep(wsPackage.content.dependencies, results);
+        this.filterPackageDep(wsPackage.content.devDependencies, results);
+    }
+    filterPackageDep(deps, results) {
+        if (!deps)
+            return;
+        for (const depName of Object.keys(deps))
+            if (micromatch.isMatch(depName, this.pattern))
+                results.add(depName);
+    }
+    async updatePackages(packages) {
+        logInfo("\n📥 Updating packages across all workspaces...");
+        const packageList = Array.from(packages).join(" ");
+        await this.exec(`pnpm update -r --latest ${packageList}`);
+    }
+    async deduplicate() {
+        logInfo("\n🔧 Deduplicating dependencies...");
+        await this.exec("pnpm dedupe");
+    }
+    async rmOldVersions() {
+        logInfo("\n🧹 Checking for old versions...");
+        const oldVersions = await this.exec(`find node_modules/.pnpm -type d -name "${this.patternWoSlash}" -depth 1 2>/dev/null || true`);
+        const versionDirs = oldVersions.trim().split("\n").filter(Boolean);
+        // Group by package name to identify duplicates
+        const packageVersions = new Map();
+        for (const dir of versionDirs) {
+            const match = dir.match(/@mxpicture\+([^@]+)@(.+)/);
+            if (!match)
+                continue;
+            const [, pkgName, version] = match;
+            const key = `@mxpicture/${pkgName.replace(/\+/g, "/")}`;
+            if (!packageVersions.has(key))
+                packageVersions.set(key, []);
+            packageVersions.get(key).push(version.split("_")[0]); // Remove peer dep suffixes
+        }
+        // Check for duplicates
+        let hasDuplicates = false;
+        for (const [pkg, versions] of packageVersions) {
+            const uniqueVersions = [...new Set(versions)];
+            if (uniqueVersions.length <= 1)
+                continue;
+            logInfo(`⚠️  Multiple versions found for ${pkg}:`, uniqueVersions.join(", "));
+            hasDuplicates = true;
+        }
+        if (hasDuplicates) {
+            logInfo("\n🔨 Reinstalling to remove duplicate versions...");
+            logInfo("   This ensures TypeScript loads the correct types.");
+            await this.exec("mv node_modules node_modules_tmp");
+            await Promise.all([
+                this.exec("rm -rf node_modules_tmp"),
+                this.exec("pnpm install"),
+            ]);
+        }
+    }
+    async verifyPackages() {
+        logSuccess("\n✅ Verifying package versions...");
+        const listOutput = await this.exec(`pnpm list ${this.pattern} --depth=0 -r --json`);
+        const workspaces = JSON.parse(listOutput);
+        const versionMap = new Map();
+        for (const workspace of workspaces) {
+            const deps = workspace.dependencies || {};
+            for (const [pkg, info] of Object.entries(deps)) {
+                if (micromatch.isMatch(pkg, this.pattern)) {
+                    if (!versionMap.has(pkg))
+                        versionMap.set(pkg, new Map());
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    versionMap.get(pkg).set(workspace.name, info.version);
+                }
+            }
+        }
+        let allConsistent = true;
+        for (const [pkg, versions] of versionMap) {
+            const uniqueVersions = new Set(versions.values());
+            if (uniqueVersions.size <= 1) {
+                logSuccess(`✅ ${pkg}: ${[...uniqueVersions][0]}`);
+                continue;
+            }
+            logInfo(`❌ Inconsistent versions for ${pkg}:`);
+            for (const [workspace, version] of versions)
+                logInfo(`   - ${workspace}: ${version}`);
+            allConsistent = false;
+        }
+        if (!allConsistent) {
+            console.error("\n❌ Version inconsistencies detected! Please review and fix manually.");
+            process.exit(1);
+        }
+        logInfo(`\n🎉 All ${this.pattern} packages updated successfully!`);
+        logInfo("\n💡 Tip: Restart your TypeScript server in VS Code to pick up the new types.");
+        logInfo('   - Cmd+Shift+P → "TypeScript: Restart TS Server"');
+    }
+}

package/dist/pkg/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./SyncPkgVersion.js";
+export * from "./UpdatePackages.js";
 export * from "./pkg.common.js";

package/dist/pkg/index.js

@@ -1,3 +1,4 @@
 // This file is auto-generated. Do not edit manually.
 export * from "./SyncPkgVersion.js";
+export * from "./UpdatePackages.js";
 export * from "./pkg.common.js";

package/dist/types/types.package.d.ts

@@ -35,3 +35,6 @@ export interface BumpParams {
 export interface SyncPkgVersionParams extends RunRepoRootWsParams {
     bump?: BumpParams;
 }
+export interface UpdatePackagesParams extends RunRepoRootWsParams {
+    pattern: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxpicture/build-api",
-  "version": "0.2.18",
+  "version": "0.2.20",
   "description": "Build utilities API",
   "type": "module",
   "author": "MXPicture",