jsgui3-server 0.0.147 → 0.0.149

package/tests/bundling-default-control-elimination.puppeteer.test.js

@@ -0,0 +1,260 @@
+const assert = require('assert');
+const path = require('path');
+const { describe, it, before, after } = require('mocha');
+
+const Server = require('../server');
+const { get_free_port } = require('../port-utils');
+const {
+    ensure_puppeteer_module,
+    launch_puppeteer_browser,
+    open_page,
+    stop_server_instance,
+    assert_clean_page_probe
+} = require('./helpers/puppeteer-e2e-harness');
+
+const button_fixture_client_path = path.join(__dirname, 'fixtures', 'bundling-default-button-client.js');
+const window_fixture_client_path = path.join(__dirname, 'fixtures', 'bundling-default-window-client.js');
+
+const window_markers = [
+    'Minimize window',
+    'window_manager',
+    '__type_name = "window"',
+    "__type_name = 'window'",
+    "__type_name='window'",
+    'add_class("window")',
+    "add_class('window')"
+];
+
+const find_window_markers = (bundle_text = '') => {
+    return window_markers.filter((marker) => bundle_text.includes(marker));
+};
+
+const read_js_bundle_from_page = async (page) => {
+    return page.evaluate(async () => {
+        const response = await fetch('/js/js.js', { cache: 'no-store' });
+        const text = await response.text();
+        return {
+            status_code: response.status,
+            body_text: text
+        };
+    });
+};
+
+const load_fixture_ctrl = (client_path, ctrl_name) => {
+    const resolved_client_path = require.resolve(client_path);
+    delete require.cache[resolved_client_path];
+
+    const fixture_module = require(resolved_client_path);
+    const ctrl_constructor = fixture_module.controls && fixture_module.controls[ctrl_name];
+    assert(ctrl_constructor, `Missing exported control jsgui.controls.${ctrl_name} in ${client_path}`);
+    return ctrl_constructor;
+};
+
+const start_fixture_server = async ({ client_path, ctrl_name, bundler }) => {
+    const ctrl_constructor = load_fixture_ctrl(client_path, ctrl_name);
+
+    const server_instance = new Server({
+        Ctrl: ctrl_constructor,
+        src_path_client_js: client_path,
+        name: `tests/bundling/${ctrl_name}`,
+        bundler
+    });
+
+    server_instance.allowed_addresses = ['127.0.0.1'];
+
+    await new Promise((resolve, reject) => {
+        const timeout_handle = setTimeout(() => reject(new Error('Publisher ready timeout')), 60000);
+        server_instance.on('ready', () => {
+            clearTimeout(timeout_handle);
+            resolve();
+        });
+    });
+
+    const port = await get_free_port();
+    await new Promise((resolve, reject) => {
+        server_instance.start(port, (error) => {
+            if (error) reject(error);
+            else resolve();
+        });
+    });
+
+    return {
+        server_instance,
+        port
+    };
+};
+
+const close_page_with_probe = async (page, page_probe) => {
+    if (page_probe && typeof page_probe.detach === 'function') {
+        page_probe.detach();
+    }
+    if (page) {
+        await page.close();
+    }
+};
+
+const stop_server_instance_with_timeout = async (server_instance, timeout_ms = 12000) => {
+    if (!server_instance) {
+        return;
+    }
+
+    await Promise.race([
+        stop_server_instance(server_instance),
+        new Promise((resolve) => setTimeout(resolve, timeout_ms))
+    ]);
+};
+
+describe('Bundling Default Control Elimination Puppeteer Tests', function () {
+    this.timeout(420000);
+
+    let puppeteer_module = null;
+    let browser_instance = null;
+
+    before(async function () {
+        this.timeout(60000);
+
+        puppeteer_module = ensure_puppeteer_module();
+        if (!puppeteer_module) {
+            this.skip();
+            return;
+        }
+
+        try {
+            browser_instance = await launch_puppeteer_browser(puppeteer_module);
+        } catch {
+            this.skip();
+        }
+    });
+
+    after(async function () {
+        if (browser_instance) {
+            await browser_instance.close();
+            browser_instance = null;
+        }
+    });
+
+    it('removes unused Window code by default and restores it when elimination is disabled', async function () {
+        this.timeout(360000);
+        let default_server_instance = null;
+        let disabled_server_instance = null;
+        let default_page = null;
+        let disabled_page = null;
+        let default_page_probe = null;
+        let disabled_page_probe = null;
+
+        try {
+            const default_server = await start_fixture_server({
+                client_path: button_fixture_client_path,
+                ctrl_name: 'Bundling_Default_Button_App'
+            });
+            default_server_instance = default_server.server_instance;
+
+            const default_open_result = await open_page(
+                browser_instance,
+                `http://127.0.0.1:${default_server.port}/`,
+                { wait_until: 'domcontentloaded' }
+            );
+            default_page = default_open_result.page;
+            default_page_probe = default_open_result.page_probe;
+
+            await default_page.waitForSelector('[data-test="bundle-test-button"]');
+
+            const default_bundle_response = await read_js_bundle_from_page(default_page);
+            assert.strictEqual(default_bundle_response.status_code, 200, 'Expected /js/js.js to load in default mode');
+            const default_markers = find_window_markers(default_bundle_response.body_text);
+            assert.strictEqual(
+                default_markers.length,
+                0,
+                `Unexpected Window markers in default bundle: ${default_markers.join(', ')}`
+            );
+
+            assert_clean_page_probe(default_page_probe);
+
+            await close_page_with_probe(default_page, default_page_probe);
+            default_page = null;
+            default_page_probe = null;
+
+            const disabled_server = await start_fixture_server({
+                client_path: button_fixture_client_path,
+                ctrl_name: 'Bundling_Default_Button_App',
+                bundler: {
+                    elimination: {
+                        enabled: false,
+                        jsgui3_html_controls: {
+                            enabled: false
+                        }
+                    }
+                }
+            });
+            disabled_server_instance = disabled_server.server_instance;
+
+            const disabled_open_result = await open_page(
+                browser_instance,
+                `http://127.0.0.1:${disabled_server.port}/`,
+                { wait_until: 'domcontentloaded' }
+            );
+            disabled_page = disabled_open_result.page;
+            disabled_page_probe = disabled_open_result.page_probe;
+
+            await disabled_page.waitForSelector('[data-test="bundle-test-button"]');
+
+            const disabled_bundle_response = await read_js_bundle_from_page(disabled_page);
+            assert.strictEqual(disabled_bundle_response.status_code, 200, 'Expected /js/js.js to load in disabled mode');
+            const disabled_markers = find_window_markers(disabled_bundle_response.body_text);
+            assert(
+                disabled_markers.length > 0,
+                'Expected Window markers when elimination is explicitly disabled'
+            );
+
+            assert(
+                default_bundle_response.body_text.length < disabled_bundle_response.body_text.length,
+                'Expected default bundle to be smaller than elimination-disabled bundle'
+            );
+
+            assert_clean_page_probe(disabled_page_probe);
+        } finally {
+            await close_page_with_probe(default_page, default_page_probe);
+            await close_page_with_probe(disabled_page, disabled_page_probe);
+            await stop_server_instance_with_timeout(default_server_instance);
+            await stop_server_instance_with_timeout(disabled_server_instance);
+        }
+    });
+
+    it('keeps Window code in the default bundle when Window control is used', async () => {
+        let server_instance = null;
+        let page = null;
+        let page_probe = null;
+
+        try {
+            const started_server = await start_fixture_server({
+                client_path: window_fixture_client_path,
+                ctrl_name: 'Bundling_Default_Window_App'
+            });
+            server_instance = started_server.server_instance;
+
+            const open_result = await open_page(
+                browser_instance,
+                `http://127.0.0.1:${started_server.port}/`,
+                { wait_until: 'domcontentloaded' }
+            );
+            page = open_result.page;
+            page_probe = open_result.page_probe;
+
+            await page.waitForSelector('.bundle-test-window');
+            await page.waitForSelector('.bundle-test-window-content');
+
+            const window_buttons = await page.$$('.bundle-test-window .title.bar button.button');
+            assert(window_buttons.length >= 2, 'Expected window title bar controls to be rendered');
+
+            const bundle_response = await read_js_bundle_from_page(page);
+            assert.strictEqual(bundle_response.status_code, 200, 'Expected /js/js.js to load');
+            const markers = find_window_markers(bundle_response.body_text);
+            assert(markers.length > 0, 'Expected Window markers when Window control is used');
+
+            assert_clean_page_probe(page_probe);
+        } finally {
+            await close_page_with_probe(page, page_probe);
+            await stop_server_instance_with_timeout(server_instance);
+        }
+    });
+});

