jsgui3-server 0.0.75 → 0.0.77

package/resources/jsbuilder/JS_AST/JS_AST_Node_Feature/JS_AST_Node_Feature_Declaration.js

@@ -0,0 +1,249 @@
+// When a declaration is treated as a feature, there is programming less specifically for it being a node.
+
+// Feature is an abstraction on top of JS_AST_Node.
+const {each} = require('lang-mini');
+
+const JS_AST_Node_Feature = require('./JS_AST_Node_Feature');
+
+class JS_AST_Node_Feature_Declaration extends JS_AST_Node_Feature {
+    constructor(spec = {}) {
+        super(spec);
+        const {node} = this;
+
+        let declared_keys, assigned_values;
+
+        // Maybe should be .declared.keys?
+
+        const declared = {};
+
+        const assigned = {};
+
+
+        // and the assigned keys property.
+
+
+        // // maybe they are not assigned keys after all.
+
+        // .assigned.values
+
+
+        // a query to get the literal values???
+
+        
+
+        Object.defineProperty(assigned, 'values', {
+            get() { 
+                if (!assigned_values) {
+                    assigned_values = [];
+
+                    //console.log('node', node);
+                    //console.log('node.source', node.source);
+
+                    if (node.type === 'VariableDeclaration') {
+
+                        // Need to look at all the child nodes.
+                        //console.log('node.child.shared.type', node.child.shared.type);
+
+                        // then go through each child declarator....
+
+                        node.query.each.child.declarator.exe(cdec => {
+                            console.log('');
+                            console.log('cdec', cdec);
+                            console.log('cdec.source', cdec.source);
+                            const dec_cn_tstr = cdec.query.collect.child.node.t.exe().join('.');
+                            console.log('dec_cn_tstr', dec_cn_tstr);
+
+                            // Can use a signature map.
+                            
+                            //  node.query.callmap.child.declarator.signature.exe({sig1: (node) => {}, sig2: node => {}}, unmapped_node => {})
+
+
+
+                            if (dec_cn_tstr === 'ArP.ArE') {
+
+
+                                // ArrayPattern.ArrayExpression
+                                const are = cdec.child_nodes[1];
+                                //console.log('are', are);
+    
+                                // then are they literals inside?
+    
+                                // .find child shared category?
+                                //  but query needs the verb.
+                                //   maybe collect is the default one now.
+                                //const sc = are.query.child.shared.category.exe();
+                                const sc = are.child.shared.category;
+                                //console.log('sc', sc);
+
+                                //throw 'stop';
+    
+                                const st = are.child.shared.type;
+                                //console.log('st', st);
+    
+                                if (sc === 'Literal') {
+                                    // can get the values....
+    
+                                    const lvalues = are.query.collect.child.value.exe();
+                                    //console.log('lvalues', lvalues);
+                                    each(lvalues, v => assigned_values.push(v));
+    
+                                } else {
+
+
+
+                                    throw 'NYI';
+                                }
+                                //console.log(sc);
+                                //if (are.)
+                            } else {
+
+                                // .query.select.by.child.count.exe(2).query.select.where.first.child.is.identifier.exe().select.where.second.child.is.literal.exe()
+                                // .quert.select.where.child.count.is.exe(2)
+
+                                if (cdec.child.count === 2) {
+                                    if (cdec.child_nodes[0].is_identifier) {
+
+
+                                        if (cdec.child_nodes[1].is_literal) {
+                                            const [name, value] = [cdec.child_nodes[0].name, cdec.child_nodes[1].value];
+                                            //console.log('[name, value]', [name, value]);
+                                            assigned_values.push(value);
+
+                                        } else {
+                                            // is it an expression?
+                                            //  we could give it the node?
+
+                                            // leaving it for the moment???
+
+                                            if (cdec.child_nodes[1].is_expression) {
+                                                assigned_values.push(cdec.child_nodes[1]);
+
+                                            }
+
+
+
+                                        }
+
+                                        //throw 'yay';
+                                        
+
+                                    } else {
+                                        throw 'NYI';
+                                    }
+
+
+                                } else {
+                                    throw 'stop';
+                                }
+
+                                //console.log('dec_cn_tstr', dec_cn_tstr);
+                                //throw 'NYI';
+
+
+                            }
+
+                        });
+
+                        
+                    } else if (node.type === 'ClassDeclaration') {
+                        throw 'NYI';
+                    } else {
+                        throw 'stop';
+                    }
+                }
+                return assigned_values;
+            }});
+        Object.defineProperty(declared, 'keys', {
+            get() { 
+                if (!declared_keys) {
+
+                    // Can try the get_object_keys function???
+
+                    declared_keys = [];
+
+                    if (node.type === 'VariableDeclaration') {
+                        //console.log('node', node);
+                        //const ks = node.query.collect.child.variabledeclarator.exe().query.collect.id.name.exe();
+                        const vdars = node.query.collect.child.variabledeclarator.exe();
+                        //console.log('vdars', vdars);
+                        //console.log('vdars[0].id', vdars[0].id);
+                        const collected_keys = vdars.query.collect.id.name.exe();
+                        each(collected_keys, key => declared_keys.push(key));
+                        //console.log('collected_keys', collected_keys);
+                    } else if (node.type === 'ClassDeclaration') {
+                        throw 'NYI';
+                    } else {
+                        throw 'stop';
+                    }
+
+                    //throw 'stop';
+                    
+                    const vdrs = node.query.select.child.node.exe(node => node.type === 'VariableDeclarator'); // and the new query system works.
+                    if (vdrs.length > 0) {
+                        //console.log('vdrs', vdrs);
+
+                        // No, a variable declarator that assigns object keys should return those keys, not the object name itself.
+
+                        each(vdrs, vdr => {
+                            const dtr = vdr.declarator;
+                            //console.log('dtr', dtr);
+                            const dtr_keys = dtr.keys;
+                            //console.log('dtr_keys', dtr_keys);
+                            each(dtr_keys, key => declared_keys.push(key));
+                        });
+                    } else {
+
+                        // Seems like class definitions are not iterating right...?
+
+                        console.log('vdrs.length', vdrs.length);
+
+                        if (vdrs.length === 0) {
+                            if (this.node.type === 'ClassDeclaration') {
+                                const key = this.node.child_nodes[0].name;
+                                console.log('key', key);
+
+                                if (key !== undefined) {
+                                    declared_keys.push(key);
+                                } else {
+                                    throw 'stop';
+                                }
+
+                                
+
+                                //throw 'NYI';
+                            } else {
+                                throw 'stop';
+                            }
+
+                        } else {
+                            throw 'NYI';
+                        }
+
+
+                        //console.log('this.node.type', this.node.type);
+                        //console.log('this.node.child_nodes.length', this.node.child_nodes.length);
+                        
+                        //console.log('this.node.signature', this.node.signature);
+                        //console.log('this.node.deep_type_signature', this.node.deep_type_signature);
+
+
+                        //throw 'NYI';
+                    }
+                    
+                    //throw 'NYI';
+                }
+                return declared_keys;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        this.declared = declared;
+        this.assigned = assigned;
+        
+
+
+    }
+}
+
+module.exports = JS_AST_Node_Feature_Declaration;

package/resources/jsbuilder/JS_AST/JS_AST_Node_Feature/JS_AST_Node_Feature_Declarator.js

@@ -0,0 +1,139 @@
+// When a declaration is treated as a feature, there is programming less specifically for it being a node.
+
+// Feature is an abstraction on top of JS_AST_Node.
+const {each} = require('lang-mini');
+
+const JS_AST_Node_Feature = require('./JS_AST_Node_Feature');
+
+class JS_AST_Node_Feature_Declarator extends JS_AST_Node_Feature {
+    constructor(spec = {}) {
+        super(spec);
+        const {node} = this;
+
+        // inner keys?
+        // .key for itself?
+
+        let keys;
+        Object.defineProperty(this, 'keys', {
+            get() { 
+
+                if (!keys) {
+                    console.log('node', node);
+                    console.log('node.source', node.source);
+                    keys = [];
+                    const found_key = key => {
+                        keys.push(key);
+                    }
+                    //console.log('node', node);
+                    //console.log('node.source', node.source);
+                    // are there 2 child nodes?
+                    // array pattern and array expression
+
+                    //console.log('node.child.count', node.child.count);
+                    //throw 'stop';
+
+                    if (node.child.count === 2) {
+                        if (node.child_nodes[0].type === 'ArrayPattern' && node.child_nodes[1].type === 'ArrayExpression') {
+
+                            const [arp, are] = node.child_nodes;
+
+                            if(arp.child.count === are.child.count) {
+                                //console.log('node.each.child.identifier', );
+
+                                //console.log('arp', arp);
+                                //console.log('arp.child.count', arp.child.count);
+                                //console.log('arp.child.shared.type', arp.child.shared.type);
+
+                                if (arp.child.shared.type === 'Identifier') {
+                                    arp.query.each.child.exe(id => {
+                                        //console.log('id', id);
+                                        //console.log('id.name', id.name);
+                                        found_key(id.name);
+                                    })
+                                } else {
+                                    throw 'stop';
+                                }
+                            } else {
+                                throw 'stop';
+                            }
+                            
+                        } else {
+
+                            // check for 
+
+                            //
+
+                            if (node.child_nodes[0].is_identifier) {
+                                console.log('node.child_nodes[1].category', node.child_nodes[1].category);
+
+                                if (node.child_nodes[1].category === 'Expression') {
+                                    //found_key(node.child_nodes[0].name);
+
+                                    // No, the keys are not like this, they are inner.
+                                    //  Possibly a prompt to improve the query system and have keys use that or be part of it.
+
+
+                                } else {
+                                    //throw 'NYI';
+                                }
+
+                                
+
+                            } else {
+                                //console.log('node.child_nodes', node.child_nodes);
+
+                                if (node.child_nodes[0].type === 'ObjectPattern') {
+                                    const opa = node.child_nodes[0];
+                                    if (opa.child.shared.type === 'ObjectProperty') {
+                                        each(opa.child_nodes, opr => {
+                                            //console.log('opr', opr);
+                                            //console.log('opr.source', opr.source);
+
+                                            if (opr.child.count === 1) {
+                                                const id = opr.child_nodes[0];
+                                                if (id.is_identifier) {
+                                                    found_key(id.name);
+                                                } else {
+                                                    throw 'stop';
+                                                }
+                                            } else {
+                                                throw 'stop';
+                                            }
+                                            
+                                        })
+                                    } else {
+                                        throw 'stop';
+                                    }
+
+                                } else {
+                                    throw 'stop';
+                                }
+
+                                //throw 'stop';
+                            }
+                        }
+
+                    } else {
+
+                        // variable declarator with a single identifier inside...
+                        //  
+
+                        // probably seems worth ignoring for now.... except logging it.
+
+                        console.log('');
+                        console.log('**node', node);
+                        console.log('**node.source', node.source);
+                        console.log('');
+
+                        //throw 'NYI';
+                    }
+                }
+                return keys;
+            },
+            enumerable: true,
+            configurable: false
+        });
+    }
+}
+
+module.exports = JS_AST_Node_Feature_Declarator;

package/resources/jsbuilder/JS_AST/JS_AST_Node_Feature/JS_AST_Root_Node_Feature/JS_AST_Root_Node_Feature.js

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

package/resources/jsbuilder/JS_AST/JS_AST_Node_Feature/JS_AST_Root_Node_Feature/JS_AST_Root_Node_Feature_Exported.js

@@ -0,0 +1,101 @@
+
+const {each} = require('lang-mini');
+
+//const find_object_keys = require('../../query/find_object_keys');
+
+// Not itself a feature?
+//  A feature of a feature?
+
+// Exported keys is an important thing to be on the lookout for.
+//  However, trying to get it working shows some need for improved querying, as well as going into more detail on Object objects.
+//  Could make a .keys feature on those in particular.
+//  Indexing will help to find the referred to objects quickly.
+//  Queries would enable quick finding with a nice API too.
+
+
+
+
+
+class JS_AST_Root_Node_Feature_Exported {
+    constructor(spec = {}) {
+        let node;
+        if (spec.node !== undefined) node = spec.node;
+        
+        
+        Object.defineProperty(this, 'node', {
+            get() { 
+                return node;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        // but an exported keys property as well.
+        //  if necessary, look back at the object declaration.
+
+        // Keys property.
+        //  A bit harder to calculate the keys of an object.
+
+        // May be worth having another query or similar part.
+        //  Obtaining keys of an object will need to be somewhat in-depth.
+
+        let keys;
+
+        // Want this to go further in terms of finding out what keys that object has.
+
+        Object.defineProperty(this, 'keys', {
+            get() { 
+
+                if (!keys) {
+                    // call the find_object_keys query.
+                    //  will go through the code seeing which keys the object is declared with / have been added to it.
+                    //  worth trying with a variety of objects / classes in codebases.
+                    //   try separately to see that the keys correctly get identified where possible.
+
+                    //console.log('node', node);
+                    //console.log('node.name', node.name);
+                    //console.log('node.type', node.type);
+
+                    if (node.is_identifier) {
+
+                        //keys = find_object_keys(node);
+                        //console.log('keys', keys);
+                        //return found_keys;
+                        console.trace();
+                        throw 'NYI';
+
+                        
+
+                        
+                    } else {
+                        throw 'NYI';
+                    }
+
+                    // need to iterate back through the scope.
+
+                    //  Lets do this here for the moment.
+
+                    // Need to be able to iterate back through previous siblings.
+                    //  So set up more code for that .siblings.previous.each
+                    //console.trace();
+
+                    //throw 'NYI';
+
+                }
+
+                return keys;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        
+
+
+
+
+
+        
+        
+    }
+}
+module.exports = JS_AST_Root_Node_Feature_Exported;

package/resources/jsbuilder/JS_AST/JS_AST_Node_Feature/JS_AST_Root_Node_Feature/JS_AST_Root_Node_Feature_Exports.js

@@ -0,0 +1,61 @@
+const JS_AST_Root_Node_Feature = require('./JS_AST_Root_Node_Feature');
+
+const JS_AST_Root_Node_Feature_Exported = require('./JS_AST_Root_Node_Feature_Exported');
+
+
+class JS_AST_Root_Node_Feature_Exports extends JS_AST_Root_Node_Feature {
+    constructor(spec = {}) {
+        super(spec);
+
+        const {node} = this;
+        /*
+        let node;
+        // exports.node
+        if (spec.node !== undefined) node = spec.node;
+        
+        // Can give it the AST node that is being exported.
+        //  Then when queried, it will be able to find out information about the node being exported.
+
+        Object.defineProperty(this, 'node', {
+            get() { 
+                return node;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        */
+
+        let exported;
+        Object.defineProperty(this, 'exported', {
+            get() { 
+
+                if (!exported) {
+                    // Exported may as well be a feature.
+                    //console.log('node', node);
+
+                    const assigned_as_node = node.child_nodes[0].child_nodes[1];
+                    //console.log('assigned_as_node', assigned_as_node);
+                    //console.log('assigned_as_node.name', assigned_as_node.name);
+                    //console.log('assigned_as_node.source', assigned_as_node.source);
+                    // we need to find the node that gets exported.
+
+                    exported = new JS_AST_Root_Node_Feature_Exported({
+                        node: assigned_as_node
+                    });
+
+                    //throw 'NYI';
+
+
+                }
+
+                return exported;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        
+        
+    }
+}
+
+module.exports = JS_AST_Root_Node_Feature_Exports;