vladx 1.3.2 → 1.5.1

package/bin/vladx

@@ -7,4 +7,7 @@
 
 const { run } = require('../src/cli/cli.js');
 
-run(process.argv.slice(2));
+run(process.argv.slice(2)).catch(err => {
+    console.error(err);
+    process.exit(1);
+});

package/examples/stdlib/ambiente.vx

@@ -0,0 +1,8 @@
+importa { prendi } da "@std/Ambiente";
+
+variabile path = prendi("PATH");
+stampa("Tuo percorso di sistema (PATH):");
+stampa(path);
+
+variabile user = prendi("USER") ?? prendi("USERNAME");
+stampa("\nUtente corrente: " + user);

package/examples/stdlib/archivio_extra.vx

@@ -0,0 +1,11 @@
+importa { elencaTutto } da "@std/ArchivioExtra";
+
+stampa("Analisi completa cartella 'src':");
+variabile fileSrc = elencaTutto("src");
+
+// Mostro solo i primi 5 per brevità
+variabile i = 0;
+per (variabile f di fileSrc) {
+    se (i < 5) stampa("- " + f);
+    i++;
+}

package/examples/stdlib/asserzione.vx

@@ -0,0 +1,11 @@
+importa { uguale, vero } da "@std/Asserzione";
+
+stampa("Esecuzione test unitari...");
+
+prova {
+    uguale(10 + 10, 20);
+    vero(5 > 0);
+    stampa("Test passati!");
+} cattura (e) {
+    stampa("Errore asserzione: " + e);
+}

package/examples/stdlib/client_web.vx

@@ -0,0 +1,7 @@
+importa { get } da "@std/ClientWeb";
+
+stampa("Recupero dati da API esterna...");
+variabile dati = get("https://jsonplaceholder.typicode.com/todos/1");
+
+stampa("Risposta ricevuta:");
+stampa(dati);

package/examples/stdlib/codifica.vx

@@ -0,0 +1,8 @@
+importa { base64, daBase64, hex, uri } da "@std/Codifica";
+
+variabile t = "VladX Core";
+
+stampa("Testo: " + t);
+stampa("Base64: " + base64(t));
+stampa("Hex: " + hex(t));
+stampa("URI encoded: " + uri("https://vlad.it?n=vlad x"));

package/examples/stdlib/collezioni.vx

@@ -0,0 +1,11 @@
+importa { CreaMappa, CreaInsieme, chiavi, valori } da "@std/Collezioni";
+
+stampa("--- MAPPA ---");
+variabile m = CreaMappa();
+m.set("chiave", "valore");
+stampa("Contenuto mappa: " + m.get("chiave"));
+
+stampa("\n--- OGGETTI ---");
+variabile obj = { nome: "Vlad", versione: 1.4 };
+stampa("Chiavi: " + chiavi(obj));
+stampa("Valori: " + valori(obj));

package/examples/stdlib/compressione.vx

@@ -0,0 +1,10 @@
+importa { comprimi, decomprimi } da "@std/Compressione";
+
+variabile segreto = "Questo è un messaggio molto lungo che vogliamo comprimere.";
+stampa("Originale (" + lunghezza(segreto) + " byte): " + segreto);
+
+variabile compresso = comprimi(segreto);
+stampa("Compresso (Base64): " + compresso);
+
+variabile decompresso = decomprimi(compresso);
+stampa("Decompresso: " + decompresso);

package/examples/stdlib/console.vx

@@ -0,0 +1,14 @@
+importa { log, errore, avviso, successo, tabella } da "@std/Console";
+
+log("Semplice log di sistema");
+successo("Operazione completata con successo!");
+avviso("Attenzione: valore instabile.");
+errore("Errore critico rilevato!");
+
+variabile dati = [
+    { id: 1, nome: "Vlad" },
+    { id: 2, nome: "Rex" }
+];
+
+stampa("\nVisualizzazione tabella:");
+tabella(dati);

package/examples/stdlib/cripto.vx

@@ -0,0 +1,8 @@
+importa { sha256, md5, uuid, casuale } da "@std/Cripto";
+
+stampa("Generazione UUID: " + uuid());
+stampa("Token casuale (Hex): " + casuale(32));
+
+variabile password = "vlad_password_sicura";
+stampa("SHA256: " + sha256(password));
+stampa("MD5: " + md5(password));

package/examples/stdlib/dati.vx

