treste 2.4.8 → 2.4.9

package/dist/std-native.js

@@ -408,10 +408,73 @@ class StdAsync {
 exports.StdAsync = StdAsync;
 /**
  * ========================================
- * GUI Module - Interface Gráfica
+ * GUI Module - Interface Gráfica Desktop com Electron
  * ========================================
  */
+// Variáveis globais para Electron
+let electronModule = null;
+let BrowserWindow = null;
+let app = null;
+function loadElectron() {
+    // Se já carregado e disponível, retornar true
+    if (electronModule && app && BrowserWindow) {
+        // Verificar se app.isReady() ou se está disponível
+        if (app && typeof app.isReady === 'function') {
+            return true;
+        }
+    }
+    try {
+        // Tentar carregar Electron
+        electronModule = require('electron');
+        if (electronModule) {
+            // Tentar acessar app e BrowserWindow
+            // Quando executado através do Node.js (não Electron main process),
+            // app e BrowserWindow podem não estar disponíveis diretamente
+            if (electronModule.app) {
+                app = electronModule.app;
+            }
+            if (electronModule.BrowserWindow) {
+                BrowserWindow = electronModule.BrowserWindow;
+            }
+            // Se temos Electron instalado mas app/BrowserWindow não estão disponíveis,
+            // ainda podemos tentar usá-los (pode funcionar em contexto Electron)
+            if (electronModule && electronModule.app && electronModule.BrowserWindow) {
+                app = electronModule.app;
+                BrowserWindow = electronModule.BrowserWindow;
+                return true;
+            }
+            // Se app ou BrowserWindow não estão disponíveis, retornar false
+            // Isso significa que não estamos no contexto Electron main process
+            return false;
+        }
+    }
+    catch (e) {
+        // Electron não instalado
+        return false;
+    }
+    return false;
+}
 class StdGUI {
+    /**
+     * Initialize Electron app
+     */
+    static ensureAppReady() {
+        if (!loadElectron()) {
+            console.error('❌ Electron não está instalado. Para usar GUI desktop, instale: npm install electron');
+            return Promise.resolve(false);
+        }
+        if (this.appReady) {
+            return Promise.resolve(true);
+        }
+        if (app.isReady()) {
+            this.appReady = true;
+            return Promise.resolve(true);
+        }
+        return app.whenReady().then(() => {
+            this.appReady = true;
+            return true;
+        });
+    }
     /**
      * Create Terminal
      */
@@ -421,7 +484,6 @@ class StdGUI {
                 console.clear();
             },
             printAt: (x, y, text) => {
-                // Basic terminal positioning
                 process.stdout.write(`\x1b[${y};${x}H${text}`);
             },
             getHeight: () => process.stdout.rows || 24,
@@ -429,51 +491,254 @@ class StdGUI {
         };
     }
     /**
-     * Create Window (placeholder)
+     * Create Desktop Window with Electron
      */
     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);
