jsgui3-server 0.0.98 → 0.0.100

package/examples/controls/1) window/server.js

@@ -0,0 +1,114 @@
+const jsgui = require('./client');
+
+const {Demo_UI, Square_Box} = jsgui.controls;
+const Server = require('../../../server');
+
+
+// what would be the (best?) way to include the whole thing in one JS file?
+//  Maybe don't try that right now.
+//  maybe standardise on the dir, then client.js and server.js inside.
+
+
+
+// Want to exclude this from the client bundle.
+//  Some kind of marking to say that it's server-side only?
+
+// Need to include JSGUI3 js within the client document.
+//   Seems like an earlier code simplification removed this functionality?
+//   Just specifying a Ctrl for the server - and giving it the 'disk_path_client_js'.
+//     May as well fix that....
+
+
+
+
+
+if (require.main === module) {
+
+    // By default should include the JS and the CSS.
+    // By reference, serving them from their respective paths.
+
+
+    // This API is not working right now.
+
+    // A very simple syntax for running a single control would be great.
+
+    // Need to in the default (server) configuration build and serve the client-side app.
+    // Want to be able to make interactive apps quickly with minimal server side code that needs to be written as boilerplate to
+    // get the app running.
+
+    // Though maybe defining a webpage, that serves the client js, and renders the control on the server, and activates it on the client,
+    // would be the right approach.
+
+    // Want to make the code really explicit, in a simple way.
+
+
+    // eg { '/': Demo_UI }
+    // eg { '*': Demo_UI }
+    //  as at least it explicitly assigns it to the '/' route
+
+
+    // But worth keeping the '/' Ctrl property?
+    //  Could change it to explicitly setting the route(s).
+
+    // Do want it to build the client js on start.
+
+    // Could extract the CSS from the file itself, or maybe better reading it from the classes and objects that are loaded / referenced.
+    // All kinds of complex server program structures exist already, so could use Publishers if needed for some things.
+    //  But need to keep the surface-level API really simple.
+
+    // Maybe define a Webpage and maybe use / define an HTML_Webpage_Publisher for example too.
+    // The clearest code would be really explicit about what it does, but in terms of almost English idioms
+    //  and on the surface-level not spelling out in great detail what it's doing, but referencing objects and
+    //  instructions with clear purposes, though details could be obscure at the top level. Eg it's the publisher's responsibility
+    //  to include the CSS and JS that's needed to get it to run. A publisher is referenced and used, and it does its thing.
+
+    // The Server could automatically involk the use of a Publisher.
+    //  May be better to either require or recommend more explicit code, have them in the examples,
+    //  but also to document some shortcuts, defaults, and abbreviations (though they may omit some essential info, so not recommended for beginners)
+
+    // Could have a tabbed view for examples for 'explicit' and 'short' notations when there are multiple.
+
+    // jsgui3-html-suite may be of use, for some more extended controls that are built on top of jsgui3-html, but not specifically
+    // client or server.
+
+
+
+
+
+
+    const server = new Server({
+        Ctrl: Demo_UI,
+        // Giving it the Ctrl and disk path client js should enable to server to get the JS-bundled CSS from the file(s).
+        //  Putting the JS files through proper parsing and into a syntax tree would be best.
+
+
+        //'js_mode': 'debug',
+        'src_path_client_js': require.resolve('./client.js'),
+        debug: true // should not minify the js, should include the symbols.
+        //js_client: require.resolve('./square_box.js')
+    });
+    // A callback or event for when the bundling has been completed
+    //  a 'ready' event.
+
+    // then start the server....
+    // be able to choose the port / ports?
+    console.log('waiting for server ready event');
+    server.on('ready', () => {
+        console.log('server ready');
+
+        // server start will change to observable?
+
+        server.start(8080, function (err, cb_start) {
+            if (err) {
+                throw err;
+            } else {
+                // Should have build it by now...
+    
+                console.log('server started');
+            }
+        });
+    })
+
+    
+
+}

package/examples/controls/{_html-server-color-palette.js → __old/_html-server-color-palette.js}

@@ -17,9 +17,9 @@ var jsgui = require('jsgui3-html');
 var Start_Stop_Toggle_Button = jsgui.Start_Stop_Toggle_Button;
 var Color_Palette = jsgui.Color_Palette;
 
-var Server = require('../../server');
+var Server = require('../../../server');
 var port = 8000;
