jsgui3-server 0.0.73 → 0.0.77

package/resources/jsbuilder/JS_AST_Node_Extended/JS_AST_Node_Extended.js

@@ -0,0 +1,88 @@
+const JS_AST_Node_Extended_Core = require('./JS_AST_Node_Extended_0-Core');
+const JS_AST_Node_Declaration = require('./JS_AST_Node_Declaration');
+
+class JS_AST_Node_Extended extends JS_AST_Node_Extended_Core {
+    constructor(spec = {}) {
+        super(spec);
+    }
+}
+
+JS_AST_Node_Extended.from_babel_node = (spec) => {
+
+    const {babel_node} = spec;
+    const {type} = babel_node;
+    if (type === 'VariableDeclaration' || type === "ClassDeclaration") {
+        return new JS_AST_Node_Declaration(spec);
+    } else {
+        return new JS_AST_Node_Extended_Core(spec);
+    }
+
+    //return new JS_AST_Node(spec);
+}
+JS_AST_Node_Extended.from_spec = spec => {
+
+    let {babel_node} = spec;
+    //console.log('spec', spec);
+
+    if (!babel_node) {
+        if (spec.source) {
+            // create it, but then upgrade its type if necessary.
+            //  or first create the babel node.
+            //   that seems to make more sense in terms of the order of parsing.
+            const parser = require('@babel/parser');
+            const babel_ast = parser.parse(spec.source, {
+                sourceType: 'module',
+                plugins: [
+                    'asyncGenerators',
+                    'bigInt',
+                    'classPrivateMethods',
+                    'classPrivateProperties',
+                    'classProperties',
+                    'doExpressions',
+                    //'exportDefaultFrom',
+                    'nullishCoalescingOperator',
+                    'numericSeparator',
+                    'objectRestSpread',
+                    'optionalCatchBinding',
+                    'optionalChaining',
+                ]});
+
+            //console.log('babel_ast', babel_ast);
+
+            babel_node_file = babel_ast;
+            babel_node_program = babel_ast.program;
+
+            //console.log('babel_node_program', babel_node_program);
+
+            const {body} = babel_node_program;
+
+            if (body.length === 1) {
+                const node0 = body[0];
+
+                babel_node = node0;
+            } else {
+                throw 'NYI';
+            }
+
+
+        }
+    }
+
+
+    if (babel_node) {
+        const {type} = babel_node;
+        
+        if (type === 'VariableDeclaration' || type === "ClassDeclaration") {
+            return new JS_AST_Node_Declaration(spec);
+        } else {
+            return new JS_AST_Node_Extended_Core(spec);
+        }
+    } else {
+        throw 'stop';
+    }
+
+    
+
+    //return new JS_AST_Node(spec);
+}
+module.exports = JS_AST_Node_Extended;

package/resources/jsbuilder/JS_AST_Node_Extended/JS_AST_Node_Extended_0-Core.js

@@ -0,0 +1,11 @@
+const JS_AST_Node = require('../JS_AST/JS_AST_Node');
+//const JS_AST_Node_Declaration = require('./JS_AST_Node_Declaration');
+
+class JS_AST_Node_Extended extends JS_AST_Node {
+    constructor(spec = {}) {
+        super(spec);
+    }
+}
+
+
+module.exports = JS_AST_Node_Extended;

package/resources/jsbuilder/JS_Builder.js

@@ -0,0 +1,11 @@
+const {each, Evented_Class} = require('lang-mini');
+// Macroscope
+class JS_Builder extends Evented_Class {
+    constructor(spec) {
+        super();
+        
+
+    }
+}
+
+module.exports = JS_Builder;

package/resources/jsbuilder/JS_File/Feature/JS_File_Declared_Object.js

