zshy 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -0,0 +1,697 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path/posix"));
+const arg_1 = __importDefault(require("arg"));
+const globby_1 = require("globby");
+const table_1 = require("table");
+const ts = __importStar(require("typescript"));
+const utils_1 = require("./utils.cjs");
+function isSourceFile(filePath) {
+    return (filePath.endsWith(".ts") || filePath.endsWith(".mts") || filePath.endsWith(".cts") || filePath.endsWith(".tsx"));
+}
+function removeExtension(filePath) {
+    return filePath.split(".").slice(0, -1).join(".") || filePath;
+}
+async function main() {
+    ///////////////////////////////////
+    ///    parse command line args  ///
+    ///////////////////////////////////
+    // Parse command line arguments using arg library
+    let args;
+    try {
+        args = (0, arg_1.default)({
+            "--help": Boolean,
+            "--verbose": Boolean,
+            "--project": String,
+            "--dry-run": Boolean,
+            // "--attw": Boolean,
+            // Aliases
+            "-h": "--help",
+            "-p": "--project",
+        });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            (0, utils_1.emojiLog)("❌", error.message, "error");
+        }
+        console.error(`Use --help for usage information`);
+        process.exit(1);
+    }
+    // Handle help flag
+    if (args["--help"]) {
+        console.log(`
+Usage: zshy [options]
+
+Options:
+  -h, --help             Show this help message
+  -p, --project <path>   Path to tsconfig.json file
+      --verbose          Enable verbose output
+      --dry-run          Don't write any files, just log what would be done
+
+Examples:
+  zshy                                    # Run build
+  zshy --project ./tsconfig.build.json    # Use specific tsconfig file (defaults to tsconfig.json)
+  zshy --verbose                          # Enable verbose logging
+  zshy --dry-run                          # Preview changes without writing files
+		`);
+        process.exit(0);
+    }
+    const userAgent = process.env.npm_config_user_agent;
+    let pmExec;
+    if (userAgent?.startsWith("pnpm")) {
+        pmExec = "pnpm exec";
+    }
+    else if (userAgent?.startsWith("yarn")) {
+        pmExec = "yarn exec";
+    }
+    else {
+        pmExec = "npx";
+    }
+    (0, utils_1.emojiLog)("💎", "Starting build... 🐒");
+    const isVerbose = args["--verbose"];
+    const isDryRun = args["--dry-run"];
+    const isAttw = false; // args["--attw"];
+    if (isVerbose) {
+        (0, utils_1.emojiLog)("ℹ️", "Verbose mode enabled");
+        (0, utils_1.emojiLog)("📦", `Detected package manager: ${pmExec}`);
+    }
+    if (isDryRun) {
+        (0, utils_1.emojiLog)("🔍", "Dry run mode enabled - no files will be written");
+    }
+    ///////////////////////////////////
+    ///    find and read pkg json   ///
+    ///////////////////////////////////
+    // Find package.json by scanning up the file system
+    let packageJsonPath = "./package.json";
+    let currentDir = process.cwd();
+    while (currentDir !== path.dirname(currentDir)) {
+        const candidatePath = path.join(currentDir, "package.json");
+        if (fs.existsSync(candidatePath)) {
+            packageJsonPath = candidatePath;
+            break;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    if (!fs.existsSync(packageJsonPath)) {
+        (0, utils_1.emojiLog)("❌", "package.json not found in current directory or any parent directories", "error");
+        process.exit(1);
+    }
+    // read package.json and extract the "zshy" exports config
+    // console.log("📦 Extracting entry points from package.json exports...");
+    const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const pkgJsonDir = path.dirname(packageJsonPath);
+    // print project root
+    (0, utils_1.emojiLog)("⚙️", `Detected project root: ${pkgJsonDir}`);
+    (0, utils_1.emojiLog)("📦", `Reading package.json from ./${path.relative(pkgJsonDir, packageJsonPath)}`);
+    /////////////////////////////////
+    ///    parse zshy config      ///
+    /////////////////////////////////
+    // const pkgJson = JSON.parse(fs.readFileSync("./package.json", "utf-8"));
+    const CONFIG_KEY = "zshy";
+    let config;
+    if (!pkgJson[CONFIG_KEY]) {
+        (0, utils_1.emojiLog)("❌", `No "${CONFIG_KEY}" key found in package.json`, "error");
+        process.exit(1);
+    }
+    if (typeof pkgJson[CONFIG_KEY] === "string") {
+        config = {
+            exports: { ".": pkgJson[CONFIG_KEY] },
+        };
+    }
+    else if (typeof pkgJson[CONFIG_KEY] === "object") {
+        config = { ...pkgJson[CONFIG_KEY] };
+        if (typeof config.exports === "string") {
+            config.exports = { ".": config.exports };
+        }
+        else if (typeof config.exports === "undefined") {
+            (0, utils_1.emojiLog)("❌", `Missing "exports" key in package.json#/${CONFIG_KEY}`, "error");
+            process.exit(1);
+        }
+        else if (typeof config.exports !== "object") {
+            (0, utils_1.emojiLog)("❌", `Invalid "exports" key in package.json#/${CONFIG_KEY}`, "error");
+            process.exit(1);
+        }
+        // Validate bin field if present
+        if (config.bin !== undefined) {
+            if (typeof config.bin === "string") {
+                // Keep string format - we'll handle this in entry point extraction
+            }
+            else if (typeof config.bin === "object" && config.bin !== null) {
+                // Object format is valid
+            }
+            else {
+                (0, utils_1.emojiLog)("❌", `Invalid "bin" key in package.json#/${CONFIG_KEY}, expected string or object`, "error");
+                process.exit(1);
+            }
+        }
+        // {
+        // 	exports: { ".": pkgJson[CONFIG_KEY].exports },
+        // };
+    }
+    else if (typeof pkgJson[CONFIG_KEY] === "undefined") {
+        (0, utils_1.emojiLog)("❌", `Missing "${CONFIG_KEY}" key in package.json`, "error");
+        process.exit(1);
+    }
+    else {
+        (0, utils_1.emojiLog)("❌", `Invalid "${CONFIG_KEY}" key in package.json, expected string or object`, "error");
+        process.exit(1);
+    }
+    if (isVerbose) {
+        (0, utils_1.emojiLog)("🔧", `Parsed zshy config: ${(0, utils_1.formatForLog)(config)}`);
+    }
+    ///////////////////////////
+    ///    read tsconfig    ///
+    ///////////////////////////
+    // Determine tsconfig.json path
+    let tsconfigPath;
+    if (args["--project"]) {
+        // CLI flag takes priority
+        const resolvedProjectPath = path.resolve(process.cwd(), args["--project"]);
+        if (fs.existsSync(resolvedProjectPath)) {
+            if (fs.statSync(resolvedProjectPath).isDirectory()) {
+                (0, utils_1.emojiLog)("❌", `--project must point to a tsconfig.json file, not a directory: ${resolvedProjectPath}`, "error");
+                process.exit(1);
+            }
+            else {
+                // Use the file directly
+                tsconfigPath = resolvedProjectPath;
+            }
+        }
+        else {
+            (0, utils_1.emojiLog)("❌", `tsconfig.json file not found: ${resolvedProjectPath}`, "error");
+            process.exit(1);
+        }
+    }
+    else if (config.tsconfig) {
+        // Fallback to package.json config
+        const resolvedProjectPath = path.resolve(pkgJsonDir, config.tsconfig);
+        if (fs.existsSync(resolvedProjectPath)) {
+            if (fs.statSync(resolvedProjectPath).isDirectory()) {
+                (0, utils_1.emojiLog)("❌", `zshy.tsconfig must point to a tsconfig.json file, not a directory: ${resolvedProjectPath}`, "error");
+                process.exit(1);
+            }
+            else {
+                // Use the file directly
+                tsconfigPath = resolvedProjectPath;
+            }
+        }
+        else {
+            (0, utils_1.emojiLog)("❌", `Tsconfig file not found: ${resolvedProjectPath}`, "error");
+            process.exit(1);
+        }
+    }
+    else {
+        // Default to tsconfig.json in the package.json directory
+        tsconfigPath = path.join(pkgJsonDir, "tsconfig.json");
+    }
+    const _parsedConfig = (0, utils_1.readTsconfig)(tsconfigPath);
+    if (!fs.existsSync(tsconfigPath)) {
+        // Check if tsconfig.json exists
+        (0, utils_1.emojiLog)("❌", `tsconfig.json not found at ${path.resolve(tsconfigPath)}`, "error");
+        process.exit(1);
+    }
+    (0, utils_1.emojiLog)("📁", `Reading tsconfig from ./${path.relative(pkgJsonDir, tsconfigPath)}`);
+    // if (_parsedConfig.rootDir) {
+    // 	console.error(
+    // 		`❌ rootDir is determined from your set of entrypoints; you can remove it from your tsconfig.json.`,
+    // 	);
+    // 	process.exit(1);
+    // }
+    // if (_parsedConfig.declarationDir) {
+    // 	console.error(
+    // 		`❌ declarationDir is not supported in zshy; you should remove it from your tsconfig.json.`,
+    // 	);
+    // 	process.exit(1);
+    // }
+    // set/override compiler options
+    delete _parsedConfig.customConditions; //  can't be set for CommonJS builds
+    const outDir = path.resolve(pkgJsonDir, _parsedConfig?.outDir || "./dist");
+    const relOutDir = path.relative(pkgJsonDir, outDir);
+    const declarationDir = path.resolve(pkgJsonDir, _parsedConfig?.declarationDir || relOutDir);
+    const relDeclarationDir = path.relative(pkgJsonDir, declarationDir);
+    // clean up outDir and declarationDir
+    if (relOutDir !== "") {
+        (0, utils_1.emojiLog)("🗑️", `Cleaning up outDir...`);
+        fs.rmSync(outDir, { recursive: true, force: true });
+        // // print success mesage in verbose mode
+        if (isVerbose) {
+            if (fs.existsSync(outDir)) {
+                (0, utils_1.emojiLog)("❌", `Failed to clean up outDir: ${relOutDir}. Directory still exists.`, "error");
+            }
+        }
+    }
+    else {
+        (0, utils_1.emojiLog)("🗑️", `Skipping cleanup of outDir as it contains source files`);
+    }
+    if (relDeclarationDir !== relOutDir && relDeclarationDir !== "") {
+        (0, utils_1.emojiLog)("🗑️", `Cleaning up declarationDir...`);
+        fs.rmSync(declarationDir, { recursive: true, force: true });
+        // // print success mesage in verbose mode
+        if (isVerbose) {
+            if (fs.existsSync(declarationDir)) {
+                (0, utils_1.emojiLog)("❌", `Failed to clean up declarationDir: ${relDeclarationDir}. Directory still exists.`, "error");
+            }
+        }
+    }
+    else {
+        if (isVerbose)
+            (0, utils_1.emojiLog)("🗑️", `Skipping cleanup of declarationDir as it contains source files`);
+    }
+    const tsconfigJson = {
+        ..._parsedConfig,
+        outDir,
+        target: _parsedConfig.target ?? ts.ScriptTarget.ES2020, // ensure compatible target for CommonJS
+        skipLibCheck: true, // skip library checks to reduce errors
+        declaration: true,
+        noEmit: false,
+        emitDeclarationOnly: false,
+        rewriteRelativeImportExtensions: true,
+        verbatimModuleSyntax: false,
+    };
+    if (relOutDir === "") {
+        if (!pkgJson.files) {
+            (0, utils_1.emojiLog)("⚠️", 'You\'re building your code to the project root. This means your compiled files will be generated alongside your source files.\n   ➜ Setting "files" in package.json to exclude TypeScript source from the published package.');
+            pkgJson.files = ["**/*.js", "**/*.mjs", "**/*.cjs", "**/*.d.ts", "**/*.d.mts", "**/*.d.cts"];
+        }
+        else {
+            console.warn(`⚠️  You\'re building your code to the project root. This means your compiled files will be generated alongside your source files.
+   ➜ Ensure that your "files" in package.json excludes TypeScript source files, or your users may experience .d.ts resolution issues in some environments:
+
+   "files": ["**/*.js", "**/*.mjs", "**/*.cjs", "**/*.d.ts", "**/*.d.mts", "**/*.d.cts"],
+`);
+        }
+    }
+    else {
+        if (!pkgJson.files) {
+            (0, utils_1.emojiLog)("⚠️", `The "files" key is missing in package.json. Setting to "${relOutDir}".`);
+            pkgJson.files = [relOutDir];
+            if (relOutDir !== relDeclarationDir) {
+                pkgJson.files.push(relDeclarationDir);
+            }
+        }
+    }
+    /////////////////////////////////
+    ///   extract entry points    ///
+    /////////////////////////////////
+    // Extract entry points from zshy exports config
+    (0, utils_1.emojiLog)("➡️", "Determining entrypoints...");
+    const entryPatterns = [];
+    const rows = [["Subpath", "Entrypoint"]];
+    for (const [exportPath, sourcePath] of Object.entries(config.exports)) {
+        if (exportPath.includes("package.json"))
+            continue;
+        let cleanExportPath;
+        if (exportPath === ".") {
+            cleanExportPath = pkgJson.name;
+        }
+        else if (exportPath.startsWith("./")) {
+            cleanExportPath = pkgJson.name + "/" + exportPath.slice(2);
+        }
+        else {
+            (0, utils_1.emojiLog)("⚠️", `Invalid subpath export "${exportPath}" — should start with "./"`, "warn");
+            process.exit(1);
+        }
+        if (typeof sourcePath === "string") {
+            if (sourcePath.includes("*")) {
+                if (!sourcePath.endsWith("/*")) {
+                    (0, utils_1.emojiLog)("❌", `Wildcard paths should not contain file extensions: ${sourcePath}`, "error");
+                    process.exit(1);
+                }
+                const pattern = sourcePath.slice(0, -2) + "/*.{ts,tsx,mts,cts}";
+                const wildcardFiles = await (0, globby_1.globby)([pattern], {
+                    ignore: ["**/*.d.ts"],
+                    cwd: pkgJsonDir,
+                    deep: 1,
+                });
+                entryPatterns.push(...wildcardFiles);
+                rows.push([`"${cleanExportPath}"`, `${sourcePath} (${wildcardFiles.length} matches)`]);
+            }
+            else if (isSourceFile(sourcePath)) {
+                entryPatterns.push(sourcePath);
+                rows.push([`"${cleanExportPath}"`, sourcePath]);
+            }
+        }
+    }
+    // Extract bin entry points from zshy bin config
+    if (config.bin) {
+        if (typeof config.bin === "string") {
+            // Single bin entry
+            if (isSourceFile(config.bin)) {
+                entryPatterns.push(config.bin);
+                rows.push([`bin:${pkgJson.name}`, config.bin]);
+            }
+        }
+        else {
+            // Multiple bin entries
+            for (const [binName, sourcePath] of Object.entries(config.bin)) {
+                if (typeof sourcePath === "string" && isSourceFile(sourcePath)) {
+                    entryPatterns.push(sourcePath);
+                    rows.push([`bin:${binName}`, sourcePath]);
+                }
+            }
+        }
+    }
+    console.log("   " +
+        (0, table_1.table)(rows, {
+            drawHorizontalLine: (lineIndex, rowCount) => {
+                return (lineIndex === 0 ||
+                    lineIndex === 1 ||
+                    // lineIndex === rowCount - 1 ||
+                    lineIndex === rowCount);
+            },
+        })
+            .split("\n")
+            .join("\n   ")
+            .trim());
+    ///////////////////////////////
+    ///   compute entry points  ///
+    ///////////////////////////////
+    // compute entry points
+    const entryPoints = await (0, utils_1.getEntryPoints)(entryPatterns);
+    // disallow .mts and .cts files
+    if (entryPoints.some((ep) => ep.endsWith(".mts") || ep.endsWith(".cts"))) {
+        (0, utils_1.emojiLog)("❌", "Source files with .mts or .cts extensions are not supported. Please use regular .ts files.", "error");
+        process.exit(1);
+    }
+    if (entryPoints.length === 0) {
+        (0, utils_1.emojiLog)("❌", "No entry points found matching the specified patterns in package.json#/zshy exports", "error");
+        process.exit(1);
+    }
+    ///////////////////////////////
+    ///   compute root dir      ///
+    ///////////////////////////////
+    // Compute common ancestor directory for all entry points
+    let rootDir;
+    if (tsconfigJson.rootDir) {
+        rootDir = path.resolve(tsconfigPath, tsconfigJson.rootDir);
+    }
+    else {
+        // compute rootDir from entrypoints
+        rootDir =
+            entryPoints.length > 0
+                ? entryPoints.reduce((common, entryPoint) => {
+                    const entryDir = path.dirname(path.resolve(entryPoint));
+                    const commonDir = path.resolve(common);
+                    // Find the longest common path
+                    const entryParts = entryDir.split(path.sep);
+                    const commonParts = commonDir.split(path.sep);
+                    let i = 0;
+                    while (i < entryParts.length && i < commonParts.length && entryParts[i] === commonParts[i]) {
+                        i++;
+                    }
+                    return commonParts.slice(0, i).join(path.sep) || path.sep;
+                }, path.dirname(path.resolve(entryPoints[0])))
+                : process.cwd();
+    }
+    const relRootDir = path.relative(pkgJsonDir, rootDir);
+    // Display resolved paths table
+    (0, utils_1.emojiLog)("🔧", "Resolved build paths:");
+    const pathRows = [["Location", "Resolved path"]];
+    // pathRows.push([
+    // 	"package.json",
+    // 	`./${path.relative(pkgJsonDir, packageJsonPath)}`,
+    // ]);
+    // pathRows.push(["tsconfig", `./${path.relative(pkgJsonDir, tsconfigPath)}`]);
+    pathRows.push(["rootDir", relRootDir ? `./${relRootDir}` : "."]);
+    pathRows.push(["outDir", relOutDir ? `./${relOutDir}` : "."]);
+    if (relDeclarationDir !== relOutDir) {
+        pathRows.push(["declarationDir", relDeclarationDir ? `./${relDeclarationDir}` : "."]);
+    }
+    console.log("   " +
+        (0, table_1.table)(pathRows, {
+            drawHorizontalLine: (lineIndex, rowCount) => {
+                return (lineIndex === 0 ||
+                    lineIndex === 1 ||
+                    // lineIndex === rowCount - 1 ||
+                    lineIndex === rowCount);
+            },
+        })
+            .split("\n")
+            .join("\n   ")
+            .trim());
+    const isTypeModule = pkgJson.type === "module";
+    if (isTypeModule) {
+        (0, utils_1.emojiLog)("🟨", `Package is an ES module (package.json#/type is "module")`);
+    }
+    else {
+        (0, utils_1.emojiLog)("🐢", `Package is a CommonJS module (${pkgJson.type === "commonjs" ? 'package.json#/type is "commonjs"' : 'package.json#/type not set to "module"'})`);
+    }
+    ///////////////////////////////
+    ///       compile tsc        ///
+    ///////////////////////////////
+    const uniqueEntryPoints = [...new Set(entryPoints)];
+    try {
+        if (isVerbose) {
+            (0, utils_1.emojiLog)("→", `Resolved entrypoints: ${(0, utils_1.formatForLog)(uniqueEntryPoints)}`);
+            (0, utils_1.emojiLog)("→", `Resolved compilerOptions: ${(0, utils_1.formatForLog)({
+                ...tsconfigJson,
+                module: ts.ModuleKind[tsconfigJson.module],
+                moduleResolution: ts.ModuleResolutionKind[tsconfigJson.moduleResolution],
+                target: ts.ScriptTarget[tsconfigJson.target],
+            })}`);
+        }
+        // Track all written files
+        const allWrittenFiles = [];
+        // CJS
+        (0, utils_1.emojiLog)("🧱", `Building CJS...${isTypeModule ? ` (rewriting .ts -> .cjs/.d.cts)` : ``}`);
+        const cjsFiles = await (0, utils_1.compileProject)({
+            configPath: tsconfigPath,
+            mode: isTypeModule ? "cts" : "ts",
+            verbose: isVerbose,
+            dryRun: isDryRun,
+            packageRoot: pkgJsonDir,
+            compilerOptions: {
+                ...tsconfigJson,
+                module: ts.ModuleKind.CommonJS,
+                moduleResolution: ts.ModuleResolutionKind.Node10,
+                outDir,
+            },
+        }, uniqueEntryPoints);
+        allWrittenFiles.push(...cjsFiles);
+        // ESM
+        (0, utils_1.emojiLog)("🧱", `Building ESM...${isTypeModule ? `` : ` (rewriting .ts -> .mjs/.d.mts)`}`);
+        const esmFiles = await (0, utils_1.compileProject)({
+            configPath: tsconfigPath,
+            mode: isTypeModule ? "ts" : "mts",
+            verbose: isVerbose,
+            dryRun: isDryRun,
+            packageRoot: pkgJsonDir,
+            compilerOptions: {
+                ...tsconfigJson,
+                module: ts.ModuleKind.ESNext,
+                moduleResolution: ts.ModuleResolutionKind.Bundler,
+                outDir,
+            },
+        }, uniqueEntryPoints);
+        allWrittenFiles.push(...esmFiles);
+        ///////////////////////////////////
+        ///      display written files  ///
+        ///////////////////////////////////
+        // Display files that were written or would be written (only in verbose mode)
+        if (isVerbose && allWrittenFiles.length > 0) {
+            (0, utils_1.emojiLog)("📜", `${isDryRun ? "[dryrun] " : ""}Writing files (${allWrittenFiles.length} total)...`);
+            // Sort files by relative path for consistent display
+            const sortedFiles = [...allWrittenFiles]
+                .map((file) => path.relative(pkgJsonDir, file))
+                .sort()
+                .map((relPath) => (relPath.startsWith(".") ? relPath : `./${relPath}`));
+            sortedFiles.forEach((file) => {
+                console.log(`     ${file}`);
+            });
+        }
+        ///////////////////////////////
+        ///   generate exports      ///
+        ///////////////////////////////
+        // generate package.json exports
+        (0, utils_1.emojiLog)("📦", `${isDryRun ? "[dryrun] " : ""}Updating package.json#/exports...`);
+        // Generate exports based on zshy config
+        const newExports = {};
+        const sourceDialects = config.sourceDialects || [];
+        for (const [exportPath, sourcePath] of Object.entries(config.exports)) {
+            if (exportPath.includes("package.json")) {
+                newExports[exportPath] = sourcePath;
+                continue;
+            }
+            const absSourcePath = path.resolve(pkgJsonDir, sourcePath);
+            const relSourcePath = path.relative(rootDir, absSourcePath);
+            const absJsPath = path.resolve(outDir, relSourcePath);
+            const absDtsPath = path.resolve(declarationDir, relSourcePath);
+            const relJsPath = "./" + path.relative(pkgJsonDir, absJsPath);
+            const relDtsPath = "./" + path.relative(pkgJsonDir, absDtsPath);
+            if (typeof sourcePath === "string") {
+                if (sourcePath.endsWith("/*")) {
+                    // Handle wildcard exports
+                    newExports[exportPath] = {
+                        types: relDtsPath,
+                        import: relJsPath,
+                        require: relJsPath,
+                    };
+                    for (const sd of sourceDialects) {
+                        newExports[exportPath] = {
+                            [sd]: sourcePath,
+                            ...newExports[exportPath],
+                        };
+                    }
+                }
+                else if (isSourceFile(sourcePath)) {
+                    const esmPath = removeExtension(relJsPath) + (isTypeModule ? `.js` : `.mjs`);
+                    const cjsPath = removeExtension(relJsPath) + (isTypeModule ? `.cjs` : `.js`);
+                    const dtsPath = removeExtension(relDtsPath) + (isTypeModule ? `.d.cts` : `.d.ts`); // ./
+                    newExports[exportPath] = {
+                        types: dtsPath,
+                        import: esmPath,
+                        require: cjsPath,
+                    };
+                    if (exportPath === ".") {
+                        pkgJson.main = cjsPath;
+                        pkgJson.module = esmPath;
+                        pkgJson.types = dtsPath;
+                    }
+                    for (const sd of sourceDialects) {
+                        newExports[exportPath] = {
+                            [sd]: sourcePath,
+                            ...newExports[exportPath],
+                        };
+                    }
+                }
+                else {
+                    (0, utils_1.emojiLog)("❌", `Invalid entrypoint: ${sourcePath}`, "error");
+                    process.exit();
+                }
+            }
+        }
+        if (isVerbose) {
+            (0, utils_1.emojiLog)("🔧", `Generated "exports": ${(0, utils_1.formatForLog)(newExports)}`);
+        }
+        ///////////////////////////////
+        ///      generate bin        ///
+        ///////////////////////////////
+        // Generate bin field based on zshy bin config
+        if (config.bin) {
+            (0, utils_1.emojiLog)("📦", `${isDryRun ? "[dryrun] " : ""}Updating package.json#/bin...`);
+            const newBin = {};
+            // Convert config.bin to object format for processing
+            const binEntries = typeof config.bin === "string" ? [[pkgJson.name, config.bin]] : Object.entries(config.bin);
+            for (const [binName, sourcePath] of binEntries) {
+                if (typeof sourcePath === "string" && isSourceFile(sourcePath)) {
+                    const absSourcePath = path.resolve(pkgJsonDir, sourcePath);
+                    const relSourcePath = path.relative(rootDir, absSourcePath);
+                    const absJsPath = path.resolve(outDir, relSourcePath);
+                    const relJsPath = "./" + path.relative(pkgJsonDir, absJsPath);
+                    // Use CommonJS entrypoint for bin
+                    const binPath = removeExtension(relJsPath) + (isTypeModule ? `.cjs` : `.js`);
+                    newBin[binName] = binPath;
+                }
+            }
+            // If original config.bin was a string, output as string
+            if (typeof config.bin === "string") {
+                pkgJson.bin = Object.values(newBin)[0];
+            }
+            else {
+                // Output as object
+                pkgJson.bin = newBin;
+            }
+        }
+        if (isVerbose) {
+            (0, utils_1.emojiLog)("🔧", `Generated "bin": ${(0, utils_1.formatForLog)(pkgJson.bin)}`);
+        }
+        ///////////////////////////////
+        ///     write pkg json      ///
+        ///////////////////////////////
+        // Update package.json with new exports
+        pkgJson.exports = newExports;
+        if (isDryRun) {
+            (0, utils_1.emojiLog)("📦", "[dryrun] Skipping package.json modification");
+        }
+        else {
+            fs.writeFileSync(packageJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+        }
+        if (isAttw) {
+            // run `@arethetypeswrong/cli --pack .` to check types
+            (0, utils_1.emojiLog)("🔍", "Checking types with @arethetypeswrong/cli...");
+            const { execFile } = await Promise.resolve().then(() => __importStar(require("node:child_process")));
+            const { promisify } = await Promise.resolve().then(() => __importStar(require("node:util")));
+            const execFileAsync = promisify(execFile);
+            const [cmd, ...args] = `${pmExec} @arethetypeswrong/cli --pack ${pkgJsonDir}`.split(" ");
+            console.dir([cmd, ...args], { depth: null });
+            let stdout = "";
+            let stderr = "";
+            let exitCode = 0;
+            try {
+                const result = await execFileAsync(cmd, args, {
+                    cwd: pkgJsonDir,
+                    encoding: "utf-8",
+                });
+                stdout = result.stdout;
+                stderr = result.stderr;
+            }
+            catch (error) {
+                stdout = error.stdout || "";
+                stderr = error.stderr || "";
+                exitCode = error.code || 1;
+            }
+            const output = stdout || stderr;
+            if (output) {
+                const indentedOutput = output
+                    .split("\n")
+                    .map((line) => `   ${line}`)
+                    .join("\n");
+                if (exitCode === 0) {
+                    console.log(indentedOutput);
+                }
+                else {
+                    console.error(indentedOutput);
+                    (0, utils_1.emojiLog)("⚠️", "ATTW found issues, but the build was not affected.", "warn");
+                }
+            }
+        }
+        (0, utils_1.emojiLog)("🎉", "Build complete! ✅");
+    }
+    catch (error) {
+        (0, utils_1.emojiLog)("❌", `Build failed: ${error}`, "error");
+        process.exit(1);
+    }
+}
+// Run the script
+main().catch((error) => {
+    (0, utils_1.emojiLog)("❌", `Script failed: ${error}`, "error");
+    process.exit(1);
+});