-var Server_Page_Context = require('../../page-context');
+var Server_Page_Context = require('../../../page-context');
 
 var server = new Server({
 	'routes': {

package/examples/controls/{scs-month-view.js → __old/scs-month-view.js}

@@ -21,7 +21,6 @@ const Month_View = jsgui.Month_View;
 // Give it a live Control?
 //  Would want to give that Control access to a server-side resource too.
 
-
 // We should be able to give that single control params too.
 
 // Body_Server

package/http/responders/HTTP_Responder.js

@@ -0,0 +1,16 @@
+
+const {tof} = require('lang-tools');
+
+class HTTP_Responder {
+    constructor(spec) {
+        const t_spec = tof(spec);
+        if (t_spec === 'object') {
+            Object.assign(this, spec);
+        } else {
+            console.trace();
+            throw 'stop';
+        }
+    }
+}
+
+module.exports = HTTP_Responder;

package/http/responders/static/Static_Route_HTTP_Responder.js

@@ -0,0 +1,106 @@
+
+const HTTP_Responder = require('../HTTP_Responder');
+
+// Looks like some Router bug fix is needed...?
+//  Need to remove the first '/' from the route???
+//  Or fix / modify the jsgui3-html Router so it does that?
+
+// May need to see how it's being put into the router.
+//   Perhaps don't want to use a tree in some / many instances.
+
+// Maybe fixing and updating the routing tree is worthwhile at this stage.
+
+
+
+
+
+class Static_Route_HTTP_Responder extends HTTP_Responder {
+    constructor(spec) {
+        super(spec);
+
+
+        //console.log('Static_Route_HTTP_Responder spec:', spec);
+
+        //console.trace();
+        //throw 'NYI';
+
+        // type, 
+
+        // Give it the bundle object as spec...?
+
+
+    }
+    handle_http(req, res) {
+        const r_headers = req.headers;
+        const accept_encoding = r_headers['accept-encoding'];
+
+        // Need to call it with the correct context.
+        //   Seems like jsgui3-html Router and Routing_Tree need some more fixes.
+
+        const {type, extension, text, route, response_buffers, response_headers} = this;
+
+
+        //console.log('accept_encoding', accept_encoding);
+
+        //console.log('typeof accept_encoding', typeof accept_encoding);
+
+
+
+        // See about 'gzip'.
+        //   Not sure why br does not show up as normal.
+
+        const supported_encodings = {};
+
+        if (accept_encoding.includes('gzip')) supported_encodings.gzip = true;
+
+        if (accept_encoding.includes('br')) supported_encodings.br = true;
+
+        //console.log('supported_encodings', supported_encodings);
+
+        if (supported_encodings.br === true) {
+            
+            for (const key in response_headers.br) {
+                const value = response_headers.br[key];
+                //console.log('[key, value]', [key, value]);
+                res.setHeader(key, value);
+            }
+
+        } else if (supported_encodings.gzip === true) {
+            //console.log('should write headers for gzipped buffer...');
+
+            for (const key in response_headers.gzip) {
+                const value = response_headers.gzip[key];
+                //console.log('[key, value]', [key, value]);
+                res.setHeader(key, value);
+            }
+        } else {
+            for (const key in response_headers.identity) {
+                const value = response_headers.identity[key];
+                //console.log('[key, value]', [key, value]);
+                res.setHeader(key, value);
+            }
+        }
+
+        // Then write the (hopefully compressed) response bodies...
+
+        if (supported_encodings.br === true) {
+            
+            res.write(response_buffers.br);
+            res.write(response_buffers.br);
+        } else if (supported_encodings.gzip === true) {
+            //console.log('should write gzipped buffer...');
+            res.write(response_buffers.gzip);
+        } else {
+            res.write(response_buffers.identity);
+        }
+
+        res.end();
+
+        //console.trace();
+        //throw 'NYI';
+
+    }
+
+}
+
+module.exports = Static_Route_HTTP_Responder;

package/package.json

@@ -11,16 +11,17 @@
     "browserify": "17.0.0",
     "child-process": "^1.0.2",
     "cookies": "^0.8.0",
-    "esbuild": "^0.19.3",
-    "fnl": "^0.0.27",
-    "fnlfs": "^0.0.28",
-    "jsgui3-client": "^0.0.79",
-    "jsgui3-webpage": "^0.0.3",
-    "jsgui3-website": "^0.0.3",
+    "esbuild": "^0.19.4",
+    "fnl": "^0.0.29",
+    "fnlfs": "^0.0.29",
+    "jsgui3-client": "^0.0.84",
+    "jsgui3-webpage": "^0.0.6",
+    "jsgui3-website": "^0.0.6",
+    "lang-tools": "^0.0.17",
     
     "multiparty": "^4.2.3",
     "ncp": "^2.0.0",
-    "obext": "^0.0.25",
+    "obext": "^0.0.27",
     "rimraf": "^3.0.2",
     "stream-to-array": "^2.3.0",
     "url-parse": "^1.5.10"
@@ -44,5 +45,5 @@
     "type": "git",
     "url": "https://github.com/metabench/jsgui3-server.git"
   },
-  "version": "0.0.98"
+  "version": "0.0.100"
 }

package/page-context.js

@@ -6,6 +6,21 @@ var Class = jsgui.Class, Data_Object = jsgui.Data_Object;
 var fp = jsgui.fp, is_defined = jsgui.is_defined;
 var get_a_sig = jsgui.get_a_sig;
 
+
+// Server_Static_Page_Context could help just by the more explicit name.
+// Used for a single rendering.
+
+// Will not be in the context of a request and response.
+//   Though could help with creating a response that can be reused.
+
+// Think we should continue making the various (very specific) bits and pieces that represent all parts of the process.
+
+// 
+
+
+
+
+
 // Need to find out what this one requires to put it in its own module.
 class Server_Page_Context extends jsgui.Page_Context {
 	constructor(spec) {

package/publishers/helpers/assigners/Assigner.js

@@ -0,0 +1,11 @@
+
+// A publisher helper?
+//  Could make that the top level class even, would help with typing.
+
+class Assigner {
+    constructor(spec = {}) {
+
+    }
+}
+
+module.exports = Assigner;

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

@@ -0,0 +1,150 @@
+
+
+// Making such specific classes with such long names seems kind of silly, but will help to keep the higher level code
+//   both explicit and easy to follow.
+
+// These classes will do specific things, to specific things (in specific ways)
+
+// Basically middleware that the app dev should not need to pay much attention to usually.
+
+
+
+
+// And likely will have some other class (system), maybe assigners, to set the routes on the server / server router.
+//   Or within the website resource???
+
+// So everything (main) that the server does will be done using various interchangable classes.
+//   Some classes will cover some very specific use cases.
+
+const zlib = require('zlib');
+
+
+
+const Assigner = require('../Assigner');
+
+const {is_array} = require('lang-tools');
+
+// And will have some very or less specific assigners for some other things.
+//   Like the compressed (text?) response headers.
+
+
+const { promisify } = require('node:util');
+
+// deflate, unzip 
+
+const gzip_compress = promisify(zlib.gzip);
+const br_compress = promisify(zlib.brotliCompress);
+
+
+// zlib.gzip(buffer[, options], callback)
+
+
+class Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner extends Assigner {
+
+    constructor(spec = {}) {
+        super(spec);
+    }
+
+    // assign to bundle....
+    //  or array would be better.
+
+    // assign to (bundle) items in array.
+
+
+    // These assign functions should (all probably) be async
+
+    async assign(arr_bundled_items) {
+        // go through them....
+
+        // Maybe check that the correct items are in the bundle.
+
+        // Perhaps check for 1 of each js, css, html
+        //   And could use a specific other class to assign these.
+
+        //   Should be OK to make classes for really specific things.
+        //     At this part of the system / API, it's not necessary / important to limit complexity in that way.
+
+        // The goal is to provide a very simple high level interface. Powerful too.
+
+        // Could assign a static_route property to the items in the bundles.
+
+
+
+
+
+        if (is_array(arr_bundled_items)) {
+
+            for (const item of arr_bundled_items) {
+                //console.log('item', item);
+
+                const {type} = item;
+
+                // And need to create the uncompressed response buffer.
+
+                // // response_buffers.identity I think....
+
+                if (item.text) {
+
+                    // Async compression definitely seems much better here.
+
+
+                    const buf_gzipped = await gzip_compress(item.response_buffers.identity);
+
+                    item.response_buffers.gzip = buf_gzipped;
+
+                    // Maybe should be 11 in many cases.
+                    //  Seems right when publishing static JS resources.???
+                    //  Compromise with 10 for the moment.
+
+                    const buf_br = await br_compress(item.response_buffers.identity, {
+                        params: {
+                            //[zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
+                            [zlib.constants.BROTLI_PARAM_QUALITY]: 10,
+                            [zlib.constants.BROTLI_PARAM_SIZE_HINT]: item.response_buffers.identity.length,
+                          }
+                    });
+
+                    item.response_buffers.br = buf_br;
+
+
+                    // The gzip response
+                    // The brotli response
+
+                    // promisifying these calls would help.
+
+
+                    /*
+
+
+                    const buf_identity_response = Buffer.from(item.text, 'utf-8');
+
+                    item.response_buffers = item.response_buffers || {};
+                    item.response_buffers.identity = buf_identity_response;
+                    */
+                } else {
+
+                }
+
+                
+
+                //console.trace();
+                //throw 'stop';
+            }
+
+        } else {
+            console.trace();
+            throw 'stop';
+        }
+
+
+
+
+    }
+
+
+}
+
+
+module.exports = Single_Control_Webpage_Server_Static_Compressed_Response_Buffers_Assigner;
+
+

package/publishers/helpers/assigners/static-headers/Single_Control_Webpage_Server_Static_Headers_Assigner.js

@@ -0,0 +1,110 @@
+
+
+const Assigner = require('../Assigner');
+
+const {is_array, each} = require('lang-tools');
+
+// And will have some very or less specific assigners for some other things.
+//   Like the compressed (text?) response headers.
+
+
+
+
+class Single_Control_Webpage_Server_Static_Headers_Assigner extends Assigner {
+
+    constructor(spec = {}) {
+        super(spec);
+    }
+
+    // assign to bundle....
+    //  or array would be better.
+
+    // assign to (bundle) items in array.
+
+    async assign(arr_bundled_items) {
+        // go through them....
+
+        // Maybe check that the correct items are in the bundle.
+
+        // Perhaps check for 1 of each js, css, html
+        //   And could use a specific other class to assign these.
+
+        //   Should be OK to make classes for really specific things.
+        //     At this part of the system / API, it's not necessary / important to limit complexity in that way.
+
+        // The goal is to provide a very simple high level interface. Powerful too.
+
+        // Could assign a static_route property to the items in the bundles.
+
+
+        if (is_array(arr_bundled_items)) {
+
+            for (const item of arr_bundled_items) {
+                //console.log('item', item);
+
+                item.response_headers = item.response_headers || {};
+
+                let str_content_type;
+
+                if (item.type === 'JavaScript') {
+                    str_content_type = 'text/javascript; charset=utf-8';
+                } else if (item.type === 'CSS') {
+                    str_content_type = 'text/css; charset=utf-8';
+                } else if (item.type === 'HTML') {
+                    str_content_type = 'text/html; charset=utf-8';
+                }
+
+                
+                
+                // Different headers depending on the returned (ie accepted) content encoding types.
+
+                    // item.response_buffers.identity / gzip / br
+
+                    // go through the item.response_buffers
+
+                each(item.response_buffers, (buf, content_encoding_name) => {
+
+                    //console.log('content_encoding_name', content_encoding_name);
+
+                    const headers_for_content_encoding = item.response_headers[content_encoding_name] = item.response_headers[content_encoding_name] || {};
+                    headers_for_content_encoding['Content-Length'] = buf.length;
+
+
+                    if (str_content_type) {
+                        headers_for_content_encoding['Content-Type'] = str_content_type;
+                    }
+
+                    if (content_encoding_name === 'identity') {
+
+                    } else {
+                        headers_for_content_encoding['Content-Encoding'] = content_encoding_name;
+
+
+                    }
+
+
+
+                });
+
+                // And setting the content types too...
+
+
+                //console.trace();
+                //throw 'stop';
+            }
+
+        } else {
+            console.trace();
+            throw 'stop';
+        }
+
+
+
+
+    }
+
+
+}
+
+
+module.exports = Single_Control_Webpage_Server_Static_Headers_Assigner;

package/publishers/helpers/assigners/static-routes/Single_Control_Webpage_Server_Static_Routes_Assigner.js

@@ -0,0 +1,92 @@
+
+
+const Assigner = require('../Assigner');
+
+const {is_array} = require('lang-tools');
+
+// And will have some very or less specific assigners for some other things.
+//   Like the compressed (text?) response headers.
+
+
+
+
+class Single_Control_Webpage_Server_Static_Routes_Assigner extends Assigner {
+
+    constructor(spec = {}) {
+        super(spec);
+    }
+
+    // assign to bundle....
+    //  or array would be better.
+
+    // assign to (bundle) items in array.
+
+    async assign(arr_bundled_items) {
+        // go through them....
+
+        // Maybe check that the correct items are in the bundle.
+
+        // Perhaps check for 1 of each js, css, html
+        //   And could use a specific other class to assign these.
+
+        //   Should be OK to make classes for really specific things.
+        //     At this part of the system / API, it's not necessary / important to limit complexity in that way.
+
+        // The goal is to provide a very simple high level interface. Powerful too.
+
+        // Could assign a static_route property to the items in the bundles.
+
+
+
+
+
+        if (is_array(arr_bundled_items)) {
+
+            for (const item of arr_bundled_items) {
+                //console.log('item', item);
+
+                
+
+                const {type} = item;
+
+                // Just very simple for the moment.
+                //  Maybe will read it from the Ctrl?
+                //  Better to have some kind of Standard_Resource_Path_Assignment_System
+
+                if (type === 'JavaScript') {
+                    item.route = '/js/js.js';
+
+
+
+                } else if (type === 'CSS') {
+                    item.route = '/css/css.css';
+
+
+
+                } else if (type === 'HTML') {
+                    item.route = '/';
+
+                } else {
+                    console.trace();
+                    throw 'NYI - type: ' + type; 
+                }
+
+                //console.trace();
+                //throw 'stop';
+            }
+
+        } else {
+            console.trace();
+            throw 'stop';
+        }
+
+
+
+
+    }
+
+
+}
+
+
+module.exports = Single_Control_Webpage_Server_Static_Routes_Assigner;