+        const title = options.title || options.título || 'Janela Trest';
+        const width = options.width || options.largura || 800;
+        const height = options.height || options.altura || 600;
+        const resizable = options.resizable !== false;
+        const center = options.center !== false;
+        const minWidth = options.minWidth || options.larguraMinima || undefined;
+        const minHeight = options.minHeight || options.alturaMinima || undefined;
+        const maxWidth = options.maxWidth || options.larguraMaxima || undefined;
+        const maxHeight = options.maxHeight || options.alturaMaxima || undefined;
+        const fullscreen = options.fullscreen || options.telaCheia || false;
+        const alwaysOnTop = options.alwaysOnTop || options.sempreNoTopo || false;
+        const winId = ++this.windowCounter;
+        let browserWindow = null;
+        // Check if Electron is available
+        if (!loadElectron()) {
+            return this.createFallbackWindow(options);
+        }
+        // Create window wrapper object immediately (window will be created when app is ready)
+        const windowWrapper = {
+            id: winId,
+            _pending: true,
+            _options: options,
+            show: () => {
+                if (browserWindow) {
+                    browserWindow.show();
+                }
+                else if (windowWrapper._pending) {
+                    windowWrapper._pendingShow = true;
+                }
+            },
+            hide: () => {
+                if (browserWindow) {
+                    browserWindow.hide();
+                }
+            },
+            close: () => {
+                if (browserWindow) {
+                    browserWindow.close();
+                    this.windows.delete(winId);
+                }
+            },
+            loadHTML: (html) => {
+                if (browserWindow) {
+                    browserWindow.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(html)}`);
+                }
+                else {
+                    windowWrapper._pendingHTML = html;
+                }
+            },
+            loadFile: (filePath) => {
+                if (browserWindow) {
+                    browserWindow.loadFile(filePath);
+                }
+                else {
+                    windowWrapper._pendingFile = filePath;
+                }
+            },
+            loadURL: (url) => {
+                if (browserWindow) {
+                    browserWindow.loadURL(url);
+                }
+                else {
+                    windowWrapper._pendingURL = url;
+                }
+            },
+            setTitle: (newTitle) => {
+                if (browserWindow) {
+                    browserWindow.setTitle(newTitle);
+                }
+                else {
+                    windowWrapper._pendingTitle = newTitle;
+                }
+            },
+            setSize: (w, h) => {
+                if (browserWindow) {
+                    browserWindow.setSize(w, h);
+                }
+            },
+            setMinimumSize: (w, h) => {
+                if (browserWindow) {
+                    browserWindow.setMinimumSize(w, h);
+                }
+            },
+            setMaximumSize: (w, h) => {
+                if (browserWindow) {
+                    browserWindow.setMaximumSize(w, h);
+                }
+            },
+            minimize: () => {
+                if (browserWindow)
+                    browserWindow.minimize();
+            },
+            maximize: () => {
+                if (browserWindow)
+                    browserWindow.maximize();
+            },
+            restore: () => {
+                if (browserWindow)
+                    browserWindow.restore();
             },
+            focus: () => {
+                if (browserWindow)
+                    browserWindow.focus();
+            },
+            on: (event, callback) => {
+                if (browserWindow) {
+                    browserWindow.on(event, callback);
+                }
+            },
+            webContents: null,
+        };
+        // Initialize app and create window in background
+        this.ensureAppReady().then((isReady) => {
+            if (!isReady) {
+                return;
+            }
+            try {
+                browserWindow = new BrowserWindow({
+                    width: width,
+                    height: height,
+                    title: title,
+                    resizable: resizable,
+                    center: center,
+                    minWidth: minWidth,
+                    minHeight: minHeight,
+                    maxWidth: maxWidth,
+                    maxHeight: maxHeight,
+                    fullscreen: fullscreen,
+                    alwaysOnTop: alwaysOnTop,
+                    webPreferences: {
+                        nodeIntegration: true,
+                        contextIsolation: false,
+                        webSecurity: false,
+                    },
+                    show: false,
+                });
+                this.windows.set(winId, browserWindow);
+                windowWrapper._pending = false;
+                windowWrapper.webContents = browserWindow.webContents;
+                browserWindow.on('closed', () => {
+                    this.windows.delete(winId);
+                    browserWindow = null;
+                });
+                // Apply pending operations
+                if (windowWrapper._pendingHTML) {
+                    browserWindow.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(windowWrapper._pendingHTML)}`);
+                }
+                else if (windowWrapper._pendingFile) {
+                    browserWindow.loadFile(windowWrapper._pendingFile);
+                }
+                else if (windowWrapper._pendingURL) {
+                    browserWindow.loadURL(windowWrapper._pendingURL);
+                }
+                if (windowWrapper._pendingTitle) {
+                    browserWindow.setTitle(windowWrapper._pendingTitle);
+                }
+                if (windowWrapper._pendingShow) {
+                    browserWindow.show();
+                }
+            }
+            catch (error) {
+                console.error('❌ Erro ao criar janela Electron:', error.message);
+            }
+        });
+        return windowWrapper;
+    }
+    /**
+     * Fallback window (quando Electron não está disponível)
+     */
+    static createFallbackWindow(options) {
+        console.warn('⚠️  Electron não disponível - usando modo fallback');
+        return {
+            id: ++this.windowCounter,
+            show: () => console.log('Window shown (fallback mode)'),
+            hide: () => console.log('Window hidden (fallback mode)'),
+            close: () => console.log('Window closed (fallback mode)'),
+            loadHTML: (html) => console.log('HTML loaded (fallback mode)'),
+            loadFile: (filePath) => console.log(`File loaded: ${filePath} (fallback mode)`),
+            loadURL: (url) => console.log(`URL loaded: ${url} (fallback mode)`),
+            setTitle: (title) => console.log(`Title set: ${title} (fallback mode)`),
+            setSize: () => { },
+            setMinimumSize: () => { },
+            setMaximumSize: () => { },
+            minimize: () => { },
+            maximize: () => { },
+            restore: () => { },
+            focus: () => { },
+            on: () => { },
+            webContents: null,
         };
     }
     /**
-     * Create Button
+     * Create Button (HTML-based)
      */
     static createButton(text, onClick) {
         return {
-            text,
-            click: onClick,
-            disable: () => console.log(`Button "${text}" disabled`),
-            enable: () => console.log(`Button "${text}" enabled`),
+            type: 'button',
+            text: text,
+            onClick: onClick,
+            disabled: false,
+            disable: function () {
+                this.disabled = true;
+            },
+            enable: function () {
+                this.disabled = false;
+            },
+            setText: function (newText) {
+                this.text = newText;
+            },
         };
     }
     /**
-     * Create Text Input
+     * Create Text Input (HTML-based)
      */
     static createText(placeholder, onChange) {
         return {
+            type: 'text',
+            placeholder: placeholder,
             value: '',
-            change: onChange,
-            focus: () => console.log('Text focused'),
-            blur: () => console.log('Text blurred'),
+            onChange: onChange,
+            setValue: function (newValue) {
+                this.value = newValue;
+            },
+            focus: function () { },
+            blur: function () { },
         };
     }
     /**
-     * Create List
+     * Create List (HTML-based)
      */
     static createList(data, onSelect) {
         return {
-            data,
-            select: onSelect,
-            update: (newData) => {
-                data = newData;
-                console.log('List updated');
+            type: 'list',
+            data: data || [],
+            onSelect: onSelect,
+            update: function (newData) {
+                this.data = newData || [];
+            },
+            add: function (item) {
+                this.data.push(item);
+            },
+            remove: function (index) {
+                if (index >= 0 && index < this.data.length) {
+                    this.data.splice(index, 1);
+                }
             },
         };
     }
@@ -482,14 +747,18 @@ class StdGUI {
      */
     static componentContainer(children) {
         return {
-            children,
-            add: (component) => {
-                children.push(component);
+            type: 'container',
+            children: children || [],
+            add: function (component) {
+                this.children.push(component);
             },
-            remove: (component) => {
-                const index = children.indexOf(component);
+            remove: function (component) {
+                const index = this.children.indexOf(component);
                 if (index > -1)
-                    children.splice(index, 1);
+                    this.children.splice(index, 1);
+            },
+            clear: function () {
+                this.children = [];
             },
         };
     }
@@ -497,20 +766,426 @@ class StdGUI {
      * Component Label
      */
     static componentLabel(text) {
-        return { text };
+        return {
+            type: 'label',
+            text: text,
+            setText: function (newText) {
+                this.text = newText;
+            },
+        };
     }
     /**
      * Component Image
      */
     static componentImage(src) {
         return {
-            src,
-            show: () => console.log(`Image shown: ${src}`),
-            hide: () => console.log(`Image hidden: ${src}`),
+            type: 'image',
+            src: src,
+            visible: true,
+            show: function () {
+                this.visible = true;
+            },
+            hide: function () {
+                this.visible = false;
+            },
+            setSrc: function (newSrc) {
+                this.src = newSrc;
+            },
+        };
+    }
+    /**
+     * Helper: Render components to HTML
+     */
+    static renderComponentToHTML(component) {
+        if (!component)
+            return '';
+        switch (component.type) {
+            case 'button':
+                return `<button onclick="window.trestGuiClickHandler(${JSON.stringify(component.text)})" ${component.disabled ? 'disabled' : ''}>${component.text}</button>`;
+            case 'text':
+                return `<input type="text" placeholder="${component.placeholder || ''}" value="${component.value || ''}" onchange="window.trestGuiChangeHandler(this.value)" />`;
+            case 'label':
+                return `<label>${component.text || ''}</label>`;
+            case 'image':
+                if (!component.visible)
+                    return '';
+                return `<img src="${component.src || ''}" alt="" />`;
+            case 'list':
+                const items = (component.data || []).map((item, index) => `<li onclick="window.trestGuiSelectHandler(${index})">${item}</li>`).join('');
+                return `<ul>${items}</ul>`;
+            case 'container':
+                const childrenHTML = (component.children || []).map((child) => this.renderComponentToHTML(child)).join('');
+                return `<div>${childrenHTML}</div>`;
+            default:
+                return '';
+        }
+    }
+    /**
+     * Keep app running (prevents Electron from closing)
+     */
+    static keepRunning() {
+        if (!loadElectron() || !app) {
+            console.warn('⚠️  Electron não disponível para manterRodando()');
+            return;
+        }
+        app.on('window-all-closed', () => {
+            // On macOS, apps typically stay active
+            if (process.platform !== 'darwin') {
+                // Keep running - don't quit automatically
+            }
+        });
+    }
+    /**
+     * Create Widget (base class for all GUI components)
+     * Allows creating GUI programmatically without HTML
+     */
+    static Widget(type, props = {}) {
+        return {
+            type: type,
+            props: props || {},
+            children: [],
+            id: `widget_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            setText: function (text) {
+                this.props.text = text;
+                this.update();
+            },
+            setVisible: function (visible) {
+                this.props.visible = visible !== false;
+                this.update();
+            },
+            setEnabled: function (enabled) {
+                this.props.enabled = enabled !== false;
+                this.update();
+            },
+            addChild: function (child) {
+                this.children.push(child);
+                this.update();
+            },
+            removeChild: function (child) {
+                const index = this.children.indexOf(child);
+                if (index > -1) {
+                    this.children.splice(index, 1);
+                    this.update();
+                }
+            },
+            update: function () {
+                // Update será implementado quando widget for adicionado a uma janela
+                if (this._parentWindow) {
+                    this._parentWindow._updateGUI();
+                }
+            },
+            toHTML: function () {
+                return this._renderToHTML();
+            },
+            _renderToHTML: function () {
+                // Implementação base - será sobrescrita por widgets específicos
+                return '';
+            }
+        };
+    }
+    /**
+     * Create Button Widget (programmatic)
+     */
+    static Button(text, onClick) {
+        const widget = this.Widget('button', {
+            text: text || '',
+            onClick: onClick,
+            enabled: true,
+            visible: true,
+            style: {}
+        });
+        widget._renderToHTML = function () {
+            const style = this.props.style || {};
+            const styleStr = Object.keys(style).map(k => `${k}:${style[k]}`).join(';');
+            const disabled = this.props.enabled === false ? 'disabled' : '';
+            const onclick = this.props.onClick ? `onclick="window.trestGuiButtonClick('${this.id}')"` : '';
+            return `<button id="${this.id}" ${onclick} ${disabled} style="${styleStr}">${this.props.text || ''}</button>`;
+        };
+        return widget;
+    }
+    /**
+     * Create Label Widget (programmatic)
+     */
+    static Label(text) {
+        const widget = this.Widget('label', {
+            text: text || '',
+            visible: true,
+            style: {}
+        });
+        widget._renderToHTML = function () {
+            const style = this.props.style || {};
+            const styleStr = Object.keys(style).map(k => `${k}:${style[k]}`).join(';');
+            return `<label id="${this.id}" style="${styleStr}">${this.props.text || ''}</label>`;
+        };
+        return widget;
+    }
+    /**
+     * Create Input Widget (programmatic)
+     */
+    static Input(placeholder = '', onChange) {
+        const widget = this.Widget('input', {
+            placeholder: placeholder || '',
+            value: '',
+            onChange: onChange,
+            enabled: true,
+            visible: true,
+            type: 'text',
+            style: {}
+        });
+        widget.setValue = function (value) {
+            this.props.value = value;
+            this.update();
+        };
+        widget.getValue = function () {
+            return this.props.value || '';
+        };
+        widget._renderToHTML = function () {
+            const style = this.props.style || {};
+            const styleStr = Object.keys(style).map(k => `${k}:${style[k]}`).join(';');
+            const disabled = this.props.enabled === false ? 'disabled' : '';
+            const onchange = this.props.onChange ? `onchange="window.trestGuiInputChange('${this.id}', this.value)"` : '';
+            return `<input id="${this.id}" type="${this.props.type || 'text'}" placeholder="${this.props.placeholder || ''}" value="${this.props.value || ''}" ${onchange} ${disabled} style="${styleStr}">`;
+        };
+        return widget;
+    }
+    /**
+     * Create VBox Layout (vertical box - like PySide6)
+     */
+    static VBox(children = [], spacing = 0) {
+        const widget = this.Widget('vbox', {
+            spacing: spacing || 0,
+            alignment: 'top'
+        });
+        widget.children = children || [];
+        widget._renderToHTML = function () {
+            const spacing = this.props.spacing || 0;
+            const style = `display: flex; flex-direction: column; gap: ${spacing}px;`;
+            const childrenHTML = this.children.map((child) => {
+                if (child && typeof child.toHTML === 'function') {
+                    return child.toHTML();
+                }
+                return typeof child === 'string' ? child : '';
+            }).join('');
+            return `<div id="${this.id}" style="${style}">${childrenHTML}</div>`;
+        };
+        return widget;
+    }
+    /**
+     * Create HBox Layout (horizontal box - like PySide6)
+     */
+    static HBox(children = [], spacing = 0) {
+        const widget = this.Widget('hbox', {
+            spacing: spacing || 0,
+            alignment: 'left'
+        });
+        widget.children = children || [];
+        widget._renderToHTML = function () {
+            const spacing = this.props.spacing || 0;
+            const style = `display: flex; flex-direction: row; gap: ${spacing}px;`;
+            const childrenHTML = this.children.map((child) => {
+                if (child && typeof child.toHTML === 'function') {
+                    return child.toHTML();
+                }
+                return typeof child === 'string' ? child : '';
+            }).join('');
+            return `<div id="${this.id}" style="${style}">${childrenHTML}</div>`;
+        };
+        return widget;
+    }
+    /**
+     * Create Grid Layout (like PySide6)
+     */
+    static Grid(rows = 1, cols = 1, spacing = 0) {
+        const widget = this.Widget('grid', {
+            rows: rows || 1,
+            cols: cols || 1,
+            spacing: spacing || 0
+        });
+        widget.children = [];
+        widget._grid = Array(rows).fill(null).map(() => Array(cols).fill(null));
+        widget.addWidget = function (child, row, col, rowSpan = 1, colSpan = 1) {
+            if (row >= 0 && row < this.props.rows && col >= 0 && col < this.props.cols) {
+                this.children.push({ widget: child, row, col, rowSpan, colSpan });
+                this._grid[row][col] = child;
+                this.update();
+            }
+        };
+        widget._renderToHTML = function () {
+            const spacing = this.props.spacing || 0;
+            const style = `display: grid; grid-template-rows: repeat(${this.props.rows}, 1fr); grid-template-columns: repeat(${this.props.cols}, 1fr); gap: ${spacing}px;`;
+            // Renderizar widgets nos lugares corretos do grid
+            const gridItems = Array(this.props.rows * this.props.cols).fill('<div></div>');
+            this.children.forEach((item) => {
+                const index = item.row * this.props.cols + item.col;
+                const rowSpan = item.rowSpan || 1;
+                const colSpan = item.colSpan || 1;
+                const gridArea = `${item.row + 1} / ${item.col + 1} / ${item.row + rowSpan + 1} / ${item.col + colSpan + 1}`;
+                const childHTML = item.widget && typeof item.widget.toHTML === 'function'
+                    ? item.widget.toHTML()
+                    : '';
+                gridItems[index] = `<div style="grid-area: ${gridArea}">${childHTML}</div>`;
+            });
+            return `<div id="${this.id}" style="${style}">${gridItems.join('')}</div>`;
+        };
+        return widget;
+    }
+    /**
+     * Create Programmatic Window (without HTML dependency)
+     * This allows creating windows and adding widgets programmatically
+     */
+    static createProgrammaticWindow(options) {
+        const title = options.title || options.título || 'Janela Trest';
+        const width = options.width || options.largura || 800;
+        const height = options.height || options.altura || 600;
+        // Create window normally
+        const window = this.createWindow(options);
+        // Add programmatic methods
+        window._widgets = [];
+        window._layout = null;
+        window._useProgrammatic = true;
+        window.setLayout = function (layout) {
+            this._layout = layout;
+            if (layout && layout._parentWindow) {
+                layout._parentWindow = this;
+            }
+            this._updateGUI();
+        };
+        window.addWidget = function (widget) {
+            this._widgets.push(widget);
+            if (widget && widget._parentWindow) {
+                widget._parentWindow = this;
+            }
+            this._updateGUI();
+        };
+        window.removeWidget = function (widget) {
+            const index = this._widgets.indexOf(widget);
+            if (index > -1) {
+                this._widgets.splice(index, 1);
+                this._updateGUI();
+            }
+        };
+        window.clear = function () {
+            this._widgets = [];
+            this._layout = null;
+            this._updateGUI();
+        };
+        window._updateGUI = function () {
+            // Gerar HTML automaticamente dos widgets
+            let contentHTML = '';
+            if (this._layout) {
+                // Se há um layout, renderizar o layout
+                if (this._layout.toHTML) {
+                    contentHTML = this._layout.toHTML();
+                }
+            }
+            else {
+                // Senão, renderizar widgets diretamente
+                contentHTML = this._widgets.map((w) => {
+                    if (w && typeof w.toHTML === 'function') {
+                        return w.toHTML();
+                    }
+                    return '';
+                }).join('');
+            }
+            // Criar HTML completo
+            const html = `<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+            padding: 20px;
+            background: #f5f5f5;
+        }
+        
+        .container {
+            background: white;
+            border-radius: 8px;
+            padding: 20px;
+            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+            min-height: calc(100vh - 40px);
+        }
+        
+        button {
+            padding: 10px 20px;
+            border: none;
+            border-radius: 4px;
+            background: #007bff;
+            color: white;
+            cursor: pointer;
+            font-size: 14px;
+            transition: background 0.3s;
+        }
+        
+        button:hover:not(:disabled) {
+            background: #0056b3;
+        }
+        
+        button:disabled {
+            background: #ccc;
+            cursor: not-allowed;
+        }
+        
+        input {
+            padding: 10px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 14px;
+            width: 100%;
+        }
+        
+        input:focus {
+            outline: none;
+            border-color: #007bff;
+        }
+        
+        label {
+            display: block;
+            margin-bottom: 5px;
+            font-weight: 500;
+            color: #333;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        ${contentHTML}
+    </div>
+    
+    <script>
+        // Handlers para widgets programáticos
+        window.trestGuiButtonClick = function(widgetId) {
+            // Callback será implementado quando widget for criado
+            console.log('Button clicked:', widgetId);
+        };
+        
+        window.trestGuiInputChange = function(widgetId, value) {
+            console.log('Input changed:', widgetId, value);
+        };
+    </script>
+</body>
+</html>`;
+            // Atualizar janela com HTML gerado
+            if (this.loadHTML) {
+                this.loadHTML(html);
+            }
         };
+        return window;
     }
 }
 exports.StdGUI = StdGUI;
+StdGUI.windows = new Map();
+StdGUI.windowCounter = 0;
+StdGUI.appReady = false;
 /**
  * ========================================
  * Database Module - SQLite