@mxpicture/build-api 0.2.4

package/dist/vscode/vscode.workspace.d.ts

@@ -0,0 +1,3 @@
+import { VSCodeWorkspace } from "../types/types.vscode.js";
+export declare const vscodeWorkspace: (workspaceFile: string) => Promise<VSCodeWorkspace>;
+export declare const vscodeWorkspaceRoot: (workspaceFile: string) => string;

package/dist/vscode/vscode.workspace.js

@@ -0,0 +1,14 @@
+import { readFile } from "fs/promises";
+import pkg from "json5";
+import { dirname } from "path";
+const __workspaces = {};
+export const vscodeWorkspace = async (workspaceFile) => {
+    let found = __workspaces[workspaceFile];
+    if (!found) {
+        const raw = await readFile(workspaceFile, "utf-8");
+        found = pkg.parse(raw);
+        __workspaces[workspaceFile] = found;
+    }
+    return { ...found };
+};
+export const vscodeWorkspaceRoot = (workspaceFile) => dirname(workspaceFile);

package/dist/vscode/workspace.vscode.d.ts

@@ -0,0 +1,11 @@
+import { WorkspaceFile } from "./types.vscode.js";
+import { MapEntry, PackageEntry, PackageJson, PnpmWorkspace } from "../types/types.common.js";
+export declare const findWorkspaceRoot: (startPath?: string) => Promise<WorkspaceFile>;
+export declare const readWorkspaceYaml: (repoRoot: string) => Promise<PnpmWorkspace>;
+export declare const readPackageJson: (dirOrFilepath: string) => Promise<PackageJson | null>;
+export declare const readPackageJsonThrow: (dirOrFilepath: string) => Promise<PackageJson>;
+export declare const readPackageJsons: (repoRoot: string) => Promise<PackageEntry[]>;
+export declare const writePackageJsons: (entries: PackageEntry[]) => Promise<void[]>;
+export declare const buildMapEntries: (pkgEntries: PackageEntry[]) => MapEntry[];
+export declare const readPackageVersions: (rootDir: string) => Promise<Record<string, string>>;
+export declare const readMinPackageVersion: (rootDir: string) => Promise<string | null>;

package/dist/vscode/workspace.vscode.js

