jsgui3-server 0.0.74 → 0.0.78

package/resources/jsbuilder/JS_AST/JS_AST_Node_4.1-Index.js

@@ -0,0 +1,344 @@
+//const babel_node_tools = require('../babel/babel_node_tools');
+// Index before query would help.
+
+// Will index the occurrances of various nodes / things.
+// Could get more into tree pattern checking too, declaratively saying what to look for and looking for multiple things at once with signature comparisons in a map.
+
+// Indexing at every level looks like it would be useful.
+//  so in order to get the info about how the names relate to nodes we consult indexes.
+
+const { each } = require('lang-mini');
+const JS_AST_Node_Basics_Callmap = require('./JS_AST_Node_3.6-Basics_Callmap');
+const JS_AST_Node_Indexes = require('./JS_AST_Node_4.0-Index_Indexes');
+
+class JS_AST_Node_Index extends JS_AST_Node_Basics_Callmap {
+    constructor(spec = {}) {
+        super(spec);
+        const {deep_iterate, inner, child} = this;
+
+        // normal object can not work with its's 'constructor' property.
+        const _map_identifiers_by_name = new Map();
+        let is_indexed = false;
+        const indexes = new JS_AST_Node_Indexes();
+        const handle_found = (index_name, key, value) => {
+            return indexes.set(index_name, key, value);
+        }
+
+        const setup_node_index = (index_name, fn_selector, fn_key) => {
+
+            if (indexes.has_index(index_name)) {
+                throw 'NYI - index already exists'
+            } else {
+                deep_iterate(node => {
+                    if (fn_selector(node)) {
+                        const key = fn_key(node);
+                        handle_found(index_name, key, node);
+                    }
+                })
+            }
+            //return indexes.get_index(index_name);
+            
+        }
+
+        const get_indexed_nodes_by_key = (index_name, key) => {
+            return indexes.get(index_name, key);
+        }
+
+        // calling multiple indexing functions on a single iteration?
+
+        // .find.all.identifiers(node => node.name = name)
+        // .find.identifiers.by.name(name) could substitute for the index.
+
+        // .idx_lookup_
+
+        // .nodes_by_name
+
+        const old = () => {
+            const do_default_indexing = () => {
+                // Will find function names too :) The functions being called
+                // could we make a shallower version that is more efficient?
+                //  ie, it gets the map from below, and adds any relevant items at the current level.
+    
+                // Making use of child nodes' own indexes would be the optimization here.
+                //  Building it out of the indexes of the child nodes, if they have indexes.
+    
+                deep_iterate(node => {
+                    // Are the child nodes all of the same type?
+                    // .child_node_shared_type property
+    
+                    if (node.is_identifier) {
+                        const name = node.name;
+                        //console.log('name', name);
+    
+                        //_map_identifiers_by_name[name] = _map_identifiers_by_name[name] || [];
+                        //if (!_map_identifiers_by_name.has(name)) _map_identifiers_by_name.set(name, [])
+                        handle_found('identifiers_by_name', name, node);
+    
+                        //_map_identifiers_by_name.get(name).push(node);
+                        //console.log('map_identifiers_by_name[name]', _map_identifiers_by_name[name]);
+                        //_map_identifiers_by_name[name].push(node);
+                    }
+                    if (node.is_declaration) {
+                        //console.log('have declaration node in index loop');
+                        //console.log('node.child_nodes.length', node.child_nodes.length);
+                        //console.log('node.signature', node.signature);
+                        //console.log('node', node);
+                        //console.log('node.child', node.child);
+                        //console.log('node.child.count', node.child.count);
+                        // node.child.collected.names???
+    
+                        if (node.child.shared.type === 'VariableDeclarator') {
+                            if (node.source.length < 800) {
+                                //console.log('node.source', node.source);
+                            }
+                            node.each.child(dec => {
+                                //console.log('dec.babel.node', dec.babel.node);
+                                //const id = dec.child.find(node => node.is_identifier);
+                                // find.identifier();
+                                const id = dec.find(node => node.is_identifier);
+                                if (id) {
+                                    //console.log('id', id);
+                                    //console.log('id.name', id.name);
+                                    //_map_names_to_declarations[id.name] = node;
+    
+                                    //_map_names_to_declarations.set(id.name, node)
+                                    handle_found('names_to_declarations', id.name, node);
+                                } else {
+                                    //console.log('node', node);
+                                    //console.log('dec.child.count', dec.child.count);
+    
+                                    // dec.child.types?
+                                    //  dec.child.collect.types
+                                    //console.log('dec.child.collect.type', dec.child.collect.type);
+                                    // object pattern and member expression.
+                                    //  {a, b, c} = lib;
+                                    if (dec.child.count === 2) {
+                                        const child_types = dec.child.all.type;
+                                        // dec.child.collect.category
+                                        const child_categories = dec.child.all.category;
+                                        //console.log('child_categories', child_categories);
+                                        // maybe any expression is allowed.
+                                        //  seems that way
+                                        if (child_types[0] === 'ObjectPattern' && child_categories[1] === 'Expression') {
+                                            const objpat = dec.child_nodes[0];
+                                            //console.log('objpat', objpat);
+                                            //console.log('objpat.child.shared.type', objpat.child.shared.type);
+                                            if (objpat.child.shared.type === 'ObjectProperty') {
+                                                objpat.each.child(objprop => {
+                                                    //console.log('objprop', objprop);
+                                                    //console.log('objprop.source', objprop.source);
+                                                    //console.log('objprop.child.count', objprop.child.count);
+                                                    if (objprop.child.count === 2) {
+                                                        //console.log('objprop.child.first', objprop.child.first);
+                                                        //console.log('objprop.child.last', objprop.child.last);
+                                                        //console.log('objprop.child.last.source', objprop.child.last.source);
+                                                        //console.log('objprop.child.first.source', objprop.child.first.source);
+                                                        if (objprop.child.first.source == objprop.child.last.source) {
+                                                            const name = objprop.child.first.name;
+                                                            //console.log('name', name);
+                                                            //_map_names_to_declarations[name] = node;
+                                                            //_map_names_to_declarations.set(name, node);
+                                                            handle_found('names_to_declarations', name, node);
+                                                        } else {
+                                                            throw 'stop';
+                                                        }
+                                                    } else {
+                                                        throw 'stop';
+                                                    }
+                                                })
+                                            } else {
+                                                throw 'stop';
+                                            }
+                                        } else {
+                                            // can be [ 'ObjectPattern', 'ThisExpression' ]
+                                            throw 'stop';
+                                        }
+                                    } else {
+                                        throw 'stop';
+                                    }
+                                }
+                                // dec.id?
+                                //  gets the identifier?
+                                // dec.child.identifier?  
+                            })
+                        }
+                        // then are all the child nodes of type 'VariableDeclarator'
+                        // .deep (self then inner)
+                        // .inner (recursively child nodes)
+                        // .child
+                        //node.child.declarators
+                    }
+                    
+    
+                    if (node.is_expression) {
+                        if (node.type === 'CallExpression') {
+                            //console.log('node.source', node.source);
+                            //console.log('node', node);
+                            //console.log('node.babel.node', node.babel.node);
+    
+                            const callee = node.first.child.node;
+                            if (callee.is_identifier) {
+                                const fncall_name = callee.name;
+                                //console.log('fncall_name', fncall_name);
+                                //_map_fn_call_names.set(fncall_name, node);
+                                handle_found('fn_call_names', fncall_name, node);
+                            } else {
+    
+                                if (callee.type === 'MemberExpression') {
+                                    //console.log('callee.child.count', callee.child.count);
+                                    let fncall_path = '';
+                                    let first = true;
+    
+                                    // .child.node.count ???
+                                    // .child.declaration.count
+    
+                                    // .count.child?
+                                    //  // don't properly have .child any longer.
+                                    //    this would be under callee.count.child.node
+    
+                                    if (callee.child_nodes.length > 1) {
+                                        //.each.child.identifier
+    
+                                        callee.each.child(id => {
+                                            if (id.is_identifier) {
+                                                if (!first) {
+                                                    fncall_path += '.';
+                                                } else {
+                                                    first = false;
+                                                }
+                                                fncall_path += id.name;
+                                            } else {
+                                                //console.log('node.source', node.source);
+    
+                                                // Calling a function that is a property of an object.
+                                                //  Not so interested right now.
+    
+                                                // Not looking for this now
+    
+                                                //throw 'stop';
+                                            }
+                                        })
+                                        handle_found('fn_call_names', fncall_name, node);
+                                        //_map_fn_call_names.set(fncall_path, node);
+                                    } else {
+                                        throw 'stop';
+                                    }
+    
+                                }
+                                //
+                                //throw 'stop';
+                            }
+                            //throw 'stop';
+                        }
+                    }
+                    //console.log('child.count', child.count);
+                    //if (child.count > 0) {
+                    //    child.each(cn => {
+                    //    })Class constructor {}specClass constructor {}spec
+                    //}
+                })
+                is_indexed = true;
+            }
+            const ensure_index = () => {
+                // maybe call it standard indexing here.
+    
+                if (!is_indexed) {
+                    do_default_indexing();
+                }
+            }
+            // this.map
+            // identifiers.name
+    
+            Object.defineProperty(this, 'is_indexed', {
+                get() { 
+                    return is_indexed;
+                },
+                //set(newValue) { bValue = newValue; },
+                enumerable: true,
+                configurable: false
+            });
+
+
+        }
+
+        
+        /*
+        Object.defineProperty(this, 'maps', {
+            get() { 
+                return maps;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        */
+        
+        /*
+        Object.defineProperty(this, 'map_identifiers_by_name', {
+            get() { 
+                ensure_index();
+                return _map_identifiers_by_name;
+                
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        */
+
+        // _map_names_to_declarations
+
+        // declaration.identifier.name
+
+        // Not so sure about the map object here.
+
+        // Makes sense as a verb, a means to access it.
+
+        /*
+
+        const map = {
+            declaration: {
+                identifier: {
+                    
+                }
+            },
+            identifier: {
+
+            }
+        }
+        Object.defineProperty(map.declaration.identifier, 'name', {
+            get() { 
+                ensure_index();
+                return _map_names_to_declarations;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(map.identifier, 'name', {
+            get() { 
+                ensure_index();
+                return _map_identifiers_by_name;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'map', {
+            get() { 
+                //ensure_index();
+                return map;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        */
+
+        this.setup_node_index = setup_node_index;
+        this.get_indexed_nodes_by_key = get_indexed_nodes_by_key;
+        // setup_node_index = (index_name, fn_selector, fn_key) => {
+            
+    }
+}
+module.exports = JS_AST_Node_Index;

