@mxpicture/build-api 0.2.22 → 0.2.23

package/dist/pkg/Pkg.d.ts

@@ -0,0 +1,24 @@
+import { PackageJson } from "../types/types.package.js";
+export declare class Pkg {
+    readonly repoRoot: string;
+    readonly repoPath: string;
+    readonly filePath: string;
+    readonly dirPath: string;
+    readonly srcPath: string;
+    readonly distPath: string;
+    readonly repoFilePath: string;
+    readonly repoDirPath: string;
+    readonly repoSrcPath: string;
+    readonly repoDistPath: string;
+    protected _content: PackageJson | null;
+    protected originalContent: PackageJson | null;
+    constructor(repoRoot: string, repoPath: string);
+    get content(): PackageJson;
+    protected set content(c: PackageJson);
+    modified(): boolean;
+    read(): Promise<PackageJson>;
+    readSync(): PackageJson;
+    write(): Promise<void>;
+    packageVersions(): Promise<Record<string, string>>;
+    protected updateOriginal(content?: PackageJson): void;
+}

package/dist/pkg/Pkg.js

@@ -0,0 +1,74 @@
+import { join, relative } from "node:path";
+import { logInfo, logSuccess } from "../logger/Logger.js";
+import { ensurePkgJsonPath, readPackageJson, readPackageJsonSync, writePackageJson, } from "./pkg.fs.js";
+import { jsonClone, jsonEqual } from "../common/common.json.js";
+export class Pkg {
+    repoRoot;
+    repoPath;
+    filePath;
+    dirPath;
+    srcPath;
+    distPath;
+    repoFilePath;
+    repoDirPath;
+    repoSrcPath;
+    repoDistPath;
+    _content = null;
+    originalContent = null;
+    constructor(repoRoot, repoPath) {
+        this.repoRoot = repoRoot;
+        this.repoPath = repoPath;
+        this.dirPath = join(repoRoot, repoPath);
+        this.filePath = ensurePkgJsonPath(this.dirPath);
+        this.srcPath = join(repoRoot, repoPath, "src");
+        this.distPath = join(repoRoot, repoPath, "dist");
+        this.repoFilePath = relative(repoRoot, this.filePath);
+        this.repoDirPath = relative(repoRoot, this.dirPath);
+        this.repoSrcPath = relative(repoRoot, this.srcPath);
+        this.repoDistPath = relative(repoRoot, this.distPath);
+    }
+    get content() {
+        if (!this._content)
+            throw new Error(`Content not loaded. ${this.filePath}`);
+        return this._content;
+    }
+    set content(c) {
+        this._content = c;
+    }
+    modified() {
+        return !jsonEqual(this.content, this.originalContent);
+    }
+    async read() {
+        if (!this._content)
+            this.updateOriginal((this.content = await readPackageJson(this.filePath)));
+        return this.content;
+    }
+    readSync() {
+        if (!this._content)
+            this.updateOriginal((this.content = readPackageJsonSync(this.filePath)));
+        return this.content;
+    }
+    async write() {
+        if (this.content && this.modified()) {
+            await writePackageJson(this.filePath, this.content);
+            logSuccess(`  ✅ package.json updated ${this.repoFilePath}\n`);
+        }
+        else {
+            logInfo(`  ⏭️ No changes in package.json. ${this.repoFilePath}\n`);
+        }
+    }
+    async packageVersions() {
+        const pkgJson = await this.read();
+        let versions = {};
+        if (pkgJson.dependencies)
+            versions = { ...versions, ...pkgJson.dependencies };
+        if (pkgJson.devDependencies)
+            versions = { ...versions, ...pkgJson.devDependencies };
+        if (pkgJson.peerDependencies)
+            versions = { ...versions, ...pkgJson.peerDependencies };
+        return versions;
+    }
+    updateOriginal(content) {
+        this.originalContent = jsonClone(content ?? this.content);
+    }
+}

package/dist/pkg/SyncPkgVersion.d.ts

@@ -1,12 +1,11 @@
-import { BumpParams, PackageEntry, SyncPkgVersionParams } from "../types/types.package.js";
-import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
+import { BumpParams, SyncPkgVersionParams } from "../types/types.package.js";
+import { Pkg } from "./Pkg.js";
 export declare const runSyncPkgVersion: (params: SyncPkgVersionParams) => Promise<void>;
 export declare class SyncPkgVersion {
-    protected readonly paths: WorkspacePaths;
     protected readonly bump: BumpParams | null;
     protected readonly noTag: boolean;
-    constructor(paths: WorkspacePaths, bump: BumpParams | null, noTag: boolean);
+    constructor(bump: BumpParams | null, noTag: boolean);
     run(): Promise<void>;
-    protected read(): Promise<PackageEntry[]>;
-    protected write(packages: PackageEntry[]): Promise<void>;
+    protected read(): Promise<Pkg[]>;
+    protected write(): Promise<void>;
 }

