zshy 0.0.4 → 0.0.6

package/out/index.cjs

@@ -37,24 +37,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const globby_1 = require("globby");
-const table_1 = require("table");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path/posix"));
-const ts = __importStar(require("typescript"));
 const arg_1 = __importDefault(require("arg"));
-const utils_ts_1 = require("./utils.js");
+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"));
+    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() {
-    console.log("💎 Starting zshy build...");
     ///////////////////////////////////
     ///    parse command line args  ///
     ///////////////////////////////////
@@ -63,8 +59,12 @@ async function main() {
     try {
         args = (0, arg_1.default)({
             "--help": Boolean,
+            "--verbose": Boolean,
+            "--project": String,
+            "--dry-run": Boolean,
             // Aliases
             "-h": "--help",
+            "-p": "--project",
         });
     }
     catch (error) {
@@ -81,12 +81,27 @@ 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                   # Use ./tsconfig.json or package.json#zshy.tsconfig
+  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);
     }
+    console.log("💎 Starting zshy build...");
+    const isVerbose = args["--verbose"];
+    const isDryRun = args["--dry-run"];
+    if (isVerbose) {
+        console.log("🗣️  Verbose mode enabled");
+    }
+    if (isDryRun) {
+        console.log("🔍 Dry run mode enabled - no files will be written");
+    }
     ///////////////////////////////////
     ///    find and read pkg json   ///
     ///////////////////////////////////
@@ -133,13 +148,26 @@ Examples:
             config.exports = { ".": config.exports };
         }
         else if (typeof config.exports === "undefined") {
-            console.error(`❌ Missing "exports" key in package.json#${CONFIG_KEY}`);
+            console.error(`❌ Missing "exports" key in package.json#/${CONFIG_KEY}`);
             process.exit(1);
         }
         else if (typeof config.exports !== "object") {
-            console.error(`❌ Invalid "exports" key in package.json#${CONFIG_KEY}`);
+            console.error(`❌ Invalid "exports" key in package.json#/${CONFIG_KEY}`);
             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 {
+                console.error(`❌ Invalid "bin" key in package.json#/${CONFIG_KEY}, expected string or object`);
+                process.exit(1);
+            }
+        }
         // {
         // 	exports: { ".": pkgJson[CONFIG_KEY].exports },
         // };
@@ -152,13 +180,34 @@ Examples:
         console.error(`❌ Invalid "${CONFIG_KEY}" key in package.json, expected string or object`);
         process.exit(1);
     }
+    if (isVerbose) {
+        console.log("🔧 Parsed zshy config:", (0, utils_1.formatForLog)(config));
+    }
     ///////////////////////////
     ///    read tsconfig    ///
     ///////////////////////////
     // Determine tsconfig.json path
     let tsconfigPath;
-    if (config.tsconfig) {
-        // Resolve the provided tsconfig path against package.json directory
+    if (args["--project"]) {
+        // CLI flag takes priority
+        const resolvedProjectPath = path.resolve(process.cwd(), args["--project"]);
+        if (fs.existsSync(resolvedProjectPath)) {
+            if (fs.statSync(resolvedProjectPath).isDirectory()) {
+                console.error(`❌ --project must point to a tsconfig.json file, not a directory: ${resolvedProjectPath}`);
+                process.exit(1);
+            }
+            else {
+                // Use the file directly
+                tsconfigPath = resolvedProjectPath;
+            }
+        }
+        else {
+            console.error(`❌ tsconfig.json file not found: ${resolvedProjectPath}`);
+            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()) {
@@ -179,7 +228,7 @@ Examples:
         // Default to tsconfig.json in the package.json directory
         tsconfigPath = path.join(pkgJsonDir, "tsconfig.json");
     }
-    const _parsedConfig = (0, utils_ts_1.readTsconfig)(tsconfigPath);
+    const _parsedConfig = (0, utils_1.readTsconfig)(tsconfigPath);
     if (!fs.existsSync(tsconfigPath)) {
         // Check if tsconfig.json exists
         console.error(`❌ tsconfig.json not found at ${path.resolve(tsconfigPath)}`);
@@ -204,6 +253,34 @@ Examples:
     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 !== "") {
+        console.log(`🗑️  Cleaning up outDir...`);
+        fs.rmSync(outDir, { recursive: true, force: true });
+        // // print success mesage in verbose mode
+        if (isVerbose) {
+            if (fs.existsSync(outDir)) {
+                console.error(`❌ Failed to clean up outDir: ${relOutDir}. Directory still exists.`);
+            }
+        }
+    }
+    else {
+        console.log(`🗑️  Skipping cleanup of outDir as it contains source files`);
+    }
+    if (relDeclarationDir !== relOutDir && relDeclarationDir !== "") {
+        console.log(`🗑️  Cleaning up declarationDir...`);
+        fs.rmSync(declarationDir, { recursive: true, force: true });
+        // // print success mesage in verbose mode
+        if (isVerbose) {
+            if (fs.existsSync(declarationDir)) {
+                console.error(`❌ Failed to clean up declarationDir: ${relDeclarationDir}. Directory still exists.`);
+            }
+        }
+    }
+    else {
+        if (isVerbose)
+            console.log(`🗑️  Skipping cleanup of declarationDir as it contains source files`);
+    }
     const tsconfigJson = {
         ..._parsedConfig,
         outDir,
@@ -218,14 +295,7 @@ Examples:
     if (relOutDir === "") {
         if (!pkgJson.files) {
             console.log('⚠️  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",
-            ];
+            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.
@@ -278,10 +348,7 @@ Examples:
                     deep: 1,
                 });
                 entryPatterns.push(...wildcardFiles);
-                rows.push([
-                    `"${cleanExportPath}"`,
-                    `${sourcePath} (${wildcardFiles.length} matches)`,
-                ]);
+                rows.push([`"${cleanExportPath}"`, `${sourcePath} (${wildcardFiles.length} matches)`]);
             }
             else if (isSourceFile(sourcePath)) {
                 entryPatterns.push(sourcePath);
@@ -289,19 +356,49 @@ Examples:
             }
         }
     }