@@ -0,0 +1,32 @@
+// Like 'Declaration', but moving away from the JS syntax and possibilities of a declaration statement containing declarations for multiple objects.
+
+const JS_File_Feature = require('./JS_File_Feature');
+
+// Or just use the AST node one?
+//  This would be a different abstraction layer, possibly needed.
+
+class JS_File_Declared_Object extends JS_File_Feature {
+    constructor(spec = {}) {
+        super(spec);
+
+        // Will iterate root declaration statements to get the declared objects from them.
+        //  Can do that now.
+
+        // Whether or not the declared object gets exported
+        //  directly
+        //  as property of object
+        //  other, such as member of array.
+        //  And the export type (here getting into detail of the statement, could reference the statement, maybe another property layer above to understand that)
+
+        // .usage
+        // .outer_corresponding_js_ast_node
+
+        console.log('JS_File_Declared_Object spec', spec);
+
+        throw 'stop';
+
+
+    }
+}
+
+module.exports = JS_File_Declared_Object;

package/resources/jsbuilder/JS_File/Feature/JS_File_Exported_Object_Info.js

@@ -0,0 +1,26 @@
+class JS_File_Exported_Object_Info {
+    constructor(spec = {}) {
+
+        // local name
+        //  does not necessarily have one, could be imported into a numbered array
+        //   but if that happens can throw exception.
+
+        /*
+            The ast_statement node where the import is done
+            declared local (imported) variable name: the name, or false if it does not have one
+
+            Lookup: the AST for the file it was imported from
+                Then information about what was exported from that.
+            
+
+            So, focus on obtaining great export information, as that will be used in the process of understanding the imports.
+
+            
+
+
+
+        */
+
+    }
+}
+module.exports = JS_File_Exported_Object_Info;

package/resources/jsbuilder/JS_File/Feature/JS_File_Exports.js

@@ -0,0 +1,79 @@
+const JS_File_Feature = require('./JS_File_Feature');
+
+class JS_File_Exports extends JS_File_Feature {
+    constructor(spec = {}) {
+        spec.name = "Exports";
+        let ast_node_exports_statement;
+        let exported_object_name;
+        let value;
+
+        if (spec.name !== 'Exports') {
+            throw 'stop';
+        }
+
+        if (spec.ast_node_exports_statement) {
+            ast_node_exports_statement = spec.ast_node_exports_statement;
+        }
+        super(spec);
+
+        // What a file exports is a 'feature' of the file.
+        //  This 'feature' API moves further away from the JS language spec and is closer to being a conceptual representation of what the file is / does.
+
+        if (ast_node_exports_statement) {
+            //console.log('ast_node_exports_statement.type_signature', ast_node_exports_statement.type_signature);
+
+            if (ast_node_exports_statement.type_signature === 'ES(AsE(ME(ID,ID),ID))') {
+                // find_x_node_using_signature ('ES(AsE(ME(ID,ID),x))')
+
+                // May require parsing such a signature into a tree?
+
+                const x_node = ast_node_exports_statement.child_nodes[0].child_nodes[1];
+                //console.log('x_node', x_node);
+                //console.log('x_node.name', x_node.name);
+
+                exported_object_name = x_node.name;
+
+            } else {
+                throw 'NYI';
+            }
+        } else {
+            throw 'expected .ast_node_exports_statement'
+        }
+
+        if (exported_object_name) {
+            // find the declaration of such an object.
+            //console.log('exported_object_name', exported_object_name);
+
+            // Query the js file for Declaration (or maybe Declared features)
+
+            // Would iterate through the root nodes looking for 'Declared' features.
+            //  Would carry out closer examination of declarations. In the case of array decomposition would need to match the elements.
+
+            // Declared features would be useful for discovering what goes into the single object that gets exported.
+            //  In many cases we will be exporting variables local to the file body.
+
+            
+
+        } else {
+            throw 'NYI';
+        }
+
+        /*
+        Object.defineProperty(this, 'value', {
+            get() { return exported_object_name; },
+            enumerable: true,
+            configurable: false
+        });
+        */
+
+        Object.defineProperty(this, 'exported_object_name', {
+            get() { return exported_object_name; },
+            enumerable: true,
+            configurable: false
+        });
+
+
+    }
+}
+
+module.exports = JS_File_Exports;