@@ -0,0 +1,149 @@
+import { dirname, join, relative, resolve } from "path";
+import { parse } from "yaml";
+import { fileURLToPath } from "url";
+import pkg from "json5";
+import { WorkspaceFileType } from "./types.vscode.js";
+import { compareVersions, concatVersion, getFileType, splitVersion, } from "./common.vscode.js";
+import { readdir, readFile, writeFile } from "fs/promises";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let __workspaceRoot = null;
+export const findWorkspaceRoot = async (startPath) => {
+    if (__workspaceRoot)
+        return __workspaceRoot;
+    let path = startPath ?? __dirname;
+    let level = 0;
+    const promises = [];
+    while (path.length > 0) {
+        promises.push((async () => {
+            const l = level;
+            const entries = await readdir(path, { withFileTypes: true });
+            let pkg = null;
+            for (const entry of entries) {
+                if (!entry.isFile())
+                    continue;
+                const type = getFileType(entry.name);
+                if (type === WorkspaceFileType.workspace)
+                    return {
+                        filePath: join(path, entry.name),
+                        dirPath: path,
+                        filename: entry.name,
+                        level: l,
+                        type,
+                    };
+                if (!pkg && type === WorkspaceFileType.package)
+                    pkg = {
+                        filePath: join(path, entry.name),
+                        dirPath: path,
+                        filename: entry.name,
+                        level: l,
+                        type,
+                    };
+            }
+            if (!pkg)
+                throw new Error("");
+            return pkg;
+        })());
+        level++;
+        path = path.replace(/\/?[^\/]+\/?$/, ""); // remove last dir
+    }
+    const results = (await Promise.allSettled(promises)).filter((r) => r.status === "fulfilled");
+    results.sort((a, b) => a.value.level - b.value.level);
+    const result = results.find((r) => r.value.type === WorkspaceFileType.workspace)?.value &&
+        results.find((r) => r.value.type === WorkspaceFileType.package)?.value;
+    if (!result)
+        throw new Error("findWorkspaceRoot: no file found");
+    __workspaceRoot = result;
+    return result;
+};
+export const readWorkspaceYaml = async (repoRoot) => {
+    const workspaceFilePath = resolve(repoRoot, "pnpm-workspace.yaml");
+    const fileContent = await readFile(workspaceFilePath, "utf8");
+    const parsed = parse(fileContent);
+    if (!parsed || !parsed.packages || !Array.isArray(parsed.packages))
+        throw new Error("No 'packages' field found in pnpm-workspace.yaml");
+    const packageColletions = await Promise.all(parsed.packages.map(async (p) => {
+        if (!p.endsWith("/*"))
+            return [p];
+        const base = p.substring(0, p.length - 2);
+        const pkgs = await readdir(join(repoRoot, base));
+        return pkgs
+            .filter((pkg) => !pkg.startsWith("."))
+            .map((pkg) => join(base, pkg));
+    }));
+    const packages = [];
+    for (const packageColletion of packageColletions)
+        packages.push(...packageColletion);
+    return { packages };
+};
+export const readPackageJson = async (dirOrFilepath) => {
+    try {
+        return readPackageJsonThrow(dirOrFilepath);
+    }
+    catch {
+        return null;
+    }
+};
+export const readPackageJsonThrow = async (dirOrFilepath) => {
+    const pkgPath = dirOrFilepath.endsWith("/package.json")
+        ? dirOrFilepath
+        : join(dirOrFilepath, "package.json");
+    return pkg.parse(await readFile(pkgPath, "utf8"));
+};
+export const readPackageJsons = async (repoRoot) => {
+    try {
+        const pnpmWS = await readWorkspaceYaml(repoRoot);
+        return Promise.all(pnpmWS.packages.map(async (repoPath) => {
+            const jsonPath = join(repoRoot, repoPath, "package.json");
+            const content = await readPackageJsonThrow(jsonPath);
+            return {
+                jsonPath,
+                repoPath,
+                content,
+                modified: false,
+                wsName: repoPath.startsWith("packages/")
+                    ? repoPath.substring(9)
+                    : repoPath,
+            };
+        }));
+    }
+    catch {
+        return [];
+    }
+};
+export const writePackageJsons = async (entries) => Promise.all(entries.map(async (entry) => {
+    if (entry.modified) {
+        await writeFile(entry.jsonPath, JSON.stringify(entry.content, null, 2) + "\n", "utf8");
+        console.log(`  ✅ Updated ${entry.content.name}\n`);
+    }
+    else {
+        console.log(`  ⏭️  No workspace dependencies to fix. ${entry.content.name}\n`);
+    }
+}));
+// Build a map of package names to their versions
+export const buildMapEntries = (pkgEntries) => {
+    const versionEntries = [];
+    for (const fromPkg of pkgEntries)
+        for (const toPkg of pkgEntries)
+            if (fromPkg.content.name !== toPkg.content.name)
+                versionEntries.push({
+                    fromPkg,
+                    toPkg,
+                    relPath: relative(fromPkg.repoPath, toPkg.repoPath),
+                });
+    return versionEntries;
+};
+export const readPackageVersions = async (rootDir) => {
+    const versions = {};
+    const packageJsons = await readPackageJsons(rootDir);
+    for (const packageJson of packageJsons)
+        versions[packageJson.repoPath] = packageJson.content.version;
+    return versions;
+};
+export const readMinPackageVersion = async (rootDir) => {
+    const versions = await readPackageVersions(rootDir);
+    const splitVersions = Object.values(versions).map(splitVersion);
+    if (splitVersions.length === 0)
+        return null;
+    splitVersions.sort(compareVersions);
+    return concatVersion(splitVersions[0]);
+};

package/dist/workspace/IFixWorkspaceDeps.d.ts

@@ -0,0 +1,22 @@
+import { ProcessMode } from "../types/types.vscode.js";
+import { FixWorkspaceDepsMain, FixWorkspaceDepsParams } from "../types/types.workspace.js";
+export declare const runFixDepsByVersion: (repoRoot: string, mode: ProcessMode) => Promise<void>;
+export declare const runFixDepsByFile: (repoRoot: string, mode: ProcessMode) => Promise<void>;
+export declare abstract class IFixWorkspaceDeps {
+    readonly repoRoot: string;
+    readonly mode: ProcessMode;
+    constructor(repoRoot: string, mode: ProcessMode);
+    protected abstract fixVersion(p: FixWorkspaceDepsParams): string | null;
+    protected abstract restoreVersion(p: FixWorkspaceDepsParams): string | null;
+    run(): Promise<void>;
+    protected handleDependencies(deps: Record<string, string> | undefined, p: FixWorkspaceDepsMain): boolean;
+    protected runSingle(p: FixWorkspaceDepsMain): boolean;
+}
+export declare class FixWorkspaceDepsVersion extends IFixWorkspaceDeps {
+    protected fixVersion(p: FixWorkspaceDepsParams): string | null;
+    protected restoreVersion(p: FixWorkspaceDepsParams): string | null;
+}
+export declare class FixWorkspaceDepsFile extends IFixWorkspaceDeps {
+    protected fixVersion(p: FixWorkspaceDepsParams): string | null;
+    protected restoreVersion(p: FixWorkspaceDepsParams): string | null;
+}