@@ -0,0 +1,21 @@
+importa { clona, fondi, raggruppa } da "@std/Dati";
+
+stampa("--- CLONE ---");
+variabile a = { x: 1 };
+variabile b = clona(a);
+b.x = 2;
+stampa("a.x (dovrebbe essere 1): " + a.x);
+
+stampa("\n--- MERGE ---");
+variabile base = { nome: "Vlad" };
+variabile extra = { eta: 25 };
+fondi(base, extra);
+stampa(base);
+
+stampa("\n--- GROUP BY ---");
+variabile persone = [
+    { nome: "Luca", citta: "Roma" },
+    { nome: "Sara", citta: "Milano" },
+    { nome: "Marco", citta: "Roma" }
+];
+stampa(raggruppa(persone, "citta"));

package/examples/stdlib/eventi.vx

@@ -0,0 +1,10 @@
+importa { CreaEmitter } da "@std/Eventi";
+
+variabile bus = CreaEmitter();
+
+bus.su("benvenuto", (dati) => {
+    stampa("Evento ricevuto! Dati: " + dati);
+});
+
+stampa("Lancio evento...");
+attendi bus.lancia("benvenuto", "Ciao da VladX");

package/examples/stdlib/json_extra.vx

@@ -0,0 +1,7 @@
+importa { codifica, analizzaSicuro } da "@std/JsonExtra";
+
+variabile dati = { api: "vladx", opzioni: [1, 2, 3] };
+stampa(codifica(dati));
+
+variabile str = '{"valido": vero}';
+stampa("Safe Parse: " + analizzaSicuro(str).valido);

package/examples/stdlib/matematica.vx

@@ -0,0 +1,9 @@
+importa { piGreco, radice, casuale, rotonda, max } da "@std/Matematica";
+
+stampa("Valore di PI: " + piGreco);
+stampa("Radice di 144: " + radice(144));
+stampa("Arrotonda 4.7: " + rotonda(4.7));
+stampa("Massimo tra 10, 50, 20: " + max(10, 50, 20));
+
+variabile n = casuale() * 10;
+stampa("Numero casuale 0-10: " + rotonda(n));

package/examples/stdlib/percorso.vx

@@ -0,0 +1,9 @@
+importa { unisci, base, cartella, estensione, assoluto } da "@std/Percorso";
+
+variabile mioFile = "/home/utente/progetti/test.vx";
+
+stampa("File: " + mioFile);
+stampa("Base: " + base(mioFile));
+stampa("Cartella: " + cartella(mioFile));
+stampa("Estensione: " + estensione(mioFile));
+stampa("Percorso assoluto di 'src': " + assoluto("src"));

package/examples/stdlib/processo.vx

@@ -0,0 +1,9 @@
+importa { id, memoria, piattaforma, versioneNode } da "@std/Processo";
+
+stampa("--- INFO PROCESSO ---");
+stampa("ID: " + id);
+stampa("Piattaforma: " + piattaforma);
+stampa("Node Version: " + versioneNode);
+
+stampa("\nUso memoria:");
+stampa(memoria());

package/examples/stdlib/server_web.vx

@@ -0,0 +1,10 @@
+importa { rispondiJson, errore } da "@std/ServerWeb";
+
+// Esempio d'uso teorico con Rete.server (vedi documentazione)
+// gestore = (richiesta) => {
+//     ritorna rispondiJson({ stato: "ok", msg: "Ciao da VladX" });
+// };
+
+variabile resp = rispondiJson({ id: 1 });
+stampa("Esempio risposta JSON:");
+stampa(resp);

package/examples/stdlib/sql_helper.vx

@@ -0,0 +1,7 @@
+importa { generaInsert } da "@std/SqlHelper";
+
+variabile utente = { nome: "Vlad", eta: 25, ruolo: "Admin" };
+variabile sql = generaInsert("utenti", utente);
+
+stampa("SQL generato:");
+stampa(sql);

package/examples/stdlib/tempo.vx

@@ -0,0 +1,9 @@
+importa { data, ora, pausa, timestamp } da "@std/Tempo";
+
+stampa("Oggi è il: " + data());
+stampa("Ora attuale: " + ora());
+stampa("Timestamp: " + timestamp());
+
+stampa("\nAttendo 1 secondo...");
+attendi pausa(1000);
+stampa("Fine attesa.");

package/examples/stdlib/testo.vx

