jsgui3-server 0.0.147 → 0.0.149

package/lab/screenshot-utils.js

@@ -0,0 +1,248 @@
+/**
+ * Screenshot Utilities for jsgui3-server
+ * 
+ * Reusable Puppeteer-based screenshot capture, extracted from
+ * tests/window-examples.puppeteer.test.js patterns.
+ * 
+ * Usage:
+ *   const { launch_browser, capture_page, close_browser } = require('./screenshot-utils');
+ *   await launch_browser();
+ *   const result = await capture_page('http://localhost:3600', {
+ *       output_path: './screenshots/full_page.png',
+ *       full_page: true
+ *   });
+ *   await close_browser();
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let puppeteer;
+let browser;
+
+/**
+ * Launch a headless Puppeteer browser.
+ * @param {Object} [options]
+ * @param {boolean} [options.headless=true]
+ * @param {string} [options.executable_path] - Custom Chrome/Chromium path
+ * @returns {Promise<import('puppeteer').Browser>}
+ */
+const launch_browser = async (options = {}) => {
+    if (browser) return browser;
+
+    if (!puppeteer) {
+        puppeteer = require('puppeteer');
+    }
+
+    const launch_options = {
+        headless: options.headless !== false ? 'new' : false,
+        args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-gpu']
+    };
+
+    if (options.executable_path || process.env.PUPPETEER_EXECUTABLE_PATH) {
+        launch_options.executablePath = options.executable_path || process.env.PUPPETEER_EXECUTABLE_PATH;
+    }
+
+    browser = await puppeteer.launch(launch_options);
+    return browser;
+};
+
+/**
+ * Capture a screenshot of a URL.
+ * @param {string} url - URL to navigate to
+ * @param {Object} [options]
+ * @param {string} [options.output_path] - File path for the PNG
+ * @param {boolean} [options.full_page=true] - Capture full scrollable page
+ * @param {number} [options.width=1280] - Viewport width
+ * @param {number} [options.height=720] - Viewport height
+ * @param {number} [options.wait_ms=1000] - Wait time after load before capture
+ * @param {string} [options.wait_for_selector] - CSS selector to wait for
+ * @returns {Promise<{path: string, width: number, height: number, size_bytes: number}>}
+ */
+const capture_page = async (url, options = {}) => {
+    if (!browser) {
+        throw new Error('Browser not launched. Call launch_browser() first.');
+    }
+
+    const {
+        output_path,
+        full_page = true,
+        width = 1280,
+        height = 720,
+        wait_ms = 1000,
+        wait_for_selector
+    } = options;
+
+    const page = await browser.newPage();
+
+    try {
+        await page.setViewport({ width, height });
+        await page.goto(url, { waitUntil: 'networkidle0', timeout: 30000 });
+
+        if (wait_for_selector) {
+            await page.waitForSelector(wait_for_selector, { timeout: 10000 });
+        }
+
+        if (wait_ms > 0) {
+            await new Promise(r => setTimeout(r, wait_ms));
+        }
+
+        // Ensure output directory exists
+        if (output_path) {
+            fs.mkdirSync(path.dirname(output_path), { recursive: true });
+        }
+
+        const screenshot_path = output_path || path.join(process.cwd(), 'screenshot.png');
+        await page.screenshot({ path: screenshot_path, fullPage: full_page });
+
+        const stats = fs.statSync(screenshot_path);
+        const dimensions = await page.evaluate(() => ({
+            width: document.documentElement.scrollWidth,
+            height: document.documentElement.scrollHeight
+        }));
+
+        return {
+            path: screenshot_path,
+            width: dimensions.width,
+            height: dimensions.height,
+            size_bytes: stats.size
+        };
+    } finally {
+        await page.close();
+    }
+};
+
+/**
+ * Capture a screenshot of a specific element on a page.
+ * @param {string} url - URL to navigate to
+ * @param {string} selector - CSS selector for the element
+ * @param {Object} [options]
+ * @param {string} [options.output_path] - File path for the PNG
+ * @param {number} [options.width=1280] - Viewport width
+ * @param {number} [options.height=720] - Viewport height
+ * @param {number} [options.wait_ms=1000] - Wait time after load
+ * @returns {Promise<{path: string, width: number, height: number, size_bytes: number}>}
+ */
+const capture_element = async (url, selector, options = {}) => {
+    if (!browser) {
+        throw new Error('Browser not launched. Call launch_browser() first.');
+    }
+
+    const {
+        output_path,
+        width = 1280,
+        height = 720,
+        wait_ms = 1000
+    } = options;
+
+    const page = await browser.newPage();
+
+    try {
+        await page.setViewport({ width, height });
+        await page.goto(url, { waitUntil: 'networkidle0', timeout: 30000 });
+        await page.waitForSelector(selector, { timeout: 10000 });
+
+        if (wait_ms > 0) {
+            await new Promise(r => setTimeout(r, wait_ms));
+        }
+
+        if (output_path) {
+            fs.mkdirSync(path.dirname(output_path), { recursive: true });
+        }
+
+        const element = await page.$(selector);
+        if (!element) {
+            throw new Error(`Element not found: ${selector}`);
+        }
+
+        const screenshot_path = output_path || path.join(process.cwd(), 'element_screenshot.png');
+        await element.screenshot({ path: screenshot_path });
+
+        const stats = fs.statSync(screenshot_path);
+        const box = await element.boundingBox();
+
+        return {
+            path: screenshot_path,
+            width: Math.round(box.width),
+            height: Math.round(box.height),
+            size_bytes: stats.size
+        };
+    } finally {
+        await page.close();
+    }
+};
+
+/**
+ * Capture multiple screenshots from a single URL — full page + individual sections.
+ * @param {string} url - URL to screenshot
+ * @param {string} output_dir - Directory to save screenshots
+ * @param {Object} [options]
+ * @param {string[]} [options.section_selectors] - CSS selectors for individual section captures
+ * @param {string[]} [options.section_names] - Names for screenshot files (parallel to selectors)
+ * @param {number} [options.width=1280]
+ * @param {number} [options.height=720]
+ * @param {number} [options.wait_ms=1000]
+ * @returns {Promise<Array<{name: string, path: string, width: number, height: number, size_bytes: number}>>}
+ */
+const capture_url_screenshots = async (url, output_dir, options = {}) => {
+    const {
+        section_selectors = [],
+        section_names = [],
+        width = 1280,
+        height = 720,
+        wait_ms = 1000
+    } = options;
+
+    fs.mkdirSync(output_dir, { recursive: true });
+
+    const results = [];
+
+    // Full page capture
+    const full_result = await capture_page(url, {
+        output_path: path.join(output_dir, 'full_page.png'),
+        full_page: true,
+        width,
+        height,
+        wait_ms
+    });
+    results.push({ name: 'full_page', ...full_result });
+
+    // Section captures
+    for (let i = 0; i < section_selectors.length; i++) {
+        const selector = section_selectors[i];
+        const name = section_names[i] || `section_${i + 1}`;
+
+        try {
+            const section_result = await capture_element(url, selector, {
+                output_path: path.join(output_dir, `${name}.png`),
+                width,
+                height,
+                wait_ms: 500
+            });
+            results.push({ name, ...section_result });
+        } catch (err) {
+            console.warn(`  ⚠ Failed to capture "${name}" (${selector}): ${err.message}`);
+            results.push({ name, error: err.message });
+        }
+    }
+
+    return results;
+};
+
+/**
+ * Close the Puppeteer browser.
+ */
+const close_browser = async () => {
+    if (browser) {
+        await browser.close();
+        browser = null;
+    }
+};
+
+module.exports = {
+    launch_browser,
+    capture_page,
+    capture_element,
+    capture_url_screenshots,
+    close_browser
+};

