jsgui3-server 0.0.98 → 0.0.100

package/publishers/http-webpageorsite-publisher.js

@@ -0,0 +1,343 @@
+
+
+
+const {each, Router, tof} = require('jsgui3-html');
+const HTTP_Publisher = require('./http-publisher');
+const {obs} = require('fnl');
+
+// The Webpage bundler should be able to come up with the compiled JS and CSS, maybe even a favicon.
+
+// HTTP_Webpageorsite_Publisher
+
+
+
+const Website = require('jsgui3-website');
+
+const Webpage_Bundler = require('../resources/processors/bundlers/webpage-bundler');
+
+// The webpage bundler - probably will be quite simple to the website bundler.
+// Think the webpage bundler should bundle static HTML content from the server into the bundle.
+
+// Better in general not to regenerate all HTML for each page request.
+
+
+const JS_Bundler = require('../resources/processors/bundlers/js-bundler');
+
+
+const Bundle = require('../resources/processors/bundlers/bundle');
+
+// Now it's the very basics of a website publisher. Quite flexible but could do with more.
+//  Better integration with bundler
+//  Rendering webpages that are dynamic and therefore not bundled (eg user specific content).
+//   Though the js could be bundled. Maybe some of the controls could be bundled? Or semi-bundled?
+
+// HTTP_Webpage_Publisher could be interesting.
+//  The Website Publisher could make use of some of its functionality.
+
+
+// Handling HTTP / bundling for a specific page could be cool.
+
+// A Webpage Publisher may be simpler and better to work on in the short term.
+//  Maybe would not need to be (as) concerned with routing.
+//  Could be useful for publishing a SPA of course, kind of a website but as a single page.
+
+// This seems more like the server router these days
+//  The main server router seems to pass everything to this - maybe that will change.
+
+// Maybe give it some kind of Website_Server????
+
+// Have the Website_Server use the Website_Publisher????
+
+// Need to somewhat separate concerns.
+
+// Publisher here could be simple in terms of bundling, and then giving the paths to the router.
+//   And could have really simple code implementation of doing just that.
+
+// This basically can be simple....
+//   But make the classes' structures more complicated where necessary to accommodate.
+
+
+// Could be just a few lines of logic probably, at least the simplest core implementation.
+
+// Think the server or the website already has a router, so have the website resource's router do the routing.
+//   Maybe upgrade the routers to handle premade (compressed) responses.
+
+// Maybe better to bundle and publish resources.
+// resource-processors in its own dir?
+//   as in it's not actually part of resources?
+
+
+
+
+// Need to basically make this do very little.
+
+// Publish (website, server_router)
+
+
+// Or publish it only under some URLs / domains....?
+
+
+
+
+
+
+// Probably is worth by default having it use the HTTP_Website_Publisher with really simple server setups.
+
+
+// Extend HTTP_Web_Item_Publisher   HTTP_Web_Page_Or_Site_Publisher  (synonym) ????
+
+// Share functionality between webpage and website where useful.
+
+
+
+
+
+class HTTP_Webpageorsite_Publisher extends HTTP_Publisher {
+
+    constructor(spec) {
+        super(spec);
+
+        if (spec.debug !== undefined) this.debug = spec.debug;
+
+        // But then some properties to do with the js client(s?) file path.
+
+        // This should be fairly simple in terms of making use of the bundler, then providing the server (maybe the router component)
+        //   with the content to serve.
+
+        // js_client_file_path ??? client_js_file_path???
+
+        let src_path_client_js;
+		if (spec.disk_path_client_js) {
+			src_path_client_js = spec.disk_path_client_js;
+		} else if (spec.src_path_client_js) {
+			src_path_client_js = spec.src_path_client_js;
+		} else if (spec.source_path_client_js) {
+			src_path_client_js = spec.source_path_client_js;
+		};
+
+		// or src_path_client_js as well...
+
+		Object.defineProperty(this, 'disk_path_client_js', {get: () => src_path_client_js, set: (value) => src_path_client_js = value});
+		Object.defineProperty(this, 'src_path_client_js', {get: () => src_path_client_js, set: (value) => src_path_client_js = value});
+		Object.defineProperty(this, 'source_path_client_js', {get: () => src_path_client_js, set: (value) => src_path_client_js = value});
+
+
+        // But then need to have some things that get it ready on this level...
+
+        // Maybe need a get_ready (async or obs) function....
+
+        this.js_bundler = new JS_Bundler({
+            'debug': this.debug || false
+        });
+
+
+    }
+
+    async get_ready() {
+
+        const {js_bundler} = this;
+        //await super.get_ready(); // Does not have one
+
+        // Then bundle (extract (process) everything in and referenced by the JS file (s) into a bundle object)
+        //   Maybe that bundle object will contain some (static) routing instructions.
+
+        //   The publisher could provide the server with a set of static routing instructions.
+        //   A (simple) Static_Routing_Instructions class could be helpful, and then could be extended, swapped, optimised etc.
+
+        // HTTP_Static_Routing_Instructions even.
+        //   Want simple code, but have it neatly wrap existing class / standard JS object. Eg facade around array even.
+        //   A type of server input or server instruction or server(router) setting.
+
+        console.log('web page or site async get_ready called');
+
+
+        // Single js client for whole website??? Could work, not so sure.
+        //   Appropriate defalt setting (using v explicit classes) will help it to work.
+
+
+
+        const {src_path_client_js} = this;
+
+        //console.log('src_path_client_js', src_path_client_js);
+
+
+        // The js_bundler may need to operate in 'debug' mode.
+
+        const js_bundler_res = await js_bundler.bundle(src_path_client_js);
+        // Should also get the CSS from it....
+
+
+
+        //console.log('js_bundler_res', js_bundler_res);
+
+        // Res of length 2 - with a css item and a js item.
+        //   js item (probably?) first.
+
+        if (js_bundler_res.length === 1) {
+            const bundle = js_bundler_res[0];
+
+            const css_item = bundle._arr.find((item) => item.type === 'CSS');
+            const js_item = bundle._arr.find((item) => item.type === 'JavaScript');
+            
+            if (css_item && js_item) {
+
+                return bundle;
+
+                // Let's but the HTML into the bundle too...
+                //   But could mark the bundle or the HTML saying it needs further preparation (reference or code inserts)
+
+
+                // Should first include references to the CSS and JS in the HTML (Control(s))
+
+
+
+                // generate (render) the HTML.
+
+                // Though possibly the webpage publisher could take over....
+
+
+
+
+
+
+
+                //console.trace();
+                //throw 'stop';
+
+
+                // Setting up a static '/' or main page....?
+                //   May want to make an object that describes / provides the code or controls to insert into every page
+                //   and to say where to do so.
+
+                // May want further '/' single page or control server code, could have some classes named very specifically
+                //   for the cases we are dealing with.
+
+
+
+
+
+
+
+
+
+                // Then get the publisher to use another bundler?
+                // a Ready_To_Serve_Static_Items_Bundler perhaps?
+
+                // Is best to do this a round-about way in terms of the classes, what they do, and having them interchangable, and
+                //   very explicit.
+
+                // Maybe it could even make 'Server_Instructions'.
+                //   Being very explicit about the stages.
+
+                // Maybe rename classes if they are too long and something shorter occurs.
+
+                // System_That_Prepares_Bundles_Of_Just_A_Single_JS_File_And_A_Single_CSS_File_To_Be_Served_Statically
+                //  And_References_To_Them_Inserted_In_HTML_Control
+
+
+                // Being mega-explicit about what gets done here will help integration of classes that do what other people would consider
+                //   better / ideal.
+
+                // JS_And_CSS_Perpare_For_Service_Class
+
+                // For the moment, make extremely specific classes for what the code is doing here.
+
+                // Single_JS_And_Single_CSS_Bundle_To_Serve_Statically_Preparer.
+                // And possibly a version that also creates instructions??? for what to do to the JSGUI control that would otherwise
+                //   be ready.
+
+                // Want to move away from having somewhat complex things in the classes themselves that operate in assumed way.
+                //   Have some relatively complex things that only need to be done on the server really explicit.
+                //   However, also want classes to represent these things so the logic could run on the client.
+
+                // Prepare the static service of the pages for the router.
+
+                // Probably worth finding ways to best include them in the HTML first....
+
+                // This part here is just getting ready to publish.
+
+
+            
+
+
+
+
+
+
+
+
+
+
+
+
+
+                // Preparers seem like they should be part of the Publishers dir structure / system.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+                // or a Bundle_Preparer_Prepare_For_Static_Routes_Assignment ?????
+
+
+
+            } else {
+                console.trace();
+                throw 'stop';
+
+            }
+
+
+
+            //console.trace();
+            //throw 'stop';
+
+        } else if (js_bundler_res._arr.length === 2) {
+
+
+            console.trace();
+            throw 'stop';
+
+            
+
+        } else {
+            console.log('js_bundler_res', js_bundler_res);
+            console.trace();
+            throw 'stop';
+        }
+
+
+
+
+
+        console.trace();
+        throw 'stop nyi';
+
+
+
+
+        
+
+
+
+
+
+
+
+    }
+
+}
+
+
+module.exports = HTTP_Webpageorsite_Publisher;
+

