@cocreate/cli 1.49.0 → 1.51.0

package/src/commands/symlink.js

@@ -1,136 +1,153 @@
-const fs = require('fs')
-const path = require("path")
-const spawn = require('../spawn');
+const fs = require("fs");
+const path = require("path");
+const spawn = require("../spawn");
 
 const cwdPath = path.resolve(process.cwd());
-let cwdNodeModulesPath = path.resolve(cwdPath, 'node_modules')
+let cwdNodeModulesPath = path.resolve(cwdPath, "node_modules");
 
-
-let reposLength, failed = [];
+let reposLength,
+	failed = [];
 
 module.exports = async function (repos, args) {
-    reposLength = repos.length
-
-    for (let i = 0; i < repos.length; i++) {
-
-        if (cwdPath === repos[i].absolutePath && !fs.existsSync(cwdNodeModulesPath)) {
-            await install(repos[i], repos)
-            reposLength -= 1
-        } else if (repos[i].install == true) {
-            reposLength -= 1
-            await install(repos[i], repos)
-        } else if (cwdPath !== repos[i].absolutePath) {
-            await createSymlink(repos[i])
-        }
-
-    }
-
-    console.log('symlink complete');
-    return failed;
-
-}
-
+	reposLength = repos.length;
+
+	for (let i = 0; i < repos.length; i++) {
+		if (
+			cwdPath === repos[i].absolutePath &&
+			!fs.existsSync(cwdNodeModulesPath)
+		) {
+			await install(repos[i], repos);
+			reposLength -= 1;
+		} else if (repos[i].install == true) {
+			reposLength -= 1;
+			await install(repos[i], repos);
+		} else if (cwdPath !== repos[i].absolutePath) {
+			await createSymlink(repos[i]);
+		}
+	}
+
+	console.log("symlink complete");
+	return failed;
+};
 
 async function createSymlink(repo) {
-    let dpath = path.resolve(repo.absolutePath);
-    if (!fs.existsSync(dpath)) {
-        failed.push({ name: 'createSymlink', des: 'path doesn\'t exist:' + dpath })
-        return console.error(dpath, 'not exist')
-    }
-    let response = ''
-
-    try {
-        let dest = path.resolve(dpath, 'node_modules');
-        if (dest) {
-            if (fs.existsSync(dest)) {
-
-                if (!cwdNodeModulesPath.includes('/CoCreateJS')) {
-                    let isSymlink = await isSymlinkDirectory(dest)
-                    if (isSymlink) {
-                        const targetPath = await getSymlinkTargetPath(dest);
-                        if (targetPath.includes('/CoCreateJS')) {
-                            console.warn('symlink already exists with CoCreateJS')
-                            return
-                        }
-                    }
-                }
-            }
-
-            await symlink(repo.name, dest)
-
-        }
-    }
-    catch (err) {
-        failed.push({ name: 'symlink', des: 'with response:' + response + err })
-        console.error(repo.name, 'failed to aquire symlink', 'with response:', response, err)
-    }
-
+	let dpath = path.resolve(repo.absolutePath);
+	if (!fs.existsSync(dpath)) {
+		failed.push({
+			name: "createSymlink",
+			error: "path doesn't exist:" + dpath
+		});
+		return console.error(dpath, "not exist");
+	}
+	let response = "";
+
+	try {
+		let dest = path.resolve(dpath, "node_modules");
+		if (dest) {
+			if (fs.existsSync(dest)) {
+				if (!cwdNodeModulesPath.includes("/CoCreateJS")) {
+					let isSymlink = await isSymlinkDirectory(dest);
+					if (isSymlink) {
+						const targetPath = await getSymlinkTargetPath(dest);
+						if (targetPath.includes("/CoCreateJS")) {
+							console.warn(
+								"symlink already exists with CoCreateJS"
+							);
+							return;
+						}
+					}
+				}
+			}
+
+			await symlink(repo.name, dest);
+		}
+	} catch (err) {
+		failed.push({
+			name: "symlink",
+			error: "with response:" + response + err
+		});
+		console.error(
+			repo.name,
+			"failed to aquire symlink",
+			"with response:",
+			response,
+			err
+		);
+	}
 }
 
 async function symlink(name, dest) {
-    try {
-        if (fs.existsSync(dest))
-            await fs.promises.rm(dest, { recursive: true, force: true });
-
-        await fs.promises.symlink(cwdNodeModulesPath, dest, 'dir');
-        console.log(name, 'node_modules symlink added');
-
-    } catch (err) {
-        failed.push({ name: 'symlink', des: 'with response: ' + response, err });
-        console.error(repo.name, 'failed to acquire symlink', 'with response:', response, err);
-    }
+	try {
+		if (fs.existsSync(dest))
+			await fs.promises.rm(dest, { recursive: true, force: true });
+
+		await fs.promises.symlink(cwdNodeModulesPath, dest, "dir");
+		console.log(name, "node_modules symlink added");
+	} catch (err) {
+		failed.push({
+			name: "symlink",
+			error: "with response: " + response,
+			err
+		});
+		console.error(
+			repo.name,
+			"failed to acquire symlink",
+			"with response:",
+			response,
+			err
+		);
+	}
 }
 
