jsgui3-server 0.0.74 → 0.0.78

package/resources/jsbuilder/JS_File/JS_File_1-Early_Parse.js

@@ -0,0 +1,175 @@
+const JS_File_Core = require('./JS_File_0-Core');
+
+class JS_File_Early_Parse extends JS_File_Core {
+    constructor(spec) {
+        super(spec);
+
+        let code_type;
+        let export_name;
+
+        
+
+        
+        this.on('recieve-line', e_recieve_line => {
+            //console.log('e_recieve_line', e_recieve_line);
+            const {str} = e_recieve_line;
+            if (str.startsWith('module.exports')) {
+                //console.log('str', str);
+                const [mexp, name] = str.split(';').join('').split(' ').join('').split('=');
+                //console.log('name', name);
+                export_name = name;
+                code_type = 'CommonJS';
+                this.raise('parsed-code-type', {
+                    value: code_type
+                });
+                //console.log('pre raise parsed-export-name');
+                this.raise('parsed-export-name', {
+                    value: name
+                });
+            }
+        });
+        
+        // preparsing? early parsing?
+        this.on('parsed-export-name', e_parse => {
+            const {value} = e_parse;
+            //console.log('parsed-export-name', value);
+            export_name = value;
+        });
+        this.on('parsed-root-class-name', e_parse => {
+            const {value} = e_parse;
+            //console.log('parsed-root-class-name', value);
+            root_class_name = value;
+        });
+
+        const arr_lines = [];
+        const ta_line_buffer = new Uint8Array(1024);
+        let byte_in_line_num = 0, line_num = 0;
+
+        let last_recieved_byte;
+        let recieved_byte;
+
+        this.on('recieve-line', e_recieve_line => {
+            //console.log('e_recieve_line', e_recieve_line);
+            const {str} = e_recieve_line;
+
+            // and strip the tabs and whitespace.
+            arr_lines.push(str);
+        });
+
+
+        this.on('recieve-line', e_recieve_line => {
+            //console.log('e_recieve_line', e_recieve_line);
+            const {str} = e_recieve_line;
+
+            // and strip the tabs and whitespace.
+            //arr_lines.push(str);
+
+            // process the line character by character.
+            
+            //console.log('e_recieve_linestr', str);
+
+            // And break up the line into statements;
+
+            const s = e_recieve_line.str, l = s.length;
+            for (let c = 0; c < l; c++) {
+                const ch = s[c];
+                this.raise('recieve-line-char', {
+                    line_num: line_num,
+                    char: ch,
+                    char_code: s.charCodeAt(c)
+                })
+            }
+        });
+
+
+        
+
+        this.on('recieve-byte', e_receive_byte => {
+            last_recieved_byte = recieved_byte;
+            recieved_byte = e_receive_byte.byte_value;
+            ta_line_buffer[byte_in_line_num++] = recieved_byte;
+            //console.log('e_receive_byte', e_receive_byte);
+
+            if (recieved_byte === 10) {
+                // lf
+                if (last_recieved_byte === 13) {
+                    // cr, for windows
+
+                    const line_until_crlf = new Uint8Array(ta_line_buffer.subarray(0, byte_in_line_num - 2));
+
+                    this.raise('recieve-line', {
+                        ta_line: line_until_crlf,
+                        bytes_length: byte_in_line_num,
+                        str: String.fromCharCode.apply(null, line_until_crlf)
+                    })
+
+                } else {
+
+                    const line_until_lf = new Uint8Array(ta_line_buffer.subarray(0, byte_in_line_num - 1));
+                    this.raise('recieve-line', {
+                        ta_line: line_until_lf,
+                        bytes_length: byte_in_line_num,
+                        str: String.fromCharCode.apply(null, line_until_lf)
+                    })
+                }
+                ta_line_buffer.fill(0);
+                line_num++;
+                byte_in_line_num = 0;
+            }
+        });
+
+        this.on('input-stream-end', e_isend => {
+            //const {str_all, sha512} = e_isend;
+
+            const line_until_end = new Uint8Array(ta_line_buffer.subarray(0, byte_in_line_num));
+            const str = String.fromCharCode.apply(null, line_until_end);
+            this.raise('recieve-line', {
+                ta_line: line_until_end,
+                bytes_length: byte_in_line_num,
+                str: str,
+                last: true
+            });
+            const str_all = arr_lines.join('\n');
+            //var crypto = require('crypto');
+
+            /*
+
+            var hash = crypto.createHash('sha512');
+            //passing the data to be hashed
+            //data = hash.update('salt1', 'utf-8');
+            const data = hash.update('str_all', 'utf-8');
+            //Creating the hash in the required format
+            const gen_hash = data.digest('hex');
+            //Printing the output on the console
+            console.log("hash : " + gen_hash);
+
+            */
+            //throw 'stop';
+
+            this.raise('complete-file-recieved', {
+                str_all: str_all
+            })
+        })
+
+        // No, will have an export object or feature?
+        //  .export object that can be queried makes a lot of sense.
+
+        
+
+
+        Object.defineProperty(this, 'export_name', {
+            // Using shorthand method names (ES2015 feature).
+            // This is equivalent to:
+            // get: function() { return bValue; },
+            // set: function(newValue) { bValue = newValue; },
+            get() { return export_name; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+
+    }
+}
+
+module.exports = JS_File_Early_Parse;

package/resources/jsbuilder/JS_File/JS_File_2-Babel.js

@@ -0,0 +1,81 @@
+const JS_File_Early_Parse = require('./JS_File_1-Early_Parse');
+const {each, tof} = require('lang-mini');
+
+const parser = require('@babel/parser');
+
+class JS_File_Babel extends JS_File_Early_Parse {
+    constructor(spec) {
+        super(spec);
+        let ready = false, babel_ast;
+        //const babel_root_declarations = [];        
+
+        Object.defineProperty(this, 'babel_ast', {
+            get() { return babel_ast; },
+            enumerable: true,
+            configurable: false
+        });
+        // root_declarations
+
+        /*
+        Object.defineProperty(this, 'babel_root_declarations', {
+            get() { return babel_root_declarations; },
+            enumerable: true,
+            configurable: false
+        });
+        */
+
+        Object.defineProperty(this, 'babel_root_nodes', {
+            get() { return babel_ast.program.body; },
+            enumerable: true,
+            configurable: false
+        });
+
+        const each_babel_root_node = (callback) => {
+            if (ready) {
+                each(babel_ast.program.body, body_node => callback(body_node));
+            } else {
+                throw 'Not ready';
+            }
+        }
+
+        // 'complete-file-recieved'  
+
+        this.on('complete-file-recieved', (e_end) => {
+            const {str_all} = e_end;
+            //sha512 = e_end.sha512;
+            //source = str_all;
+            //console.log('str_all.length', str_all.length);
+            //console.log('arr_lines', arr_lines);
+
+            //console.log('str_all', str_all);
+
+            //throw 'stop';
+
+            babel_ast = parser.parse(str_all, {
+                sourceType: 'module',
+                plugins: [
+                    'asyncGenerators',
+                    'bigInt',
+                    'classPrivateMethods',
+                    'classPrivateProperties',
+                    'classProperties',
+                    'doExpressions',
+                    //'exportDefaultFrom',
+                    'nullishCoalescingOperator',
+                    'numericSeparator',
+                    'objectRestSpread',
+                    'optionalCatchBinding',
+                    'optionalChaining',
+                ]});
+            //console.log('ast', ast);
+            this.raise('parsed-ast', {
+                value: babel_ast
+            });
+        })
+
+        this.on('parsed-ast', e_parsed_ast => ready = true);
+
+    }
+}
+
+module.exports = JS_File_Babel;

package/resources/jsbuilder/JS_File/JS_File_3-JS_AST_Node.js

@@ -0,0 +1,86 @@
+const JS_File_Babel = require('./JS_File_2-Babel');
+const JS_AST_Node = require('../JS_AST/JS_AST_Node');
+
+//const JS_AST_Node_Root_Interpreted = require('../JS_AST/JS_AST_Node_Feature/JS_AST_Root_Node_Feature/JS_AST_Root_Node_Interpreted');
+
+const JS_AST_Node_Root_Interpreted = require('../JS_AST/JS_AST_Node_Feature/JS_AST_Root_Node_Feature/JS_AST_Root_Node_Interpreted');
+
+class JS_File_JS_AST_Node extends JS_File_Babel {
+    constructor(spec) {
+        super(spec);0
+
+        // This looks like the place to create the mirror of the Babel structure.
+        //  Respond to ast-ready.
+
+        let js_ast_node_file;
+        let node_body, node_root;
+
+        this.on('parsed-ast', e_parsed_ast => {
+
+            //console.log('e_parsed_ast', e_parsed_ast);
+            //throw 'stop';
+
+            // This is the point where the mirror AST_Node construction gets made.
+            //  Each of these nodes will have a path from the root of the document.
+
+            // Will later work on 
+
+            // Create an AST node that represents the document.
+            //  then there will be a body node
+
+            //console.log('e_parsed_ast', e_parsed_ast);
+            //throw 'stop';
+
+            // Make a root node with extra feature detection capabilities.
+            //  with
+
+            // The root node is the file node. That's questionable though.
+            //  Prefer to think of the body root.
+            //  But need to start saying body rather than root.
+
+
+            js_ast_node_file = new JS_AST_Node_Root_Interpreted({
+                babel_node: e_parsed_ast.value,
+                source: this.source,
+                root_node: true
+            });
+
+            node_root = js_ast_node_file;
+            //console.log('Object.keys(js_ast_node_file)', Object.keys(js_ast_node_file));
+            //console.log('(js_ast_node_file.type)', (js_ast_node_file.type));
+            //const node_body = js_ast_node_file.child_nodes[0].child_nodes[0];
+            node_body = js_ast_node_file.child_nodes[0];
+
+            //console.log('(node_body.type)', (node_body.type));
+            //throw 'stop';
+
+            this.raise('parsed-node_body', {
+                value: node_body
+            });
+
+            //console.log('js_ast_node_file', js_ast_node_file);
+            //console.log('js_ast_node_file.type', js_ast_node_file.type);
+            //console.log('js_ast_node_file.babel.type', js_ast_node_file.babel.type);
+            //console.log('js_ast_node_file.babel.node', js_ast_node_file.babel.node);
+            //throw 'stop';
+        });
+
+        Object.defineProperty(this, 'js_ast_node_file', {
+            get() { 
+                return js_ast_node_file;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'node_root', {
+            get() { 
+                return node_root;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+    }
+}
+
+module.exports = JS_File_JS_AST_Node;