package/dist/workspace/IFixWorkspaceDeps.js

@@ -0,0 +1,118 @@
+import { buildMapEntries, readPackageJsons, writePackageJsons, } from "./workspace.common.js";
+export const runFixDepsByVersion = async (repoRoot, mode) => new FixWorkspaceDepsVersion(repoRoot, mode).run();
+export const runFixDepsByFile = async (repoRoot, mode) => new FixWorkspaceDepsFile(repoRoot, mode).run();
+export class IFixWorkspaceDeps {
+    repoRoot;
+    mode;
+    constructor(repoRoot, mode) {
+        this.repoRoot = repoRoot;
+        this.mode = mode;
+    }
+    async run() {
+        if (this.mode === "fix")
+            console.log("🔧 Fixing workspace dependencies...\n");
+        else
+            console.log("🔧 Restoring workspace dependencies...\n");
+        const pkgs = await readPackageJsons(this.repoRoot);
+        const mapEntries = buildMapEntries(pkgs);
+        const versionMap = new Map();
+        const workspacePackages = new Set();
+        for (const pkg of pkgs) {
+            versionMap.set(pkg.content.name, pkg.content.version);
+            workspacePackages.add(pkg.content.name);
+        }
+        console.log("📋 Version map:");
+        for (const map of mapEntries)
+            console.log(`  ${map.fromPkg.content.name} --> ${map.toPkg.content.name}: ${map.relPath}`);
+        console.log();
+        for (const consumingPkg of pkgs) {
+            console.log(`📦 Processing ${consumingPkg.content.name}...`);
+            try {
+                consumingPkg.modified = this.runSingle({
+                    consumingPkg,
+                    mapEntries,
+                    versionMap,
+                    workspacePackages,
+                });
+            }
+            catch (err) {
+                console.error(`\nError processing ${consumingPkg.content.name}:`, err);
+                throw err;
+            }
+        }
+        await writePackageJsons(pkgs);
+        if (this.mode === "fix")
+            console.log("✅ Done fixing workspace dependencies!");
+        else
+            console.log("✅ Done restoring workspace dependencies!");
+    }
+    // Replace workspace:* with file:...
+    handleDependencies(deps, p) {
+        if (!deps)
+            return false;
+        const handler = this.mode === "fix" ? this.fixVersion : this.restoreVersion;
+        let modified = false;
+        for (const [name, version] of Object.entries(deps)) {
+            const newVersion = handler({ ...p, pkg: name, version });
+            if (!newVersion)
+                continue;
+            console.log(`  ✓ Replaced ${name}: ${version} → ${newVersion}`);
+            deps[name] = newVersion;
+            modified = true;
+        }
+        return modified;
+    }
+    runSingle(p) {
+        let modified = false;
+        modified =
+            this.handleDependencies(p.consumingPkg.content.dependencies, p) ||
+                modified;
+        modified =
+            this.handleDependencies(p.consumingPkg.content.devDependencies, p) ||
+                modified;
+        modified =
+            this.handleDependencies(p.consumingPkg.content.peerDependencies, p) ||
+                modified;
+        return modified;
+    }
+}
+export class FixWorkspaceDepsVersion extends IFixWorkspaceDeps {
+    fixVersion(p) {
+        if (p.version !== "workspace:*")
+            return null;
+        const actualVersion = p.versionMap.get(p.pkg);
+        if (!actualVersion) {
+            console.error(`  ERROR: Could not find version for workspace dependency ${p.pkg}`);
+            throw new Error(`Cannot resolve workspace dependency: ${p.pkg}`);
+        }
+        return `^${actualVersion}`;
+    }
+    restoreVersion(p) {
+        if (p.workspacePackages.has(p.pkg) && p.version.startsWith("^")) {
+            // Verify the version matches what fix script would have created
+            const actualVersion = p.versionMap.get(p.pkg);
+            if (actualVersion && p.version === `^${actualVersion}`) {
+                return "workspace:*";
+            }
+        }
+        return null;
+    }
+}
+export class FixWorkspaceDepsFile extends IFixWorkspaceDeps {
+    fixVersion(p) {
+        if (p.version !== "workspace:*")
+            return null;
+        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}`);
+            throw new Error(`Cannot resolve workspace dependency: ${p.pkg}`);
+        }
+        return `file:${mapEntry.relPath}`;
+    }
+    restoreVersion(p) {
+        if (!p.version.startsWith("file:"))
+            return null;
+        return "workspace:*";
+    }
+}

package/dist/workspace/WorkspacePaths.d.ts

@@ -0,0 +1,7 @@
+export declare class WorkspacePaths {
+    readonly repoRoot: string;
+    readonly workspacesDir: string;
+    static instance(repoRoot: string, workspacesName?: string): WorkspacePaths;
+    private constructor();
+    workspaceByPath(path: string): Promise<string | null>;
+}

package/dist/workspace/WorkspacePaths.js

@@ -0,0 +1,30 @@
+import { stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+const __instances = {};
+export class WorkspacePaths {
+    repoRoot;
+    workspacesDir;
+    static instance(repoRoot, workspacesName = "packages") {
+        const workspacesDir = join(repoRoot, workspacesName);
+        if (!__instances[workspacesDir])
+            __instances[workspacesDir] = new WorkspacePaths(repoRoot, workspacesDir);
+        return __instances[workspacesDir];
+    }
+    constructor(repoRoot, workspacesDir) {
+        this.repoRoot = repoRoot;
+        this.workspacesDir = workspacesDir;
+    }
+    async workspaceByPath(path) {
+        try {
+            const pkgPath = relative(this.workspacesDir, path);
+            const pkg = pkgPath.split(sep).shift();
+            if (!pkg)
+                return null;
+            const pkgJsonPath = join(this.workspacesDir, pkg, "package.json");
+            return (await stat(pkgJsonPath)).isFile() ? pkg : null;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/workspace/fixWorkspaceDeps.d.ts

@@ -0,0 +1,22 @@
+import { FixWorkspaceDepsMain, FixWorkspaceDepsParams } from "../types/types.workspace.js";
+export type ProcessMode = "fix" | "restore";
+export declare const runFixDepsByVersion: (repoRoot: string, mode: ProcessMode) => Promise<void>;
+export declare const runFixDepsByFile: (repoRoot: string, mode: ProcessMode) => Promise<void>;
+export declare abstract class IFixWorkspaceDeps {
+    readonly repoRoot: string;
+    readonly mode: ProcessMode;
+    constructor(repoRoot: string, mode: ProcessMode);
+    protected abstract fixVersion(p: FixWorkspaceDepsParams): string | null;
+    protected abstract restoreVersion(p: FixWorkspaceDepsParams): string | null;
+    run(): Promise<void>;
+    protected handleDependencies(deps: Record<string, string> | undefined, p: FixWorkspaceDepsMain): boolean;
+    protected runSingle(p: FixWorkspaceDepsMain): boolean;
+}
+export declare class FixWorkspaceDepsVersion extends IFixWorkspaceDeps {
+    protected fixVersion(p: FixWorkspaceDepsParams): string | null;
+    protected restoreVersion(p: FixWorkspaceDepsParams): string | null;
+}
+export declare class FixWorkspaceDepsFile extends IFixWorkspaceDeps {
+    protected fixVersion(p: FixWorkspaceDepsParams): string | null;
+    protected restoreVersion(p: FixWorkspaceDepsParams): string | null;
+}

package/dist/workspace/fixWorkspaceDeps.js

@@ -0,0 +1,118 @@
+import { buildMapEntries, readPackageJsons, writePackageJsons, } from "./workspace.common.js";
+export const runFixDepsByVersion = async (repoRoot, mode) => new FixWorkspaceDepsVersion(repoRoot, mode).run();
+export const runFixDepsByFile = async (repoRoot, mode) => new FixWorkspaceDepsFile(repoRoot, mode).run();
+export class IFixWorkspaceDeps {
+    repoRoot;
+    mode;
+    constructor(repoRoot, mode) {
+        this.repoRoot = repoRoot;
+        this.mode = mode;
+    }
+    async run() {
+        if (this.mode === "fix")
+            console.log("🔧 Fixing workspace dependencies...\n");
+        else
+            console.log("🔧 Restoring workspace dependencies...\n");
+        const pkgs = await readPackageJsons(this.repoRoot);
+        const mapEntries = buildMapEntries(pkgs);
+        const versionMap = new Map();
+        const workspacePackages = new Set();
+        for (const pkg of pkgs) {
+            versionMap.set(pkg.content.name, pkg.content.version);
+            workspacePackages.add(pkg.content.name);
+        }
+        console.log("📋 Version map:");
+        for (const map of mapEntries)
+            console.log(`  ${map.fromPkg.content.name} --> ${map.toPkg.content.name}: ${map.relPath}`);
+        console.log();
+        for (const consumingPkg of pkgs) {
+            console.log(`📦 Processing ${consumingPkg.content.name}...`);
+            try {
+                consumingPkg.modified = this.runSingle({
+                    consumingPkg,
+                    mapEntries,
+                    versionMap,
+                    workspacePackages,
+                });
+            }
+            catch (err) {
+                console.error(`\nError processing ${consumingPkg.content.name}:`, err);
+                throw err;
+            }
+        }
+        await writePackageJsons(pkgs);
+        if (this.mode === "fix")
+            console.log("✅ Done fixing workspace dependencies!");
+        else
+            console.log("✅ Done restoring workspace dependencies!");
+    }
+    // Replace workspace:* with file:...
+    handleDependencies(deps, p) {
+        if (!deps)
+            return false;
+        const handler = this.mode === "fix" ? this.fixVersion : this.restoreVersion;
+        let modified = false;
+        for (const [name, version] of Object.entries(deps)) {
+            const newVersion = handler({ ...p, pkg: name, version });
+            if (!newVersion)
+                continue;
+            console.log(`  ✓ Replaced ${name}: ${version} → ${newVersion}`);
+            deps[name] = newVersion;
+            modified = true;
+        }
+        return modified;
+    }
+    runSingle(p) {
+        let modified = false;
+        modified =
+            this.handleDependencies(p.consumingPkg.content.dependencies, p) ||
+                modified;
+        modified =
+            this.handleDependencies(p.consumingPkg.content.devDependencies, p) ||
+                modified;
+        modified =
+            this.handleDependencies(p.consumingPkg.content.peerDependencies, p) ||
+                modified;
+        return modified;
+    }
+}
+export class FixWorkspaceDepsVersion extends IFixWorkspaceDeps {
+    fixVersion(p) {
+        if (p.version !== "workspace:*")
+            return null;
+        const actualVersion = p.versionMap.get(p.pkg);
+        if (!actualVersion) {
+            console.error(`  ERROR: Could not find version for workspace dependency ${p.pkg}`);
+            throw new Error(`Cannot resolve workspace dependency: ${p.pkg}`);
+        }
+        return `^${actualVersion}`;
+    }
+    restoreVersion(p) {
+        if (p.workspacePackages.has(p.pkg) && p.version.startsWith("^")) {
+            // Verify the version matches what fix script would have created
+            const actualVersion = p.versionMap.get(p.pkg);
+            if (actualVersion && p.version === `^${actualVersion}`) {
+                return "workspace:*";
+            }
+        }
+        return null;
+    }
+}
+export class FixWorkspaceDepsFile extends IFixWorkspaceDeps {
+    fixVersion(p) {
+        if (p.version !== "workspace:*")
+            return null;
+        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}`);
+            throw new Error(`Cannot resolve workspace dependency: ${p.pkg}`);
+        }
+        return `file:${mapEntry.relPath}`;
+    }
+    restoreVersion(p) {
+        if (!p.version.startsWith("file:"))
+            return null;
+        return "workspace:*";
+    }
+}