-
 async function install(repo, repos) {
-    let dpath = repo.absolutePath
-    if (!fs.existsSync(dpath)) {
-        failed.push({ name: 'install', des: 'path doesn\'t exist:' + dpath })
-        return console.error(dpath, 'not exist')
-    }
-    try {
-        console.log('installing', repo.name)
-        let exitCode = await spawn(repo.packageManager, ['install'], {
-            cwd: repo.absolutePath,
-            shell: true,
-            stdio: 'inherit'
-        });
-
-        if (exitCode !== 0) {
-            failed.push({
-                name: repo.name,
-                des: `${repo.packageManager} install failed`
-            })
-            console.error(`${repo.name}: ${repo.packageManager} install failed`.red)
-        } else {
-            console.log(`${repo.name}: ${repo.packageManager} install succesful`.green)
-
-        }
-
-    }
-    catch (err) {
-        console.error(repo.name, 'did not install', err)
-    }
-
+	let dpath = repo.absolutePath;
+	if (!fs.existsSync(dpath)) {
+		failed.push({ name: "install", error: "path doesn't exist:" + dpath });
+		return console.error(dpath, "not exist");
+	}
+	try {
+		console.log("installing", repo.name);
+		let exitCode = await spawn(repo.packageManager, ["install"], {
+			cwd: repo.absolutePath,
+			shell: true,
+			stdio: "inherit"
+		});
+
+		if (exitCode !== 0) {
+			failed.push({
+				name: repo.name,
+				error: `${repo.packageManager} install failed`
+			});
+			console.error(
+				`${repo.name}: ${repo.packageManager} install failed`.red
+			);
+		} else {
+			console.log(
+				`${repo.name}: ${repo.packageManager} install succesful`.green
+			);
+		}
+	} catch (err) {
+		console.error(repo.name, "did not install", err);
+	}
 }
 
 async function isSymlinkDirectory(path) {
-    try {
-        const stats = await fs.promises.lstat(path);
-        return stats.isSymbolicLink();
-    } catch (err) {
-        throw err;
-    }
+	try {
+		const stats = await fs.promises.lstat(path);
+		return stats.isSymbolicLink();
+	} catch (err) {
+		throw err;
+	}
 }
 
 async function getSymlinkTargetPath(symlinkPath) {
-    try {
-        const target = await fs.promises.readlink(symlinkPath);
-        const targetPath = fs.realpathSync(target);
-        return targetPath;
-    } catch (err) {
-        throw err;
-    }
+	try {
+		const target = await fs.promises.readlink(symlinkPath);
+		const targetPath = fs.realpathSync(target);
+		return targetPath;
+	} catch (err) {
+		throw err;
+	}
 }
 
-// module.exports = { symlink }
+// module.exports = { symlink }

package/src/execute.js

@@ -1,65 +1,78 @@
 const path = require("path");
 const fs = require("fs");
-const spawn = require('./spawn');
-const util = require('node:util');
-const exec = util.promisify(require('node:child_process').exec);
-const { color } = require('./fonts');
+const spawn = require("./spawn");
+const util = require("node:util");
+const exec = util.promisify(require("node:child_process").exec);
+const { color } = require("./fonts");
 
 module.exports = async function execute(command, repos = [], config) {
-    let failed = [];
-    let args = command.replaceAll("'", '"').trim().split(' ')
-    let type = args[0]
-    args.shift()
+	let failed = [];
+	let [filename, ...args] = command.replaceAll("'", '"').trim().split(" ");
 
-    let predefined = path.resolve(__dirname, 'commands', type + '.js');
+	let type;
 
-    if (fs.existsSync(predefined)) {
-        console.warn(color.blue + `executing a predefined command in ${predefined}` + color.reset);
+	if (filename.endsWith(".js")) {
+		type = filename.slice(0, -3);
+	} else {
+		type = filename;
+		filename += ".js";
+	}
 
-        if (repos.length == 1)
-            console.log(color.blue + `running on ${repos[0].name} repo` + color.reset)
-        else if (repos.length)
-            console.log(color.blue + 'running on all repos' + color.reset)
+	let predefined = path.resolve(__dirname, "commands", filename);
+	let isPredefined = fs.existsSync(predefined);
+	let repositories = [];
 
-        failed = require(predefined)(repos, args)
+	for (let repo of repos) {
+		try {
+			if (
+				repo.exclude &&
+				(repo.exclude.includes(type) || repo.exclude.includes(filename))
+			) {
+				continue;
+			}
 
-    } else {
+			const packageJsonPath = path.resolve(repo.path, "package.json");
+			const packageObj = require(packageJsonPath);
+			repo.entry = packageObj.main;
 
-        for (let repo of repos) {
-            try {
-                if (repo.exclude && repo.exclude.includes(type))
-                    continue
-                console.log(color.green + `${repo.name}: ` + color.reset, command)
-                let exitCode;
-                if (config.hideMessage) {
-                    const { error } = await exec(command, {
-                        cwd: repo.absolutePath,
-                    });
+			if (isPredefined) {
+				repositories.push(repo);
+				continue;
+			}
 
-                    if (error)
-                        exitCode = 1
-                } else {
-                    exitCode = await spawn(type, args, {
-                        cwd: repo.absolutePath,
-                        shell: true,
-                        stdio: 'inherit'
-                    })
-                }
+			console.log(color.green + `${repo.name}: ` + color.reset, command);
+			let exitCode;
+			if (config.hideMessage) {
+				const { error } = await exec(command, {
+					cwd: repo.absolutePath
+				});
 
-                if (exitCode !== 0)
-                    failed.push({
-                        name: repo.name,
-                        des: 'command failed: ' + command
-                    })
+				if (error) exitCode = 1;
+			} else {
+				exitCode = await spawn(type, args, {
+					cwd: repo.absolutePath,
+					shell: true,
+					stdio: "inherit"
+				});
+			}
 
+			if (exitCode !== 0) {
+				repo.error = "command failed: " + command;
+				failed.push(repo);
+			}
+		} catch (err) {
+			console.error(
+				color.red +
+					`an error occured executing command in ${repo.name} repository` +
+					color.reset,
+				err.message
+			);
+		}
+	}
 
-            }
-            catch (err) {
-                console.error(color.red + `an error occured executing command in ${repo.name} repository` + color.reset, err.message);;
-            }
-        }
-    }
+	if (isPredefined) {
+		failed = require(predefined)(repositories, args);
+	}
 
-    return failed;
-
-}
+	return failed;
+};