package/resources/jsbuilder/JS_File/Feature/JS_File_Feature.js

@@ -0,0 +1,18 @@
+class JS_File_Feature {
+    constructor(spec = {}) {
+
+        let name;
+
+        if (spec.name) {
+            name = spec.name;
+        }
+
+        Object.defineProperty(this, 'name', {
+            get() { return name; },
+            enumerable: true,
+            configurable: false
+        });
+    }
+}
+
+module.exports = JS_File_Feature;

package/resources/jsbuilder/JS_File/Feature/JS_File_Imported_Object_Info.js

@@ -0,0 +1,26 @@
+class JS_File_Imported_Object_Info {
+    constructor(spec = {}) {
+
+        // local name
+        //  does not necessarily have one, could be imported into a numbered array
+        //   but if that happens can throw exception.
+
+        /*
+            The ast_statement node where the import is done
+            declared local (imported) variable name: the name, or false if it does not have one
+
+            Lookup: the AST for the file it was imported from
+                Then information about what was exported from that.
+
+
+            So, focus on obtaining great export information, as that will be used in the process of understanding the imports.
+
+            
+
+
+
+        */
+
+    }
+}
+module.exports = JS_File_Imported_Object_Info;

package/resources/jsbuilder/JS_File/Feature/JS_File_Imports.js

@@ -0,0 +1,9 @@
+const JS_File_Feature = require('./JS_File_Feature');
+
+class JS_File_Exports extends JS_File_Feature {
+    constructor(spec) {
+        super(spec);
+    }
+}
+
+module.exports = JS_File_Exports;

package/resources/jsbuilder/JS_File/JS_File.js

@@ -0,0 +1,12 @@
+const JS_File_Changing = require('./JS_File_6-Changing');
+
+class JS_File extends JS_File_Changing {
+    constructor(spec) {
+        super(spec);
+
+        
+
+    }
+}
+
+module.exports = JS_File;

package/resources/jsbuilder/JS_File/JS_File_0-Core.js