package/module.js

@@ -16,10 +16,17 @@ jsgui.controls.Active_HTML_Document = require('./controls/Active_HTML_Document')
 
 //const Resource_Publisher = require('./publishing/http-resource-publisher');
 //jsgui.Resource_Publisher = Resource_Publisher;
-const Server = require('./server');
-jsgui.Server = Server;
-jsgui.serve = Server.serve;
-jsgui.fs2 = require('./fs2');
+const Server = require('./server');
+jsgui.Server = Server;
+jsgui.serve = Server.serve;
+jsgui.Process_Resource = Server.Process_Resource;
+jsgui.Remote_Process_Resource = Server.Remote_Process_Resource;
+jsgui.HTTP_SSE_Publisher = Server.HTTP_SSE_Publisher;
+if (jsgui.Resource) {
+    jsgui.Resource.Process = Server.Process_Resource;
+    jsgui.Resource.Remote_Process = Server.Remote_Process_Resource;
+}
+jsgui.fs2 = require('./fs2');
 
 // Port utilities for auto-port selection
 const port_utils = require('./port-utils');

package/package.json

@@ -10,8 +10,8 @@
     "esbuild": "^0.27.1",
     "fnl": "^0.0.37",
     "fnlfs": "^0.0.34",
-    "jsgui3-client": "^0.0.128",
-    "jsgui3-html": "^0.0.179",
+    "jsgui3-client": "^0.0.129",
+    "jsgui3-html": "^0.0.180",
     "jsgui3-webpage": "^0.0.8",
     "jsgui3-website": "^0.0.8",
     "lang-tools": "^0.0.44",
@@ -43,7 +43,7 @@
     "type": "git",
     "url": "https://github.com/metabench/jsgui3-server.git"
   },
