treste 2.0.0 → 2.1.0

package/dist/std-native.js

@@ -0,0 +1,705 @@
+"use strict";
+/**
+ * Native Standard Library Implementations
+ * Bibliotecas nativas em TypeScript para o Trest Language
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdModules = exports.StdCrypto = exports.StdDate = exports.StdJSON = exports.StdFileSystem = exports.StdDatabase = exports.StdGUI = exports.StdAsync = exports.StdHTTP = void 0;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const url_1 = require("url");
+/**
+ * ========================================
+ * HTTP Module - Cliente e Servidor HTTP
+ * ========================================
+ */
+class StdHTTP {
+    /**
+     * GET Request
+     */
+    static async GET(url, options = {}) {
+        return this.request(url, 'GET', null, options);
+    }
+    /**
+     * POST Request
+     */
+    static async POST(url, data, options = {}) {
+        return this.request(url, 'POST', data, options);
+    }
+    /**
+     * PUT Request
+     */
+    static async PUT(url, data, options = {}) {
+        return this.request(url, 'PUT', data, options);
+    }
+    /**
+     * DELETE Request
+     */
+    static async DELETE(url, options = {}) {
+        return this.request(url, 'DELETE', null, options);
+    }
+    /**
+     * Generic HTTP Request
+     */
+    static request(urlStr, method, data = null, options = {}) {
+        return new Promise((resolve, reject) => {
+            try {
+                const url = new url_1.URL(urlStr);
+                const isHttps = url.protocol === 'https:';
+                const requestOptions = {
+                    hostname: url.hostname,
+                    port: url.port || (isHttps ? 443 : 80),
+                    path: url.pathname + url.search,
+                    method: method,
+                    headers: options.headers || {
+                        'Content-Type': 'application/json',
+                    },
+                };
+                const client = isHttps ? https : http;
+                const req = client.request(requestOptions, (res) => {
+                    let body = '';
+                    res.on('data', (chunk) => {
+                        body += chunk;
+                    });
+                    res.on('end', () => {
+                        try {
+                            const parsed = JSON.parse(body);
+                            resolve({
+                                status: res.statusCode,
+                                data: parsed,
+                                headers: res.headers,
+                            });
+                        }
+                        catch {
+                            resolve({
+                                status: res.statusCode,
+                                data: body,
+                                headers: res.headers,
+                            });
+                        }
+                    });
+                });
+                req.on('error', (error) => {
+                    reject({ status: 0, error: error.message });
+                });
+                if (data) {
+                    const dataStr = typeof data === 'string' ? data : JSON.stringify(data);
+                    req.write(dataStr);
+                }
+                req.end();
+            }
+            catch (error) {
+                reject({ status: 0, error: error.message });
+            }
+        });
+    }
+    /**
+     * Create HTTP Server
+     */
+    static createServer() {
+        const routes = new Map();
+        const addRoute = (method, path, handler) => {
+            if (!routes.has(path)) {
+                routes.set(path, new Map());
+            }
+            routes.get(path).set(method, handler);
+        };
+        const server = http.createServer((req, res) => {
+            const handlers = routes.get(req.url || '/');
+            const handler = handlers?.get(req.method || 'GET');
+            if (handler) {
+                const requestObj = {
+                    url: req.url,
+                    method: req.method,
+                    headers: req.headers,
+                    body: '',
+                };
+                let body = '';
+                req.on('data', (chunk) => {
+                    body += chunk;
+                });
+                req.on('end', () => {
+                    try {
+                        requestObj.body = JSON.parse(body);
+                    }
+                    catch {
+                        requestObj.body = body;
+                    }
+                    const responseObj = {
+                        status: (code) => {
+                            res.statusCode = code;
+                            return responseObj;
+                        },
+                        send: (data) => {
+                            const dataStr = typeof data === 'string' ? data : JSON.stringify(data);
+                            res.end(dataStr);
+                            return responseObj;
+                        },
+                        json: (data) => {
+                            res.setHeader('Content-Type', 'application/json');
+                            res.end(JSON.stringify(data));
+                            return responseObj;
+                        },
+                    };
+                    handler(requestObj, responseObj);
+                });
+            }
+            else {
+                res.statusCode = 404;
+                res.end('Not Found');
+            }
+        });
+        return {
+            listen: (port, callback) => {
+                server.listen(port, () => {
+                    if (callback)
+                        callback();
+                });
+            },
+            get: (path, handler) => addRoute('GET', path, handler),
+            post: (path, handler) => addRoute('POST', path, handler),
+            put: (path, handler) => addRoute('PUT', path, handler),
+            delete: (path, handler) => addRoute('DELETE', path, handler),
+        };
+    }
+    /**
+     * Fetch API
+     */
+    static async fetch(url, options = {}) {
+        return this.request(url, options.method || 'GET', options.body, options);
+    }
+}
+exports.StdHTTP = StdHTTP;
+/**
+ * ========================================
+ * Async Module - Promises, Delay
+ * ========================================
+ */
+class StdAsync {
+    /**
+     * Create Promise
+     */
+    static createPromise(executor) {
+        return new Promise((resolve, reject) => {
+            executor(resolve, reject);
+        });
+    }
+    /**
+     * Promise.all
+     */
+    static allPromises(promises) {
+        return Promise.all(promises);
+    }
+    /**
+     * Promise.race
+     */
+    static anyPromise(promises) {
+        return Promise.race(promises);
+    }
+    /**
+     * Delay/Sleep
+     */
+    static delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * setInterval
+     */
+    static repeatInterval(fn, ms) {
+        return setInterval(() => fn(), ms);
+    }
+    /**
+     * clearInterval
+     */
+    static clearRepeat(id) {
+        clearInterval(id);
+    }
+    /**
+     * setTimeout
+     */
+    static setTimer(fn, ms) {
+        return setTimeout(() => fn(), ms);
+    }
+    /**
+     * clearTimeout
+     */
+    static clearTimer(id) {
+        clearTimeout(id);
+    }
+}
+exports.StdAsync = StdAsync;
+/**
+ * ========================================
+ * GUI Module - Interface Gráfica
+ * ========================================
+ */
+class StdGUI {
+    /**
+     * Create Terminal
+     */
+    static createTerminal() {
+        return {
+            clear: () => {
+                console.clear();
+            },
+            printAt: (x, y, text) => {
+                // Basic terminal positioning
+                process.stdout.write(`\x1b[${y};${x}H${text}`);
+            },
+            getHeight: () => process.stdout.rows || 24,
+            getWidth: () => process.stdout.columns || 80,
+        };
+    }
+    /**
+     * Create Window (placeholder)
+     */
+    static createWindow(options) {
+        console.log(`Creating window: ${options.title || 'Untitled'}`);
+        return {
+            show: () => console.log('Window shown'),
+            hide: () => console.log('Window hidden'),
+            close: () => console.log('Window closed'),
+            addComponent: (component) => {
+                console.log('Component added', component);
+            },
+        };
+    }
+    /**
+     * Create Button
+     */
+    static createButton(text, onClick) {
+        return {
+            text,
+            click: onClick,
+            disable: () => console.log(`Button "${text}" disabled`),
+            enable: () => console.log(`Button "${text}" enabled`),
+        };
+    }
+    /**
+     * Create Text Input
+     */
+    static createText(placeholder, onChange) {
+        return {
+            value: '',
+            change: onChange,
+            focus: () => console.log('Text focused'),
+            blur: () => console.log('Text blurred'),
+        };
+    }
+    /**
+     * Create List
+     */
+    static createList(data, onSelect) {
+        return {
+            data,
+            select: onSelect,
+            update: (newData) => {
+                data = newData;
+                console.log('List updated');
+            },
+        };
+    }
+    /**
+     * Component Container
+     */
+    static componentContainer(children) {
+        return {
+            children,
+            add: (component) => {
+                children.push(component);
+            },
+            remove: (component) => {
+                const index = children.indexOf(component);
+                if (index > -1)
+                    children.splice(index, 1);
+            },
+        };
+    }
+    /**
+     * Component Label
+     */
+    static componentLabel(text) {
+        return { text };
+    }
+    /**
+     * Component Image
+     */
+    static componentImage(src) {
+        return {
+            src,
+            show: () => console.log(`Image shown: ${src}`),
+            hide: () => console.log(`Image hidden: ${src}`),
+        };
+    }
+}
+exports.StdGUI = StdGUI;
+/**
+ * ========================================
+ * Database Module - SQLite
+ * ========================================
+ */
+class StdDatabase {
+    /**
+     * Open Database
+     */
+    static openDB(dbPath) {
+        if (this.dbConnections.has(dbPath)) {
+            return this.dbConnections.get(dbPath);
+        }
+        // For now, use file-based mock database
+        const db = {
+            path: dbPath,
+            execute: (query, params = []) => {
+                console.log(`[DB] Executing: ${query}`, params);
+                return { success: true };
+            },
+            query: (query, params = []) => {
+                console.log(`[DB] Querying: ${query}`, params);
+                return [];
+            },
+            transaction: (fn) => {
+                console.log('[DB] Transaction started');
+                fn();
+                console.log('[DB] Transaction committed');
+            },
+            close: () => {
+                console.log(`[DB] Closed: ${dbPath}`);
+                this.dbConnections.delete(dbPath);
+            },
+        };
+        this.dbConnections.set(dbPath, db);
+        return db;
+    }
+    /**
+     * Query Builder
+     */
+    static createQueryBuilder(table) {
+        const builder = {
+            table,
+            selectFields: '*',
+            whereClause: '',
+            orderClause: '',
+            limitValue: '',
+            conditions: [],
+            select: function (fields) {
+                this.selectFields = fields;
+                return this;
+            },
+            where: function (condition) {
+                this.whereClause = `WHERE ${condition}`;
+                return this;
+            },
+            order: function (field) {
+                this.orderClause = `ORDER BY ${field}`;
+                return this;
+            },
+            limit: function (n) {
+                this.limitValue = `LIMIT ${n}`;
+                return this;
+            },
+            execute: function () {
+                const sql = `SELECT ${this.selectFields} FROM ${this.table} ${this.whereClause} ${this.orderClause} ${this.limitValue}`;
+                console.log(`[Query Builder] ${sql}`);
+                return [];
+            },
+        };
+        return builder;
+    }
+    /**
+     * Basic Model
+     */
+    static Model(table) {
+        return {
+            table,
+            find: (id) => {
+                console.log(`[Model] Finding ${table} with id: ${id}`);
+                return null;
+            },
+            all: () => {
+                console.log(`[Model] Getting all ${table}`);
+                return [];
+            },
+            create: (data) => {
+                console.log(`[Model] Creating ${table}:`, data);
+                return { id: 1, ...data };
+            },
+            update: (id, data) => {
+                console.log(`[Model] Updating ${table} ${id}:`, data);
+                return { success: true };
+            },
+            delete: (id) => {
+                console.log(`[Model] Deleting ${table} ${id}`);
+                return { success: true };
+            },
+        };
+    }
+}
+exports.StdDatabase = StdDatabase;
+StdDatabase.dbConnections = new Map();
+/**
+ * ========================================
+ * Enhanced File System Module
+ * ========================================
+ */
+class StdFileSystem {
+    /**
+     * Read File
+     */
+    static readFile(filePath) {
+        try {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Cannot read file: ${error.message}`);
+        }
+    }
+    /**
+     * Write File
+     */
+    static writeFile(filePath, content) {
+        try {
+            fs.writeFileSync(filePath, content, 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Cannot write file: ${error.message}`);
+        }
+    }
+    /**
+     * File Exists
+     */
+    static exists(filePath) {
+        return fs.existsSync(filePath);
+    }
+    /**
+     * Delete File
+     */
+    static deleteFile(filePath) {
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch (error) {
+            throw new Error(`Cannot delete file: ${error.message}`);
+        }
+    }
+    /**
+     * List Directory
+     */
+    static listDir(dirPath) {
+        try {
+            return fs.readdirSync(dirPath);
+        }
+        catch (error) {
+            throw new Error(`Cannot list directory: ${error.message}`);
+        }
+    }
+    /**
+     * Create Directory
+     */
+    static createDir(dirPath) {
+        try {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+        catch (error) {
+            throw new Error(`Cannot create directory: ${error.message}`);
+        }
+    }
+    /**
+     * Delete Directory
+     */
+    static deleteDir(dirPath) {
+        try {
+            fs.rmSync(dirPath, { recursive: true, force: true });
+        }
+        catch (error) {
+            throw new Error(`Cannot delete directory: ${error.message}`);
+        }
+    }
+    /**
+     * Get File Stats
+     */
+    static getStats(filePath) {
+        try {
+            const stats = fs.statSync(filePath);
+            return {
+                size: stats.size,
+                isFile: stats.isFile(),
+                isDirectory: stats.isDirectory(),
+                createdAt: stats.birthtime,
+                modifiedAt: stats.mtime,
+            };
+        }
+        catch (error) {
+            throw new Error(`Cannot get stats: ${error.message}`);
+        }
+    }
+}
+exports.StdFileSystem = StdFileSystem;
+/**
+ * ========================================
+ * JSON Module
+ * ========================================
+ */
+class StdJSON {
+    /**
+     * Parse JSON
+     */
+    static parse(jsonStr) {
+        try {
+            return JSON.parse(jsonStr);
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON: ${error.message}`);
+        }
+    }
+    /**
+     * Stringify JSON
+     */
+    static stringify(obj, indent = 0) {
+        return JSON.stringify(obj, null, indent);
+    }
+}
+exports.StdJSON = StdJSON;
+/**
+ * ========================================
+ * Date Module
+ * ========================================
+ */
+class StdDate {
+    /**
+     * Current Date
+     */
+    static now() {
+        return new Date();
+    }
+    /**
+     * Format Date
+     */
+    static format(date, formatStr = 'YYYY-MM-DD HH:mm:ss') {
+        const d = new Date(date);
+        const year = d.getFullYear();
+        const month = String(d.getMonth() + 1).padStart(2, '0');
+        const day = String(d.getDate()).padStart(2, '0');
+        const hours = String(d.getHours()).padStart(2, '0');
+        const minutes = String(d.getMinutes()).padStart(2, '0');
+        const seconds = String(d.getSeconds()).padStart(2, '0');
+        return formatStr
+            .replace('YYYY', String(year))
+            .replace('MM', month)
+            .replace('DD', day)
+            .replace('HH', hours)
+            .replace('mm', minutes)
+            .replace('ss', seconds);
+    }
+    /**
+     * Get Timezone
+     */
+    static timezone() {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+}
+exports.StdDate = StdDate;
+/**
+ * ========================================
+ * Crypto Module
+ * ========================================
+ */
+const crypto = __importStar(require("crypto"));
+class StdCrypto {
+    /**
+     * Hash MD5
+     */
+    static md5(text) {
+        return crypto.createHash('md5').update(text).digest('hex');
+    }
+    /**
+     * Hash SHA256
+     */
+    static sha256(text) {
+        return crypto.createHash('sha256').update(text).digest('hex');
+    }
+    /**
+     * Hash SHA512
+     */
+    static sha512(text) {
+        return crypto.createHash('sha512').update(text).digest('hex');
+    }
+    /**
+     * Random Bytes
+     */
+    static randomBytes(length) {
+        return crypto.randomBytes(length).toString('hex');
+    }
+    /**
+     * Encrypt AES
+     */
+    static encrypt(text, key) {
+        const algorithm = 'aes-256-cbc';
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv(algorithm, Buffer.from(key.slice(0, 32).padEnd(32, '0')), iv);
+        let encrypted = cipher.update(text, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return iv.toString('hex') + ':' + encrypted;
+    }
+    /**
+     * Decrypt AES
+     */
+    static decrypt(encrypted, key) {
+        const algorithm = 'aes-256-cbc';
+        const parts = encrypted.split(':');
+        const iv = Buffer.from(parts[0], 'hex');
+        const encryptedText = parts[1];
+        const decipher = crypto.createDecipheriv(algorithm, Buffer.from(key.slice(0, 32).padEnd(32, '0')), iv);
+        let decrypted = decipher.update(encryptedText, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+}
+exports.StdCrypto = StdCrypto;
+/**
+ * Export all modules
+ */
+exports.StdModules = {
+    HTTP: StdHTTP,
+    Async: StdAsync,
+    GUI: StdGUI,
+    Database: StdDatabase,
+    FileSystem: StdFileSystem,
+    JSON: StdJSON,
+    Date: StdDate,
+    Crypto: StdCrypto,
+};
+//# sourceMappingURL=std-native.js.map