jsgui3-server 0.0.121 → 0.0.122

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

@@ -1,139 +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-tools');
-
-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
-        });
-    }
-}
-
+// 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-tools');
+
+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

@@ -1,10 +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;
-
+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

@@ -1,101 +1,101 @@
-
-const {each} = require('lang-tools');
-
-//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
-        });
-        
-
-
-
-
-
-        
-        
-    }
-}
+
+const {each} = require('lang-tools');
+
+//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

@@ -1,61 +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
-        });
-        
-        
-    }
-}
-
+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;