package/resources/jsbuilder/JS_AST/JS_AST_Node_5.0-Category.js

@@ -0,0 +1,39 @@
+const JS_AST_Node_Index = require('./JS_AST_Node_4.1-Index');
+
+const {type_abbreviations, map_expression_categories, map_literal_categories, map_statement_categories, map_categories} = require('../babel/babel_consts');
+
+
+
+
+class JS_AST_Node_Category extends JS_AST_Node_Index {
+    constructor(spec = {}) {
+        super(spec);
+
+        Object.defineProperty(this, 'category', {
+            get() { 
+                //console.log('babel', babel);
+                //console.log('babel_node', babel_node);
+                //console.log('babel.node', babel.node);
+                return this.babel.category;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'cat', {
+            get() { 
+                throw 'NYI'
+                //console.log('babel', babel);
+                //console.log('babel_node', babel_node);
+                //console.log('babel.node', babel.node);
+                return babel.abbreviated_category;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+    }
+}
+
+module.exports = JS_AST_Node_Category;

package/resources/jsbuilder/JS_AST/JS_AST_Node_5.1-Category_Identifier.js

@@ -0,0 +1,31 @@
+const JS_AST_Node_Category = require('./JS_AST_Node_5.0-Category');
+
+class JS_AST_Node_Category_Identifier extends JS_AST_Node_Category {
+    constructor(spec = {}) {
+        super(spec);
+
+        Object.defineProperty(this, 'is_identifier', {
+            get() { 
+                return this.babel.is_identifier;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+
+
+        if (this.is_identifier) {
+            Object.defineProperty(this, 'name', {
+                get() { return this.babel.name; },
+                //set(newValue) { bValue = newValue; },
+                enumerable: true,
+                configurable: false
+            });
+        }
+        // Overwrite the name property later on?
+        
+
+    }
+}
+
+module.exports = JS_AST_Node_Category_Identifier;

package/resources/jsbuilder/JS_AST/JS_AST_Node_5.2-Category_Literal.js

@@ -0,0 +1,29 @@
+const JS_AST_Node_Category_Identifier = require('./JS_AST_Node_5.1-Category_Identifier');
+
+class JS_AST_Node_Category_Literal extends JS_AST_Node_Category_Identifier {
+    constructor(spec = {}) {
+        super(spec);
+
+        Object.defineProperty(this, 'is_literal', {
+            get() { 
+                return this.babel.is_literal;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        if (this.is_literal) {
+            Object.defineProperty(this, 'value', {
+                get() { 
+                    return this.babel.node.value;
+                },
+                enumerable: true,
+                configurable: false
+            });
+        }
+
+
+    }
+}
+
+module.exports = JS_AST_Node_Category_Literal;

package/resources/jsbuilder/JS_AST/JS_AST_Node_5.3-Category_Expression.js

@@ -0,0 +1,27 @@
+const JS_AST_Node_Category_Literal = require('./JS_AST_Node_5.2-Category_Literal');
+
+class JS_AST_Node_Category_Expression extends JS_AST_Node_Category_Literal {
+    constructor(spec = {}) {
+        super(spec);
+
+        Object.defineProperty(this, 'is_expression', {
+            get() { 
+                return this.babel.is_expression;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        // See if we can evaluate expressions?
+        //  Probably not worth it right now....
+
+        // // .can_evaluate property
+        //  so with some expression patterns we will be able to do so. maybe just a few.
+        //   
+
+
+
+    }
+}
+
+module.exports = JS_AST_Node_Category_Expression;

package/resources/jsbuilder/JS_AST/JS_AST_Node_5.4-Category_Pattern.js

@@ -0,0 +1,9 @@
+const JS_AST_Node_Category_Expression = require('./JS_AST_Node_5.3-Category_Expression');
+
+class JS_AST_Node_Category_Pattern extends JS_AST_Node_Category_Expression {
+    constructor(spec = {}) {
+        super(spec);
+    }
+}
+
+module.exports = JS_AST_Node_Category_Pattern;

package/resources/jsbuilder/JS_AST/JS_AST_Node_5.5-Category_Declaration.js

@@ -0,0 +1,44 @@
+const JS_AST_Node_Category_Pattern = require('./JS_AST_Node_5.4-Category_Pattern');
+const JS_AST_Node_Feature_Declaration = require('./JS_AST_Node_Feature/JS_AST_Node_Feature_Declaration');
+
+class JS_AST_Node_Category_Declaration extends JS_AST_Node_Category_Pattern {
+    constructor(spec = {}) {
+        super(spec);
+
+        Object.defineProperty(this, 'is_declaration', {
+            get() { 
+                return this.babel.is_declaration;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        if (this.is_declaration) {
+
+            // include the declaration feature here?
+            //  
+
+            const declaration = new JS_AST_Node_Feature_Declaration({ // some of the code is out of the way - maybe it will get complex / longwinded?
+                node: this
+            });
+
+            // But outside of / on a lower level to the feature, more commands and queries to enable better access to declarations would help.
+
+
+
+            // declaration.declared.keys
+            // Set up retrieval of info on what is declared.
+
+            //  .declared property?
+            // .declared.keys
+
+            // .declared makes for good syntax to access the data.
+            //   make use of inner class declaration and variable declaration and declarator nodes.
+            //    more detailed code on them will enable the declaration category to work well.
+
+            this.declaration = declaration;
+        }
+    }
+}
+
+module.exports = JS_AST_Node_Category_Declaration;

package/resources/jsbuilder/JS_AST/JS_AST_Node_5.6-Category_Statement.js

@@ -0,0 +1,22 @@
+const JS_AST_Node_Category_Declaration = require('./JS_AST_Node_5.5-Category_Declaration');
+
+class JS_AST_Node_Category_Statement extends JS_AST_Node_Category_Declaration {
+    constructor(spec = {}) {
+        super(spec);
+
+        Object.defineProperty(this, 'is_statement', {
+            get() { 
+                return this.babel.is_statement;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+
+        
+        
+
+    }
+}
+
+module.exports = JS_AST_Node_Category_Statement;

package/resources/jsbuilder/JS_AST/JS_AST_Node_6.0-Type.js

@@ -0,0 +1,87 @@
+const JS_AST_Node_Category_Statement = require('./JS_AST_Node_5.6-Category_Statement');
+
+const {type_abbreviations, map_expression_categories, map_literal_categories, map_statement_categories, map_categories} = require('../babel/babel_consts');
+class JS_AST_Node_Type extends JS_AST_Node_Category_Statement {
+    constructor(spec = {}) {
+        super(spec);
+
+        Object.defineProperty(this, 'type', {
+            get() { return this.babel.node.type; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        Object.defineProperty(this, 'abbreviated_type', {
+            get() { 
+                const abb = type_abbreviations[this.babel.node.type];
+                if (abb) {
+                    return abb;
+                } else {
+                    console.log('this.babel.node.type', this.babel.node.type);
+                    throw 'stop';
+                }
+               
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 't', {
+            get() { 
+                return this.abbreviated_type;
+               
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+    }
+}
+
+module.exports = JS_AST_Node_Type;
+
+
+
+// Declaration and declarator seem like among the most important types to focus on for the moment.
+//  A very important objective is to find out about what is declared within a piece of code.
+//  Will get these queries, and possibly a small layer on top, getting the relevant info about the files that get used to build the jsgui client application.
+
+// There will be a variety of files and structures to test. As far as reasonable, there will be general purpose interpretation functions being used, want to get it working in
+//  some less standard file arrangements, such as exporting the result of a function call. So long as that code is out of the way (OK within this large structure), and only used in the
+//  cases where it is relevant, then it's good to have it in there. Will later get the build system correctly interpreting details from a variety of files, specifically react files will
+//  be one of the first to be incorporated into the jsgui build system.
+
+
+
+
+
+
+
+// Then have declaration types
+//  Class declaration
+//  Variable declaration (which includes const)
+
+// Declarator types
+
+// Functionality to enable to effective querying of specific types of nodes, to get data out of them in an easy way.
+//  Declaration keys
+//  Declaration map_key_to_js_ast_node
+//   will match up the object and array deconstruction.
+
+// Continue trying the system with various pieces of syntax, and get out the required data in a simple way.
+//  Get it expressed in a nice query (can use filter and select functions) and have specific functions that will be used / needed to interpret imports, exports, and some of the things that
+//  come in between.
+
+// More work on scope analysis / iteration / rules?
+
+//  visible_to? so is a node somewhere in the document visible to another node?
+//  leave scope itself for the moment from the core, but see if we can get good iteration through it with a simple function, and / or simple rules.
+
+
+
+
+
+
+
+

package/resources/jsbuilder/JS_AST/JS_AST_Node_6.1-Type_Class_Declaration.js

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

package/resources/jsbuilder/JS_AST/JS_AST_Node_6.2-Type_Variable_Declaration.js

@@ -0,0 +1,28 @@
+const JS_AST_Node_Type_Class_Declaration = require('./JS_AST_Node_6.1-Type_Class_Declaration');
+
+const JS_AST_Node_Feature = require('./JS_AST_Node_Feature/JS_AST_Node_Feature');
+
+class JS_AST_Node_Type_Variable_Declaration extends JS_AST_Node_Type_Class_Declaration {
+    constructor(spec = {}) {
+        super(spec);
+
+        // Possibly 'Declaration' is a feature.
+        //  Makes sense really.
+
+
+        // Code that is specific for variable rather than class declarations would be best here.
+
+        
+
+
+
+        if (this.type === 'VariableDeclaration') {
+            // .declaration.names
+            // .declaration.keys
+            // .declaration.map
+
+        }
+    }
+}
+
+module.exports = JS_AST_Node_Type_Variable_Declaration;