@@ -0,0 +1,10 @@
+importa { maiuscolo, minuscolo, capitalizza, slugify, pulisci } da "@std/Testo";
+
+variabile testo = "   vladx è fantastico   ";
+
+stampa("Originale: '" + testo + "'");
+stampa("Pulisci: '" + pulisci(testo) + "'");
+stampa("Maiuscolo: " + maiuscolo(testo));
+stampa("Minuscolo: " + minuscolo(testo));
+stampa("Capitalizza: " + capitalizza("vlad"));
+stampa("Slugify: " + slugify("Benvenuti su VladX 2.0!"));

package/examples/stdlib/url.vx

@@ -0,0 +1,11 @@
+importa { analizza, componi } da "@std/Url";
+
+variabile link = "https://vladx.org/search?q=syntax&lang=it#top";
+variabile info = analizza(link);
+
+stampa("Host: " + info.host);
+stampa("Protocollo: " + info.protocollo);
+stampa("Query: " + info.query.q);
+
+variabile nuovoLink = componi("https://api.test.com", { chiave: "123", utente: "vlad" });
+stampa("Nuovo URL: " + nuovoLink);

package/examples/stdlib/validazione.vx

@@ -0,0 +1,5 @@
+importa { email, url, ip } da "@std/Validazione";
+
+stampa("Email valida? " + email("test@vladx.it")); // vero
+stampa("URL valido? " + url("httttp://errore")); // falso
+stampa("IP valido? " + ip("192.168.1.1")); // vero

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vladx",
-  "version": "1.3.2",
+  "version": "1.5.1",
   "description": "VladX - Linguaggio di programmazione con sintassi italiana",
   "main": "src/index.js",
   "type": "commonjs",
@@ -19,5 +19,9 @@
     "interpreter"
   ],
   "author": "VladX Team",
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "better-sqlite3": "^12.6.2",
+    "mysql2": "^3.16.2"
+  }
 }

package/programs/1/index.vx

@@ -1,4 +1,16 @@
-stampa("Ciao dal programma 1!");
-costante saluti = { matteo: "Ciao!", vlad: "Ehilà!" };
-stampa("Matteo dice: " + saluti.matteo);
-stampa("Vlad dice: " + saluti.vlad);
+classe Persona {
+    funzione costruttore(nome, eta) {
+        questo.nome = nome;
+        questo.eta = eta;
+    }
+
+    funzione saluta() {
+        stampa("Ciao, sono " + questo.nome + " e ho " + questo.eta + " anni");
+    }
+}
+
+variabile p1 = nuovo Persona("Mario", 25);
+p1.saluta();
+
+variabile p2 = nuovo Persona("Luigi", 30);
+p2.saluta();

package/programs/main/index.vx

@@ -1,12 +1,15 @@
 variabile passport = {}
 passport.nome = chiedi("Come ti chiami? ")
-passport.eta = chiedi("Quanti anni hai? ")
-
-se(passport.eta >= 18) {
-    stampa("Sei maggiorenne")
+se(Archivio.esiste(`passports/${passport.nome}.json`))  {
+    stampa("GIA ESISTE, VATTENE!!")
 } altrimenti {
-    stampa("Sei minorenne")
-}
-stampa(passport)
+    passport.eta = chiedi("Quanti anni hai? ")
+
+    se(passport.eta >= 18) {
+        stampa("Sei maggiorenne")
+    } altrimenti {
+        stampa("Sei minorenne")
+    }
 
-Archivio.scrivi(`passports/${passport.nome}.txt`, JSON.stringify(passport))
+    Archivio.scrivi(`passports/${passport.nome}.json`, JSON.stringify(passport))
+}

package/programs/main/passports/Alina.json

@@ -0,0 +1 @@
+{"nome":"Alina","eta":"39"}

package/programs/main/passports/Tanya.json

@@ -0,0 +1 @@
+{"nome":"Tanya","eta":"70"}

package/programs/main/passports/vlad.json

@@ -0,0 +1 @@
+{"nome":"vlad","eta":"13"}

package/programs/main/test_async.vx

@@ -0,0 +1,25 @@
+stampa("--- Test Async/Await ---")
+
+asincrono funzione aspetta_e_ritorna(ms, val) {
+    stampa(`Attendo ${ms}ms...`)
+    aspetta(ms) // Nota: 'aspetta' è sincrono bloccante nella mia implementazione attuale, ma simula lavoro.
+    // Per testare await vero, avrei bisogno di funzioni async native che ritornano promise.
+    // Ma 'asincrono' funzione ritorna Promise, quindi 'attendi' dovrebbe funzionare su di essa.
+    stampa("Fatto!")
+    ritorna val
+}
+
+asincrono funzione main() {
+    stampa("Inizio main")
+    variabile p = aspetta_e_ritorna(500, 42)
+    stampa(`P è una Promise? ${tipo(p) == 'promessa'}`) // Dovrebbe essere vero (promessa)
+    
+    variabile risultato = attendi p
+    stampa(`Risultato: ${risultato}`)
+    
+    variabile diretto = attendi aspetta_e_ritorna(200, 100)
+    stampa(`Diretto: ${diretto}`)
+}
+
+attendi main()
+stampa("Fine script")

