@wavemaker-ai/wm-reactnative-cli 1.0.0

package/src/custom-logger/steps.js

@@ -0,0 +1,117 @@
+const previewSteps = [
+  {
+    step: 1,
+    start: "Setting up directories",
+    stop: "",
+    succeed: "Setup directories finished",
+    fail: "Setup directories failed",
+    info: "",
+    warn: "",
+    total: 1,
+  },
+  {
+    step: 2,
+    start: "Authenticating user",
+    stop: "",
+    succeed: "Authentication successful",
+    fail: "Authentication failed",
+    info: "",
+    warn: "",
+    total: 1,
+  },
+  {
+    step: 3,
+    start: "Downloading project",
+    stop: "",
+    succeed: "Project downloaded",
+    fail: "Project download failed",
+    info: "",
+    warn: "",
+    total: 5
+  },
+  {
+    step: 4,
+    start: "Transpiling project",
+    stop: "",
+    succeed: "Project transpiled successfully",
+    fail: "Transpiling project failed",
+    info: "",
+    warn: "",
+    total: 6
+  },
+  {
+    step: 5,
+    start: "Installing dependencies",
+    stop: "",
+    succeed: "Dependencies installed",
+    fail: "Dependencies installation failed",
+    info: "",
+    warn: "",
+    total: 4
+  },
+];
+
+
+const androidBuildSteps = [
+  {
+    step: 1,
+    start: "Setting up build directories",
+    stop: "",
+    succeed: "Project directories successfully set up.",
+    fail: "Failed to set up project directories.",
+    info: "",
+    warn: "",
+    total: 6
+  },
+  {
+    step: 2,
+    start: "Verifying prerequisites...",
+    stop: "",
+    succeed: "All required prerequisites are met.",
+    fail: "Missing or incompatible prerequisites detected.",
+    info: "",
+    warn: "",
+    total: 2
+  },
+  {
+    step: 3,
+    start: "Installing dependencies...",
+    stop: "",
+    succeed: "All dependencies installed successfully.",
+    fail: "Dependency installation failed.",
+    info: "",
+    warn: "",
+    total: 4
+  },
+  {
+    step: 4,
+    start: "Ejecting project configuration...",
+    stop: "",
+    succeed: "Project ejected successfully.",
+    fail: "Project ejection failed.",
+    info: "",
+    warn: "",
+    total: 2
+  },
+  {
+    step: 5,
+    start: "Generating Artifact...",
+    stop: "",
+    succeed: "Build successful! APK/IPA generated.",
+    fail: "Build failed! Error generating APK/IPA.",
+    info: "",
+    warn: "",
+    total: 2,
+  },
+];
+
+
+function calculateTotalSteps(process){
+    return process.reduce((sum, step) => sum + (step.total || 0), 0);
+}
+
+module.exports={
+  previewSteps,
+  androidBuildSteps,
+  calculateTotalSteps
+}

package/src/custom-logger/task-logger.js

