@youcan/cli 1.0.0 → 1.0.2

package/dist/utils/network.js

@@ -0,0 +1,76 @@
+import { createServer } from 'net';
+import { platform } from 'process';
+import { execaCommand } from 'execa';
+import stdout from './system/stdout.js';
+import { stripln, getcols } from './helpers.js';
+
+async function isPortAvailable(port) {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once('error', (err) => {
+            server.close();
+            if (err.code === 'EADDRINUSE')
+                resolve(false);
+            reject(err);
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port);
+    });
+}
+const PID_GETTER_CLASS_MAP = {
+    async darwin(port) {
+        const { stdout: out, stderr: err } = await execaCommand('netstat -anv -p TCP && netstat -anv -p UDP');
+        const warning = err.toString().trim();
+        warning && stdout.warn(warning);
+        const line = stripln(out, 2);
+        const col = getcols(line, [0, 3, 8], 10)
+            .filter(col => !!col[0].match(/^(udp|tcp)/))
+            .find((col) => {
+            const matches = col[1].match(/\.(\d+)$/);
+            return matches && matches[1] === String(port);
+        });
+        if (col && col[2].length)
+            return (parseInt(col[2], 10));
+        return null;
+    },
+    async linux(port) {
+        const { stdout: out, stderr: err } = await execaCommand('netstat -tunlp');
+        const warning = err.toString().trim();
+        warning && stdout.warn(warning);
+        const data = stripln(out.toString(), 2);
+        const cols = getcols(data, [3, 6], 7).find((col) => {
+            const matches = col[0].match(/:(\d+)$/);
+            return matches && matches[1] === String(port);
+        });
+        if (cols && cols[1]) {
+            const pid = cols[1].split('/', 1)[0];
+            if (pid.length)
+                return parseInt(pid, 10);
+        }
+        return null;
+    },
+    async win32(port) {
+        const { stdout: out, stderr: err } = await execaCommand('netstat -ano');
+        const warning = err.toString().trim();
+        warning && stdout.warn(warning);
+        const data = stripln(out.toString(), 4);
+        const cols = getcols(data, [1, 4], 5).find((col) => {
+            const matches = col[0].match(/:(\d+)$/);
+            return matches && matches[1] === String(port);
+        });
+        if (cols && cols[1].length && parseInt(cols[1], 10) > 0)
+            return parseInt(cols[1], 10);
+        return null;
+    },
+};
+async function getPidByPort(port) {
+    if (!(platform in PID_GETTER_CLASS_MAP))
+        throw new Error('Unsupported platform, process will have to be killed manually.');
+    const getter = PID_GETTER_CLASS_MAP[platform];
+    return await getter(port);
+}
+
+export { getPidByPort, isPortAvailable };

package/dist/utils/system/deleteFile.js

@@ -0,0 +1,12 @@
+import fs from 'fs';
+
+/**
+ * @param filePath - The path of the file to delete.
+ *
+*/
+function deleteFile(filePath) {
+    if (fs.existsSync(filePath))
+        fs.unlinkSync(filePath);
+}
+
+export { deleteFile as default };

package/dist/utils/system/ls.js

@@ -0,0 +1,9 @@
+import { readdirSync, statSync } from 'fs';
+
+function lsDir(path) {
+    return readdirSync(path).filter((file) => {
+        return statSync(`${path}/${file}`).isDirectory() && file[0] !== '.';
+    });
+}
+
+export { lsDir };

package/dist/utils/system/openLink.js

@@ -0,0 +1,15 @@
+import { execSync } from 'child_process';
+
+const { platform } = process;
+const PLATFORM_OPEN_CMD_MAP = {
+    win32: 'cmd /c start',
+    linux: 'xdg-open',
+    darwin: 'open',
+};
+function openLink(url) {
+    if (!(platform in PLATFORM_OPEN_CMD_MAP))
+        throw new Error('Platform not supported');
+    execSync(`${PLATFORM_OPEN_CMD_MAP[platform]} '${url}'`);
+}
+
+export { openLink as default };

package/dist/utils/system/saveFile.js

@@ -0,0 +1,9 @@
+import fs from 'fs';
+import { pipeline } from 'stream/promises';
+
+async function saveHttpFile(res, filename) {
+    const fileStream = fs.createWriteStream(filename);
+    return await pipeline(res.body, fileStream);
+}
+
+export { saveHttpFile };

package/dist/utils/system/stdout.js

@@ -0,0 +1,15 @@
+import kleur from 'kleur';
+
+const stdout = console;
+/**
+ * Print to standard output with meaningful colors
+ */
+function log(arg) { return stdout.log(kleur.gray(arg)); }
+function info(arg) { return log(kleur.blue(arg)); }
+function warn(arg) { return log(kleur.yellow(arg)); }
+function error(arg) { return log(kleur.bgRed().white(arg)); }
+function success(arg) { return log(kleur.green(arg)); }
+function clear() { return stdout.clear(); }
+var stdout$1 = { log, info, warn, error, clear, success };
+
+export { stdout$1 as default };

package/dist/utils/system/writeToFile.js

@@ -0,0 +1,12 @@
+import fs from 'fs';
+
+/**
+ * @param filePath - The path to the file to write to.
+ * @param content - The content to write to the file.
+ * @returns A promise that resolves when the file has been written.
+*/
+function writeToFile(filePath, content) {
+    return fs.writeFileSync(filePath, content, { encoding: 'utf-8', flag: 'w' });
+}
+
+export { writeToFile as default };

package/dist/utils/system/zipFolder.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+import archiver from 'archiver';
+import { lsDir } from './ls.js';
+
+/**
+ * Zip folder and save it to a given path and return zip folder path
+ */
+async function zipFolder(folderPath, folderName) {
+    return new Promise((resolve, reject) => {
+        try {
+            const zipPath = path.resolve(folderPath, `${folderName}.zip`);
+            const output = fs.createWriteStream(zipPath);
+            const archive = archiver('zip', {
+                zlib: { level: 9 },
+            });
+            output.on('close', () => {
+                resolve(zipPath);
+            });
+            archive.on('error', (err) => {
+                reject(err);
+            });
+            archive.pipe(output);
+            archive.directory(path.resolve(folderPath, folderName), false);
+            archive.finalize();
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+async function zipDirectory(dirPath, folderName) {
+    const ls = lsDir(dirPath);
+    return new Promise((resolve, reject) => {
+        try {
+            const zip = path.resolve(dirPath, `${folderName}.zip`);
+            const output = fs.createWriteStream(zip);
+            const archive = archiver('zip', {
+                zlib: { level: 9 },
+            });
+            output.on('close', () => {
+                resolve(zip);
+            });
+            archive.on('error', (err) => {
+                reject(err);
+            });
+            archive.pipe(output);
+            ls.forEach(folder => archive.directory(path.resolve(dirPath, folder), folder));
+            archive.finalize();
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+
+export { zipDirectory, zipFolder };

package/dist/utils/system.js

@@ -0,0 +1,17 @@
+const kill = (pid, signal = 'SIGTERM', timeout = 1000) => new Promise((resolve, reject) => {
+    process.kill(pid, signal);
+    let count = 0;
+    setInterval(() => {
+        try {
+            process.kill(pid, 0);
+        }
+        catch (e) {
+            resolve();
+        }
+        count += 100;
+        if (count > timeout)
+            reject(new Error('Timeout process kill'));
+    }, 100);
+});
+
+export { kill };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@youcan/cli",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "YouCan CLI for developers.",
   "author": "YouCan <contact@youcan.shop> (https://youcan.shop)",
   "keywords": [],