package/dist/pkg/SyncPkgVersion.js

@@ -1,15 +1,14 @@
-import { join } from "node:path";
-import { readPackageEntries, readPackageEntryThrow, writePackageEntries, } from "../workspace/workspace.pkg.js";
-import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
 import { bumpVersion, compareVersionsGT, concatVersion, splitVersion, } from "./pkg.common.js";
 import { verifiedGit } from "../git/git.util.js";
-export const runSyncPkgVersion = async (params) => new SyncPkgVersion(WorkspacePaths.instance(params.repoRoot, params.workspacesName), params.noBump ? null : (params.bump ?? { patch: true }), !!params.noTag).run();
+import { initWorkspace, workspace } from "../workspace/Workspace.js";
+export const runSyncPkgVersion = async (params) => {
+    initWorkspace(params.repoRoot);
+    return new SyncPkgVersion(params.noBump ? null : (params.bump ?? { patch: true }), !!params.noTag).run();
+};
 export class SyncPkgVersion {
-    paths;
     bump;
     noTag;
-    constructor(paths, bump, noTag) {
-        this.paths = paths;
+    constructor(bump, noTag) {
         this.bump = bump;
         this.noTag = noTag;
     }
@@ -31,26 +30,22 @@ export class SyncPkgVersion {
             maxVersion = bumpVersion(maxVersion, this.bump);
         const newVersion = concatVersion(maxVersion);
         // set/update
-        for (const entry of packages) {
+        for (const entry of packages)
             entry.content.version = newVersion;
-            entry.modified = true;
-        }
-        await this.write(packages);
+        await this.write();
         // create tag
         if (!this.noTag) {
-            const git = await verifiedGit(this.paths.repoRoot);
+            const git = await verifiedGit(workspace().repoRoot);
             await git.addAnnotatedTag(`v${newVersion}`, `Release v${newVersion}`);
             await git.pushTags();
         }
     }
     async read() {
-        const [packages, root] = await Promise.all([
-            readPackageEntries(this.paths.repoRoot),
-            readPackageEntryThrow(join(this.paths.repoRoot, "package.json")),
-        ]);
-        return [...packages, root];
+        const ws = workspace();
+        await ws.loadPackages();
+        return [ws.mainPackage, ...ws.packages];
     }
-    async write(packages) {
-        await writePackageEntries(packages);
+    async write() {
+        return workspace().write();
     }
 }

package/dist/pkg/UpdatePackages.d.ts

@@ -1,16 +1,14 @@
-import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
-import { PackageEntry, UpdatePackagesParams } from "../types/types.package.js";
+import { PackageJson, 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);
+    constructor(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 filterPackages(wsPackages: PackageJson[], results: Set<string>): void;
+    protected filterPackage(wsPackage: PackageJson, 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>;

package/dist/pkg/UpdatePackages.js

@@ -1,15 +1,15 @@
-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();
+import { initWorkspace, workspace } from "../workspace/Workspace.js";
+export const runUpdatePackages = async (params) => {
+    initWorkspace(params.repoRoot);
+    return new UpdatePackages(params.pattern).run();
+};
 export class UpdatePackages {
-    paths;
     pattern;
     patternWoSlash;
-    constructor(paths, pattern) {
-        this.paths = paths;
+    constructor(pattern) {
         this.pattern = pattern;
         this.patternWoSlash = pattern.replaceAll("/", "+");
     }
@@ -35,7 +35,7 @@ export class UpdatePackages {
         console.log(`\n▶ ${command}`);
         try {
             return (await execAsync(command, {
-                cwd: this.paths.repoRoot,
+                cwd: workspace().repoRoot,
                 encoding: "utf-8",
             })).stdout;
         }
@@ -45,9 +45,10 @@ export class UpdatePackages {
         }
     }
     async getPackages() {
-        const wsPackages = await readPackageEntries(this.paths.repoRoot);
+        const ws = workspace();
+        const pkgs = await ws.loadPackages();
         const packageNames = new Set();
-        this.filterPackages(wsPackages, packageNames);
+        this.filterPackages(pkgs.map((p) => p.content), packageNames);
         return packageNames;
     }
     filterPackages(wsPackages, results) {
@@ -55,8 +56,8 @@ export class UpdatePackages {
             this.filterPackage(wsPackage, results);
     }
     filterPackage(wsPackage, results) {
-        this.filterPackageDep(wsPackage.content.dependencies, results);
-        this.filterPackageDep(wsPackage.content.devDependencies, results);
+        this.filterPackageDep(wsPackage.dependencies, results);
+        this.filterPackageDep(wsPackage.devDependencies, results);
     }
     filterPackageDep(deps, results) {
         if (!deps)

package/dist/pkg/index.d.ts

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

package/dist/pkg/index.js

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

package/dist/pkg/pkg.fs.d.ts

@@ -0,0 +1,5 @@
+import { PackageJson } from "../types/types.package.js";
+export declare const readPackageJson: (dirOrFilepath: string) => Promise<PackageJson>;
+export declare const readPackageJsonSync: (dirOrFilepath: string) => PackageJson;
+export declare const writePackageJson: (jsonPath: string, content: PackageJson) => Promise<void>;
+export declare const ensurePkgJsonPath: (dirOrFilepath: string) => string;

package/dist/pkg/pkg.fs.js

@@ -0,0 +1,11 @@
+import json5 from "json5";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { formatJsonStringify } from "../format/format.code.js";
+import { readFileSync } from "node:fs";
+export const readPackageJson = async (dirOrFilepath) => json5.parse(await readFile(ensurePkgJsonPath(dirOrFilepath), "utf8"));
+export const readPackageJsonSync = (dirOrFilepath) => json5.parse(readFileSync(ensurePkgJsonPath(dirOrFilepath), "utf8"));
+export const writePackageJson = async (jsonPath, content) => writeFile(jsonPath, await formatJsonStringify(json5.stringify(content)));
+export const ensurePkgJsonPath = (dirOrFilepath) => dirOrFilepath.endsWith("/package.json")
+    ? dirOrFilepath
+    : join(dirOrFilepath, "package.json");

package/dist/types/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./types.barrel.js";
 export * from "./types.changelog.js";
-export * from "./types.changeset.js";
 export * from "./types.cleanup.js";
 export * from "./types.code.js";
 export * from "./types.deps.js";

package/dist/types/index.js

@@ -1,7 +1,6 @@
 // This file is auto-generated. Do not edit manually.
 export * from "./types.barrel.js";
 export * from "./types.changelog.js";
-export * from "./types.changeset.js";
 export * from "./types.cleanup.js";
 export * from "./types.code.js";
 export * from "./types.deps.js";

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

@@ -1,16 +1,15 @@
-import { RunRepoRootWsParams } from "./types.run.js";
+import type { Pkg } from "../pkg/Pkg.js";
+import { RunRepoRootParams } from "./types.run.js";
 export interface BarrelGroup {
     dirPath: string;
     files: string[];
-    packageDir: string;
-    packageJsonPath: string;
+    pkg: Pkg;
 }
 export interface BarrelResult {
     barrelDirs: string[];
-    packageDir: string;
-    packageJsonPath: string;
+    pkg: Pkg;
 }
-export interface BarrelParams extends RunRepoRootWsParams {
+export interface BarrelParams extends RunRepoRootParams {
     excludes?: RegExp[];
     fileHeader?: string;
 }

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

@@ -1,4 +1,4 @@
-import { RunRepoRootWsParams } from "./types.run.js";
+import { RunRepoRootParams } from "./types.run.js";
 export interface ToBeDeleted {
     name: string;
     moveSuffix?: string;
@@ -7,6 +7,6 @@ export interface ToCleanup extends ToBeDeleted {
     path: string;
     moveTo?: string;
 }
-export interface CleanupParams extends RunRepoRootWsParams {
+export interface CleanupParams extends RunRepoRootParams {
     toBeDeleted?: ToBeDeleted[];
 }

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

@@ -1,4 +1,6 @@
-import { MapEntry, PackageEntry } from "./types.package.js";
+import type { Pkg } from "../pkg/Pkg.js";
+import { MapEntry } from "./types.package.js";
+import { RunRepoRootParams } from "./types.run.js";
 export declare enum DepsProcessMode {
     fix = "fix",
     restore = "restore"
@@ -9,7 +11,7 @@ export declare enum DepsReplacementMode {
 }
 export interface FixWorkspaceDepsMain {
     mapEntries: MapEntry[];
-    consumingPkg: PackageEntry;
+    consumingPkg: Pkg;
     versionMap: Map<string, string>;
     workspacePackages: Set<string>;
 }
@@ -17,8 +19,7 @@ export interface FixWorkspaceDepsData extends FixWorkspaceDepsMain {
     pkg: string;
     version: string;
 }
-export interface FixWorkspaceDepsParams {
-    repoRoot: string;
+export interface FixWorkspaceDepsParams extends RunRepoRootParams {
     mode: DepsProcessMode;
     replacement: DepsReplacementMode;
 }

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

@@ -1,7 +1,7 @@
 import type { DiffResult } from "simple-git";
 export interface GitChangedResult {
     path: string;
-    sinceCommit: string;
+    sinceCommitTag: string;
     hasChanged: boolean;
     changedFiles: string[];
 }
@@ -12,7 +12,7 @@ export interface GitChangedContent {
 }
 export interface GitChangedContentsResult {
     path: string;
-    sinceCommit: string;
+    sinceCommitTag: string;
     files: GitChangedContent[];
 }
 export interface GitCommitHash {

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

@@ -1,2 +1,2 @@
-import { RunPackagesDirParams } from "./types.run.js";
-export type NpmPublisherParams = RunPackagesDirParams;
+import { RunRepoRootParams } from "./types.run.js";
+export type NpmPublisherParams = RunRepoRootParams;

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

@@ -1,4 +1,5 @@
-import { RunRepoRootWsParams } from "./types.run.js";
+import type { Pkg } from "../pkg/Pkg.js";
+import { RunRepoRootParams } from "./types.run.js";
 export interface PackageVersion {
     major: number;
     minor: number | null;
@@ -15,16 +16,9 @@ export interface PackageJson {
     peerDependencies?: Record<string, string>;
     [key: string]: unknown;
 }
-export interface PackageEntry {
-    jsonPath: string;
-    repoPath: string | null;
-    wsName: string;
-    content: PackageJson;
-    modified: boolean;
-}
 export interface MapEntry {
-    fromPkg: PackageEntry;
-    toPkg: PackageEntry;
+    fromPkg: Pkg;
+    toPkg: Pkg;
     relPath: string;
 }
 export interface BumpParams {
@@ -32,11 +26,11 @@ export interface BumpParams {
     minor?: boolean;
     patch?: boolean;
 }
-export interface SyncPkgVersionParams extends RunRepoRootWsParams {
+export interface SyncPkgVersionParams extends RunRepoRootParams {
     bump?: BumpParams;
     noBump?: boolean;
     noTag?: boolean;
 }
-export interface UpdatePackagesParams extends RunRepoRootWsParams {
+export interface UpdatePackagesParams extends RunRepoRootParams {
     pattern: string;
 }

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

@@ -1,7 +1,3 @@
-export interface RunRepoRootWsParams {
+export interface RunRepoRootParams {
     repoRoot: string;
-    workspacesName: string;
-}
-export interface RunPackagesDirParams {
-    packagesDir: string;
 }

package/dist/vscode/vscode.settings.d.ts

@@ -1,3 +1,5 @@
 import { VSCodeSettings } from "../types/types.vscode.js";
 export declare const vscodeSettings: (dir?: string) => Promise<VSCodeSettings>;
 export declare const clangFormatStyle: (cwd: string) => Promise<string>;
+/** @internal test-only */
+export declare const __resetSettings: () => void;

package/dist/vscode/vscode.settings.js

@@ -24,3 +24,7 @@ export const clangFormatStyle = async (cwd) => {
         throw new Error("C_Cpp.clang_format_style not found in settings.json");
     return settings["C_Cpp.clang_format_style"];
 };
+/** @internal test-only */
+export const __resetSettings = () => {
+    __settings = null;
+};

package/dist/vscode/vscode.storage.d.ts

@@ -1,3 +1,5 @@
 import { VSCodeStorage } from "../types/types.vscode.js";
 export declare const storagePath: () => string;
 export declare const storage: () => VSCodeStorage;
+/** @internal test-only */
+export declare const __resetStorage: () => void;

package/dist/vscode/vscode.storage.js

@@ -13,3 +13,7 @@ export const storage = () => {
         throw new Error("VS Code storage.json could not be loaded");
     return __storage;
 };
+/** @internal test-only */
+export const __resetStorage = () => {
+    __storage = undefined;
+};

package/dist/workspace/Workspace.d.ts

@@ -0,0 +1,25 @@
+import { PnpmWorkspace } from "../types/types.workspace.js";
+import { Pkg } from "../pkg/Pkg.js";
+export declare const initWorkspace: (repoRoot: string) => Workspace;
+export declare const workspace: () => Workspace;
+interface WorkspaceData {
+    pnpmWs: PnpmWorkspace;
+    mainPackage: Pkg;
+    packages: Pkg[];
+}
+export declare class Workspace {
+    readonly repoRoot: string;
+    protected _data: WorkspaceData | null;
+    static __init(repoRoot: string): Workspace;
+    static __get(): Workspace;
+    private constructor();
+    get pnpmWs(): PnpmWorkspace;
+    get packages(): Pkg[];
+    get mainPackage(): Pkg;
+    protected set data(c: WorkspaceData);
+    protected get data(): WorkspaceData;
+    read(): Promise<void>;
+    loadPackages(): Promise<Pkg[]>;
+    write(): Promise<void>;
+}
+export {};

package/dist/workspace/Workspace.js

@@ -0,0 +1,70 @@
+import { readWorkspaceYaml } from "./workspace.common.js";
+import { Pkg } from "../pkg/Pkg.js";
+import { jsonClone } from "../common/common.json.js";
+let __instance = null;
+export const initWorkspace = (repoRoot) => Workspace.__init(repoRoot);
+export const workspace = () => Workspace.__get();
+export class Workspace {
+    repoRoot;
+    _data = null;
+    static __init(repoRoot) {
+        return (__instance = new Workspace(repoRoot));
+    }
+    static __get() {
+        if (!__instance)
+            throw new Error("Workspace not initialized. initWorkspace()");
+        return __instance;
+    }
+    constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+    }
+    get pnpmWs() {
+        return jsonClone(this.data.pnpmWs);
+    }
+    get packages() {
+        return this.data.packages;
+    }
+    get mainPackage() {
+        return this.data.mainPackage;
+    }
+    set data(c) {
+        this._data = c;
+    }
+    get data() {
+        if (!this._data)
+            throw new Error(`Data not loaded. ${this.repoRoot}`);
+        return this._data;
+    }
+    async read() {
+        if (!this._data) {
+            const pnpmWs = await readWorkspaceYaml(this.repoRoot);
+            const packages = pnpmWs.packages.map((repoPath) => new Pkg(this.repoRoot, repoPath));
+            this.data = {
+                pnpmWs,
+                packages,
+                mainPackage: new Pkg(this.repoRoot, "."),
+            };
+        }
+    }
+    async loadPackages() {
+        try {
+            await this.read();
+            await Promise.all([
+                this.mainPackage.read(),
+                ...this.packages.map((pkg) => pkg.read()),
+            ]);
+            return this.packages;
+        }
+        catch {
+            return [];
+        }
+    }
+    async write() {
+        if (!this._data)
+            return;
+        await Promise.all([
+            this.mainPackage.write(),
+            ...this.packages.map((pkg) => pkg.write()),
+        ]);
+    }
+}

package/dist/workspace/WorkspacePaths.d.ts

@@ -1,7 +1 @@
-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>;
-}
+export {};

package/dist/workspace/WorkspacePaths.js

@@ -1,30 +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;
-        }
-    }
-}
+// import { stat } from "node:fs/promises";
+// import { join, relative, sep } from "node:path";
+export {};
+// const __instances: Record<string, WorkspacePaths> = {};
+// export class WorkspacePaths {
+//   public static instance(
+//     repoRoot: string,
+//     workspacesName: string = "packages",
+//   ): WorkspacePaths {
+//     const workspacesDir = join(repoRoot, workspacesName);
+//     if (!__instances[workspacesDir])
+//       __instances[workspacesDir] = new WorkspacePaths(repoRoot, workspacesDir);
+//     return __instances[workspacesDir];
+//   }
+//   private constructor(
+//     public readonly repoRoot: string,
+//     public readonly workspacesDir: string,
+//   ) {}
+//   public async workspaceByPath(path: string): Promise<string | null> {
+//     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/index.d.ts

@@ -1,3 +1,3 @@
+export * from "./Workspace.js";
 export * from "./WorkspacePaths.js";
 export * from "./workspace.common.js";
-export * from "./workspace.pkg.js";