@mxpicture/build-api 0.2.15 → 0.2.17

package/dist/barrel/Barrel.js

@@ -1,8 +1,8 @@
 import { basename, dirname, join, relative } from "node:path";
 import { readdir, rm, writeFile } from "node:fs/promises";
-import { Pkg } from "../pkg/Pkg.js";
 import { logInfo, logSuccess } from "../logger/Logger.js";
 import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
+import { readPackageJsonThrow, writePackageJson, } from "../workspace/workspace.pkg.js";
 // /** File patterns to exclude from barrel exports */
 export const DEFAULT_EXCLUDED_PATTERNS = [
     /\.test\.ts$/,
@@ -94,16 +94,15 @@ export class Barrel {
     }
     async updatePackageExports(packageDir, packageJsonPath, exports) {
         try {
-            const pkgJson = new Pkg(packageJsonPath);
             const pkgName = relative(this.paths.workspacesDir, packageDir);
             logInfo(`📦 updating ${pkgName} package.json ...`);
-            const pkg = await pkgJson.readJson();
+            const pkg = await readPackageJsonThrow(packageJsonPath);
             if (!this.hasExportsChanged(exports, pkg.exports)) {
                 logInfo(`🧹 No changes in ${pkgName}, nothing to do`);
                 return;
             }
             pkg.exports = { ...exports };
-            await pkgJson.writeJson(pkg);
+            await writePackageJson(packageJsonPath, pkg);
             logSuccess(`✅ ${pkgName} update successful`);
         }
         catch (error) {

package/dist/deps/FixWorkspaceDeps.js

@@ -1,6 +1,6 @@
 import { logInfo, logSuccess } from "../logger/Logger.js";
 import { DepsReplacementMode, } from "../types/types.deps.js";
-import { buildMapEntries, readPackageJsons, writePackageJsons, } from "../workspace/workspace.common.js";
+import { buildMapEntries, readPackageEntries, writePackageEntries, } from "../workspace/workspace.pkg.js";
 export const runFixDeps = async (p) => instanceFixDeps(p).run();
 export const instanceFixDeps = (p) => p.replacement === DepsReplacementMode.version
     ? new FixWorkspaceDepsVersion(p.repoRoot, p.mode)
@@ -17,7 +17,7 @@ export class IFixWorkspaceDeps {
             logInfo("🔧 Fixing workspace dependencies...\n");
         else
             logInfo("🔧 Restoring workspace dependencies...\n");
-        const pkgs = await readPackageJsons(this.repoRoot);
+        const pkgs = await readPackageEntries(this.repoRoot);
         const mapEntries = buildMapEntries(pkgs);
         const versionMap = new Map();
         const workspacePackages = new Set();
@@ -44,7 +44,7 @@ export class IFixWorkspaceDeps {
                 throw err;
             }
         }
-        await writePackageJsons(pkgs);
+        await writePackageEntries(pkgs);
         if (this.mode === "fix")
             logSuccess("✅ Done fixing workspace dependencies!");
         else

package/dist/format/format.code.d.ts

@@ -1,5 +1,5 @@
 import { SourceFile } from "../types/types.code.js";
 export declare const formatCode: (...lines: string[]) => Promise<string>;
 export declare const formatJson: (...lines: string[]) => Promise<string>;
-export declare const formatJson2Spaces: (...lines: string[]) => Promise<string>;
+export declare const formatJsonStringify: (...lines: string[]) => Promise<string>;
 export declare const createSourceFiles: (filePaths: string[]) => SourceFile[];

package/dist/format/format.code.js

@@ -2,7 +2,7 @@ import ts from "typescript";
 import { format } from "prettier";
 export const formatCode = async (...lines) => format(lines.join("\n"), { parser: "typescript" });
 export const formatJson = async (...lines) => format(lines.join("\n"), { parser: "json" });
-export const formatJson2Spaces = async (...lines) => format(lines.join("\n"), { parser: "json", tabWidth: 2, useTabs: false });
+export const formatJsonStringify = async (...lines) => format(lines.join("\n"), { parser: "json-stringify" });
 export const createSourceFiles = (filePaths) => {
     const program = ts.createProgram(filePaths, {
         target: ts.ScriptTarget.ES2023,

package/dist/npmPublish/NpmPublisher.js

@@ -1,8 +1,8 @@
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
-import { readPackageJson } from "../workspace/workspace.common.js";
 import { logError, logInfo, logSuccess } from "../logger/Logger.js";
 import { execAsync } from "../common/common.fs.js";
+import { readPackageJson } from "../workspace/workspace.pkg.js";
 export const runNpmPublisher = async (params) => new NpmPublisher(params.packagesDir).run();
 export class NpmPublisher {
     packagesDir;

package/dist/pkg/SyncPkgVersion.d.ts

@@ -0,0 +1,13 @@
+import { BumpParams, PackageEntry, SyncPkgVersionParams } from "../types/types.package.js";
+import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
+export declare const runSyncPkgVersion: (params: SyncPkgVersionParams) => Promise<void>;
+export declare class SyncPkgVersion {
+    protected readonly paths: WorkspacePaths;
+    protected readonly bump?: BumpParams | undefined;
+    constructor(paths: WorkspacePaths, bump?: BumpParams | undefined);
+    run(): Promise<void>;
+    protected read(): Promise<PackageEntry[]>;
+    protected readRoot(): Promise<PackageEntry>;
+    protected write(entries: PackageEntry[]): Promise<void>;
+    protected writeRoot(entry: PackageEntry): Promise<void>;
+}

package/dist/pkg/SyncPkgVersion.js

@@ -0,0 +1,45 @@
+import { join } from "node:path";
+import { readPackageEntries, readPackageEntryThrow, writePackageEntries, writePackageEntry, } from "../workspace/workspace.pkg.js";
+import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
+import { bumpVersion, compareVersionsGT, concatVersion, splitVersion, } from "./pkg.common.js";
+export const runSyncPkgVersion = async (params) => new SyncPkgVersion(WorkspacePaths.instance(params.repoRoot, params.workspacesName), params.bump).run();
+export class SyncPkgVersion {
+    paths;
+    bump;
+    constructor(paths, bump) {
+        this.paths = paths;
+        this.bump = bump;
+    }
+    async run() {
+        const [entries, root] = await Promise.all([this.read(), this.readRoot()]);
+        let maxVersion = splitVersion(root.content.version);
+        for (const entry of entries) {
+            const version = splitVersion(entry.content.version);
+            if (compareVersionsGT(version, maxVersion))
+                maxVersion = version;
+        }
+        // bump
+        maxVersion = bumpVersion(maxVersion, this.bump ?? { patch: true });
+        const newVersion = concatVersion(maxVersion);
+        // set/update
+        root.content.version = newVersion;
+        root.modified = true;
+        for (const entry of entries) {
+            entry.content.version = newVersion;
+            entry.modified = true;
+        }
+        await Promise.all([this.write(entries), this.writeRoot(root)]);
+    }
+    async read() {
+        return await readPackageEntries(this.paths.repoRoot);
+    }
+    async readRoot() {
+        return readPackageEntryThrow(join(this.paths.repoRoot, "package.json"));
+    }
+    async write(entries) {
+        await writePackageEntries(entries);
+    }
+    async writeRoot(entry) {
+        await writePackageEntry(entry);
+    }
+}

package/dist/pkg/index.d.ts

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

package/dist/pkg/index.js

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

package/dist/pkg/pkg.common.d.ts

@@ -1,5 +1,6 @@
-import { PackageVersion } from "../types/types.package.js";
+import { BumpParams, PackageVersion } from "../types/types.package.js";
 export declare const splitVersion: (version: string) => PackageVersion;
 export declare const concatVersion: (version: PackageVersion) => string;
 export declare const compareVersions: (a: PackageVersion | string, b: PackageVersion | string) => number;
 export declare const compareVersionsGT: (a: PackageVersion | string, b: PackageVersion | string) => boolean;
+export declare const bumpVersion: (version: PackageVersion, bump: BumpParams) => PackageVersion;

package/dist/pkg/pkg.common.js

@@ -39,3 +39,19 @@ export const compareVersions = (a, b) => {
     return 0;
 };
 export const compareVersionsGT = (a, b) => compareVersions(a, b) > 0;
+export const bumpVersion = (version, bump) => {
+    const result = { ...version };
+    if (bump.major) {
+        result.major = result.major ? result.major + 1 : 1;
+        result.minor = 0;
+        result.patch = 0;
+    }
+    else if (bump.minor) {
+        result.minor = result.minor ? result.minor + 1 : 1;
+        result.patch = 0;
+    }
+    else if (bump.patch) {
+        result.patch = result.patch ? result.patch + 1 : 1;
+    }
+    return result;
+};

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

@@ -1,3 +1,4 @@
+import { RunRepoRootWsParams } from "./types.run.js";
 export interface PackageVersion {
     major: number;
     minor: number | null;
@@ -16,7 +17,7 @@ export interface PackageJson {
 }
 export interface PackageEntry {
     jsonPath: string;
-    repoPath: string;
+    repoPath: string | null;
     wsName: string;
     content: PackageJson;
     modified: boolean;
@@ -26,3 +27,11 @@ export interface MapEntry {
     toPkg: PackageEntry;
     relPath: string;
 }
+export interface BumpParams {
+    major?: boolean;
+    minor?: boolean;
+    patch?: boolean;
+}
+export interface SyncPkgVersionParams extends RunRepoRootWsParams {
+    bump?: BumpParams;
+}

package/dist/workspace/index.d.ts

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

package/dist/workspace/index.js

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

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

@@ -1,14 +1,5 @@
 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 readPackageJsonSync: (dirOrFilepath: string) => 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/workspace/workspace.common.js

@@ -1,11 +1,7 @@
-import { readdir, readFile, writeFile } from "node:fs/promises";
+import { readdir, readFile } from "node:fs/promises";
 import { WorkspaceFileType, } from "../types/types.workspace.js";
-import { join, relative, resolve } from "node:path";
-import { splitVersion, compareVersions, concatVersion, } from "../pkg/pkg.common.js";
-import json5 from "json5";
+import { join, resolve } from "node:path";
 import { parse } from "yaml";
-import { logInfo, logSuccess } from "../logger/Logger.js";
-import { readFileSync } from "node:fs";
 export const DEFAULT_WORKSPACE_FILE_ENDING = ".code-workspace";
 export const getFileType = (filename) => filename.endsWith(DEFAULT_WORKSPACE_FILE_ENDING)
     ? WorkspaceFileType.workspace
@@ -82,81 +78,3 @@ export const readWorkspaceYaml = async (repoRoot) => {
         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 json5.parse(await readFile(pkgPath, "utf8"));
-};
-export const readPackageJsonSync = (dirOrFilepath) => {
-    const pkgPath = dirOrFilepath.endsWith("/package.json")
-        ? dirOrFilepath
-        : join(dirOrFilepath, "package.json");
-    return json5.parse(readFileSync(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");
-        logSuccess(`  ✅ Updated ${entry.content.name}\n`);
-    }
-    else {
-        logInfo(`  ⏭️  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/workspace.pkg.d.ts

@@ -0,0 +1,15 @@
+import { PackageJson, PackageEntry, MapEntry } from "../types/types.package.js";
+export declare const readPackageJson: (dirOrFilepath: string) => Promise<PackageJson | null>;
+export declare const readPackageEntry: (dirOrFilepath: string) => Promise<PackageEntry | null>;
+export declare const readPackageJsonThrow: (dirOrFilepath: string) => Promise<PackageJson>;
+export declare const readPackageEntryThrow: (dirOrFilepath: string) => Promise<PackageEntry>;
+export declare const readPackageJsonSync: (dirOrFilepath: string) => PackageJson;
+export declare const readPackageEntrySync: (dirOrFilepath: string) => PackageEntry;
+export declare const readPackageJsons: (repoRoot: string) => Promise<PackageJson[]>;
+export declare const readPackageEntries: (repoRoot: string) => Promise<PackageEntry[]>;
+export declare const writePackageEntries: (entries: PackageEntry[]) => Promise<void[]>;
+export declare const writePackageJson: (jsonPath: string, content: PackageJson) => Promise<void>;
+export declare const writePackageEntry: (entry: 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/workspace/workspace.pkg.js

@@ -0,0 +1,123 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { splitVersion, compareVersions, concatVersion, } from "../pkg/pkg.common.js";
+import json5 from "json5";
+import { logInfo, logSuccess } from "../logger/Logger.js";
+import { readFileSync } from "node:fs";
+import { readWorkspaceYaml } from "./workspace.common.js";
+import { formatJsonStringify } from "../format/format.code.js";
+const ensurePkgJsonPath = (dirOrFilepath) => dirOrFilepath.endsWith("/package.json")
+    ? dirOrFilepath
+    : join(dirOrFilepath, "package.json");
+export const readPackageJson = async (dirOrFilepath) => {
+    try {
+        return readPackageJsonThrow(dirOrFilepath);
+    }
+    catch {
+        return null;
+    }
+};
+export const readPackageEntry = async (dirOrFilepath) => {
+    try {
+        return readPackageEntryThrow(dirOrFilepath);
+    }
+    catch {
+        return null;
+    }
+};
+export const readPackageJsonThrow = async (dirOrFilepath) => json5.parse(await readFile(ensurePkgJsonPath(dirOrFilepath), "utf8"));
+export const readPackageEntryThrow = async (dirOrFilepath) => {
+    const pkgPath = ensurePkgJsonPath(dirOrFilepath);
+    const parts = pkgPath.split(sep);
+    parts.pop();
+    const wsName = parts.pop();
+    if (!wsName)
+        throw new Error(`Path ${pkgPath} does not conatin any workspace`);
+    return {
+        jsonPath: pkgPath,
+        repoPath: null,
+        content: await readPackageJsonThrow(pkgPath),
+        modified: false,
+        wsName,
+    };
+};
+export const readPackageJsonSync = (dirOrFilepath) => json5.parse(readFileSync(ensurePkgJsonPath(dirOrFilepath), "utf8"));
+export const readPackageEntrySync = (dirOrFilepath) => {
+    const pkgPath = ensurePkgJsonPath(dirOrFilepath);
+    const parts = pkgPath.split(sep);
+    parts.pop();
+    const wsName = parts.pop();
+    if (!wsName)
+        throw new Error(`Path ${pkgPath} does not conatin any workspace`);
+    return {
+        jsonPath: pkgPath,
+        repoPath: null,
+        content: readPackageJsonSync(pkgPath),
+        modified: false,
+        wsName,
+    };
+};
+export const readPackageJsons = async (repoRoot) => (await readPackageEntries(repoRoot)).map((entry) => entry.content);
+export const readPackageEntries = 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 writePackageEntries = async (entries) => Promise.all(entries.map(writePackageEntry));
+export const writePackageJson = async (jsonPath, content) => writeFile(jsonPath, await formatJsonStringify(json5.stringify(content)));
+export const writePackageEntry = async (entry) => {
+    if (entry.modified) {
+        await writePackageJson(entry.jsonPath, entry.content);
+        logSuccess(`  ✅ package.json updated ${entry.content.name}\n`);
+    }
+    else {
+        logInfo(`  ⏭️ No changes in package.json. ${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.jsonPath, toPkg.jsonPath),
+                });
+    return versionEntries;
+};
+export const readPackageVersions = async (rootDir) => {
+    const versions = {};
+    const packageEntries = await readPackageEntries(rootDir);
+    for (const packageEntry of packageEntries) {
+        if (!packageEntry.repoPath)
+            continue;
+        versions[packageEntry.repoPath] = packageEntry.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mxpicture/build-api",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "Build utilities API",
   "type": "module",
   "author": "MXPicture",
@@ -11,7 +11,6 @@
   },
   "exports": {
     "./barrel": "./dist/barrel/index.js",
-    "./changeset": "./dist/changeset/index.js",
     "./cleanup": "./dist/cleanup/index.js",
     "./common": "./dist/common/index.js",
     "./deps": "./dist/deps/index.js",

package/dist/changeset/Changeset.d.ts

@@ -1,14 +0,0 @@
-import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
-import { ChangesetParams } from "../types/types.changeset.js";
-import { PackageJson } from "../types/types.package.js";
-export declare const runChangeset: (params: ChangesetParams) => Promise<void>;
-export declare class Changeset {
-    protected readonly paths: WorkspacePaths;
-    constructor(paths: WorkspacePaths);
-    run(): Promise<void>;
-    protected readPackages(): Promise<PackageJson[]>;
-    protected range4Compare(): Promise<string>;
-    protected findChangedPackages(range: string, packages: PackageJson[]): Promise<string[]>;
-    protected findChangedInPackage(range: string, pkg: PackageJson): Promise<string[]>;
-    protected write(changed: string[]): Promise<void>;
-}

package/dist/changeset/Changeset.js

@@ -1,84 +0,0 @@
-import { join } from "node:path";
-import { readPackageJsons } from "../workspace/workspace.common.js";
-import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
-import { execAsync } from "../common/common.fs.js";
-import { mkdir, writeFile } from "node:fs/promises";
-export const runChangeset = async (params) => new Changeset(WorkspacePaths.instance(params.repoRoot, params.workspacesName)).run();
-export class Changeset {
-    paths;
-    constructor(paths) {
-        this.paths = paths;
-    }
-    async run() {
-        const [range, packages] = await Promise.all([
-            this.range4Compare(),
-            this.readPackages(),
-        ]);
-        const changed = await this.findChangedPackages(range, packages);
-        // 4) If nothing changed, exit quietly
-        if (changed.length === 0) {
-            console.log("No publishable package changes detected.");
-            return;
-        }
-        return this.write(changed);
-    }
-    // 1) Discover workspace packages (assuming packages/*)
-    async readPackages() {
-        return (await readPackageJsons(this.paths.repoRoot)).map((p) => p.content);
-    }
-    // 2) Determine range to compare: last Changesets tag if available, else initial commit
-    async range4Compare() {
-        let lastTag = "";
-        try {
-            // Tags like @your-scope/pkg-a@0.1.1 or pkg-a@0.1.1 are created by Changesets on publish
-            lastTag = (await execAsync("git tag --list --sort=-creatordate | head -n 1")).stdout
-                .toString()
-                .trim();
-        }
-        catch { }
-        return lastTag ? `${lastTag}..HEAD` : "";
-    }
-    // 3) Find changed packages
-    async findChangedPackages(range, packages) {
-        const changed = [];
-        const results = await Promise.all(packages.map((pkg) => this.findChangedInPackage(range, pkg)));
-        for (const result of results)
-            changed.push(...result);
-        return changed;
-    }
-    async findChangedInPackage(range, pkg) {
-        const changed = [];
-        if (pkg.private)
-            return []; // ignore private packages
-        const cmd = range
-            ? `git diff --name-only ${range} -- "${pkg.dir}"`
-            : `git diff --name-only HEAD^ -- "${pkg.dir}" || true`;
-        const diff = (await execAsync(cmd, {
-            cwd: this.paths.repoRoot,
-        }))
-            .toString()
-            .split("\n")
-            .filter(Boolean)
-            // optionally ignore docs/tests-only changes:
-            .filter((f) => !/\b(README\.md|CHANGELOG\.md|\.md|\.spec\.(t|j)s|\.test\.(t|j)s)\b/i.test(f));
-        if (diff.length > 0)
-            changed.push(pkg.name);
-        return changed;
-    }
-    // 5) Write a Changeset file marking every changed package as 'patch'
-    async write(changed) {
-        const changesetDir = join(this.paths.repoRoot, ".changeset");
-        await mkdir(changesetDir, { recursive: true });
-        const sha = execAsync("git rev-parse --short HEAD").toString().trim();
-        const header = changed.map((name) => `"${name}": patch`).join("\n");
-        const body = `---
-${header}
----
-
-Auto-generated patch release for changed packages in ${sha}.
-`;
-        const filePath = join(changesetDir, `auto-${sha}.md`);
-        await writeFile(filePath, body, "utf8");
-        console.log(`Created ${filePath} for packages:\n - ${changed.join("\n - ")}`);
-    }
-}

package/dist/changeset/index.d.ts

@@ -1 +0,0 @@
-export * from "./Changeset.js";

package/dist/changeset/index.js

@@ -1,2 +0,0 @@
-// This file is auto-generated. Do not edit manually.
-export * from "./Changeset.js";

package/dist/pkg/Pkg.d.ts

@@ -1,7 +0,0 @@
-import { PackageJson } from "../types/types.package.js";
-export declare class Pkg {
-    readonly packageJsonPath: string;
-    constructor(packageJsonPath: string);
-    readJson(): Promise<PackageJson>;
-    writeJson(pkg: PackageJson): Promise<void>;
-}

package/dist/pkg/Pkg.js

@@ -1,13 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-export class Pkg {
-    packageJsonPath;
-    constructor(packageJsonPath) {
-        this.packageJsonPath = packageJsonPath;
-    }
-    async readJson() {
-        return JSON.parse(await readFile(this.packageJsonPath, "utf8"));
-    }
-    async writeJson(pkg) {
-        return writeFile(this.packageJsonPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
-    }
-}