@endgame45/nodescript 1.0.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@endgame45/nodescript",
+  "version": "1.0.0",
+  "main": "src/nodescript.js",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "test": "echo \"No tests specified\" && exit 0",
+    "lint": "eslint .",
+    "prepare": "npm run lint"
+  },
+  "keywords": [
+    "nodescript",
+    "node",
+    "library"
+  ],
+  "author": "horizonstudios",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2"
+  },
+  "devDependencies": {
+    "eslint": "^7.32.0"
+  }
+}

package/src/nodescript.js

@@ -0,0 +1,327 @@
+const util = require('util');
+const chalk = require('chalk');
+
+const SUPPORTED_FONTS = new Set([
+    'bold', 'dim', 'italic', 'underline', 'inverse', 'hidden', 'strikethrough'
+]);
+
+function parseColor(styler, color, isBg = false) {
+    if (!color) return styler;
+    const c = String(color).trim();
+    try {
+        if (/^#/.test(c)) {
+            return isBg ? styler.bgHex(c) : styler.hex(c);
+        }
+        if (/^rgb\(/i.test(c)) {
+            const nums = c
+                .replace(/^[^(]*\(/, '')
+                .replace(/\).*/, '')
+                .split(',')
+                .map(n => parseInt(n, 10) || 0);
+            return isBg ? styler.bgRgb(nums[0], nums[1], nums[2]) : styler.rgb(nums[0], nums[1], nums[2]);
+        }
+        // fallback to CSS keyword (named color)
+        return isBg ? styler.bgKeyword(c) : styler.keyword(c);
+    } catch (e) {
+        return styler; // if chalk call fails, return base styler
+    }
+}
+
+function applyFonts(styler, font) {
+    if (!font) return styler;
+    const parts = Array.isArray(font) ? font : String(font).split(/\s+/);
+    for (const p of parts) {
+        if (SUPPORTED_FONTS.has(p)) {
+            // chaining returns a styled chalk instance
+            styler = styler[p];
+        }
+    }
+    return styler;
+}
+
+function buildStyler(config) {
+    let styler = chalk;
+    styler = parseColor(styler, config.textColor, false);
+    styler = parseColor(styler, config.bgColor, true);
+    styler = applyFonts(styler, config.font);
+    return styler;
+}
+
+/**
+ * Parse duration input into milliseconds.
+ * Supported inputs:
+ *  - number => treated as seconds
+ *  - string with unit: "30s", "2m", "1.5h", "200ms" (unit optional -> seconds)
+ *  - object: { hours: 1, minutes: 2, seconds: 30, ms: 100 }
+ */
+function parseDuration(input) {
+    if (input == null) return 0;
+    // numeric: treat as seconds
+    if (typeof input === 'number' && Number.isFinite(input)) {
+        return Math.max(0, input) * 1000;
+    }
+    if (typeof input === 'string') {
+        const s = input.trim().toLowerCase();
+        const m = s.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)?$/);
+        if (!m) throw new TypeError('Invalid duration string: ' + input);
+        const value = parseFloat(m[1]);
+        const unit = m[2] || 's';
+        switch (unit) {
+            case 'ms': return Math.max(0, value);
+            case 's': return Math.max(0, value) * 1000;
+            case 'm': return Math.max(0, value) * 60 * 1000;
+            case 'h': return Math.max(0, value) * 60 * 60 * 1000;
+            default: return Math.max(0, value) * 1000;
+        }
+    }
+    if (typeof input === 'object') {
+        let ms = 0;
+        if (input.ms) ms += Number(input.ms) || 0;
+        if (input.seconds) ms += (Number(input.seconds) || 0) * 1000;
+        if (input.minutes) ms += (Number(input.minutes) || 0) * 60 * 1000;
+        if (input.hours) ms += (Number(input.hours) || 0) * 60 * 60 * 1000;
+        // backward-compatible: allow singular keys
+        if (input.second && !input.seconds) ms += (Number(input.second) || 0) * 1000;
+        if (input.minute && !input.minutes) ms += (Number(input.minute) || 0) * 60 * 1000;
+        if (input.hour && !input.hours) ms += (Number(input.hour) || 0) * 60 * 60 * 1000;
+        if (ms === 0 && ('value' in input)) {
+            // allow {value: 30, unit: 's'}
+            const unit = String(input.unit || 's').toLowerCase();
+            const v = Number(input.value) || 0;
+            switch (unit) {
+                case 'ms': ms += v; break;
+                case 's': ms += v * 1000; break;
+                case 'm': ms += v * 60 * 1000; break;
+                case 'h': ms += v * 60 * 60 * 1000; break;
+                default: ms += v * 1000; break;
+            }
+        }
+        return Math.max(0, ms);
+    }
+    throw new TypeError('Unsupported duration type: ' + typeof input);
+}
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+class LoopBuilder {
+    constructor(durationMs = 1000) {
+        this.durationMs = durationMs; // default interval between calls
+        this.fn = null;
+        this.fnArgs = [];
+        this._stopped = false;
+    }
+
+    // set duration (accepts same inputs as parseDuration)
+    duration(d) {
+        this.durationMs = parseDuration(d);
+        return this;
+    }
+    every(d) { return this.duration(d); }
+
+    // set target function to call; fn can be sync or async
+    call(fn, ...args) {
+        if (typeof fn !== 'function') {
+            throw new TypeError('call(fn) expects a function');
+        }
+        this.fn = fn;
+        this.fnArgs = args;
+        return this;
+    }
+
+    // stop the running loop
+    stop() {
+        this._stopped = true;
+        if (this._stopResolve) {
+            this._stopResolve();
+            this._stopResolve = null;
+        }
+        return this;
+    }
+
+    // run a fixed number of iterations
+    async times(n) {
+        if (!this.fn) throw new Error('No function set. Use .call(fn) before .times()');
+        if (!Number.isFinite(n) || n < 0) throw new TypeError('times(n) expects a non-negative number');
+
+        this._stopped = false;
+        for (let i = 0; i < n; i++) {
+            if (this._stopped) break;
+            const res = this.fn(...this.fnArgs);
+            if (res && typeof res.then === 'function') await res;
+            if (i < n - 1 && this.durationMs > 0) await sleep(this.durationMs);
+        }
+        return this;
+    }
+
+    // run while predicate returns truthy. predicate can be a function or a simple boolean accessor function
+    async while(predicate, { checkBefore = true } = {}) {
+        if (!this.fn) throw new Error('No function set. Use .call(fn) before .while()');
+        if (typeof predicate !== 'function') {
+            throw new TypeError('while(predicate) expects a function that returns boolean');
+        }
+
+        this._stopped = false;
+        if (checkBefore) {
+            while (!this._stopped && predicate()) {
+                const res = this.fn(...this.fnArgs);
+                if (res && typeof res.then === 'function') await res;
+                if (this.durationMs > 0) {
+                    // allow stop() to resolve early
+                    await Promise.race([sleep(this.durationMs), new Promise(r => { this._stopResolve = r; })]);
+                }
+            }
+        } else {
+            // run at least once, then check
+            do {
+                if (this._stopped) break;
+                const res = this.fn(...this.fnArgs);
+                if (res && typeof res.then === 'function') await res;
+                if (this.durationMs > 0) {
+                    await Promise.race([sleep(this.durationMs), new Promise(r => { this._stopResolve = r; })]);
+                }
+            } while (!this._stopped && predicate());
+        }
+        return this;
+    }
+
+    // run until predicate returns truthy
+    async until(predicate, opts) {
+        if (typeof predicate !== 'function') {
+            throw new TypeError('until(predicate) expects a function that returns boolean');
+        }
+        // run while predicate() is false
+        return this.while(() => !predicate(), opts);
+    }
+
+    // start without waiting for completion; returns controller { stop() } and a promise `done`
+    start() {
+        if (!this.fn) throw new Error('No function set. Use .call(fn) before .start()');
+        this._stopped = false;
+        const done = (async () => {
+            try {
+                // run forever until stopped
+                while (!this._stopped) {
+                    const res = this.fn(...this.fnArgs);
+                    if (res && typeof res.then === 'function') await res;
+                    if (this.durationMs > 0) {
+                        await Promise.race([sleep(this.durationMs), new Promise(r => { this._stopResolve = r; })]);
+                    }
+                }
+            } finally {
+                // noop
+            }
+        })();
+        return {
+            stop: () => this.stop(),
+            done
+        };
+    }
+}
+
+const nsc = {
+    // user-configurable properties
+    textColor: null,
+    bgColor: null,
+    font: null,
+
+    _getStyler() {
+        return buildStyler({
+            textColor: this.textColor,
+            bgColor: this.bgColor,
+            font: this.font
+        });
+    },
+
+    // nsc.log can be used in two ways:
+    // 1) nsc.log('a', 'b', 123)
+    // 2) nsc.log(() => { console.log('inside will be styled') })   <-- temporary override of console.log
+    log(...args) {
+        // callback-mode: override console.log while invoking the function
+        if (args.length === 1 && typeof args[0] === 'function') {
+            const fn = args[0];
+            const originalLog = console.log;
+            const styler = this._getStyler();
+
+            console.log = (...innerArgs) => {
+                const out = util.format(...innerArgs);
+                originalLog(styler(out));
+            };
+
+            try {
+                const result = fn();
+                // support async callbacks (promises)
+                if (result && typeof result.then === 'function') {
+                    return result
+                        .then(res => {
+                            console.log = originalLog;
+                            return res;
+                        })
+                        .catch(err => {
+                            console.log = originalLog;
+                            throw err;
+                        });
+                }
+                // sync
+                console.log = originalLog;
+                return result;
+            } catch (err) {
+                console.log = originalLog;
+                throw err;
+            }
+        }
+
+        // normal-mode: format args and print styled
+        const styler = this._getStyler();
+        const out = util.format(...args);
+        console.log(styler(out));
+    },
+
+    /**
+     * Wait for the given duration and resolve the returned Promise.
+     * - numeric values are treated as seconds
+     * - accepts strings like "30s", "2m", "1.5h", "200ms"
+     * - accepts objects like { seconds: 30 } or { hours: 1, minutes: 2 }
+     *
+     * Usage:
+     *   nsc.wait(30).then(() => main());
+     *   nsc.wait('2m').then(main);
+     *   await nsc.wait({ minutes: 1 });
+     */
+    wait(duration) {
+        const ms = parseDuration(duration);
+        return new Promise(resolve => setTimeout(resolve, ms));
+    },
+
+    // alias for fluent naming: nsc.next(30).then(...)
+    next(duration) {
+        return this.wait(duration);
+    },
+
+    // loop fluent API:
+    // Examples:
+    //   await nsc.loop.duration('2s').call(main).times(30);
+    //   await nsc.loop.duration('1m').call(main).while(() => conditionIsTrue);
+    //   const ctl = nsc.loop.duration('5s').call(main).start(); ctl.stop();
+    loop: {
+        duration(d) { return new LoopBuilder(parseDuration(d)); },
+        every(d) { return new LoopBuilder(parseDuration(d)); },
+        // start a condition-based loop; usage: nsc.loop.while(() => x===y).call(main).start()
+        while(predicate) {
+            if (typeof predicate !== 'function') throw new TypeError('loop.while(predicate) expects a function');
+            const builder = new LoopBuilder();
+            // chainable: immediate return builder with .call and .duration supported
+            builder._initialWhilePredicate = predicate;
+            // expose helper to run directly: builder.call(fn).while(predicate)
+            return {
+                call: (fn, ...args) => {
+                    builder.call(fn, ...args);
+                    return builder.while(predicate);
+                }
+            };
+        }
+    }
+};
+
+module.exports = nsc;