package/programs/main/test_async_advanced.vx

@@ -0,0 +1,35 @@
+stampa("--- Test Async Advanced ---")
+
+// 1. Async Arrow Function
+variabile saluta = asincrono (nome) => {
+    aspetta(100)
+    ritorna `Ciao, ${nome}!`
+}
+
+// 2. Async Class Method
+classe Lavoratore {
+    funzione costruttore(nome) {
+        questo.nome = nome
+    }
+
+    asincrono funzione lavora(compito) {
+        stampa(`${questo.nome} sta lavorando a: ${compito}...`)
+        aspetta(300)
+        ritorna `${compito} completato`
+    }
+}
+
+asincrono funzione test() {
+    stampa("Test Arrow Function...")
+    variabile promessa = saluta("Vlad")
+    stampa(`Tipo: ${tipo(promessa)}`)
+    stampa(attendi promessa)
+
+    stampa("\nTest Class Method...")
+    variabile v = nuovo Lavoratore("Vlado")
+    variabile res = attendi v.lavora("Refactoring")
+    stampa(res)
+}
+
+attendi test()
+stampa("\nFine Test Advanced")

package/programs/main/test_backend.vx

@@ -0,0 +1,33 @@
+stampa("--- Test Base64 ---")
+variabile testo = "Ciao VladX"
+variabile enc = Base64.codifica(testo)
+stampa(`Encoded: ${enc}`)
+variabile dec = Base64.decodifica(enc)
+stampa(`Decoded: ${dec}`)
+
+stampa("\n--- Test Buffer ---")
+variabile buf = Buffer.from("Hello", "utf8")
+stampa(`Is Buffer: ${Buffer.isBuffer(buf)}`)
+
+stampa("\n--- Test SQLite ---")
+variabile db = SQLite.apri("test.db")
+db.esegui("CREATE TABLE IF NOT EXISTS utenti (id INTEGER PRIMARY KEY, nome TEXT)")
+variabile result = db.esegui("INSERT INTO utenti (nome) VALUES ('Marco')")
+stampa(`Inserito ID: ${result.ultimoId}`)
+variabile utenti = db.interroga("SELECT * FROM utenti")
+stampa(`Utenti: ${JSON.stringify(utenti)}`)
+db.chiudi()
+Archivio.elimina("test.db")
+
+stampa("\n--- Test MySQL (connection failure expected) ---")
+prova {
+    variabile conn = MySQL.connetti({
+        host: "127.0.0.1",
+        user: "root",
+        password: "wrong_password",
+        connectTimeout: 2000
+    })
+    conn.chiudi()
+} cattura (err) {
+    stampa(`Errore catturato correttamente: ${err}`)
+}

package/programs/tests/test_new_features.vx

@@ -0,0 +1,53 @@
+// Test Nuove Funzionalità VladX
+
+stampa("--- TEST SCEGLI-CASO ---");
+variabile colore = "verde";
+scegli (colore) {
+    caso "rosso":
+        stampa("Alt!");
+        interrompi;
+    caso "verde":
+        stampa("Vai!");
+        interrompi;
+    predefinito:
+        stampa("Colore ignoto");
+}
+
+stampa("\n--- TEST DESTRUTTURAZIONE ---");
+variabile [a, b] = [10, 20];
+stampa("a: " + a + ", b: " + b); // 10, 20
+
+variabile { nome, eta } = { nome: "Vlad", eta: 25, citta: "Roma" };
+stampa("Nome: " + nome + ", Eta: " + eta); // Vlad, 25
+
+stampa("\n--- TEST OPERATORE TERNARIO ---");
+variabile x = 10;
+variabile risultato = x > 5 ? "Maggiore" : "Minore";
+stampa("Risultato: " + risultato); // Maggiore
+
+stampa("\n--- TEST NULLISH COALESCING ---");
+variabile n = nullo;
+variabile val = n ?? "Default";
+stampa("Valore: " + val); // Default
+
+stampa("\n--- TEST OPTIONAL CHAINING ---");
+variabile utente = { info: { nome: "Luca" } };
+stampa("Nome utente: " + utente?.info?.nome); // Luca
+stampa("Cognome utente: " + (utente?.info?.cognome ?? "N/A")); // N/A
+
+stampa("\n--- TEST METODI ARRAY ---");
+variabile numeri = [1, 2, 3, 4, 5];
+variabile raddoppiati = attendi numeri.mappa((n) => n * 2);
+stampa("Raddoppiati: " + raddoppiati); // [2, 4, 6, 8, 10]
+
+variabile pari = attendi numeri.filtra((n) => n % 2 == 0);
+stampa("Pari: " + pari); // [2, 4]
+
+stampa("\n--- TEST MATEMATICA ---");
+stampa("PI: " + Matematica.piGreco);
+stampa("Radice di 16: " + Matematica.radice(16));
+stampa("Casuale (0-1): " + Matematica.casuale());
+
+stampa("\n--- TEST TEMPO ---");
+stampa("Data oggi: " + Tempo.data());
+stampa("Ora attuale: " + Tempo.ora());