package/tests/configuration-validation.test.js

@@ -309,23 +309,26 @@ describe('Configuration Validation Tests', function() {
                 assert.strictEqual(bundler.minify_config.enabled, false);
             });
 
-            it('should default to enabled minification', function() {
-                const bundler = new Core_JS_Single_File_Minifying_Bundler_Using_ESBuild({
-                    minify: {
-                        level: 'aggressive'
-                    }
-                });
-
-                assert.strictEqual(bundler.minify_config.enabled, true);
-                assert.strictEqual(bundler.minify_config.level, 'aggressive');
-            });
-
-            it('should handle missing minify configuration', function() {
-                const bundler = new Core_JS_Single_File_Minifying_Bundler_Using_ESBuild({});
-
-                assert.deepStrictEqual(bundler.minify_config, {});
-            });
-        });
+            it('should default to enabled minification', function() {
+                const bundler = new Core_JS_Single_File_Minifying_Bundler_Using_ESBuild({
+                    minify: {
+                        level: 'aggressive'
+                    }
+                });
+
+                assert.strictEqual(bundler.minify_config.level, 'aggressive');
+                assert.notStrictEqual(bundler.get_minify_options(), false);
+            });
+
+            it('should handle missing minify configuration', function() {
+                const bundler = new Core_JS_Single_File_Minifying_Bundler_Using_ESBuild({});
+
+                assert.deepStrictEqual(bundler.minify_config, {
+                    enabled: true,
+                    level: 'normal'
+                });
+            });
+        });
 
         describe('Core_JS_Non_Minifying_Bundler_Using_ESBuild', function() {
             it('should accept valid sourcemap configuration', function() {
@@ -527,4 +530,4 @@ describe('Configuration Validation Tests', function() {
             assert.deepStrictEqual(minimalPublisher.bundler_config, {});
         });
     });
-});
+});

