jsgui3-server 0.0.147 → 0.0.149

package/tests/error-handling.test.js

@@ -7,11 +7,33 @@ const path = require('path');
 const Core_JS_Non_Minifying_Bundler_Using_ESBuild = require('../resources/processors/bundlers/js/esbuild/Core_JS_Non_Minifying_Bundler_Using_ESBuild');
 const Core_JS_Single_File_Minifying_Bundler_Using_ESBuild = require('../resources/processors/bundlers/js/esbuild/Core_JS_Single_File_Minifying_Bundler_Using_ESBuild');
 const Advanced_JS_Bundler_Using_ESBuild = require('../resources/processors/bundlers/js/esbuild/Advanced_JS_Bundler_Using_ESBuild');
-const Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner = require('../publishers/helpers/assigners/static-compressed-response-buffers/Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner');
-const HTTP_Webpage_Publisher = require('../publishers/http-webpage-publisher');
-const Server = require('../server');
-
-describe('Error Handling Tests', function() {
+const Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner = require('../publishers/helpers/assigners/static-compressed-response-buffers/Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner');
+const HTTP_Webpage_Publisher = require('../publishers/http-webpage-publisher');
+const Server = require('../server');
+
+const await_observable = (observable) => {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle_once = (settle_fn, value) => {
+            if (settled) return;
+            settled = true;
+            settle_fn(value);
+        };
+
+        observable.on('error', (error) => settle_once(reject, error));
+        observable.on('next', (value) => settle_once(resolve, value));
+        observable.on('complete', (value) => settle_once(resolve, value));
+    });
+};
+
+const close_server_instance = (server_instance) => {
+    if (!server_instance || typeof server_instance.close !== 'function') {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => server_instance.close(() => resolve()));
+};
+
+describe('Error Handling Tests', function() {
     this.timeout(15000);
 
     let testJsFile;
@@ -49,12 +71,12 @@ describe('Error Handling Tests', function() {
     describe('Bundler Error Handling', function() {
         describe('Core_JS_Non_Minifying_Bundler_Using_ESBuild', function() {
             it('should handle invalid JavaScript syntax gracefully', async function() {
-                const bundler = new Core_JS_Non_Minifying_Bundler_Using_ESBuild();
-
-                try {
-                    await bundler.bundle_js_string(invalidJsContent);
-                    assert.fail('Should have thrown an error for invalid JavaScript');
-                } catch (error) {
+                const bundler = new Core_JS_Non_Minifying_Bundler_Using_ESBuild();
+
+                try {
+                    await await_observable(bundler.bundle_js_string(invalidJsContent));
+                    assert.fail('Should have thrown an error for invalid JavaScript');
+                } catch (error) {
                     assert(error, 'Should throw an error for invalid JavaScript');
                     // ESBuild errors typically contain information about the syntax issue
                     assert(error.message || error.toString(), 'Error should have a message');
@@ -62,35 +84,35 @@ describe('Error Handling Tests', function() {
             });
 
             it('should handle non-existent files', async function() {
-                const bundler = new Core_JS_Non_Minifying_Bundler_Using_ESBuild();
-
-                try {
-                    await bundler.bundle('/completely/nonexistent/file.js');
-                    assert.fail('Should have thrown an error for non-existent file');
-                } catch (error) {
+                const bundler = new Core_JS_Non_Minifying_Bundler_Using_ESBuild();
+
+                try {
+                    await await_observable(bundler.bundle('/completely/nonexistent/file.js'));
+                    assert.fail('Should have thrown an error for non-existent file');
+                } catch (error) {
                     assert(error, 'Should throw an error for non-existent file');
                 }
             });
 
-            it('should handle empty JavaScript content', async function() {
-                const bundler = new Core_JS_Non_Minifying_Bundler_Using_ESBuild();
-
-                const result = await bundler.bundle_js_string('');
-                assert(result, 'Should handle empty content');
-                const bundle = result[0];
-                assert(bundle._arr[0], 'Should produce a bundle item');
-            });
+            it('should handle empty JavaScript content', async function() {
+                const bundler = new Core_JS_Non_Minifying_Bundler_Using_ESBuild();
+
+                const result = await await_observable(bundler.bundle_js_string(''));
+                assert(result, 'Should handle empty content');
+                const bundle = Array.isArray(result) ? result[0] : result;
+                assert(bundle._arr[0], 'Should produce a bundle item');
+            });
 
             it('should handle very large JavaScript content', async function() {
                 const bundler = new Core_JS_Non_Minifying_Bundler_Using_ESBuild();
 
-                // Create a very large JS file (10MB)
-                const largeContent = 'console.log("test");\n'.repeat(100000);
-
-                try {
-                    const result = await bundler.bundle_js_string(largeContent);
-                    assert(result, 'Should handle large content');
-                } catch (error) {
+                // Create a very large JS file (10MB)
+                const largeContent = 'console.log("test");\n'.repeat(100000);
+
+                try {
+                    const result = await await_observable(bundler.bundle_js_string(largeContent));
+                    assert(result, 'Should handle large content');
+                } catch (error) {
                     // Large files might cause memory issues, which is acceptable
                     assert(error, 'Large files may cause errors due to memory constraints');
                 }
@@ -103,12 +125,12 @@ describe('Error Handling Tests', function() {
                     const arrow = ( => {
                         console.log('invalid arrow function');
                     };
-                `;
-
-                try {
-                    await bundler.bundle_js_string(es6ErrorContent);
-                    assert.fail('Should have thrown an error for invalid ES6 syntax');
-                } catch (error) {
+                `;
+
+                try {
+                    await await_observable(bundler.bundle_js_string(es6ErrorContent));
+                    assert.fail('Should have thrown an error for invalid ES6 syntax');
+                } catch (error) {
                     assert(error, 'Should throw an error for invalid ES6 syntax');
                 }
             });
@@ -116,14 +138,14 @@ describe('Error Handling Tests', function() {
 
         describe('Core_JS_Single_File_Minifying_Bundler_Using_ESBuild', function() {
             it('should handle minification errors gracefully', async function() {
-                const bundler = new Core_JS_Single_File_Minifying_Bundler_Using_ESBuild({
-                    minify: { enabled: true, level: 'aggressive' }
-                });
-
-                try {
-                    await bundler.bundle(invalidJsContent);
-                    assert.fail('Should have thrown an error for invalid JavaScript during minification');
-                } catch (error) {
+                const bundler = new Core_JS_Single_File_Minifying_Bundler_Using_ESBuild({
+                    minify: { enabled: true, level: 'aggressive' }
+                });
+
+                try {
+                    await await_observable(bundler.bundle(invalidJsContent));
+                    assert.fail('Should have thrown an error for invalid JavaScript during minification');
+                } catch (error) {
                     assert(error, 'Should throw an error for invalid JavaScript during minification');
                 }
             });
@@ -136,11 +158,11 @@ describe('Error Handling Tests', function() {
                     }
                 });
 
-                // Should not crash during construction, but may fail during bundling
-                try {
-                    await bundler.bundle(validJsContent);
-                    // If it succeeds, the invalid level might be ignored
-                } catch (error) {
+                // Should not crash during construction, but may fail during bundling
+                try {
+                    await await_observable(bundler.bundle(validJsContent));
+                    // If it succeeds, the invalid level might be ignored
+                } catch (error) {
                     // This is acceptable - invalid levels might cause errors
                     assert(error, 'Invalid minification level may cause errors');
                 }
@@ -156,12 +178,12 @@ describe('Error Handling Tests', function() {
                         const const = 'test';
                         return const;
                     }
-                `;
-
-                try {
-                    await bundler.bundle(keywordConflictContent);
-                    // ESBuild might handle this gracefully
-                } catch (error) {
+                `;
+
+                try {
+                    await await_observable(bundler.bundle(keywordConflictContent));
+                    // ESBuild might handle this gracefully
+                } catch (error) {
                     assert(error, 'Reserved keywords may cause minification errors');
                 }
             });
@@ -172,15 +194,17 @@ describe('Error Handling Tests', function() {
                 const bundler = new Advanced_JS_Bundler_Using_ESBuild();
 
                 // Create invalid JS file
-                const invalidFile = path.join(__dirname, 'temp_invalid.js');
-                await fs.writeFile(invalidFile, invalidJsContent);
-
-                try {
-                    await bundler.bundle(invalidFile);
-                    assert.fail('Should have thrown an error for invalid JavaScript in advanced bundling');
-                } catch (error) {
-                    assert(error, 'Should throw an error for invalid JavaScript in advanced bundling');
-                } finally {
+                const invalidFile = path.join(__dirname, 'temp_invalid.js');
+                await fs.writeFile(invalidFile, invalidJsContent);
+
+                try {
+                    const result = await await_observable(bundler.bundle(invalidFile));
+                    const js_item = result[0] && result[0]._arr && result[0]._arr.find((item) => item.type === 'JavaScript');
+                    assert(js_item, 'Should return fallback JavaScript bundle item');
+                    assert(js_item.text.includes('Bundling failed'), 'Fallback bundle should indicate failure');
+                } catch (error) {
+                    assert(error, 'Advanced bundling should either return fallback or throw an error');
+                } finally {
                     try {
                         await fs.unlink(invalidFile);
                     } catch (err) {
@@ -205,14 +229,14 @@ describe('Error Handling Tests', function() {
 
                     console.log('test');
                 `;
-
-                const malformedFile = path.join(__dirname, 'temp_malformed.js');
-                await fs.writeFile(malformedFile, malformedCssContent);
-
-                try {
-                    await bundler.bundle(malformedFile);
-                    // Should still work even with malformed CSS in strings
-                } catch (error) {
+
+                const malformedFile = path.join(__dirname, 'temp_malformed.js');
+                await fs.writeFile(malformedFile, malformedCssContent);
+
+                try {
+                    await await_observable(bundler.bundle(malformedFile));
+                    // Should still work even with malformed CSS in strings
+                } catch (error) {
                     // CSS extraction errors are acceptable
                     assert(error, 'CSS extraction errors are acceptable');
                 } finally {
@@ -422,75 +446,87 @@ describe('Error Handling Tests', function() {
         });
     });
 
-    describe('Server-Level Error Handling', function() {
-        it('should handle server startup errors', async function() {
-            const server = new Server();
-
-            try {
-                await server.serve({
-                    ctrl: class InvalidControl {
-                        // Missing required methods
-                    },
-                    port: 3003,
-                    bundler: {
-                        compression: {
+    describe('Server-Level Error Handling', function() {
+        it('should handle server startup errors', async function() {
+            let server_instance = null;
+
+            try {
+                server_instance = await Server.serve({
+                    ctrl: class InvalidControl {
+                        // Missing required methods
+                    },
+                    host: '127.0.0.1',
+                    port: 3003,
+                    bundler: {
+                        compression: {
                             enabled: 'invalid'
                         }
                     }
-                });
-                assert.fail('Should have thrown an error for invalid configuration');
-            } catch (error) {
-                assert(error, 'Should throw error for invalid server configuration');
-            }
-        });
-
-        it('should handle port binding errors', async function() {
-            const server1 = new Server();
-            const server2 = new Server();
-
-            // Start first server
-            await server1.serve({
-                ctrl: class TestControl {
-                    all_html_render() {
-                        return Promise.resolve('<html></html>');
-                    }
-                },
-                port: 3004
-            });
-
-            // Try to start second server on same port
-            try {
-                await server2.serve({
-                    ctrl: class TestControl {
-                        all_html_render() {
-                            return Promise.resolve('<html></html>');
-                        }
-                    },
-                    port: 3004 // Same port
-                });
-                assert.fail('Should have failed to bind to occupied port');
-            } catch (error) {
-                assert(error, 'Should throw error for port binding conflict');
-            }
-
-            // Clean up
-            await server1.stop();
-        });
-
-        it('should handle invalid control classes', async function() {
-            const server = new Server();
-
-            try {
-                await server.serve({
-                    ctrl: "not_a_class", // Invalid control
-                    port: 3005
-                });
-                assert.fail('Should have thrown an error for invalid control');
-            } catch (error) {
-                assert(error, 'Should throw error for invalid control class');
-            }
-        });
-    });
+                });
+                assert.fail('Should have thrown an error for invalid configuration');
+            } catch (error) {
+                assert(error, 'Should throw error for invalid server configuration');
+            } finally {
+                await close_server_instance(server_instance);
+            }
+        });
+
+        it('should handle port binding errors', async function() {
+            let server1 = null;
+            let server2 = null;
+
+            // Start first server
+            server1 = await Server.serve({
+                ctrl: class TestControl {
+                    all_html_render() {
+                        return Promise.resolve('<html></html>');
+                    }
+                },
+                host: '127.0.0.1',
+                port: 3004
+            });
+
+            // Try to start second server on same port
+            try {
+                server2 = await Server.serve({
+                    ctrl: class TestControl {
+                        all_html_render() {
+                            return Promise.resolve('<html></html>');
+                        }
+                    },
+                    host: '127.0.0.1',
+                    port: 3004 // Same port
+                });
+                assert.fail('Should have failed to bind to occupied port');
+            } catch (error) {
+                assert(error, 'Should throw error for port binding conflict');
+            }
+
+            // Clean up
+            await close_server_instance(server1);
+            await close_server_instance(server2);
+        });
+
+        it('should handle invalid control classes', async function() {
+            let server_instance = null;
+
+            try {
+                server_instance = await Server.serve({
+                    page: {
+                        route: '/',
+                        content: "not_a_class"
+                    },
+                    host: '127.0.0.1',
+                    port: 3005
+                });
+                assert.fail('Should have thrown an error for invalid control');
+            } catch (error) {
+                assert(error, 'Should throw error for invalid control class');
+            } finally {
+                await close_server_instance(server_instance);
+            }
+        });
+    });
 
     describe('Configuration Validation Errors', function() {
         it('should validate all configuration paths', function() {
@@ -544,12 +580,12 @@ describe('Error Handling Tests', function() {
 
             // Try to bundle a file in a directory without read permissions
             // This is hard to test reliably across different systems, so we'll skip
-            // actual permission testing and just verify error handling structure
-            try {
-                await bundler.bundle('/root/private/file.js');
-            } catch (error) {
-                // Expected to fail
-                assert(error, 'Should handle permission errors');
+            // actual permission testing and just verify error handling structure
+            try {
+                await await_observable(bundler.bundle('/root/private/file.js'));
+            } catch (error) {
+                // Expected to fail
+                assert(error, 'Should handle permission errors');
             }
         });
 
@@ -564,11 +600,11 @@ describe('Error Handling Tests', function() {
                 []
             ];
 
-            for (const invalidPath of invalidPaths) {
-                try {
-                    await bundler.bundle(invalidPath);
-                    // May not throw for all invalid paths
-                } catch (error) {
+            for (const invalidPath of invalidPaths) {
+                try {
+                    await await_observable(bundler.bundle(invalidPath));
+                    // May not throw for all invalid paths
+                } catch (error) {
                     assert(error, 'Should handle invalid file paths');
                 }
             }
@@ -580,12 +616,12 @@ describe('Error Handling Tests', function() {
             // Create a file with invalid UTF-8 content
             const invalidUtf8File = path.join(__dirname, 'temp_invalid_utf8.js');
             const invalidBuffer = Buffer.from([0xFF, 0xFE, 0xFD]); // Invalid UTF-8
-            await fs.writeFile(invalidUtf8File, invalidBuffer);
-
-            try {
-                await bundler.bundle(invalidUtf8File);
-                // ESBuild might handle encoding issues gracefully
-            } catch (error) {
+            await fs.writeFile(invalidUtf8File, invalidBuffer);
+
+            try {
+                await await_observable(bundler.bundle(invalidUtf8File));
+                // ESBuild might handle encoding issues gracefully
+            } catch (error) {
                 assert(error, 'Should handle encoding errors');
             } finally {
                 try {
@@ -692,24 +728,31 @@ describe('Error Handling Tests', function() {
     });
 
     describe('Memory and Performance Error Handling', function() {
-        it('should handle out of memory conditions gracefully', async function() {
-            const bundler = new Core_JS_Single_File_Minifying_Bundler_Using_ESBuild();
-
-            // Create extremely large content that might cause OOM
-            const hugeContent = 'const data = "' + 'x'.repeat(100 * 1024 * 1024) + '";'; // 100MB string
-
-            try {
-                await bundler.bundle(hugeContent);
-                // If it succeeds, that's fine
-            } catch (error) {
-                // OOM errors are acceptable for very large content
-                assert(error, 'Should handle OOM errors gracefully');
-                assert(error.message.includes('out of memory') ||
-                       error.message.includes('Maximum call stack') ||
-                       error.code === 'ENOBUFS' ||
-                       true, 'Error should be memory-related or acceptable');
-            }
-        });
+        it('should handle out of memory conditions gracefully', async function() {
+            const bundler = new Core_JS_Single_File_Minifying_Bundler_Using_ESBuild();
+
+            // Create extremely large content that might cause OOM
+            const hugeContent = 'const data = "' + 'x'.repeat(20 * 1024 * 1024) + '";'; // 20MB string
+
+            try {
+                const timeout_promise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error('oom_test_timeout')), 12000);
+                });
+                await Promise.race([
+                    await_observable(bundler.bundle(hugeContent)),
+                    timeout_promise
+                ]);
+                // If it succeeds, that's fine
+            } catch (error) {
+                // OOM errors are acceptable for very large content
+                assert(error, 'Should handle OOM errors gracefully');
+                assert(error.message.includes('out of memory') ||
+                       error.message.includes('Maximum call stack') ||
+                       error.message.includes('oom_test_timeout') ||
+                       error.code === 'ENOBUFS' ||
+                       true, 'Error should be memory-related or acceptable');
+            }
+        });
 
         it('should handle timeout conditions', async function() {
             const bundler = new Core_JS_Single_File_Minifying_Bundler_Using_ESBuild();
@@ -730,10 +773,10 @@ describe('Error Handling Tests', function() {
                     setTimeout(() => reject(new Error('Test timeout')), 10000);
                 });
 
-                await Promise.race([
-                    bundler.bundle(slowContent),
-                    timeoutPromise
-                ]);
+                await Promise.race([
+                    await_observable(bundler.bundle(slowContent)),
+                    timeoutPromise
+                ]);
             } catch (error) {
                 if (error.message === 'Test timeout') {
                     // Accept timeout - bundling can be slow

package/tests/fixtures/bundling-default-button-client.js

@@ -0,0 +1,37 @@
+const jsgui = require('jsgui3-html');
+const { controls } = jsgui;
+
+class Bundling_Default_Button_App extends controls.Active_HTML_Document {
+    constructor(spec = {}) {
+        super(spec);
+
+        if (!spec.el) {
+            this.compose_ui();
+        }
+    }
+
+    compose_ui() {
+        const { context } = this;
+
+        const root = new controls.div({ context });
+        root.add_class('bundle-test-root');
+
+        const label = new controls.div({ context });
+        label.add_class('bundle-test-label');
+        label.add('button-only-ui');
+        root.add(label);
+
+        const action_button = new controls.Button({
+            context,
+            text: 'Run'
+        });
+        action_button.add_class('bundle-test-button');
+        action_button.dom.attributes['data-test'] = 'bundle-test-button';
+        root.add(action_button);
+
+        this.body.add(root);
+    }
+}
+
+controls.Bundling_Default_Button_App = Bundling_Default_Button_App;
+module.exports = jsgui;

package/tests/fixtures/bundling-default-window-client.js

@@ -0,0 +1,34 @@
+const jsgui = require('jsgui3-html');
+const { controls } = jsgui;
+
+class Bundling_Default_Window_App extends controls.Active_HTML_Document {
+    constructor(spec = {}) {
+        super(spec);
+
+        if (!spec.el) {
+            this.compose_ui();
+        }
+    }
+
+    compose_ui() {
+        const { context } = this;
+
+        const main_window = new controls.Window({
+            context,
+            title: 'Bundling Window',
+            pos: [24, 24],
+            size: [420, 260]
+        });
+        main_window.add_class('bundle-test-window');
+
+        const message = new controls.div({ context });
+        message.add_class('bundle-test-window-content');
+        message.add('window-ui-ready');
+        main_window.inner.add(message);
+
+        this.body.add(main_window);
+    }
+}
+
+controls.Bundling_Default_Window_App = Bundling_Default_Window_App;
+module.exports = jsgui;

package/tests/fixtures/control_scan_manifest_expectations.json

@@ -0,0 +1,48 @@
+{
+  "static_alias": {
+    "entry_file": "temp_control_scan_static_alias_client.js",
+    "uses_jsgui3_html": true,
+    "dynamic_control_access_detected": false,
+    "reachable_files": [
+      "temp_control_scan_static_alias_client.js"
+    ],
+    "used_identifiers": [
+      "Active_HTML_Document",
+      "Button"
+    ],
+    "selected_controls": [
+      "Active_HTML_Document",
+      "Button"
+    ],
+    "unmatched_identifiers": [],
+    "package_aliases": [
+      "ui"
+    ],
+    "controls_aliases": [
+      "controls",
+      "ui_controls"
+    ]
+  },
+  "dynamic_alias": {
+    "entry_file": "temp_control_scan_dynamic_alias_client.js",
+    "uses_jsgui3_html": true,
+    "dynamic_control_access_detected": true,
+    "reachable_files": [
+      "temp_control_scan_dynamic_alias_client.js"
+    ],
+    "used_identifiers": [
+      "Active_HTML_Document"
+    ],
+    "selected_controls": [
+      "Active_HTML_Document"
+    ],
+    "unmatched_identifiers": [],
+    "package_aliases": [
+      "ui"
+    ],
+    "controls_aliases": [
+      "controls",
+      "ui_controls"
+    ]
+  }
+}