nano-wait-js 1.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luiz Filipe Seabra de marco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# Nano-Wait-JS
+

package/nano-wait.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+// nano-wait.js
+const os = require('os');
+const wifi = require('node-wifi');
+
+// Inicializa node-wifi
+wifi.init({ iface: null }); // null = qualquer interface
+
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+
+// Função para obter pontuação de Wi-Fi (0-1)
+async function wifiScore(ssid) {
+    if (!ssid) return 0;
+    try {
+        const networks = await wifi.scan();
+        const network = networks.find(n => n.ssid === ssid);
+        if (!network) return 0;
+        // RSSI normalizado de -100 a 0 dBm → 0 a 1
+        const score = clamp((network.signal_level + 100)/100, 0, 1);
+        return score;
+    } catch (e) {
+        return 0;
+    }
+}
+
+// Função principal de espera
+async function wait(t = 1, options = {}) {
+    const {
+        smart = false,
+        profile = 'default',
+        explain = false,
+        verbose = false,
+        headless = false,
+        wifiSSID = null
+    } = options;
+
+    // Perfis de execução
+    const profiles = {
+        ci: { minFactor: 0.5, maxFactor: 1.5, verbose: true },
+        testing: { minFactor: 0.8, maxFactor: 1.2, verbose: false },
+        rpa: { minFactor: 0.9, maxFactor: 1.1, verbose: false },
+        default: { minFactor: 0.8, maxFactor: 1.2, verbose: false }
+    };
+
+    const prof = profiles[profile] || profiles.default;
+
+    // CPU load
+    let cpuLoad = 0;
+    if (smart) {
+        const cpus = os.cpus();
+        const idle = cpus.map(c => c.times.idle);
+        const total = cpus.map(c => Object.values(c.times).reduce((a,b)=>a+b,0));
+        const avgIdle = idle.reduce((a,b)=>a+b,0)/idle.length;
+        const avgTotal = total.reduce((a,b)=>a+b,0)/total.length;
+        cpuLoad = 1 - (avgIdle / avgTotal);
+    }
+
+    // Wi-Fi score
+    let wifi_score = 0;
+    if (smart && wifiSSID && !headless) {
+        wifi_score = await wifiScore(wifiSSID);
+    }
+
+    // Fator adaptativo combinando CPU + Wi-Fi
+    let factor = 1;
+    if (smart) {
+        factor = clamp(1 - ((cpuLoad + wifi_score)/2), prof.minFactor, prof.maxFactor);
+    }
+
+    // Tempo final (mínimo 50ms)
+    const finalTime = Math.max(0.05, t * factor);
+
+    if (verbose || prof.verbose) {
+        console.log(`[NanoWait] requested=${t}s factor=${factor.toFixed(2)} final=${finalTime.toFixed(2)}s cpuLoad=${cpuLoad.toFixed(2)} wifiScore=${wifi_score.toFixed(2)} profile=${profile}`);
+    }
+
+    if (explain) {
+        return {
+            requested: t,
+            final: finalTime,
+            cpuLoad,
+            wifiScore: wifi_score,
+            factor,
+            profile
+        };
+    }
+
+    return new Promise(res => setTimeout(res, finalTime * 1000));
+}
+
+// ===================== CLI =====================
+if (require.main === module) {
+    // Executado via terminal
+    const args = process.argv.slice(2); // remove node + arquivo
+    const t = parseFloat(args[0]) || 1;
+
+    const options = {
+        smart: args.includes('--smart'),
+        explain: args.includes('--explain'),
+        verbose: args.includes('--verbose'),
+        headless: args.includes('--headless'),
+        profile: 'default',
+        wifiSSID: null
+    };
+
+    // Ver perfil
+    const profileIndex = args.findIndex(a => ['ci','testing','rpa','default'].includes(a));
+    if (profileIndex >= 0) options.profile = args[profileIndex];
+
+    // Wi-Fi
+    const wifiIndex = args.findIndex(a => a.startsWith('--wifi='));
+    if (wifiIndex >= 0) options.wifiSSID = args[wifiIndex].split('=')[1];
+
+    (async () => {
+        const result = await wait(t, options);
+        if (options.explain) console.log(result);
+    })();
+}
+
+// Exporta para uso via require()
+module.exports = { wait };

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "nano-wait-js",
+  "version": "1.0.0",
+  "description": "Adaptive wait engine for Node.js inspired by NanoWait Python",
+  "main": "nano-wait.js",
+  "bin": {
+    "nano-wait": "./nano-wait.js"
+  },
+  "scripts": {
+    "test": "node teste.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LuizSeabraDeMarco/Nano-Wait-JS.git"
+  },
+  "keywords": ["nano-wait", "adaptive wait", "automation", "rpa", "smart wait"],
+  "author": "Luiz Seabra",
+  "license": "MIT",
+  "dependencies": {
+    "node-wifi": "^2.0.15"
+  },
+  "type": "commonjs"
+}

package/teste.js

@@ -0,0 +1,16 @@
+// test.js
+const { wait } = require('./nano-wait');
+
+(async () => {
+    console.log('=== Teste do NanoWait ===\n');
+
+    console.log('1) Espera simples de 2 segundos adaptativa (smart + verbose):');
+    await wait(2, { smart: true, profile: 'testing', verbose: true });
+    console.log('Fim da espera!\n');
+
+    console.log('2) Espera com explain mode:');
+    const report = await wait(1.5, { smart: true, profile: 'ci', explain: true, verbose: true });
+    console.log('Relatório do Explain Mode:');
+    console.log(report);
+    console.log('\nTeste concluído!');
+})();