npm - jsgui3-server - Versions diffs - 0.0.138 → 0.0.140 - Mend

jsgui3-server 0.0.138 → 0.0.140

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

package/AGENTS.md +87 -0
package/README.md +12 -0
package/docs/GUIDE_TO_AGENTIC_WORKFLOWS_BY_GROK.md +19 -0
package/docs/advanced-usage-examples.md +1360 -0
package/docs/agent-development-guide.md +386 -0
package/docs/api-reference.md +916 -0
package/docs/broken-functionality-tracker.md +285 -0
package/docs/bundling-system-deep-dive.md +525 -0
package/docs/cli-reference.md +393 -0
package/docs/comprehensive-documentation.md +1403 -0
package/docs/configuration-reference.md +808 -0
package/docs/controls-development.md +859 -0
package/docs/documentation-review/CURRENT_REVIEW.md +95 -0
package/docs/function-publishers-json-apis.md +847 -0
package/docs/getting-started-with-json.md +518 -0
package/docs/minification-compression-sourcemaps-status.md +482 -0
package/docs/minification-compression-sourcemaps-test-results.md +205 -0
package/docs/publishers-guide.md +313 -0
package/docs/resources-guide.md +615 -0
package/docs/serve-helpers.md +406 -0
package/docs/simple-server-api-design.md +13 -0
package/docs/system-architecture.md +275 -0
package/docs/troubleshooting.md +698 -0
package/examples/json/README.md +115 -0
package/examples/json/basic-api/README.md +345 -0
package/examples/json/basic-api/server.js +199 -0
package/examples/json/simple-api/README.md +125 -0
package/examples/json/simple-api/diagnostic-report.json +73 -0
package/examples/json/simple-api/diagnostic-test.js +433 -0
package/examples/json/simple-api/server-debug.md +58 -0
package/examples/json/simple-api/server.js +91 -0
package/examples/json/simple-api/test.js +215 -0
package/http/responders/static/Static_Route_HTTP_Responder.js +1 -2
package/package.json +19 -8
package/publishers/helpers/assigners/static-compressed-response-buffers/Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner.js +65 -12
package/publishers/helpers/preparers/static/bundle/Static_Routes_Responses_Webpage_Bundle_Preparer.js +6 -1
package/publishers/http-function-publisher.js +59 -38
package/publishers/http-webpage-publisher.js +48 -1
package/resources/processors/bundlers/js/esbuild/Advanced_JS_Bundler_Using_ESBuild.js +38 -146
package/resources/processors/bundlers/js/esbuild/Core_JS_Non_Minifying_Bundler_Using_ESBuild.js +54 -5
package/resources/processors/bundlers/js/esbuild/Core_JS_Single_File_Minifying_Bundler_Using_ESBuild.js +36 -4
package/serve-factory.js +36 -9
package/server.js +10 -4
package/test-report.json +0 -0
package/tests/README.md +250 -0
package/tests/assigners.test.js +316 -0
package/tests/bundlers.test.js +329 -0
package/tests/configuration-validation.test.js +530 -0
package/tests/content-analysis.test.js +641 -0
package/tests/end-to-end.test.js +496 -0
package/tests/error-handling.test.js +746 -0
package/tests/performance.test.js +653 -0
package/tests/publishers.test.js +395 -0
package/tests/temp_invalid.js +7 -0
package/tests/temp_invalid_utf8.js +1 -0
package/tests/temp_malformed.js +10 -0
package/tests/test-runner.js +261 -0

package/tests/publishers.test.js ADDED Viewed