package/publishers/http-website-publisher.js

@@ -9,6 +9,9 @@ const {obs} = require('fnl');
 
 // The Webpage bundler should be able to come up with the compiled JS and CSS, maybe even a favicon.
 
+// HTTP_Webpageorsite_Publisher
+
+
 
 const Website = require('jsgui3-website');
 
@@ -70,12 +73,19 @@ const Bundle = require('../resources/processors/bundlers/bundle');
 
 
 
+// Probably is worth by default having it use the HTTP_Website_Publisher with really simple server setups.
+
+
+// Extend HTTP_Web_Item_Publisher   HTTP_Web_Page_Or_Site_Publisher  (synonym) ????
 
+// Share functionality between webpage and website where useful.
 
 
+const HTTP_Webpageorsite_Publisher = require('./http-webpageorsite-publisher');
 
 
-class HTTP_Website_Publisher extends HTTP_Publisher {
+
+class HTTP_Website_Publisher extends HTTP_Webpageorsite_Publisher {
     // Website generally serves JS from a single address.
     //  Webpage could have its specific JS.
 
@@ -97,6 +107,11 @@ class HTTP_Website_Publisher extends HTTP_Publisher {
         super(spec)
         // A website property.
 
+        //console.trace();
+        //throw 'stop';
+
+        // spec webpage????
+
         let website;
         if (spec.website) {
             if (spec.website instanceof Website) {
@@ -112,6 +127,13 @@ class HTTP_Website_Publisher extends HTTP_Publisher {
             }
         });
 
+
+        // A get_ready function for every level of the class for web publishing may help.
+
+
+
+
+
         // The publisher should not have a router (for the moment???)
         //   It should however determine routes, and provide them to the router.
 
@@ -131,9 +153,13 @@ class HTTP_Website_Publisher extends HTTP_Publisher {
 
 
 
+
+
+
         // Disk path client js being a property of the website itself?
         //   Critical overall functionality, dont want to remove it from here for the moment. See if not critical here.
 
+        /*
 
         let disk_path_client_js;
         if (spec.disk_path_client_js) disk_path_client_js = spec.disk_path_client_js;
@@ -143,6 +169,8 @@ class HTTP_Website_Publisher extends HTTP_Publisher {
             }
         });
 
+        */
+
 
 
         // And this could be an observable too.
@@ -177,6 +205,11 @@ class HTTP_Website_Publisher extends HTTP_Publisher {
 
 
 
+        // Will probably insert new bundling code here - but refer to advanced classes that handle the details.
+
+        console.log('\n\nskipping __old__setup_website_publishing');
+        console.trace();
+        console.log('\n\n');
 
 
         const __old__setup_website_publishing = (website) => {
@@ -511,7 +544,18 @@ class HTTP_Website_Publisher extends HTTP_Publisher {
 
             */
         } else {
-            this.raise('ready');
+
+            // Do the async get_ready function....
+
+            (async() => {
+
+                await this.get_ready();
+                this.raise('ready');
+
+            })();
+
+
+            //
         }
 
         // Create a router for the website if it does not already have one.
@@ -532,6 +576,11 @@ class HTTP_Website_Publisher extends HTTP_Publisher {
 
     }
 
+    async get_ready() {
+        await super.get_ready();
+
+    }
+
 
     handle_http(req, res) {
         // Because it's already been set up in the router! It should have been.

package/resources/compile/server-resource-compilation.js

@@ -1,3 +1,5 @@
+// Or will use some different 'Bundler' classes for the moment.
+// Bundlers will extract CSS from JS too.
 
 // Will make use of features already in jsgui to handle / do compilation.
 

package/resources/jsbuilder/JS_AST/JS_AST_Node_0-Core.js

@@ -125,6 +125,32 @@ class JS_AST_Node_Core {
             configurable: false
         });
 
+
+        this.remove = () => {
+            const {parent_node} = this;
+            if (parent_node) {
+                const i = parent_node.child_nodes.indexOf(this);
+                if (typeof i === 'number') {
+                    parent_node.child_nodes.splice(i, 1);
+                }
+            }
+        }
+
+
+        /*
+            // Remove node - tell the parent to remove that node from its childnodes.
+
+            function removeItemOnce(arr, value) {
+                var index = arr.indexOf(value);
+                if (index > -1) {
+                    arr.splice(index, 1);
+                }
+                return arr;
+            }
+
+        */
+
+
         Object.defineProperty(this, 'root_node', {
             get() { 
                 return root_node;

package/resources/processors/bundlers/css-bundler.js

@@ -1,5 +1,5 @@
 const Bundler = require('./bundler');
-const Bundle = require('./bundle');
+//const Bundle = require('./bundle');
 const {obs, prom_or_cb} = require('fnl');
 const {tof, each} = require('jsgui3-html');
 const fnlfs = require('fnlfs');
@@ -59,6 +59,12 @@ const bundle_css_from_js_str = (js_str, options = {}) => {
     // Moving towards using observables as a matter of course for longer-running functions.
 
     // Seems like this makes a settimeout as well???
+
+
+    // OK, but see about also getting the JS without the CSS parts.
+
+
+
     return obs((next, complete, error) => {
 
         //console.log('js_str.length', js_str.length);
@@ -69,7 +75,17 @@ const bundle_css_from_js_str = (js_str, options = {}) => {
             source: js_str
         };
 
+        // This part is kind-of slow.
+
+        console.log('pre create js ast node');
         const js_ast_node = JS_AST_Node.from_spec(spec);
+        console.log('post create js ast node');
+
+        // Maybe a faster / different JS parser.
+        //  Or do it using regex / specialised algorithm of some sort.
+
+
+
 
         //console.log('!!js_ast_node', !!js_ast_node);
 
@@ -91,7 +107,14 @@ const bundle_css_from_js_str = (js_str, options = {}) => {
         // Just assigning a template literal to .css?
         const css_ae_nodes = [];
 
+        // How about removing those parts from the JS AST?
+
+
+
         js_ast_node.deep_iterate(node => {
+
+            // Maybe this part is slow? Don't think so though.
+
             //console.log('node', node);
             //console.log('Object.keys(node)', Object.keys(node));
             //console.log('node.type_signature', node.type_signature);

package/resources/processors/bundlers/js/JS_Bundler.js

@@ -0,0 +1,52 @@
+
+
+
+const {Evented_Class} = require('lang-tools');
+const {obs} = require('fnl');
+
+// Or just use the advanced ESBuild version for the moment.
+
+const maybe_unneeded_class = () => {
+    class JS_Bundler extends Evented_Class {
+        constructor(spec) {
+            super();
+    
+    
+        }
+        bundle(js_file_path) {
+            // Is it a string path...?
+            //  If it's a string it should be a path.
+    
+            if (typeof js_file_path === 'string') {
+
+                
+    
+    
+    
+                // Possibly first parse analysis...
+    
+                // Extract the CSS from it
+                // Extract the JS from it.
+    
+            } else {
+                console.trace();
+    
+                console.log('\njs_file_path', js_file_path, '\n');
+                throw 'Expected string js_file_path';
+            }
+    
+    
+    
+        }
+    
+    
+    
+    }
+}
+
+
+
+const JS_Bundler = require('./esbuild/Advanced_JS_Bundler_Using_ESBuild');
+
+
+module.exports = JS_Bundler;