@mxpicture/build-api 0.2.4

package/dist/barrel/Barrel.d.ts

@@ -0,0 +1,15 @@
+import { BarrelGroup, BarrelResult } from "../types/types.barrel.js";
+export declare const DEFAULT_EXCLUDED_PATTERNS: RegExp[];
+export declare const DEFAULT_HEADER = "// This file is auto-generated. Do not edit manually.\n";
+export declare class Barrel {
+    readonly packagesDir: string;
+    protected readonly excludes: RegExp[];
+    protected readonly fileHeader: string;
+    constructor(packagesDir: string, excludes?: RegExp[], fileHeader?: string);
+    run(): Promise<void>;
+    protected isExcluded(fileName: string): boolean;
+    protected persistBarrel(group: BarrelGroup): Promise<BarrelGroup>;
+    protected updatePackageExports(packageDir: string, packageJsonPath: string, exports: Record<string, string>): Promise<void>;
+    protected hasExportsChanged(a: Record<string, string> | undefined, b: Record<string, string> | undefined): boolean;
+    protected extractExports(result: BarrelResult): Record<string, string>;
+}

package/dist/barrel/Barrel.js

@@ -0,0 +1,136 @@
+import { basename, dirname, join, relative } from "node:path";
+import { readdir, rm, writeFile } from "node:fs/promises";
+import { Pkg } from "../pkg/Pkg.js";
+// /** File patterns to exclude from barrel exports */
+export const DEFAULT_EXCLUDED_PATTERNS = [
+    /\.test\.ts$/,
+    /\.spec\.ts$/,
+    /\.d\.ts$/,
+    /index\.ts$/,
+    /(.+\/|^)src\/(.+\/|)scripts?\/.+\.m?ts$/,
+    /\/4testing(\/|$)/,
+];
+// /** Header comment added to every generated barrel file */
+export const DEFAULT_HEADER = "// This file is auto-generated. Do not edit manually.\n";
+export class Barrel {
+    packagesDir;
+    excludes;
+    fileHeader;
+    constructor(packagesDir, excludes, fileHeader) {
+        this.packagesDir = packagesDir;
+        this.excludes = excludes ?? DEFAULT_EXCLUDED_PATTERNS;
+        this.fileHeader = fileHeader ?? DEFAULT_HEADER;
+    }
+    async run() {
+        const packageDirs = (await readdir(this.packagesDir)).map((p) => join(this.packagesDir, p));
+        const promises = [];
+        for (const packageDir of packageDirs) {
+            try {
+                const srcDirPath = join(packageDir, "src");
+                const packageJsonPath = join(packageDir, "package.json");
+                const items = (await readdir(srcDirPath, { recursive: true })).sort();
+                let currentGroup;
+                for (const item of items) {
+                    const filename = basename(item);
+                    const dirPath = join(srcDirPath, dirname(item));
+                    const filePath = join(dirPath, filename);
+                    if (dirPath !== currentGroup?.dirPath) {
+                        if (currentGroup)
+                            promises.push(this.persistBarrel({ ...currentGroup }));
+                        currentGroup = {
+                            dirPath,
+                            files: [],
+                            packageDir,
+                            packageJsonPath,
+                        };
+                    }
+                    if (this.isExcluded(filePath) ||
+                        (!filename.endsWith(".ts") && !filename.endsWith(".mts")))
+                        continue;
+                    currentGroup.files.push(filename);
+                }
+                if (currentGroup)
+                    promises.push(this.persistBarrel({ ...currentGroup }));
+            }
+            catch {
+                continue;
+            }
+        }
+        const barrelGroups = (await Promise.all(promises)).filter((prom) => prom.files.length > 0);
+        const results = [];
+        for (const barrelGroup of barrelGroups) {
+            let found = results.find((res) => barrelGroup.packageDir === res.packageDir);
+            if (!found) {
+                found = {
+                    barrelDirs: [],
+                    packageDir: barrelGroup.packageDir,
+                    packageJsonPath: barrelGroup.packageJsonPath,
+                };
+                results.push(found);
+            }
+            found.barrelDirs.push(barrelGroup.dirPath);
+        }
+        await Promise.all(results.map(async (res) => this.updatePackageExports(res.packageDir, res.packageJsonPath, this.extractExports(res))));
+    }
+    isExcluded(fileName) {
+        return this.excludes.some((pattern) => pattern.test(fileName));
+    }
+    async persistBarrel(group) {
+        const barrelPath = join(group.dirPath, "index.ts");
+        // no files --> skip/delete index.ts
+        if (group.files.length === 0) {
+            await rm(barrelPath, { recursive: true, force: true });
+            return group;
+        }
+        const content = `${this.fileHeader}${group.files
+            .sort()
+            .map((f) => `export * from "./${basename(f, ".ts")}.js";`)
+            .join("\n")}\n`;
+        await writeFile(barrelPath, content);
+        return group;
+    }
+    async updatePackageExports(packageDir, packageJsonPath, exports) {
+        try {
+            const pkgJson = new Pkg(packageJsonPath);
+            const pkgName = relative(this.packagesDir, packageDir);
+            console.log(`📦 updating ${pkgName} package.json ...`);
+            const pkg = await pkgJson.readJson();
+            if (!this.hasExportsChanged(exports, pkg.exports)) {
+                console.log(`🧹 No changes in ${pkgName}, nothing to do`);
+                return;
+            }
+            pkg.exports = { ...exports };
+            await pkgJson.writeJson(pkg);
+            console.log(`✅ ${pkgName} update successful`);
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    hasExportsChanged(a, b) {
+        if (!a)
+            a = {};
+        if (!b)
+            b = {};
+        if (Object.keys(a).length !== Object.keys(b).length)
+            return true;
+        if (!a && !b)
+            return false;
+        if (!a || !b)
+            return true;
+        for (const entryA of Object.entries(a)) {
+            if (b[entryA[0]] !== entryA[1])
+                return true;
+        }
+        return false;
+    }
+    extractExports(result) {
+        const record = {};
+        for (const barrelDir of result.barrelDirs) {
+            const ex = relative(join(result.packageDir, "src"), barrelDir);
+            record[`./${ex}`] = `./dist/${ex}/index.js`;
+        }
+        record["./package.json"] = "./package.json";
+        return record;
+    }
+}

package/dist/barrel/index.d.ts

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

package/dist/barrel/index.js

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

package/dist/cleanup/Cleanup.d.ts

@@ -0,0 +1,24 @@
+import { ToBeDeleted, ToCleanup } from "../types/types.cleanup.js";
+import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
+import { Logger } from "../types/types.workspace.js";
+export interface CleanupParams {
+    repoRoot: string;
+    workspacesName?: string;
+    logger?: Logger;
+    toBeDeleted?: ToBeDeleted[];
+}
+export declare const runCleanup: (params: CleanupParams) => Promise<void>;
+export declare class Cleanup {
+    protected readonly paths: WorkspacePaths;
+    protected readonly log: Logger;
+    protected readonly toBeDeleted: ToBeDeleted[];
+    constructor(paths: WorkspacePaths, log: Logger, toBeDeleted: ToBeDeleted[]);
+    run(): Promise<void>;
+    read(): Promise<ToCleanup[]>;
+    cleanup(toCleanups: ToCleanup[]): Promise<void>;
+    cleanupSingle(toCleanup: ToCleanup): Promise<void>;
+    protected readDir(dir: string): Promise<ToCleanup[]>;
+    protected buildRemovePaths(basePath: string): ToCleanup[];
+    protected move(toCleanup: ToCleanup): Promise<void>;
+    protected remove(toCleanup: ToCleanup): Promise<void>;
+}

package/dist/cleanup/Cleanup.js

@@ -0,0 +1,83 @@
+import { readdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { WorkspacePaths } from "../workspace/WorkspacePaths.js";
+// moveSuffix: e.g. mv node_modules node_modules_tmp && rm -rf node_modules_tmp (async)
+const DEFAULT_TO_BE_DELETED = [
+    { name: "node_modules", moveSuffix: "_tmp" },
+    { name: "dist", moveSuffix: "_tmp" },
+    { name: "tsconfig.tsbuildinfo" },
+    { name: ".tsbuildinfo" },
+];
+export const runCleanup = async (params) => new Cleanup(WorkspacePaths.instance(params.repoRoot, params.workspacesName), params.logger ?? (() => { }), params.toBeDeleted ?? DEFAULT_TO_BE_DELETED).run();
+export class Cleanup {
+    paths;
+    log;
+    toBeDeleted;
+    constructor(paths, log, toBeDeleted) {
+        this.paths = paths;
+        this.log = log;
+        this.toBeDeleted = toBeDeleted;
+    }
+    async run() {
+        const items = await this.read();
+        return this.cleanup(items);
+    }
+    async read() {
+        const dirs = await readdir(this.paths.workspacesDir);
+        const toCleanupsTmp = await Promise.all(dirs.map((dir) => this.readDir(dir)));
+        const toCleanups = this.buildRemovePaths(this.paths.repoRoot);
+        for (const tmp of toCleanupsTmp)
+            toCleanups.push(...tmp);
+        return toCleanups;
+    }
+    async cleanup(toCleanups) {
+        await Promise.all(toCleanups.map(async (x) => this.cleanupSingle(x)));
+    }
+    async cleanupSingle(toCleanup) {
+        this.log(`🧹 Cleanup started ${toCleanup.name} ...`);
+        try {
+            if (!toCleanup.moveTo) {
+                await this.remove(toCleanup);
+                this.log(`✅ ${toCleanup.name} removed sucessfully`);
+                return;
+            }
+            this.log(`📦 Moving ${toCleanup.name} to ${toCleanup.name}${toCleanup.moveSuffix}`);
+            await this.move(toCleanup);
+            this.log(`📦 Start async removing ${toCleanup.name} (${toCleanup.name}${toCleanup.moveSuffix})`);
+            this.remove(toCleanup)
+                .then(() => this.log(`✅ ${toCleanup.name} (async) removed sucessfully`))
+                .catch((e) => {
+                this.log(`❌ Removing ${toCleanup.name} (async) failed ${e}`);
+            });
+        }
+        catch (error) {
+            this.log(`❌ Removing ${toCleanup.name} failed ${error}`);
+        }
+    }
+    async readDir(dir) {
+        const packgeDir = join(this.paths.workspacesDir, dir);
+        if (!(await this.paths.workspaceByPath(packgeDir)))
+            return [];
+        return this.buildRemovePaths(packgeDir);
+    }
+    buildRemovePaths(basePath) {
+        return this.toBeDeleted.map((d) => {
+            const path = join(basePath, d.name);
+            return {
+                ...d,
+                path,
+                moveTo: d.moveSuffix ? `${path}${d.moveSuffix}` : undefined,
+            };
+        });
+    }
+    async move(toCleanup) {
+        if (toCleanup.moveTo)
+            return rename(toCleanup.path, toCleanup.moveTo);
+    }
+    async remove(toCleanup) {
+        return rm(toCleanup.moveTo ?? toCleanup.path, {
+            force: true,
+            recursive: true,
+        });
+    }
+}

package/dist/cleanup/index.d.ts

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

package/dist/cleanup/index.js

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

package/dist/deps/FixWorkspaceDeps.d.ts

@@ -0,0 +1,30 @@
+import { DepsProcessMode, DepsReplacementMode } from "../types/types.deps.js";
+import { FixWorkspaceDepsMain, FixWorkspaceDepsParams } from "../types/types.workspace.js";
+export declare const runFixDeps: (p: {
+    repoRoot: string;
+    mode: DepsProcessMode;
+    replacement: DepsReplacementMode;
+}) => Promise<void>;
+export declare const instanceFixDeps: (p: {
+    repoRoot: string;
+    mode: DepsProcessMode;
+    replacement: DepsReplacementMode;
+}) => FixWorkspaceDepsVersion | FixWorkspaceDepsFile;
+export declare abstract class IFixWorkspaceDeps {
+    readonly repoRoot: string;
+    readonly mode: DepsProcessMode;
+    constructor(repoRoot: string, mode: DepsProcessMode);
+    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/deps/FixWorkspaceDeps.js

@@ -0,0 +1,121 @@
+import { DepsReplacementMode } from "../types/types.deps.js";
+import { buildMapEntries, readPackageJsons, writePackageJsons, } from "../workspace/workspace.common.js";
+export const runFixDeps = async (p) => instanceFixDeps(p).run();
+export const instanceFixDeps = (p) => p.replacement === DepsReplacementMode.version
+    ? new FixWorkspaceDepsVersion(p.repoRoot, p.mode)
+    : new FixWorkspaceDepsFile(p.repoRoot, p.mode);
+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/deps/index.d.ts

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

package/dist/deps/index.js

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

package/dist/osInfo/index.d.ts

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

package/dist/osInfo/index.js

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

package/dist/osInfo/osInfo.common.d.ts

@@ -0,0 +1,4 @@
+import { OSInfo } from "../types/types.os.js";
+export declare const osInfo: () => OSInfo;
+export declare const defaultInfo: () => OSInfo;
+export declare const wslInfo: () => OSInfo;

package/dist/osInfo/osInfo.common.js

@@ -0,0 +1,56 @@
+import { join, sep } from "path";
+import * as os from "os";
+import { execSync } from "child_process";
+let __info = null;
+export const osInfo = () => {
+    if (!__info) {
+        const isWSL = os.release().toLowerCase().includes("microsoft");
+        __info = isWSL ? wslInfo() : defaultInfo();
+        if (!__info)
+            throw new Error("Load OS info failed");
+    }
+    return __info;
+};
+export const defaultInfo = () => {
+    const platform = process.platform;
+    const homedir = os.homedir();
+    const configDirParts = [];
+    if (platform === "win32") {
+        if (process.env.APPDATA)
+            configDirParts.push(process.env.APPDATA);
+    }
+    else if (platform === "darwin") {
+        configDirParts.push(homedir, "Library", "Application Support");
+    }
+    else {
+        configDirParts.push(homedir, ".config");
+    }
+    return {
+        username: os.userInfo().username,
+        homedir,
+        platform,
+        configDir: join(...configDirParts),
+    };
+};
+export const wslInfo = () => {
+    const whoamiParts = execSync("whoami.exe").toString().split(sep);
+    if (whoamiParts.length === 0)
+        throw new Error("Windows user could not be determined");
+    // const winUser = process.env["WINUSER"] || process.env["USER"];
+    const platform = process.platform;
+    let username = whoamiParts[whoamiParts.length - 1];
+    // remove AD group
+    const userParts = username.split("\\");
+    username = userParts[userParts.length - 1];
+    username = username.replace("\r", "").replace("\n", "");
+    const parts = ["/mnt", "c", "Users", username];
+    const homedir = join(...parts);
+    const configDir = join(homedir, "AppData", "Roaming");
+    return {
+        username,
+        homedir,
+        configDir,
+        platform,
+        isWSL: true,
+    };
+};

package/dist/pkg/Pkg.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,13 @@
+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");
+    }
+}

package/dist/pkg/index.d.ts

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

package/dist/pkg/index.js

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

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

@@ -0,0 +1,5 @@
+import { 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;

package/dist/pkg/pkg.common.js

@@ -0,0 +1,41 @@
+export const splitVersion = (version) => {
+    const parts = version.split(".");
+    let major = parts.shift();
+    const prefix = major.startsWith("v") ? "v" : null;
+    if (major.startsWith("v"))
+        major = major.substring(1);
+    const minor = parts.shift();
+    const patch = parts.shift();
+    return {
+        major: Number(major),
+        minor: minor ? Number(minor) : null,
+        patch: patch ? Number(patch) : null,
+        prefix,
+    };
+};
+export const concatVersion = (version) => {
+    let result = version.major.toString();
+    if (version.prefix)
+        result = version.prefix + result;
+    if (version.minor)
+        result += "." + version.minor.toString();
+    if (version.patch)
+        result += "." + version.patch.toString();
+    return result;
+};
+export const compareVersions = (a, b) => {
+    a = typeof a === "string" ? splitVersion(a) : a;
+    b = typeof b === "string" ? splitVersion(b) : b;
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor === null || b.minor === null)
+        return 0;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    if (a.patch === null || b.patch === null)
+        return 0;
+    if (a.patch !== b.patch)
+        return a.patch - b.patch;
+    return 0;
+};
+export const compareVersionsGT = (a, b) => compareVersions(a, b) > 0;

package/dist/scripts/fix-workspace-deps.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env ts-node
+export {};

package/dist/scripts/fix-workspace-deps.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env ts-node
+import { Argument, program } from "@commander-js/extra-typings";
+import { argv, cwd } from "node:process";
+import { isAbsolute, join } from "node:path";
+import { runFixDepsByVersion } from "../deps/FixWorkspaceDeps.js";
+// todo integrate into cli and use it --> thats fine because it only gets executed after build
+program
+    .version("1.0.0")
+    .description("Fix/restore workspace dependencies CLI")
+    .addArgument(new Argument("<mode>", "fix / restore").choices(["fix", "restore"]))
+    .addArgument(new Argument("<repoRoot>", "Repos root path"))
+    .action(async (mode, repoRoot) => {
+    const root = isAbsolute(repoRoot) ? repoRoot : join(cwd(), repoRoot);
+    await runFixDepsByVersion(root, mode);
+});
+program.parse(argv);

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types.barrel.js";
+export * from "./types.cleanup.js";
+export * from "./types.deps.js";
+export * from "./types.os.js";
+export * from "./types.package.js";
+export * from "./types.vscode.js";
+export * from "./types.workspace.js";

package/dist/types/index.js

@@ -0,0 +1,8 @@
+// This file is auto-generated. Do not edit manually.
+export * from "./types.barrel.js";
+export * from "./types.cleanup.js";
+export * from "./types.deps.js";
+export * from "./types.os.js";
+export * from "./types.package.js";
+export * from "./types.vscode.js";
+export * from "./types.workspace.js";

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

@@ -0,0 +1,11 @@
+export interface BarrelGroup {
+    dirPath: string;
+    files: string[];
+    packageDir: string;
+    packageJsonPath: string;
+}
+export interface BarrelResult {
+    barrelDirs: string[];
+    packageDir: string;
+    packageJsonPath: string;
+}

package/dist/types/types.barrel.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+export interface ToBeDeleted {
+    name: string;
+    moveSuffix?: string;
+}
+export interface ToCleanup extends ToBeDeleted {
+    path: string;
+    moveTo?: string;
+}

package/dist/types/types.cleanup.js

@@ -0,0 +1 @@
+export {};