-    console.log("   " + (0, table_1.table)(rows).split("\n").join("\n   ").trim());
+    // 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_ts_1.getEntryPoints)(entryPatterns);
+    const entryPoints = await (0, utils_1.getEntryPoints)(entryPatterns);
     // disallow .mts and .cts files
     if (entryPoints.some((ep) => ep.endsWith(".mts") || ep.endsWith(".cts"))) {
         console.error("❌ Source files with .mts or .cts extensions are not supported. Please use regular .ts files.");
         process.exit(1);
     }
     if (entryPoints.length === 0) {
-        console.error("❌ No entry points found matching the specified patterns in package.json#zshy exports");
+        console.error("❌ No entry points found matching the specified patterns in package.json#/zshy exports");
         process.exit(1);
     }
     ///////////////////////////////
@@ -323,37 +420,60 @@ Examples:
                     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]) {
+                    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();
     }
-    // console.dir(_commonAncestor, { depth: null });
     const relRootDir = path.relative(pkgJsonDir, rootDir);
-    console.log(`📂 Transpiling ${relRootDir ? `./${relRootDir}` : "."} (rootDir) to ${relOutDir ? `./${relOutDir}` : "."} (outDir)`);
+    // Display resolved paths table
+    console.log("🔧 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) {
-        console.log(`📂 Writing declaration files to ${relDeclarationDir ? `./${relDeclarationDir}` : "."} (declarationDir)`);
+        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) {
-        console.log(`🟨 Package is an ES module (package.json#type is \"module\")`);
+        console.log(`🟨 Package is an ES module (package.json#/type is \"module\")`);
     }
     else {
-        console.log(`🐢 Package is a CommonJS module (${pkgJson.type === "commonjs" ? 'package.json#type is "commonjs"' : 'package.json#type not set to "module"'})`);
+        console.log(`🐢 Package is a CommonJS module (${pkgJson.type === "commonjs" ? 'package.json#/type is "commonjs"' : 'package.json#/type not set to "module"'})`);
     }
     ///////////////////////////////
     ///       compile tsc        ///
     ///////////////////////////////
     try {
+        // Track all written files
+        const allWrittenFiles = [];
         // CJS
         console.log(`🧱 Building CJS...${isTypeModule ? ` (rewriting .ts -> .cjs/.d.cts)` : ``}`);
-        await (0, utils_ts_1.compileProject)({
+        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,
@@ -361,11 +481,15 @@ Examples:
                 outDir,
             },
         }, entryPoints);
+        allWrittenFiles.push(...cjsFiles);
         // ESM
         console.log(`🧱 Building ESM...${isTypeModule ? `` : ` (rewriting .ts -> .mjs/.d.mts)`}`);
-        await (0, utils_ts_1.compileProject)({
+        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,
@@ -373,11 +497,27 @@ Examples:
                 outDir,
             },
         }, entryPoints);