@@ -0,0 +1,395 @@
+const assert = require('assert');
+const { describe, it, beforeEach, afterEach } = require('mocha');
+// Import publisher classes
+const HTTP_Webpage_Publisher = require('../publishers/http-webpage-publisher');
+describe('Publisher Component Isolation Tests', function() {
+    this.timeout(15000); // Increase timeout for publisher operations
+    let mockControl;
+    let mockWebpage;
+    beforeEach(function() {
+        // Create mock control class
+        mockControl = class MockControl {
+            constructor(spec) {
+                this.context = spec.context;
+                this.head = {
+                    add: function(element) {
+                        // Mock add method
+                    }
+                };
+                this.body = {
+                    add: function(element) {
+                        // Mock add method
+                    }
+                };
+            }
+            active() {
+                // Mock activation
+            }
+            all_html_render() {
+                return Promise.resolve(`<!DOCTYPE html>
+<html>
+<head><title>Test Page</title></head>
+<body>
+    <div id="control-root">
+        <h1>Test Control</h1>
+        <p>This is a test control for publisher testing.</p>
+    </div>
+    <script src="/js/js.js"></script>
+</body>
+</html>`);
+            }
+        };
+        // Create mock webpage
+        mockWebpage = {
+            content: mockControl
+        };
+    });
+    describe('HTTP_Webpage_Publisher', function() {
+        it('should initialize with default configuration', function() {
+            const publisher = new HTTP_Webpage_Publisher({
+                webpage: mockWebpage
+            });
+            assert(publisher.webpage === mockWebpage, 'Should store webpage reference');
+            assert(publisher.bundler_config, 'Should initialize bundler config');
+            assert(publisher.static_routes_responses_webpage_bundle_preparer,
+                   'Should create bundle preparer');
+        });
+        it('should accept and validate bundler configuration', function() {
+            const validConfig = {
+                webpage: mockWebpage,
+                bundler: {
+                    compression: {
+                        enabled: true,
+                        algorithms: ['gzip', 'br'],
+                        threshold: 1024
+                    },
+                    minify: {
+                        enabled: true,
+                        level: 'normal'
+                    },
+                    sourcemaps: {
+                        enabled: true,
+                        format: 'inline'
+                    }
+                }
+            };
+            const publisher = new HTTP_Webpage_Publisher(validConfig);
+            assert.deepStrictEqual(publisher.bundler_config, validConfig.bundler,
+                                 'Should store valid bundler configuration');
+        });
+        it('should validate compression configuration - boolean enabled', function() {
+            assert.throws(() => {
+                new HTTP_Webpage_Publisher({
+                    webpage: mockWebpage,
+                    bundler: {
+                        compression: {
+                            enabled: 'invalid' // Should be boolean
+                        }
+                    }
+                });
+            }, /bundler\.compression\.enabled must be a boolean/);
+        });
+        it('should validate compression configuration - array algorithms', function() {
+            assert.throws(() => {
+                new HTTP_Webpage_Publisher({
+                    webpage: mockWebpage,
+                    bundler: {
+                        compression: {
+                            algorithms: 'invalid' // Should be array
+                        }
+                    }
+                });
+            }, /bundler\.compression\.algorithms must be an array/);
+        });
+        it('should validate compression configuration - valid algorithms', function() {
+            assert.throws(() => {
+                new HTTP_Webpage_Publisher({
+                    webpage: mockWebpage,
+                    bundler: {
+                        compression: {
+                            algorithms: ['gzip', 'invalid_algorithm']
+                        }
+                    }
+                });
+            }, /Invalid compression algorithm: invalid_algorithm/);
+        });
+        it('should validate compression configuration - threshold number', function() {
+            assert.throws(() => {
+                new HTTP_Webpage_Publisher({
+                    webpage: mockWebpage,
+                    bundler: {
+                        compression: {
+                            threshold: 'invalid' // Should be number
+                        }
+                    }
+                });
+            }, /bundler\.compression\.threshold must be a non-negative number/);
+        });
+        it('should validate compression configuration - negative threshold', function() {
+            assert.throws(() => {
+                new HTTP_Webpage_Publisher({
+                    webpage: mockWebpage,
+                    bundler: {
+                        compression: {
+                            threshold: -1 // Should be non-negative
+                        }
+                    }
+                });
+            }, /bundler\.compression\.threshold must be a non-negative number/);
+        });
+        it('should accept valid compression algorithms', function() {
+            const publisher = new HTTP_Webpage_Publisher({
+                webpage: mockWebpage,
+                bundler: {
+                    compression: {
+                        algorithms: ['gzip', 'br']
+                    }
+                }
+            });
+            assert.deepStrictEqual(publisher.bundler_config.compression.algorithms, ['gzip', 'br']);
+        });
+        it('should initialize bundle preparer with configuration', function() {
+            const config = {
+                webpage: mockWebpage,
+                bundler: {
+                    compression: {
+                        enabled: true,
+                        algorithms: ['gzip']
+                    }
+                }
+            };
+            const publisher = new HTTP_Webpage_Publisher(config);
+            // Verify preparer was created with config
+            assert(publisher.static_routes_responses_webpage_bundle_preparer,
+                   'Should create bundle preparer');
+            assert.deepStrictEqual(
+                publisher.static_routes_responses_webpage_bundle_preparer.bundler_config,
+                config.bundler,
+                'Preparer should receive bundler config'
+            );
+        });
+        it('should handle missing bundler configuration gracefully', function() {
+            const publisher = new HTTP_Webpage_Publisher({
+                webpage: mockWebpage
+                // No bundler config
+            });
+            assert.deepStrictEqual(publisher.bundler_config, {},
+                                 'Should default to empty bundler config');
+        });
+        it('should handle missing compression configuration gracefully', function() {
+            const publisher = new HTTP_Webpage_Publisher({
+                webpage: mockWebpage,
+                bundler: {
+                    // Empty bundler config
+                }
+            });
+            assert.deepStrictEqual(publisher.bundler_config, {});
+        });
+        it('should handle partial bundler configuration', function() {
+            const partialConfig = {
+                webpage: mockWebpage,
+                bundler: {
+                    compression: {
+                        enabled: true
+                        // Missing other compression options
+                    }
+                    // Missing minify and sourcemaps
+                }
+            };
+            const publisher = new HTTP_Webpage_Publisher(partialConfig);
+            assert.strictEqual(publisher.bundler_config.compression.enabled, true);
+            assert(!publisher.bundler_config.minify, 'Should not have minify config');
+            assert(!publisher.bundler_config.sourcemaps, 'Should not have sourcemaps config');
+        });
+        it('should handle handle_http method', function() {
+            const publisher = new HTTP_Webpage_Publisher({
+                webpage: mockWebpage
+            });
+            // Mock request and response
+            const mockReq = {
+                url: '/test',
+                headers: {}
+            };
+            let responseWritten = false;
+            let statusCode = null;
+            let headers = {};
+            const mockRes = {
+                writeHead: function(code, h) {
+                    statusCode = code;
+                    headers = h;
+                },
+                end: function() {
+                    responseWritten = true;
+                }
+            };
+            publisher.handle_http(mockReq, mockRes);
+            // Note: This test may need adjustment based on actual handle_http implementation
+            // For now, just verify it doesn't crash
+            assert(responseWritten || statusCode, 'Should handle HTTP request');
+        });
+        it('should pass configuration to bundle preparer correctly', function() {
+            const complexConfig = {
+                webpage: mockWebpage,
+                bundler: {
+                    minify: {
+                        enabled: true,
+                        level: 'aggressive',
+                        options: {
+                            drop_console: true
+                        }
+                    },
+                    sourcemaps: {
+                        enabled: true,
+                        format: 'inline',
+                        includeInProduction: false
+                    },
+                    compression: {
+                        enabled: true,
+                        algorithms: ['br'],
+                        brotli: { quality: 6 },
+                        threshold: 2048
+                    }
+                }
+            };
+            const publisher = new HTTP_Webpage_Publisher(complexConfig);
+            // Verify complex configuration is passed through
+            assert.deepStrictEqual(publisher.bundler_config, complexConfig.bundler);
+            assert.strictEqual(publisher.static_routes_responses_webpage_bundle_preparer.bundler_config,
+                             complexConfig.bundler);
+        });
+        it('should handle configuration inheritance and defaults', function() {
+            // Test that defaults are applied when partial config is provided
+            const partialConfig = {
+                webpage: mockWebpage,
+                bundler: {
+                    compression: {
+                        // Only specify some options
+                        enabled: true
+                    }
+                }
+            };
+            const publisher = new HTTP_Webpage_Publisher(partialConfig);
+            // Should have the specified option
+            assert.strictEqual(publisher.bundler_config.compression.enabled, true);
+            // Should not have unspecified options (they will be undefined)
+            assert(!publisher.bundler_config.compression.algorithms,
+                   'Should not set default algorithms when not specified');
+        });
+    });
+    describe('Configuration Validation Edge Cases', function() {
+        it('should handle null/undefined webpage', function() {
+            // This might be allowed or not depending on implementation
+            const publisher = new HTTP_Webpage_Publisher({
+                // No webpage
+            });
+            assert(!publisher.webpage, 'Should handle missing webpage');
+        });
+        it('should handle empty bundler config object', function() {
+            const publisher = new HTTP_Webpage_Publisher({
+                webpage: mockWebpage,
+                bundler: {}
+            });
+            assert.deepStrictEqual(publisher.bundler_config, {});
+        });
+        it('should handle deeply nested configuration', function() {
+            const deepConfig = {
+                webpage: mockWebpage,
+                bundler: {
+                    minify: {
+                        options: {
+                            compress: {
+                                drop_console: true,
+                                drop_debugger: true
+                            }
+                        }
+                    }
+                }
+            };
+            const publisher = new HTTP_Webpage_Publisher(deepConfig);
+            assert.strictEqual(
+                publisher.bundler_config.minify.options.compress.drop_console,
+                true
+            );
+            assert.strictEqual(
+                publisher.bundler_config.minify.options.compress.drop_debugger,
+                true
+            );
+        });
+    });
+    describe('Integration with Static_Routes_Responses_Webpage_Bundle_Preparer', function() {
+        it('should create preparer with correct configuration', function() {
+            const config = {
+                webpage: mockWebpage,
+                bundler: {
+                    compression: {
+                        enabled: true,
+                        algorithms: ['gzip']
+                    }
+                }
+            };
+            const publisher = new HTTP_Webpage_Publisher(config);
+            const preparer = publisher.static_routes_responses_webpage_bundle_preparer;
+            // Verify preparer has the config
+            assert.strictEqual(preparer.bundler_config, config.bundler);
+            // Verify preparer creates compressed response buffers assigner with config
+            assert(preparer.compressed_response_buffers_assigner);
+            assert.strictEqual(
+                preparer.compressed_response_buffers_assigner.compression_config,
+                config.bundler.compression
+            );
+        });
+    });
+});