@@ -0,0 +1,202 @@
+const {each, Evented_Class} = require('lang-mini');
+const crypto = require('crypto');
+
+const whitespace_chars = {
+    '32': true
+}
+
+/*
+
+const get_char_type = e_rlc => {
+    const {char, char_code} = e_rlc;
+
+    if (char_code === 32 || char_code === 9 || char_code === 13 || char_code === 10) return 'whitespace';
+    if (char === '0' || char === '1' || char === '2' || char === '3' || char === '4' || char === '5' || char === '6' || char === '7' || char === '8' || char === '9') return 'digit'
+
+    if (char === '=' || char === '<' || char === '>' || char === '(' || char === ')' || char === '{' || char === "," ||
+        char === '}' || char === '[' || char === ']' || char === ':' || char === ';' || char === '?' || char === '!' || char === '.' || char === '&' || char === '%' ||
+        char === '"' || char === '\'' || char === '|' || char === '~' || char === '#' || char === '@' ||  
+        char === '+' || char === '*' || char === '/' || char === '\\' || char === '-' || char === '^') return 'punctuation'
+    if (char_code >= 65 && char_code <= 90) return 'letter' // ucase
+    if (char_code >= 97 && char_code <= 122) return 'letter' // lcase
+    if (char === '_' || char === '$') return 'letter-like';
+    console.log('char', char);
+    console.log('e_rlc', e_rlc);
+    throw 'unknown';
+}
+*/
+
+class JS_File extends Evented_Class {
+    constructor(spec = {}) {
+        super();
+
+        const rs = (() => spec.rs || undefined)();
+        const line_break_hex = (() => spec.line_break_hex || '0A')();
+        
+
+        let path = spec.path;
+
+        let sha512, source;
+
+        //Object.assign(this, {
+        //    body: {}
+        //})
+
+        
+
+        Object.defineProperty(this, 'path', {
+            get() { return path; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'sha512', {
+            get() { return sha512; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'source', {
+            get() { return source; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+
+
+        //if (spec.source) source = spec.source;
+
+        
+        //this.on('recieve-line-char', e_rlc => {
+        //    //console.log('e_rlc', e_rlc);
+        //    const char_type = get_char_type(e_rlc)
+        //    //console.log('char_type', char_type);
+        //    /*
+        //    if (!began_first_token_of_line) {
+        //        if (whitespace_chars[e_rlc.char_code]) {
+
+        //        } else {
+        //            began_first_token_of_line = true;
+        //        }
+        //    }
+        //    */
+        //})
+
+        
+
+        if (rs) {
+            this.on('complete-file-recieved', (e_end) => {
+                const {str_all} = e_end;
+                //console.log('e_end', e_end);
+
+                // Work out the hash value here?
+
+                //sha512 = e_end.sha512;
+                source = str_all;
+                //console.log('source', source);
+                //throw 'stop';
+            })
+
+            // Wait for subclass listeners to be set up.
+            //setTimeout(() => {
+                
+
+                // Interpret it in chunks.
+                // Read it line by line, after character by character.
+                //  Very event driven parser, or partial parser at least.
+
+                //let buf1;
+
+                
+
+                
+
+                // An array of tokens as strings???
+
+                //  Or just be able to identify the first tokens?
+                //   The part before the equals sign?
+
+                // Best to creat OO oprogrammatic objects from these.
+                //  But maybe best to use an existing parsing tool.
+
+                // Identifying all variable declarations may be possible.
+                //   All function calls too...
+
+                // Identifying all local variable references.
+                //  Putting it into JS objects would make sense.
+                //   Into highly OO JS objects in the right structure.
+
+                // Could raise an event whenever it finds a token.
+                //  Then will need to make sense of these tokens.
+
+                // Being able to get a list of which declarations were made where in the code would helo.
+
+                // block, conditional, switch, loop
+
+                // Maybe an existing parser would make a lot more sense.
+                //  Be better able to identify 
+
+                // https://esprima.org/
+                // 
+
+                //console.log('rs', rs);
+
+                rs.on('data', chunk => {
+                    //if (!buf1) {buf1 = chunk} else {
+                    // buf1 = Buffer.concat([buf1, chunk]);
+                    const l = chunk.length;
+                    //console.log('l', l);
+                    for (let c = 0; c < l; c++) {
+                        this.raise('recieve-byte', {
+                            byte_value: chunk.readUInt8(c)
+                        });
+                    }
+                    //}
+                });
+                let ast;
+
+                rs.on('end', e_end => {
+
+                    
+
+                    //console.log('arr_lines.length', arr_lines.length);
+                    this.raise('input-stream-end', {
+                        //str_all: str_all,
+                        //sha512: gen_hash
+                    });
+
+                    this.raise('ready');
+                });
+            //}, 0);
+            // then divide by line break character?
+            //  not sure of the formating, probably unicode.
+        } else {
+
+            // may have been given the source in the constructor.
+
+            throw 'stop';
+        }
+
+    }
+}
+
+// Worth being able to load this abstraction from the string text too.
+
+
+JS_File.load_from_stream = (rs, path) => {
+    const res = new JS_File({rs: rs, path: path});
+    return res;
+}
+
+JS_File.load_from_path = (path) => {
+
+}
+
+// Interpret / arrange a file in terms of the other objects within this system.
+
+// References at the beginning - will also work in terms of references to declarations, platforms, and declaration sequences.
+
+// Make it operate in a streaming way?
+//  Event driven too?
+//   So it can have events as it goes through the file or the stream.
+module.exports = JS_File;