@@ -0,0 +1,147 @@
+const readline = require("readline");
+const chalk = require("chalk");
+const { ProgressBar, overallProgressBar } = require("./progress-bar");
+
+class CustomSpinnerBar {
+    constructor(options = {}) {
+        if (!options.newInstance && CustomSpinnerBar.instance) {
+            return CustomSpinnerBar.instance;
+        }
+        
+        if (!options.newInstance) {
+            CustomSpinnerBar.instance = this;
+        }
+
+        this.text = options.text || "Loading";
+        this.spinner = options.spinner || [
+            "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏",
+        ];
+        this.interval = options.interval || 80;
+        this.stream = process.stderr;
+        this.frameIndex = 0;
+        this.isSpinning = false;
+        this.spinnerInterval = null;
+
+        this.progressBar = new ProgressBar(options);
+    }
+
+    start(text) {
+        if (global.verbose) return;
+        if (text) this.text = text;
+        this.isSpinning = true;
+        this.frameIndex = 0;
+        this.resetProgressBar();
+        this.progressBar.start();
+        this.render();
+        this.spinnerInterval = setInterval(() => this.render(), this.interval);
+        return this;
+    }
+
+    stop() {
+        if (global.verbose) return this;
+        this.isSpinning = false;
+        clearInterval(this.spinnerInterval);
+        this.spinnerInterval = null;
+        readline.clearLine(this.stream, 0);
+        readline.cursorTo(this.stream, 0);
+        return this;
+    }
+
+    succeed(text) {
+        if (global?.verbose) return this;
+        this.stop();
+
+        this.progressBar.setProgress(this.progressBar.total);
+
+        let output = `${chalk.green("✔")} ${text || this.text}`;
+        output += " " + this.progressBar.render();
+
+        this.stream.write(`${output}\n`);
+        return this;
+    }
+
+    fail(text) {
+        if (global.verbose) return this;
+        this.stop();
+        let finalText = text || this.text;
+        if(global.logDirectory){
+            finalText += chalk.gray(" Check logs at: ") + chalk.cyan(global.logDirectory);
+        }
+        this.stream.write(`${chalk.red('✖')} ${chalk.bold.red(finalText)}\n`);
+        process.exit(1);
+        // return this;
+    }
+
+    info(text) {
+        if (global.verbose) return this;
+        this.stop();
+        this.stream.write(`${chalk.blue("ℹ")} ${text || this.text}\n`);
+        return this;
+    }
+
+    warn(text) {
+        if (global.verbose) return this;
+        this.stop();
+        this.stream.write(`${chalk.yellow("⚠")} ${text || this.text}\n`);
+        return this;
+    }
+
+    render() {
+        if (global.verbose) return;
+        readline.clearLine(this.stream, 0);
+        readline.cursorTo(this.stream, 0);
+    
+        const frame = this.spinner[this.frameIndex] || '';
+        const progressBar = this.progressBar?.render() || '';
+        const overallProgress = overallProgressBar?.render() || '';
+    
+        const output = `${chalk.cyan(frame)} ${this.text} ${progressBar} ${overallProgressBar.status() ?`| ${overallProgress}` : ''}`;
+        this.stream.write(output);
+    
+        this.frameIndex = (this.frameIndex + 1) % this.spinner.length;
+    }
+    
+    setText(text) {
+        this.text = text;
+        return this;
+    }
+
+    resetProgressBar(startValue = 0) {
+        this.progressBar.value = Math.min(Math.max(0, startValue), this.progressBar.total);
+        this.progressBar.startTime = Date.now();
+        return this;
+    }
+
+    setProgress(value) {
+        this.progressBar.setProgress(value);
+        overallProgressBar.setProgress(value);
+        return this;
+    }
+
+    incrementProgress(amount = 1) {
+        this.progressBar.incrementProgress(amount);
+        overallProgressBar.incrementProgress(amount);
+        return this;
+    }
+
+    setTotal(total) {
+        this.progressBar.setTotal(total);
+        return this;
+    }
+
+    enableProgressBar() {
+        this.progressBar.enable();
+        return this;
+    }
+
+    disableProgressBar() {
+        this.progressBar.disable();
+        return this;
+    }
+}
+
+// Exporting singleton instance and function for new instance
+module.exports = {
+    spinnerBar: new CustomSpinnerBar(),
+    createNewSpinnerBar: (options) => new CustomSpinnerBar({ ...options, newInstance: true })
+};

package/src/exec.js

@@ -0,0 +1,73 @@
+const execa = require('execa');
+const logger = require('./logger');
+const loggerLabel = 'exec';
+
+function isErrorWithoutWarning(v) {
+    const lowerV = v.toLowerCase();
+    return lowerV.includes("error") && (!lowerV.includes("warning") && !lowerV.includes("warn"));
+}
+
+class OutputPipe {
+    constructor(bufferSize, log, loggerLabel) {
+        this.output = '';
+        this.content = [];
+        this.bufferSize = bufferSize || 100;
+        this.logOutput = (log !== false);
+        this.loggerLabel = loggerLabel;
+    }
+    log(str, isErrorType) {
+        let reminder = '';
+        str.split('\n').forEach((v, i, splits) => {
+            if (i < splits.length - 1) {
+                v && (this.logOutput || isErrorType) && (isErrorType && isErrorWithoutWarning(v) ? logger.error({label: this.loggerLabel, message: v}) : logger.debug({label: this.loggerLabel, message: v}));
+                if (this.content.length > this.bufferSize) {
+                    this.content.shift();
+                }
+                this.content.push(v);
+            } else {
+                reminder = v;
+            }
+        });
+        return reminder;
+    }
+    push(str, isErrorType) {
+        if (str) {
+            this.output = this.log(this.output + str, isErrorType) || '';
+        }
+    }
+    flush() {
+        this.log(this.output + '\n');
+    }
+}
+
+module.exports = {
+    'exec': (cmd, args, options) => {
+        logger.info({
+            label: loggerLabel,
+            message: `
+        \x1b[1;34m    ╔════════════════════════════════════╗
+            ║ Executing: ${cmd} ${(args && args.join(' '))}
+            ╚════════════════════════════════════╝\x1b[0m
+            `
+        });
+        
+        const outputPipe = new OutputPipe(100, options && options.log, cmd.substr(cmd.lastIndexOf('/') + 1));
+        const spawn = execa(cmd, args, {...options, env:{...process.env, FORCE_COLOR:'1'}});
+        spawn.stdout.on('data', (data) => {
+            outputPipe.push(String.fromCharCode.apply(null, new Uint16Array(data)));
+        });
+        spawn.stderr.on('data', (data) => {
+            outputPipe.push(String.fromCharCode.apply(null, new Uint16Array(data)), true);
+        });
+        return new Promise((resolve, reject) => {
+            spawn.on('close', code => {
+                outputPipe.flush();
+                if (code == 0) {
+                    resolve(outputPipe.content);
+                } else {
+                    reject(code);
+                }
+            });
+        });
+    }
+};