package/tests/content-analysis.test.js

@@ -571,12 +571,13 @@ describe('Content Analysis Tests', function() {
                 })
             };
 
-            const results = {};
-
-            for (const [name, bundler] of Object.entries(bundlers)) {
-                const startTime = Date.now();
-                const result = await bundler.bundle(testJsFile);
-                const endTime = Date.now();
+            const results = {};
+
+            for (const [name, bundler] of Object.entries(bundlers)) {
+                const startTime = Date.now();
+                const bundle_input = name === 'minifying' ? testJsContent : testJsFile;
+                const result = await bundler.bundle(bundle_input);
+                const endTime = Date.now();
 
                 const bundle = result[0];
                 const jsItem = bundle._arr.find(item => item.type === 'JavaScript');

package/tests/control-optimizer-cache-behavior.test.js

@@ -0,0 +1,52 @@
+const assert = require('assert');
+const path = require('path');
+const { describe, it } = require('mocha');
+
+const JSGUI3_HTML_Control_Optimizer = require('../resources/processors/bundlers/js/esbuild/JSGUI3_HTML_Control_Optimizer');
+
+const entry_file_path = path.join(__dirname, 'fixtures', 'bundling-default-button-client.js');
+
+describe('Control Optimizer Cache Behavior Tests', function () {
+    this.timeout(60000);
+
+    it('records cache hits on repeated optimize calls when cache is enabled', async function () {
+        const optimizer = new JSGUI3_HTML_Control_Optimizer({
+            package_name: 'jsgui3-html',
+            cacheEnabled: true,
+            sharedCache: false
+        });
+
+        const first_result = await optimizer.optimize(entry_file_path);
+        const second_result = await optimizer.optimize(entry_file_path);
+
+        assert.strictEqual(first_result.enabled, true);
+        assert.strictEqual(second_result.enabled, true);
+        assert(first_result.manifest.selected_controls.includes('Button'));
+
+        const cache_stats = optimizer.cache_stats;
+        assert(cache_stats.entry_analysis_misses >= 1, 'Expected at least one entry analysis cache miss');
+        assert(cache_stats.entry_analysis_hits >= 1, 'Expected at least one entry analysis cache hit');
+        assert(cache_stats.controls_map_hits >= 1, 'Expected cached controls map reuse');
+    });
+
+    it('avoids cache hits when cache is disabled', async function () {
+        const optimizer = new JSGUI3_HTML_Control_Optimizer({
+            package_name: 'jsgui3-html',
+            cacheEnabled: false,
+            sharedCache: false
+        });
+
+        const first_result = await optimizer.optimize(entry_file_path);
+        const second_result = await optimizer.optimize(entry_file_path);
+
+        assert.strictEqual(first_result.enabled, true);
+        assert.strictEqual(second_result.enabled, true);
+
+        const cache_stats = optimizer.cache_stats;
+        assert.strictEqual(cache_stats.entry_analysis_hits, 0, 'Expected no entry analysis cache hits');
+        assert.strictEqual(cache_stats.file_scan_hits, 0, 'Expected no file scan cache hits');
+        assert.strictEqual(cache_stats.controls_map_hits, 0, 'Expected no controls map cache hits');
+        assert(cache_stats.file_scan_misses >= 2, 'Expected repeated uncached file scans');
+        assert(cache_stats.controls_map_misses >= 2, 'Expected repeated uncached controls map reads');
+    });
+});

package/tests/control-scan-manifest-regression.test.js

@@ -0,0 +1,144 @@
+const assert = require('assert');
+const { describe, it, before, after } = require('mocha');
+const fs = require('fs').promises;
+const path = require('path');
+
+const Advanced_JS_Bundler_Using_ESBuild = require('../resources/processors/bundlers/js/esbuild/Advanced_JS_Bundler_Using_ESBuild');
+
+const fixture_file_path = path.join(__dirname, 'fixtures', 'control_scan_manifest_expectations.json');
+const update_snapshots = process.env.UPDATE_CONTROL_SCAN_MANIFEST === '1';
+
+const normalize_manifest = (manifest) => {
+    const safe_array = (value) => Array.isArray(value) ? Array.from(value).sort() : [];
+    const safe_paths = (value) => Array.isArray(value) ? value.map(file_path => path.basename(file_path)).sort() : [];
+
+    return {
+        entry_file: manifest && manifest.entry_file_path ? path.basename(manifest.entry_file_path) : null,
+        uses_jsgui3_html: Boolean(manifest && manifest.uses_jsgui3_html),
+        dynamic_control_access_detected: Boolean(manifest && manifest.dynamic_control_access_detected),
+        reachable_files: safe_paths(manifest && manifest.reachable_files),
+        used_identifiers: safe_array(manifest && manifest.used_identifiers),
+        selected_controls: safe_array(manifest && manifest.selected_controls),
+        unmatched_identifiers: safe_array(manifest && manifest.unmatched_identifiers),
+        package_aliases: safe_array(manifest && manifest.package_aliases),
+        controls_aliases: safe_array(manifest && manifest.controls_aliases)
+    };
+};
+
+const extract_scan_manifest = (bundle_result) => {
+    const bundle = bundle_result[0];
+    const analysis = bundle && bundle.bundle_analysis && bundle.bundle_analysis.jsgui3_html_control_scan;
+    assert(analysis, 'Expected bundle_analysis.jsgui3_html_control_scan metadata');
+    return analysis;
+};
+
+describe('Control Scan Manifest Regression Tests', function () {
+    this.timeout(120000);
+
+    const temp_fixture_paths = [];
+
+    const write_temp_fixture = async (file_name, source_text) => {
+        const temp_path = path.join(__dirname, file_name);
+        await fs.writeFile(temp_path, source_text, 'utf8');
+        temp_fixture_paths.push(temp_path);
+        return temp_path;
+    };
+
+    before(async function () {
+        // Ensure fixture directory exists when update mode writes snapshots.
+        await fs.mkdir(path.dirname(fixture_file_path), { recursive: true });
+    });
+
+    after(async function () {
+        await Promise.all(temp_fixture_paths.map(async (temp_path) => {
+            try {
+                await fs.unlink(temp_path);
+            } catch (err) {
+                // Ignore missing temp files.
+            }
+        }));
+    });
+
+    it('should match strict manifest snapshot for static and dynamic alias usage', async function () {
+        const static_alias_fixture_path = await write_temp_fixture('temp_control_scan_static_alias_client.js', `
+const ui = require('jsgui3-html');
+const ui_controls = ui.controls;
+const { Button: Button_Control } = ui_controls;
+
+class Tiny_Static_Alias_App extends ui_controls.Active_HTML_Document {
+    constructor(spec = {}) {
+        super(spec);
+        if (!spec.el) {
+            const button = new Button_Control({ context: this.context });
+            button.add('ok');
+            this.body.add(button);
+        }
+    }
+}
+
+module.exports = { Tiny_Static_Alias_App };
+`);
+
+        const dynamic_alias_fixture_path = await write_temp_fixture('temp_control_scan_dynamic_alias_client.js', `
+const ui = require('jsgui3-html');
+const ui_controls = ui.controls;
+
+class Tiny_Dynamic_Alias_App extends ui_controls.Active_HTML_Document {
+    constructor(spec = {}) {
+        super(spec);
+        if (!spec.el) {
+            const control_name = 'Button';
+            const Dynamic_Control = ui_controls[control_name];
+            const button = new Dynamic_Control({ context: this.context });
+            button.add('ok');
+            this.body.add(button);
+        }
+    }
+}
+
+module.exports = { Tiny_Dynamic_Alias_App };
+`);
+
+        const bundler = new Advanced_JS_Bundler_Using_ESBuild({
+            debug: false,
+            bundler: {
+                minify: {
+                    enabled: true,
+                    level: 'normal'
+                },
+                elimination: {
+                    enabled: true,
+                    jsgui3_html_controls: {
+                        enabled: true
+                    }
+                }
+            }
+        });
+
+        const static_manifest = extract_scan_manifest(await bundler.bundle(static_alias_fixture_path));
+        const dynamic_manifest = extract_scan_manifest(await bundler.bundle(dynamic_alias_fixture_path));
+
+        const snapshot = {
+            static_alias: normalize_manifest(static_manifest),
+            dynamic_alias: normalize_manifest(dynamic_manifest)
+        };
+
+        if (update_snapshots) {
+            await fs.writeFile(fixture_file_path, `${JSON.stringify(snapshot, null, 2)}\n`, 'utf8');
+            return;
+        }
+
+        let expected_snapshot;
+        try {
+            const expected_text = await fs.readFile(fixture_file_path, 'utf8');
+            expected_snapshot = JSON.parse(expected_text);
+        } catch (err) {
+            assert.fail(
+                `Missing manifest expectation fixture at ${fixture_file_path}. ` +
+                'Run with UPDATE_CONTROL_SCAN_MANIFEST=1 to generate it.'
+            );
+        }
+
+        assert.deepStrictEqual(snapshot, expected_snapshot);
+    });
+});

package/tests/end-to-end.test.js

@@ -171,12 +171,13 @@ describe('End-to-End Integration Tests', function() {
                 ...base_serve_options,
                 debug: false,
                 bundler: {
-                    compression: {
-                        enabled: true,
-                        algorithms: ['gzip', 'br']
-                    }
-                }
-            });
+                    compression: {
+                        enabled: true,
+                        algorithms: ['gzip', 'br'],
+                        threshold: 0
+                    }
+                }
+            });
 
             const css_identity_response = await makeRequest(`http://localhost:${serverPort}/css/css.css`, {
                 'Accept-Encoding': 'identity'
@@ -399,28 +400,28 @@ describe('End-to-End Integration Tests', function() {
         });
 
         it('should handle server port conflicts', async function() {
-            // Start first server
-            const server1 = await start_server({
+            this.timeout(60000);
+            const server_1 = await Server.serve({
                 ...base_serve_options,
                 debug: false,
                 host: '127.0.0.1'
             });
 
-            // Try to start second server on same port
+            let conflicting_server = null;
             try {
-                await start_server({
+                conflicting_server = await Server.serve({
                     ...base_serve_options,
-                    port: serverPort, // Same port
+                    port: serverPort,
                     debug: false,
                     host: '127.0.0.1'
                 });
                 assert.fail('Should have failed to start server on occupied port');
             } catch (error) {
                 assert(error, 'Should throw error for port conflict');
+            } finally {
+                await stop_server(conflicting_server);
+                await stop_server(server_1);
             }
-
-            // Clean up
-            await stop_server(server1);
         });
     });
 });