+        allWrittenFiles.push(...esmFiles);
+        ///////////////////////////////////
+        ///      display written files  ///
+        ///////////////////////////////////
+        // Display files that were written or would be written (only in verbose mode)
+        if (isVerbose && allWrittenFiles.length > 0) {
+            console.log(`📜 ${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
-        console.log("📦 Updating package.json exports...");
+        console.log("📦 Updating package.json#/exports...");
         // Generate exports based on zshy config
         const newExports = {};
         const sourceDialects = config.sourceDialects || [];
@@ -386,15 +526,26 @@ Examples:
                 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
-                    const relSourcePath = "./" +
-                        path.relative(pkgJsonDir, path.resolve(outDir, sourcePath.slice(0, -2))) +
-                        "/*";
+                    // const relSourcePath =
+                    // 	"./" +
+                    // 	path.relative(
+                    // 		pkgJsonDir,
+                    // 		path.resolve(outDir, sourcePath.slice(0, -2)),
+                    // 	) +
+                    // 	"/*";
                     newExports[exportPath] = {
-                        import: relSourcePath,
-                        require: relSourcePath,
+                        types: relDtsPath,
+                        import: relJsPath,
+                        require: relJsPath,
                     };
                     for (const sd of sourceDialects) {
                         newExports[exportPath] = {
@@ -404,44 +555,18 @@ Examples:
                     }
                 }
                 else if (isSourceFile(sourcePath)) {
-                    // Handle regular TypeScript entry points
-                    // const basePath = sourcePath.slice(0, -3); // ./v4/index.ts
-                    const absSourcePath = path.resolve(pkgJsonDir, sourcePath); // /path/to/v4/index.ts
-                    const sourcePathRelativeToRootDir = path.relative(rootDir, absSourcePath); // index.ts
-                    const outPath = path.resolve(pkgJsonDir, outDir, sourcePathRelativeToRootDir); // /path/to/dist/index.ts
-                    const outPathNoExt = removeExtension(outPath); // /path/to/dist/index
-                    // For declaration files, use declarationDir if it's different from outDir
-                    const declarationPath = path.resolve(pkgJsonDir, declarationDir, sourcePathRelativeToRootDir); // /path/to/types/index.ts
-                    const declarationPathNoExt = removeExtension(declarationPath); // /path/to/types/index
-                    const esmFile = isTypeModule
-                        ? `${outPathNoExt}.js`
-                        : `${outPathNoExt}.mjs`; // ./v4/index.js or ./v4/index.mjs
-                    const cjsFile = isTypeModule
-                        ? `${outPathNoExt}.cjs`
-                        : `${outPathNoExt}.js`;
-                    const dtsFile = isTypeModule
-                        ? `${declarationPathNoExt}.d.cts`
-                        : `${declarationPathNoExt}.d.ts`;
-                    const relEsmFile = "./" + path.relative(pkgJsonDir, esmFile);
-                    const relCjsFile = "./" + path.relative(pkgJsonDir, cjsFile);
-                    const relDtsFile = "./" + path.relative(pkgJsonDir, dtsFile);
+                    const esmPath = removeExtension(relJsPath) + (isTypeModule ? `.js` : `.mjs`); // ./v4/index.js or ./v4/index.mjs
+                    const cjsPath = removeExtension(relJsPath) + (isTypeModule ? `.cjs` : `.js`);
+                    const dtsPath = removeExtension(relDtsPath) + (isTypeModule ? `.d.cts` : `.d.ts`); // ./
                     newExports[exportPath] = {
-                        types: relDtsFile,
-                        import: relEsmFile,
-                        require: relCjsFile,
-                        // import: {
-                        //   types: relDtsFile,
-                        //   default: relEsmFile,
-                        // },
-                        // require: {
-                        //   types: relDtsFile,
-                        //   default: relCjsFile,
-                        // },
+                        types: dtsPath,
+                        import: esmPath,
+                        require: cjsPath,
                     };
                     if (exportPath === ".") {
-                        pkgJson.main = relCjsFile;
-                        pkgJson.module = relEsmFile;
-                        pkgJson.types = relDtsFile;
+                        pkgJson.main = cjsPath;
+                        pkgJson.module = esmPath;
+                        pkgJson.types = dtsPath;
                     }
                     for (const sd of sourceDialects) {
                         newExports[exportPath] = {
@@ -450,6 +575,45 @@ Examples:
                         };
                     }
                 }
+                else {
+                    console.error(`❌ Invalid entrypoint: ${sourcePath}`);
+                    process.exit();
+                }
+            }
+        }
+        ///////////////////////////////
+        ///      generate bin        ///
+        ///////////////////////////////
+        // Generate bin field based on zshy bin config
+        if (config.bin) {
+            console.log("📦 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];
+                if (isVerbose) {
+                    console.log(`🗣️ Updated package.json#/bin: "${Object.values(newBin)[0]}"`);
+                }
+            }
+            else {
+                // Output as object
+                pkgJson.bin = newBin;
+                if (isVerbose) {
+                    console.log("🗣️  Updated package.json#/bin: " + (0, utils_1.formatForLog)(newBin));
+                }
             }
         }
         ///////////////////////////////
@@ -457,9 +621,16 @@ Examples:
         ///////////////////////////////
         // Update package.json with new exports
         pkgJson.exports = newExports;
-        fs.writeFileSync(packageJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
-        // console.log("✅ Updating package.json#exports");
-        console.log("   " + JSON.stringify(newExports, null, 2).split("\n").join("\n   "));
+        if (isDryRun) {
+            console.log("🔍 Skipping package.json modification (dry-run)");
+        }
+        else {
+            fs.writeFileSync(packageJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+        }
+        // console.log("✅ Updating package.json#/exports");
+        if (isVerbose) {
+            console.log(`🗣️  Updated package.json#/exports: ${(0, utils_1.formatForLog)(newExports)}`);
+        }
         // // run `@arethetypeswrong/cli --pack .` to check types
         // console.log("🔍 Checking types with @arethetypeswrong/cli...");
         // const { execSync } = await import("node:child_process");