package/src/index.js

@@ -0,0 +1,3 @@
+const config = require("./commands/config.js");
+
+module.exports = { config };

package/src/spinner.js

@@ -0,0 +1,85 @@
+// Define an object holding various spinner patterns, each pattern is an array of strings representing different frames
+const spinnerPatterns = {
+	// Dots pattern: sequential increase in dots
+	dots: [".  ", ".. ", "..."],
+
+	// Bar filling up incrementally
+	bar: ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"],
+
+	// A bouncing ball effect using Braille characters
+	bouncingBall: ["⠁", "⠂", "⠄", "⡀", "⢀", "⠠", "⠐", "⠈"],
+
+	// Wave pattern: characters form a wave-like effect
+	wave: ["⎺", "⎻", "⎼", "⎽", "⎼", "⎻"],
+
+	// Rotating arrows pattern for direction indication
+	arrows: ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
+
+	// Rotating dots pattern with increasing and decreasing length
+	rotatingDots: [
+		".    ",
+		"..   ",
+		"...  ",
+		".... ",
+		".....",
+		" ....",
+		"  ...",
+		"   ..",
+		"    ."
+	],
+
+	// Horizontal bounce pattern to simulate a bouncing ball effect
+	horizontalBounce: [
+		"[    ]",
+		"[=   ]",
+		"[==  ]",
+		"[=== ]",
+		"[ ===]",
+		"[  ==]",
+		"[   =]"
+	]
+};
+
+// spinner.js
+
+/**
+ * Creates a spinner with the specified configuration
+ * @param {Object} options - Configuration options for the spinner
+ * @param {string} options.type - The type of spinner pattern
+ * @param {number} options.milliseconds - Interval in milliseconds for frame change
+ * @param {string} options.prefix - String to prefix before the spinner frame
+ * @param {string} options.suffix - String to suffix after the spinner frame
+ * @param {Function} options.onComplete - Callback function to execute when the spinner ends
+ * @returns {Object} - An object with an `end` method to stop the spinner
+ */
+function createSpinner({
+	type = "dots", // Default type is 'dots'
+	milliseconds = 200, // Default interval time is 200 ms
+	prefix = "", // Default prefix is an empty string
+	suffix = "", // Default suffix is an empty string
+	onComplete = () => process.stdout.write("\r") // Default onComplete action is to clear the line
+}) {
+	// Get the frames for the specified spinner type, fall back to 'dots' pattern if type not found
+	const frames = spinnerPatterns[type] || spinnerPatterns.dots;
+	let spinnerIndex = 0; // Track current frame index
+
+	// Set an interval to update the spinner frame
+	const interval = setInterval(() => {
+		// Write spinner frame to the process standard output along with prefix and suffix
+		process.stdout.write(`\r${prefix}${frames[spinnerIndex]}${suffix}`);
+		// Update frame index, reset to 0 if it exceeds available frames
+		spinnerIndex = (spinnerIndex + 1) % frames.length;
+	}, milliseconds);
+
+	// Return an interface to interact with spinner
+	return {
+		// Method to stop the spinner and execute the onComplete callback
+		end: () => {
+			clearInterval(interval); // Clear the frame update interval
+			onComplete(); // Execute onComplete callback (default clears the current line)
+		}
+	};
+}
+
+// Export createSpinner function as a module
+module.exports = createSpinner;