package/dist/workspace/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./WorkspacePaths.js";
+export * from "./workspace.common.js";

package/dist/workspace/index.js

@@ -0,0 +1,3 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./WorkspacePaths.js";
+export * from "./workspace.common.js";

package/dist/workspace/workspace.common.d.ts

@@ -0,0 +1,13 @@
+import { PnpmWorkspace, WorkspaceFile, WorkspaceFileType } from "../types/types.workspace.js";
+import { PackageJson, PackageEntry, MapEntry } from "../types/types.package.js";
+export declare const DEFAULT_WORKSPACE_FILE_ENDING = ".code-workspace";
+export declare const getFileType: (filename: string) => WorkspaceFileType;
+export declare const findWorkspaceRoot: (startPath: string) => Promise<WorkspaceFile>;
+export declare const readWorkspaceYaml: (repoRoot: string) => Promise<PnpmWorkspace>;
+export declare const readPackageJson: (dirOrFilepath: string) => Promise<PackageJson | null>;
+export declare const readPackageJsonThrow: (dirOrFilepath: string) => Promise<PackageJson>;
+export declare const readPackageJsons: (repoRoot: string) => Promise<PackageEntry[]>;
+export declare const writePackageJsons: (entries: PackageEntry[]) => Promise<void[]>;
+export declare const buildMapEntries: (pkgEntries: PackageEntry[]) => MapEntry[];
+export declare const readPackageVersions: (rootDir: string) => Promise<Record<string, string>>;
+export declare const readMinPackageVersion: (rootDir: string) => Promise<string | null>;