-  "version": "0.0.147",
+  "version": "0.0.149",
   "scripts": {
     "cli": "node cli.js",
     "serve": "node cli.js serve",
@@ -53,13 +53,23 @@
     "test:assigners": "node tests/test-runner.js --test=assigners.test.js",
     "test:publishers": "node tests/test-runner.js --test=publishers.test.js",
     "test:config": "node tests/test-runner.js --test=configuration-validation.test.js",
+    "test:admin-ui": "node tests/test-runner.js --test=admin-ui-render.test.js",
+    "test:serve": "node tests/test-runner.js --test=serve.test.js",
+    "test:serve:resources": "node tests/test-runner.js --test=serve-resources.test.js",
+    "test:resources:process": "node tests/test-runner.js --test=process-resource.test.js",
+    "test:resources:remote": "node tests/test-runner.js --test=remote-process-resource.test.js",
+    "test:resources:pool": "node tests/test-runner.js --test=server-resource-pool.test.js",
+    "test:sse": "node tests/test-runner.js --test=http-sse-publisher.test.js",
     "test:e2e": "node tests/test-runner.js --test=end-to-end.test.js",
     "test:content": "node tests/test-runner.js --test=content-analysis.test.js",
+    "test:bundler:cache": "node tests/test-runner.js --test=control-optimizer-cache-behavior.test.js",
     "test:performance": "node tests/test-runner.js --test=performance.test.js",
     "test:errors": "node tests/test-runner.js --test=error-handling.test.js",
     "test:examples:controls": "node tests/test-runner.js --test=examples-controls.e2e.test.js",
+    "test:puppeteer:bundling": "node tests/test-runner.js --test=bundling-default-control-elimination.puppeteer.test.js",
     "test:puppeteer:windows": "node tests/test-runner.js --test=window-examples.puppeteer.test.js",
+    "test:puppeteer:resources": "node tests/test-runner.js --test=window-resource-integration.puppeteer.test.js",
     "test:debug": "node tests/test-runner.js --debug",
     "test:verbose": "node tests/test-runner.js --verbose"
   }
-}
+}

package/publishers/Publishers.js

@@ -7,10 +7,11 @@ const Publishers = {
     'html': require('./http-html-publisher'),
     'jpeg': require('./http-jpeg-publisher'),
     'js': require('./http-js-publisher'),
-    'observable': require('./http-observable-publisher'),
-    'png': require('./http-png-publisher'),
+    'observable': require('./http-observable-publisher'),
+    'sse': require('./http-sse-publisher'),
+    'png': require('./http-png-publisher'),
     'resource': require('./http-resource-publisher'),
     'svg': require('./http-svg-publisher')
 }
 
-module.exports = Publishers;
+module.exports = Publishers;

package/publishers/helpers/assigners/static-compressed-response-buffers/Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner.js

@@ -65,11 +65,11 @@ class Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner
 
     async assign(arr_bundled_items) {
         // Get compression configuration with defaults
-        const enabled = this.compression_config.enabled !== false; // Default: true
-        const algorithms = this.compression_config.algorithms || ['gzip', 'br'];
-        const gzipLevel = this.compression_config.gzip?.level || 6;
-        const brotliQuality = this.compression_config.brotli?.quality || 6;
-        const threshold = this.compression_config.threshold || 1024;
+        const enabled = this.compression_config.enabled !== false; // Default: true
+        const algorithms = this.compression_config.algorithms || ['gzip', 'br'];
+        const gzipLevel = this.compression_config.gzip?.level ?? 6;
+        const brotliQuality = this.compression_config.brotli?.quality ?? 6;
+        const threshold = this.compression_config.threshold ?? 1024;
 
         if (!enabled) {
             console.log('Compression disabled, skipping compression assignment');

package/publishers/http-observable-publisher.js

@@ -27,6 +27,9 @@ class Observable_Publisher extends HTTP_Publisher {
         this.type = 'observable';
         this.obs = obs;
 
+        // Expose schema if provided (either in spec or on the observable itself)
+        this.schema = spec.schema || obs.schema || null;
+
         this.keep_alive_interval_ms = (spec && spec.keep_alive_interval_ms !== undefined)
             ? spec.keep_alive_interval_ms
             : default_keep_alive_interval_ms;
@@ -301,6 +304,11 @@ class Observable_Publisher extends HTTP_Publisher {
             this._write_sse(res, `event: paused\ndata: ${this._stringify_sse_data({ status: 'paused' })}\n\n`);
         }
 
+        // Send schema if available
+        if (this.schema) {
+            this._write_sse(res, `event: schema\ndata: ${this._stringify_sse_data(this.schema)}\n\n`);
+        }
+
         let removed = false;
         const remove_connection = () => {
             if (removed) return;