package/programs/tests/test_stdlib.vx

@@ -0,0 +1,26 @@
+// Test Integrazione Standard Library VladX
+
+importa { maiuscolo, slugify } da "@std/Testo";
+importa { sha256, uuid } da "@std/Cripto";
+importa { log, successo, avviso } da "@std/Console";
+importa { data, ora } da "@std/Tempo"; // Modulo integrato precendente (ora anche in @std/Cronometro)
+importa { media, somma } da "@std/Calcolo";
+
+stampa("--- TEST @std/Testo ---");
+stampa("Maiuscolo: " + maiuscolo("vladx"));
+stampa("Slug: " + slugify("Questo è un test!"));
+
+stampa("\n--- TEST @std/Cripto ---");
+stampa("SHA256: " + sha256("segreto"));
+stampa("UUID: " + uuid());
+
+stampa("\n--- TEST @std/Calcolo ---");
+variabile voti = [10, 8, 9, 7];
+stampa("Media: " + media(voti));
+stampa("Somma: " + somma(voti));
+
+stampa("\n--- TEST @std/Console ---");
+successo("Questo è un messaggio di successo!");
+avviso("Attenzione: questo è un avviso.");
+
+stampa("\n--- FINE TEST ---");

package/programs/tests/test_templates.vx

@@ -0,0 +1,8 @@
+// Test Template Strings
+variabile nome = "Vlad";
+variabile eta = 25;
+variabile messaggio = `Ciao, mi chiamo ${nome} e ho ${eta} anni.`;
+stampa(messaggio);
+
+variabile calc = `Il doppio di ${eta} è ${eta * 2}.`;
+stampa(calc);

package/src/cli/cli.js

@@ -52,7 +52,7 @@ function showVersion() {
     console.log(`VladX v${VERSION}`);
 }
 
-function runFile(filePath) {
+async function runFile(filePath) {
     const absolutePath = path.resolve(filePath);
 
     if (!fs.existsSync(absolutePath)) {
@@ -71,7 +71,7 @@ function runFile(filePath) {
 
         const interpreter = new Interpreter();
         interpreter.currentPath = absolutePath;
-        interpreter.interpret(ast);
+        await interpreter.interpret(ast);
     } catch (error) {
         console.error(colorize(`✗ Errore: ${error.message}`, 'red'));
         process.exit(1);
@@ -129,9 +129,11 @@ function showAST(filePath) {
     }
 }
 
-function run(args) {
+async function run(args) {
     if (args.length === 0) {
-        startREPL();
+        startREPL(); // REPL start is synchronous in loop initialization but internal loop is async, it doesn't return promise of completion?
+        // startREPL calls repl.start(). repl.start() sets up listeners and returns. 
+        // It keeps process alive via readline.
         return;
     }
 
@@ -159,7 +161,7 @@ function run(args) {
                 console.error(colorize('✗ Errore: Specificare un file da eseguire', 'red'));
                 process.exit(1);
             }
-            runFile(args[1]);
+            await runFile(args[1]);
             break;
 
         case 'lex':
@@ -181,7 +183,7 @@ function run(args) {
         default:
             // Assume it's a file path
             if (command.endsWith('.vx') || fs.existsSync(command)) {
-                runFile(command);
+                await runFile(command);
             } else {
                 console.error(colorize(`✗ Comando sconosciuto: ${command}`, 'red'));
                 console.log('Usa "vladx --help" per vedere i comandi disponibili.');