jsgui3-server 0.0.151 → 0.0.155

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

@@ -16,8 +16,10 @@ const normalize_manifest = (manifest) => {
         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),
+        dynamic_resource_access_detected: Boolean(manifest && manifest.dynamic_resource_access_detected),
         reachable_files: safe_paths(manifest && manifest.reachable_files),
         used_identifiers: safe_array(manifest && manifest.used_identifiers),
+        selected_root_features: safe_array(manifest && manifest.selected_root_features),
         selected_controls: safe_array(manifest && manifest.selected_controls),
         unmatched_identifiers: safe_array(manifest && manifest.unmatched_identifiers),
         package_aliases: safe_array(manifest && manifest.package_aliases),

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

@@ -12,6 +12,7 @@ describe('End-to-End Integration Tests', function() {
 
     let server;
     let serverPort = 3001; // Use a different port for testing
+    const test_host = '127.0.0.1';
     let testControl;
     let test_client_path;
     let base_serve_options;
@@ -36,7 +37,7 @@ describe('End-to-End Integration Tests', function() {
         const server_instance = await Server.serve(serve_options);
         const port = server_instance.port || serve_options.port;
         if (port) {
-            await wait_for_route(`http://localhost:${port}/js/js.js`);
+            await wait_for_route(`http://${test_host}:${port}/js/js.js`);
         }
         return server_instance;
     };
@@ -86,7 +87,7 @@ describe('End-to-End Integration Tests', function() {
                 }
             });
 
-            const js_identity_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+            const js_identity_response = await makeRequest(`http://${test_host}:${serverPort}/js/js.js`, {
                 'Accept-Encoding': 'identity'
             });
 
@@ -97,7 +98,7 @@ describe('End-to-End Integration Tests', function() {
             );
 
             // Test gzip compressed JavaScript
-            const js_gzip_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+            const js_gzip_response = await makeRequest(`http://${test_host}:${serverPort}/js/js.js`, {
                 'Accept-Encoding': 'gzip'
             });
 
@@ -112,7 +113,7 @@ describe('End-to-End Integration Tests', function() {
             );
 
             // Test brotli compressed JavaScript
-            const br_js_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+            const br_js_response = await makeRequest(`http://${test_host}:${serverPort}/js/js.js`, {
                 'Accept-Encoding': 'br'
             });
 
@@ -148,7 +149,7 @@ describe('End-to-End Integration Tests', function() {
             });
 
             // Test JavaScript with sourcemaps
-            const js_gzip_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+            const js_gzip_response = await makeRequest(`http://${test_host}:${serverPort}/js/js.js`, {
                 'Accept-Encoding': 'gzip'
             });
 
@@ -179,7 +180,7 @@ describe('End-to-End Integration Tests', function() {
                 }
             });
 
-            const css_identity_response = await makeRequest(`http://localhost:${serverPort}/css/css.css`, {
+            const css_identity_response = await makeRequest(`http://${test_host}:${serverPort}/css/css.css`, {
                 'Accept-Encoding': 'identity'
             });
 
@@ -190,7 +191,7 @@ describe('End-to-End Integration Tests', function() {
             );
 
             // Test gzip compressed CSS
-            const css_gzip_response = await makeRequest(`http://localhost:${serverPort}/css/css.css`, {
+            const css_gzip_response = await makeRequest(`http://${test_host}:${serverPort}/css/css.css`, {
                 'Accept-Encoding': 'gzip'
             });
 
@@ -223,9 +224,9 @@ describe('End-to-End Integration Tests', function() {
             });
 
             // Test HTML (should not be compressed due to threshold)
-            const htmlResponse = await makeRequest(`http://localhost:${serverPort}/`, {
-                'Accept-Encoding': 'gzip'
-            });
+            const htmlResponse = await makeRequest(`http://${test_host}:${serverPort}/`, {
+                'Accept-Encoding': 'gzip'
+            });
 
             assert.strictEqual(htmlResponse.statusCode, 200);
             assert(!htmlResponse.headers['content-encoding'], 'HTML should not be compressed due to threshold');
@@ -250,7 +251,7 @@ describe('End-to-End Integration Tests', function() {
                 }
             });
 
-            const baseline_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+            const baseline_response = await makeRequest(`http://${test_host}:${serverPort}/js/js.js`, {
                 'Accept-Encoding': 'identity'
             });
             assert.strictEqual(baseline_response.statusCode, 200);
@@ -276,7 +277,7 @@ describe('End-to-End Integration Tests', function() {
                 });
 
                 // Test JavaScript
-                const minified_response = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
+                const minified_response = await makeRequest(`http://${test_host}:${serverPort}/js/js.js`, {
                     'Accept-Encoding': 'identity'
                 });
 
@@ -305,9 +306,9 @@ describe('End-to-End Integration Tests', function() {
             });
 
             // Test with gzip request but compression disabled
-            const jsResponse = await makeRequest(`http://localhost:${serverPort}/js/js.js`, {
-                'Accept-Encoding': 'gzip'
-            });
+            const jsResponse = await makeRequest(`http://${test_host}:${serverPort}/js/js.js`, {
+                'Accept-Encoding': 'gzip'
+            });
 
             assert.strictEqual(jsResponse.statusCode, 200);
             assert(!jsResponse.headers['content-encoding'], 'Should not have content-encoding when compression disabled');
@@ -332,11 +333,11 @@ describe('End-to-End Integration Tests', function() {
 
             // Make multiple concurrent requests
             const requests = [];
-            for (let i = 0; i < 5; i++) {
-                requests.push(makeRequest(`http://localhost:${serverPort}/js/js.js`, {
-                    'Accept-Encoding': 'gzip'
-                }));
-            }
+            for (let i = 0; i < 5; i++) {
+                requests.push(makeRequest(`http://${test_host}:${serverPort}/js/js.js`, {
+                    'Accept-Encoding': 'gzip'
+                }));
+            }
 
             const responses = await Promise.all(requests);
 
@@ -366,7 +367,7 @@ describe('End-to-End Integration Tests', function() {
             ];
 
             for (const test of tests) {
-                const response = await makeRequest(`http://localhost:${serverPort}${test.path}`);
+                const response = await makeRequest(`http://${test_host}:${serverPort}${test.path}`);
                 assert.strictEqual(response.statusCode, 200);
                 assert(response.headers['content-type'].includes(test.expectedType),
                        `Should serve correct content type for ${test.path}`);

package/tests/fixtures/control_scan_manifest_expectations.json

@@ -3,6 +3,7 @@
     "entry_file": "temp_control_scan_static_alias_client.js",
     "uses_jsgui3_html": true,
     "dynamic_control_access_detected": false,
+    "dynamic_resource_access_detected": false,
     "reachable_files": [
       "temp_control_scan_static_alias_client.js"
     ],
@@ -10,6 +11,7 @@
       "Active_HTML_Document",
       "Button"
     ],
+    "selected_root_features": [],
     "selected_controls": [
       "Active_HTML_Document",
       "Button"
@@ -19,7 +21,6 @@
       "ui"
     ],
     "controls_aliases": [
-      "controls",
       "ui_controls"
     ]
   },
@@ -27,12 +28,14 @@
     "entry_file": "temp_control_scan_dynamic_alias_client.js",
     "uses_jsgui3_html": true,
     "dynamic_control_access_detected": true,
+    "dynamic_resource_access_detected": false,
     "reachable_files": [
       "temp_control_scan_dynamic_alias_client.js"
     ],
     "used_identifiers": [
       "Active_HTML_Document"
     ],
+    "selected_root_features": [],
     "selected_controls": [
       "Active_HTML_Document"
     ],
@@ -41,7 +44,6 @@
       "ui"
     ],
     "controls_aliases": [
-      "controls",
       "ui_controls"
     ]
   }

package/tests/helpers/playwright-e2e-harness.js

@@ -0,0 +1,326 @@
+const assert = require('assert');
+const path = require('path');
+
+const Server = require('../../server');
+const { get_free_port } = require('../../port-utils');
+
+const default_viewport = {
+    width: 1366,
+    height: 900
+};
+
+const ensure_playwright_module = () => {
+    try {
+        return require('playwright');
+    } catch {
+        return null;
+    }
+};
+
+const launch_playwright_browser = async (playwright_module, launch_options = {}) => {
+    const resolved_playwright = playwright_module || ensure_playwright_module();
+    if (!resolved_playwright || !resolved_playwright.chromium) {
+        throw new Error('Playwright Chromium is unavailable in this environment.');
+    }
+
+    const normalized_options = {
+        headless: true,
+        args: ['--no-sandbox', '--disable-setuid-sandbox'],
+        ...launch_options
+    };
+
+    if (!normalized_options.executablePath && process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH) {
+        normalized_options.executablePath = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH;
+    }
+
+    return resolved_playwright.chromium.launch(normalized_options);
+};
+
+const start_control_example_server = async ({
+    examples_root_path,
+    dir_name,
+    ctrl_name,
+    server_name_prefix = 'examples/controls'
+}) => {
+    const example_dir_path = path.join(examples_root_path, dir_name);
+    const example_client_path = path.join(example_dir_path, 'client.js');
+
+    const jsgui_module = require(example_client_path);
+    const ctrl_constructor = jsgui_module.controls && jsgui_module.controls[ctrl_name];
+    assert(ctrl_constructor, `Missing exported control jsgui.controls.${ctrl_name} in ${example_client_path}`);
+
+    const server_instance = new Server({
+        Ctrl: ctrl_constructor,
+        src_path_client_js: example_client_path,
+        name: `${server_name_prefix}/${dir_name}`
+    });
+
+    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,
+        example_client_path
+    };
+};
+
+const stop_server_instance = async (server_instance) => {
+    if (!server_instance) {
+        return;
+    }
+
+    await new Promise((resolve) => {
+        server_instance.close(() => resolve());
+    });
+};
+
+const attach_page_probe = (page) => {
+    const probe = {
+        console_errors: [],
+        page_errors: [],
+        request_failures: []
+    };
+
+    const console_handler = (message) => {
+        if (message.type() === 'error') {
+            probe.console_errors.push(message.text());
+        }
+    };
+
+    const page_error_handler = (error) => {
+        probe.page_errors.push(error instanceof Error ? error.message : String(error));
+    };
+
+    const request_failed_handler = (request) => {
+        const failure = request.failure();
+        probe.request_failures.push({
+            url: request.url(),
+            method: request.method(),
+            error_text: failure ? failure.errorText : 'unknown'
+        });
+    };
+
+    page.on('console', console_handler);
+    page.on('pageerror', page_error_handler);
+    page.on('requestfailed', request_failed_handler);
+
+    probe.detach = () => {
+        page.off('console', console_handler);
+        page.off('pageerror', page_error_handler);
+        page.off('requestfailed', request_failed_handler);
+    };
+
+    return probe;
+};
+
+const assert_clean_page_probe = (probe, {
+    allowed_console_error_patterns = [],
+    allowed_page_error_patterns = [],
+    allowed_request_failure_patterns = []
+} = {}) => {
+    const is_allowed_message = (message, allowed_patterns) => {
+        return allowed_patterns.some((pattern) => {
+            if (pattern instanceof RegExp) {
+                return pattern.test(message);
+            }
+            return String(message).includes(String(pattern));
+        });
+    };
+
+    const blocked_console_errors = probe.console_errors.filter((message) => {
+        return !is_allowed_message(message, allowed_console_error_patterns);
+    });
+
+    const blocked_page_errors = probe.page_errors.filter((message) => {
+        return !is_allowed_message(message, allowed_page_error_patterns);
+    });
+
+    const blocked_request_failures = probe.request_failures.filter((failure_item) => {
+        const label = `${failure_item.method} ${failure_item.url} ${failure_item.error_text}`;
+        return !is_allowed_message(label, allowed_request_failure_patterns);
+    });
+
+    assert.strictEqual(
+        blocked_console_errors.length,
+        0,
+        `Unexpected browser console errors: ${blocked_console_errors.join(' | ')}`
+    );
+    assert.strictEqual(
+        blocked_page_errors.length,
+        0,
+        `Unexpected browser page errors: ${blocked_page_errors.join(' | ')}`
+    );
+    assert.strictEqual(
+        blocked_request_failures.length,
+        0,
+        `Unexpected browser request failures: ${JSON.stringify(blocked_request_failures)}`
+    );
+};
+
+const open_page = async (browser_instance, target_url, options = {}) => {
+    const viewport = options.viewport || default_viewport;
+
+    const page = await browser_instance.newPage({ viewport });
+
+    const page_probe = attach_page_probe(page);
+
+    await page.goto(target_url, {
+        waitUntil: options.wait_until || 'load'
+    });
+
+    return {
+        page,
+        page_probe
+    };
+};
+
+const close_page_with_probe = async (page, page_probe) => {
+    if (page_probe && typeof page_probe.detach === 'function') {
+        page_probe.detach();
+    }
+
+    if (page && !page.isClosed()) {
+        await page.close();
+    }
+};
+
+const set_input_value_with_events = async (
+    page,
+    selector,
+    next_value,
+    event_names = ['input', 'change']
+) => {
+    await page.$eval(selector, (element, value, events) => {
+        element.value = String(value);
+        for (const event_name of events) {
+            element.dispatchEvent(new Event(event_name, { bubbles: true }));
+        }
+    }, next_value, event_names);
+};
+
+const wait_for_text_content = async (page, selector, expected_text_or_regex, timeout_ms = 6000) => {
+    if (expected_text_or_regex instanceof RegExp) {
+        await page.waitForFunction(
+            (selector_arg, regex_source, regex_flags) => {
+                const element = document.querySelector(selector_arg);
+                if (!element) return false;
+                const value = (element.textContent || '').trim();
+                const expected_regex = new RegExp(regex_source, regex_flags);
+                return expected_regex.test(value);
+            },
+            { timeout: timeout_ms },
+            selector,
+            expected_text_or_regex.source,
+            expected_text_or_regex.flags
+        );
+        return;
+    }
+
+    const expected_text = String(expected_text_or_regex);
+    await page.waitForFunction(
+        (selector_arg, expected_text_arg) => {
+            const element = document.querySelector(selector_arg);
+            if (!element) return false;
+            return (element.textContent || '').trim() === expected_text_arg;
+        },
+        { timeout: timeout_ms },
+        selector,
+        expected_text
+    );
+};
+
+const drag_by = async (page, selector, delta_x, delta_y) => {
+    const locator = page.locator(selector).first();
+    const box = await locator.boundingBox();
+    assert(box, `Missing bounding box for selector: ${selector}`);
+
+    const start_x = box.x + box.width / 2;
+    const start_y = box.y + box.height / 2;
+
+    await page.mouse.move(start_x, start_y);
+    await page.mouse.down();
+    await page.mouse.move(start_x + delta_x, start_y + delta_y, { steps: 12 });
+    await page.mouse.up();
+};
+
+const run_interaction_story = async ({
+    page,
+    story_name,
+    steps
+}) => {
+    assert(Array.isArray(steps) && steps.length > 0, 'Interaction story requires at least one step');
+
+    const step_results = [];
+
+    for (let index = 0; index < steps.length; index += 1) {
+        const step_spec = steps[index] || {};
+        const step_name = step_spec.name || `step_${index + 1}`;
+        const started_at = Date.now();
+
+        try {
+            if (typeof step_spec.run === 'function') {
+                await step_spec.run(page);
+            }
+            if (typeof step_spec.assert === 'function') {
+                await step_spec.assert(page);
+            }
+
+            step_results.push({
+                step_name,
+                duration_ms: Date.now() - started_at
+            });
+        } catch (error) {
+            error.message = `[${story_name} :: ${step_name}] ${error.message}`;
+            throw error;
+        }
+    }
+
+    return step_results;
+};
+
+const wait_for_condition = async (condition_fn, timeout_ms = 6000, interval_ms = 25) => {
+    const started_at = Date.now();
+
+    while ((Date.now() - started_at) <= timeout_ms) {
+        const condition_result = await condition_fn();
+        if (condition_result) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval_ms));
+    }
+
+    return false;
+};
+
+module.exports = {
+    ensure_playwright_module,
+    launch_playwright_browser,
+    start_control_example_server,
+    stop_server_instance,
+    open_page,
+    close_page_with_probe,
+    attach_page_probe,
+    assert_clean_page_probe,
+    set_input_value_with_events,
+    wait_for_text_content,
+    drag_by,
+    run_interaction_story,
+    wait_for_condition
+};

package/tests/helpers/puppeteer-e2e-harness.js

@@ -301,6 +301,64 @@ const wait_for_condition = async (condition_fn, timeout_ms = 6000, interval_ms =
     return false;
 };
 
+const extract_esbuild_warning_headers_from_warning_records = (warning_records = []) => {
+    if (!Array.isArray(warning_records)) {
+        return [];
+    }
+
+    return warning_records.map((warning_record) => {
+        if (!warning_record || typeof warning_record !== 'object') {
+            return '';
+        }
+        const warning_text = String(warning_record.text || '').trim();
+        const warning_id = warning_record.id ? `[${String(warning_record.id)}]` : '';
+        return warning_id ? `${warning_text} ${warning_id}`.trim() : warning_text;
+    }).filter((warning_header) => warning_header.length > 0);
+};
+
+const extract_esbuild_warning_headers_from_bundle = (bundle) => {
+    const warning_records = bundle &&
+        bundle.bundle_analysis &&
+        bundle.bundle_analysis.esbuild_warnings;
+    return extract_esbuild_warning_headers_from_warning_records(warning_records);
+};
+
+const assert_no_unexpected_esbuild_warning_headers = (warning_headers, {
+    allowed_warning_patterns = [],
+    required_warning_patterns = []
+} = {}) => {
+    const headers = Array.isArray(warning_headers) ? warning_headers : [];
+    const is_pattern_match = (value, pattern) => {
+        if (pattern instanceof RegExp) {
+            return pattern.test(value);
+        }
+        return value.includes(String(pattern));
+    };
+    const is_allowed_warning = (warning_header) => {
+        return allowed_warning_patterns.some((pattern) => is_pattern_match(warning_header, pattern));
+    };
+    const unexpected_warning_headers = headers.filter((warning_header) => !is_allowed_warning(warning_header));
+    assert.strictEqual(
+        unexpected_warning_headers.length,
+        0,
+        `Unexpected esbuild warnings detected:\n${unexpected_warning_headers.join('\n')}`
+    );
+
+    const missing_required_patterns = required_warning_patterns.filter((pattern) => {
+        return !headers.some((warning_header) => is_pattern_match(warning_header, pattern));
+    });
+    assert.strictEqual(
+        missing_required_patterns.length,
+        0,
+        `Missing required esbuild warning patterns: ${missing_required_patterns.map((pattern) => String(pattern)).join(', ')}`
+    );
+
+    return {
+        warning_headers: headers,
+        unexpected_warning_headers
+    };
+};
+
 module.exports = {
     ensure_puppeteer_module,
     launch_puppeteer_browser,
@@ -313,5 +371,8 @@ module.exports = {
     wait_for_text_content,
     drag_by,
     run_interaction_story,
-    wait_for_condition
+    wait_for_condition,
+    extract_esbuild_warning_headers_from_warning_records,
+    extract_esbuild_warning_headers_from_bundle,
+    assert_no_unexpected_esbuild_warning_headers
 };