package/tests/temp_invalid.js ADDED Viewed

@@ -0,0 +1,7 @@
+            function invalidFunction() {
+                // Missing closing brace and syntax error
+                console.log('invalid syntax'
+                return "this will never execute";
+            }

package/tests/temp_invalid_utf8.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ ��

package/tests/temp_malformed.js ADDED Viewed

@@ -0,0 +1,10 @@
+                    const css = `
+                        .test-class {
+                            color: red;
+                            /* Missing closing brace
+                            background: blue
+                        `;
+                    console.log('test');

package/tests/test-runner.js ADDED Viewed

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+/**
+ * Comprehensive Test Runner for JSGUI3 Minification, Compression, and Sourcemaps
+ *
+ * This test runner executes all test suites and provides detailed reporting
+ * for the minification, compression, and sourcemap features.
+ */
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs').promises;
+class TestRunner {
+    constructor() {
+        this.testResults = {
+            total: 0,
+            passed: 0,
+            failed: 0,
+            skipped: 0,
+            duration: 0,
+            suites: []
+        };
+        this.testFiles = [
+            'bundlers.test.js',
+            'assigners.test.js',
+            'publishers.test.js',
+            'configuration-validation.test.js',
+            'end-to-end.test.js',
+            'content-analysis.test.js',
+            'performance.test.js',
+            'error-handling.test.js'
+        ];
+    }
+    async runAllTests() {
+        console.log('🚀 Starting JSGUI3 Minification, Compression & Sourcemaps Test Suite\n');
+        console.log('=' .repeat(80));
+        const startTime = Date.now();
+        for (const testFile of this.testFiles) {
+            await this.runTestFile(testFile);
+        }
+        this.testResults.duration = Date.now() - startTime;
+        this.printSummary();
+        this.generateReport();
+        return this.testResults.failed === 0;
+    }
+    async runTestFile(testFile) {
+        const testPath = path.join(__dirname, testFile);
+        try {
+            await fs.access(testPath);
+        } catch (error) {
+            console.log(`⚠️  Skipping ${testFile} - file not found`);
+            this.testResults.suites.push({
+                name: testFile,
+                status: 'skipped',
+                error: 'File not found'
+            });
+            this.testResults.skipped++;
+            return;
+        }
+        console.log(`\n📋 Running ${testFile}...`);
+        return new Promise((resolve) => {
+            const mocha = spawn('node', ['node_modules/mocha/bin/mocha.js', testPath, '--timeout', '30000', '--reporter', 'spec'], {
+                stdio: 'inherit',
+                cwd: process.cwd(),
+                env: { ...process.env, JSGUI_DEBUG: '0' }
+            });
+            let output = '';
+            let errorOutput = '';
+            mocha.stdout?.on('data', (data) => {
+                output += data.toString();
+            });
+            mocha.stderr?.on('data', (data) => {
+                errorOutput += data.toString();
+            });
+            mocha.on('close', (code) => {
+                const suiteResult = {
+                    name: testFile,
+                    status: code === 0 ? 'passed' : 'failed',
+                    exitCode: code,
+                    output: output,
+                    errorOutput: errorOutput
+                };
+                this.testResults.suites.push(suiteResult);
+                if (code === 0) {
+                    console.log(`✅ ${testFile} passed`);
+                    this.testResults.passed++;
+                } else {
+                    console.log(`❌ ${testFile} failed (exit code: ${code})`);
+                    this.testResults.failed++;
+                }
+                this.testResults.total++;
+                resolve();
+            });
+            mocha.on('error', (error) => {
+                console.log(`❌ ${testFile} error: ${error.message}`);
+                this.testResults.suites.push({
+                    name: testFile,
+                    status: 'error',
+                    error: error.message
+                });
+                this.testResults.failed++;
+                this.testResults.total++;
+                resolve();
+            });
+        });
+    }
+    printSummary() {
+        console.log('\n' + '='.repeat(80));
+        console.log('📊 TEST SUMMARY');
+        console.log('='.repeat(80));
+        console.log(`Total Test Suites: ${this.testResults.total}`);
+        console.log(`✅ Passed: ${this.testResults.passed}`);
+        console.log(`❌ Failed: ${this.testResults.failed}`);
+        console.log(`⚠️  Skipped: ${this.testResults.skipped}`);
+        console.log(`⏱️  Duration: ${(this.testResults.duration / 1000).toFixed(2)}s`);
+        const successRate = this.testResults.total > 0 ?
+            ((this.testResults.passed / this.testResults.total) * 100).toFixed(1) : 0;
+        console.log(`📈 Success Rate: ${successRate}%`);
+        if (this.testResults.failed > 0) {
+            console.log('\n❌ Failed Test Suites:');
+            this.testResults.suites
+                .filter(suite => suite.status === 'failed' || suite.status === 'error')
+                .forEach(suite => {
+                    console.log(`   - ${suite.name}: ${suite.error || 'Exit code ' + suite.exitCode}`);
+                });
+        }
+        console.log('\n' + '='.repeat(80));
+        if (this.testResults.failed === 0) {
+            console.log('🎉 All tests passed! The minification, compression, and sourcemap features are working correctly.');
+        } else {
+            console.log('⚠️  Some tests failed. Please review the implementation and fix the issues.');
+        }
+    }
+    async generateReport() {
+        const reportPath = path.join(__dirname, '..', 'test-report.json');
+        const report = {
+            timestamp: new Date().toISOString(),
+            summary: {
+                total: this.testResults.total,
+                passed: this.testResults.passed,
+                failed: this.testResults.failed,
+                skipped: this.testResults.skipped,
+                duration: this.testResults.duration,
+                successRate: this.testResults.total > 0 ?
+                    ((this.testResults.passed / this.testResults.total) * 100).toFixed(1) : 0
+            },
+            suites: this.testResults.suites.map(suite => ({
+                name: suite.name,
+                status: suite.status,
+                exitCode: suite.exitCode,
+                error: suite.error
+            })),
+            environment: {
+                nodeVersion: process.version,
+                platform: process.platform,
+                arch: process.arch,
+                cwd: process.cwd()
+            }
+        };
+        try {
+            await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+            console.log(`📄 Detailed report saved to: ${reportPath}`);
+        } catch (error) {
+            console.log(`⚠️  Failed to save report: ${error.message}`);
+        }
+    }
+    async runSpecificTest(testName) {
+        if (!this.testFiles.includes(testName)) {
+            console.log(`❌ Test file '${testName}' not found. Available tests:`);
+            this.testFiles.forEach(file => console.log(`   - ${file}`));
+            return false;
+        }
+        console.log(`🎯 Running specific test: ${testName}\n`);
+        console.log('='.repeat(80));
+        const startTime = Date.now();
+        await this.runTestFile(testName);
+        this.testResults.duration = Date.now() - startTime;
+        this.printSummary();
+        this.generateReport();
+        return this.testResults.failed === 0;
+    }
+    async runWithOptions(options) {
+        if (options.debug) {
+            process.env.JSGUI_DEBUG = '1';
+            console.log('🐛 Debug mode enabled');
+        }
+        if (options.verbose) {
+            console.log('📝 Verbose output enabled');
+        }
+        if (options.specific) {
+            return await this.runSpecificTest(options.specific);
+        } else {
+            return await this.runAllTests();
+        }
+    }
+}
+// CLI Interface
+async function main() {
+    const args = process.argv.slice(2);
+    const options = {
+        debug: args.includes('--debug'),
+        verbose: args.includes('--verbose'),
+        specific: args.find(arg => arg.startsWith('--test='))?.split('=')[1]
+    };
+    const runner = new TestRunner();
+    try {
+        const success = await runner.runWithOptions(options);
+        process.exit(success ? 0 : 1);
+    } catch (error) {
+        console.error('💥 Test runner failed:', error);
+        process.exit(1);
+    }
+}
+// Export for programmatic use
+module.exports = TestRunner;
+// Run if called directly
+if (require.main === module) {
+    main();
+}