jsgui3-server 0.0.121 → 0.0.123

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

@@ -1,180 +1,180 @@
-
-
-const JS_AST_Node = require('../../JS_AST_Node');
-const JS_AST_Root_Node_Feature_Exports = require('./JS_AST_Root_Node_Feature_Exports');
-
-
-const {each} = require('lang-tools');
-// A map of named / relevant inner nodes could be a useful feature of the ast node overall.
-
-// or is it an index if it's mapping to an array?
-
-// idx_named_nodes (so it can apply to ancestors or others in the ast)
-
-// map_named_inner_nodes
-
-// map_named_inner_nodes['exports'] = [...] // always an array
-
-
-class JS_AST_Root_Node_Interpreted extends JS_AST_Node {
-
-    // Root node features could be of use.
-    //  Want to recognise features in a convenient way.
-    //  Signatures could definitely help with that
-    //   But a feature may not be best recognised with a signature.
-
-    // Could do a more formal decision tree for determining features.
-    // could have a set of determinations and values.
-    //  
-
-
-    // This is the best place for it to come up with more info on the import and export?
-    //  Or further down near the core?
-
-    constructor(spec) {
-        super(spec);
-
-        const {get_arr_named_node, index_named_node} = this;
-
-        // .exported.type      'object', 'class'
-        // .exported.keys
-
-        // This will handle non-special case things.
-        //  If there is demand jsgui or other special cases could be brought into normal interpretation.
-
-        // An index of the relevant statements.
-
-        let ast_node_exports_statement;
-        //let arr_ast_node_import_statements = [];
-
-        const get_module_exports_statement_node = () => {
-
-            if (!ast_node_exports_statement) {
-
-
-                this.setup_node_index('identifiers_by_name', node => node.is_identifier, node => node.name);
-
-                //let res;
-                const mod_ids = this.get_indexed_nodes_by_key('identifiers_by_name', 'module');
-                each(mod_ids, node => {
-                    // want to be able to get the next sibling from a node easily.
-                    //console.log('node', node);
-                    //console.log('node.parent_node', node.parent_node);
-
-                    //console.log('node.sibling.count', node.sibling.count);
-
-                    if (node.sibling.count === 1) {
-                        const sibling = node.sibling.collect()[0];
-                        //console.log('sibling.name', sibling.name);
-                        if (sibling.name === 'exports') {
-                            //console.log('node.parent_node.parent_node', node.parent_node.parent_node);
-                            //console.log('node.parent_node.parent_node.parent_node', node.parent_node.parent_node.parent_node);
-                            //console.log('node.parent.node.parent.node.parent.node', node.parent.node.parent.node.parent.node);
-                            //console.log('node.ggparent.node', node.ggparent.node);
-                            //console.log('node.ggparent.node.is_statement', node.ggparent.node.is_statement);
-
-                            if (node.ggparent.node && node.ggparent.node.is_statement) {
-                                ast_node_exports_statement = node.ggparent.node;
-                            }
-                        }
-                    }
-                });
-            }
-
-            // Get the Member Expression module.exports
-
-            //  Signature matches probably are the best way to compare for the moment.
-            //   How about just indexing shallow signatures?
-
-            // Looking it up from the index seems like it makes the most sense.
-
-            // sig_from_source
-            // sig(src)
-
-            // Maybe set this up before.
-            // Nodes by type as well?
-
-            //console.log('mod_ids', mod_ids);
-            return ast_node_exports_statement;
-
-        }
-
-        let exports;
-        Object.defineProperty(this, 'exports', {
-            get() { 
-                if (exports === undefined) {
-                    // Worth creating some kind of 'feature' object here.
-                    //  Would have more understanding of the node being exported?
-
-                    // Create the exports feature, and that will be given the module.exports statement (or maybe the exported statement)
-
-                    // exports.exported.node
-                    //  could be ok for the moment.
-
-                    // will really be querying the exports object
-                    //  exports.exported.keys
-                    //  exports.exported.type
-
-                    // // const $1 = new $2($3);\n 
-                    // const $1 = new $2($3);\n 
-
-                    // find the exports statement.
-                    //this.select
-
-                    const exports_statement_node = get_module_exports_statement_node();
-                    //console.log('exports_statement_node', exports_statement_node);
-
-                    exports = new JS_AST_Root_Node_Feature_Exports({
-                        node: exports_statement_node
-                    });
-
-                    //let node;
-
-                    /*
-                    Object.defineProperty(exports, 'node', {
-                        get() { 
-                            return ;
-                        },
-                        enumerable: true,
-                        configurable: false
-                    });
-                    */
-                    
-
-                    //const module_exports_statement_node = get_module_exports_statement_node();
-                    //console.log('module_exports_statement_node', module_exports_statement_node);
-
-
-                     
-                     
-
-                    
-
-
-
-
-                    
-
-                }
-                return exports;
-            },
-            enumerable: true,
-            configurable: false
-        });
-        
-        
-        //
-        // Further properties.
-        //  Need to look into .exports.
-        //   Don't want so much functionality on the JS_File side of things, it's better to layer the relevant abstractions on top of JS_AST_Node.
-
-
-
-
-
-
-
-    }
-}
-
+
+
+const JS_AST_Node = require('../../JS_AST_Node');
+const JS_AST_Root_Node_Feature_Exports = require('./JS_AST_Root_Node_Feature_Exports');
+
+
+const {each} = require('lang-tools');
+// A map of named / relevant inner nodes could be a useful feature of the ast node overall.
+
+// or is it an index if it's mapping to an array?
+
+// idx_named_nodes (so it can apply to ancestors or others in the ast)
+
+// map_named_inner_nodes
+
+// map_named_inner_nodes['exports'] = [...] // always an array
+
+
+class JS_AST_Root_Node_Interpreted extends JS_AST_Node {
+
+    // Root node features could be of use.
+    //  Want to recognise features in a convenient way.
+    //  Signatures could definitely help with that
+    //   But a feature may not be best recognised with a signature.
+
+    // Could do a more formal decision tree for determining features.
+    // could have a set of determinations and values.
+    //  
+
+
+    // This is the best place for it to come up with more info on the import and export?
+    //  Or further down near the core?
+
+    constructor(spec) {
+        super(spec);
+
+        const {get_arr_named_node, index_named_node} = this;
+
+        // .exported.type      'object', 'class'
+        // .exported.keys
+
+        // This will handle non-special case things.
+        //  If there is demand jsgui or other special cases could be brought into normal interpretation.
+
+        // An index of the relevant statements.
+
+        let ast_node_exports_statement;
+        //let arr_ast_node_import_statements = [];
+
+        const get_module_exports_statement_node = () => {
+
+            if (!ast_node_exports_statement) {
+
+
+                this.setup_node_index('identifiers_by_name', node => node.is_identifier, node => node.name);
+
+                //let res;
+                const mod_ids = this.get_indexed_nodes_by_key('identifiers_by_name', 'module');
+                each(mod_ids, node => {
+                    // want to be able to get the next sibling from a node easily.
+                    //console.log('node', node);
+                    //console.log('node.parent_node', node.parent_node);
+
+                    //console.log('node.sibling.count', node.sibling.count);
+
+                    if (node.sibling.count === 1) {
+                        const sibling = node.sibling.collect()[0];
+                        //console.log('sibling.name', sibling.name);
+                        if (sibling.name === 'exports') {
+                            //console.log('node.parent_node.parent_node', node.parent_node.parent_node);
+                            //console.log('node.parent_node.parent_node.parent_node', node.parent_node.parent_node.parent_node);
+                            //console.log('node.parent.node.parent.node.parent.node', node.parent.node.parent.node.parent.node);
+                            //console.log('node.ggparent.node', node.ggparent.node);
+                            //console.log('node.ggparent.node.is_statement', node.ggparent.node.is_statement);
+
+                            if (node.ggparent.node && node.ggparent.node.is_statement) {
+                                ast_node_exports_statement = node.ggparent.node;
+                            }
+                        }
+                    }
+                });
+            }
+
+            // Get the Member Expression module.exports
+
+            //  Signature matches probably are the best way to compare for the moment.
+            //   How about just indexing shallow signatures?
+
+            // Looking it up from the index seems like it makes the most sense.
+
+            // sig_from_source
+            // sig(src)
+
+            // Maybe set this up before.
+            // Nodes by type as well?
+
+            //console.log('mod_ids', mod_ids);
+            return ast_node_exports_statement;
+
+        }
+
+        let exports;
+        Object.defineProperty(this, 'exports', {
+            get() { 
+                if (exports === undefined) {
+                    // Worth creating some kind of 'feature' object here.
+                    //  Would have more understanding of the node being exported?
+
+                    // Create the exports feature, and that will be given the module.exports statement (or maybe the exported statement)
+
+                    // exports.exported.node
+                    //  could be ok for the moment.
+
+                    // will really be querying the exports object
+                    //  exports.exported.keys
+                    //  exports.exported.type
+
+                    // // const $1 = new $2($3);\n 
+                    // const $1 = new $2($3);\n 
+
+                    // find the exports statement.
+                    //this.select
+
+                    const exports_statement_node = get_module_exports_statement_node();
+                    //console.log('exports_statement_node', exports_statement_node);
+
+                    exports = new JS_AST_Root_Node_Feature_Exports({
+                        node: exports_statement_node
+                    });
+
+                    //let node;
+
+                    /*
+                    Object.defineProperty(exports, 'node', {
+                        get() { 
+                            return ;
+                        },
+                        enumerable: true,
+                        configurable: false
+                    });
+                    */
+                    
+
+                    //const module_exports_statement_node = get_module_exports_statement_node();
+                    //console.log('module_exports_statement_node', module_exports_statement_node);
+
+
+                     
+                     
+
+                    
+
+
+
+
+                    
+
+                }
+                return exports;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        
+        
+        //
+        // Further properties.
+        //  Need to look into .exports.
+        //   Don't want so much functionality on the JS_File side of things, it's better to layer the relevant abstractions on top of JS_AST_Node.
+
+
+
+
+
+
+
+    }
+}
+
 module.exports = JS_AST_Root_Node_Interpreted;

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

@@ -1,43 +1,43 @@
-// Similar in purpose to a document feature.
-
-// Will be used to handle special cases / unusual ways of declaring exports.
-
-// So the root node could itself feature exports.
-
-// So a feature could be that JSGUI_AST_Interpreter understands it and understands what it's about.
-//  However, want the Interpreter to itself be / act as a node within the AST.
-
-// JSGUI_AST_Root_Node_Interpretation
-
-// So it loads the node, an also applies higher level special case rules.
-//  If it does not recognise how a JS file works, then program in the special rules that will allow it to.
-//  Normal types of syntax should be covered on a lower level. This special case system will allow that to
-//  not accumulate too much code clutter and continue to be a nice codebase. 
-
-// So the feature would be 'JSGUI Interpreted'.
-
-// At least special case rules and interpretation can be as lengthy as required to do the task, and stay out of the way of lower level parts.
-
-
-const Root_Node_Interpreted = require('./JS_AST_Root_Node_Interpreted');
-
-
-
-
-
-class JSGUI_Root_Node_Interpreted extends Root_Node_Interpreted {
-    constructor(spec) {
-        super(spec);
-
-
-        // .exported.type      'object', 'class'
-        // .exported.keys
-
-    }
-}
-
-
-module.exports = JSGUI_Root_Node_Interpreted;
-
-
-
+// Similar in purpose to a document feature.
+
+// Will be used to handle special cases / unusual ways of declaring exports.
+
+// So the root node could itself feature exports.
+
+// So a feature could be that JSGUI_AST_Interpreter understands it and understands what it's about.
+//  However, want the Interpreter to itself be / act as a node within the AST.
+
+// JSGUI_AST_Root_Node_Interpretation
+
+// So it loads the node, an also applies higher level special case rules.
+//  If it does not recognise how a JS file works, then program in the special rules that will allow it to.
+//  Normal types of syntax should be covered on a lower level. This special case system will allow that to
+//  not accumulate too much code clutter and continue to be a nice codebase. 
+
+// So the feature would be 'JSGUI Interpreted'.
+
+// At least special case rules and interpretation can be as lengthy as required to do the task, and stay out of the way of lower level parts.
+
+
+const Root_Node_Interpreted = require('./JS_AST_Root_Node_Interpreted');
+
+
+
+
+
+class JSGUI_Root_Node_Interpreted extends Root_Node_Interpreted {
+    constructor(spec) {
+        super(spec);
+
+
+        // .exported.type      'object', 'class'
+        // .exported.keys
+
+    }
+}
+
+
+module.exports = JSGUI_Root_Node_Interpreted;
+
+
+

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

@@ -1,12 +1,12 @@
-
-
-// Covers the case such as in lang-tools:
-
-// An Evented_Class is made
-// Object.assign is used to assign its properties.
-
-// May as well not treat this as a special case?
-//  Just the logic within find_keys
-// It's fine to go into various specifics if it's written in a way so that if they don't occurr, no unwanted effects.
-
-
+
+
+// Covers the case such as in lang-tools:
+
+// An Evented_Class is made
+// Object.assign is used to assign its properties.
+
+// May as well not treat this as a special case?
+//  Just the logic within find_keys
+// It's fine to go into various specifics if it's written in a way so that if they don't occurr, no unwanted effects.
+
+

package/resources/jsbuilder/JS_AST/JS_AST_Node_Group.js

@@ -1,35 +1,35 @@
-// Basically a collection but chose a shorter name.
-
-
-// Want to be able to operate on the group as a whole.
-
-
-// each.child
-// each.ancestor
-// each.inner
-// each (including self buut no ancestrors)
-
-// each will produce the callback
-// all the array
-// first the item
-
-// filter like each with a callback
-// select returns the array
-
-
-
-// .filter
-
-
-
-// .all
-//  is collect
-
-// .find.all
-//  that is select
-
-// 
-
-// .find.first
-
-
+// Basically a collection but chose a shorter name.
+
+
+// Want to be able to operate on the group as a whole.
+
+
+// each.child
+// each.ancestor
+// each.inner
+// each (including self buut no ancestrors)
+
+// each will produce the callback
+// all the array
+// first the item
+
+// filter like each with a callback
+// select returns the array
+
+
+
+// .filter
+
+
+
+// .all
+//  is collect
+
+// .find.all
+//  that is select
+
+// 
+
+// .find.first
+
+

package/resources/jsbuilder/JS_AST/JS_AST_Operation.js

@@ -1,11 +1,11 @@
-class JS_AST_Operation {
-    constructor(spec = {}) {
-        let name;
-
-        if (spec.name !== undefined) {
-            name = spec.name;
-        }
-    }
-}
-
-module.exports = JS_AST_Operation;
+class JS_AST_Operation {
+    constructor(spec = {}) {
+        let name;
+
+        if (spec.name !== undefined) {
+            name = spec.name;
+        }
+    }
+}
+
+module.exports = JS_AST_Operation;

package/resources/jsbuilder/JS_AST/JS_AST_Operation_On_Relationship.js

@@ -1,32 +1,32 @@
-class JS_AST_Operation_On_Relationship {
-    constructor(spec = {}) {
-
-
-
-        
-        let operation, relationship;
-
-        if (spec.operation !== undefined) {
-            operation = spec.operation;
-        }
-
-        if (spec.relationship !== undefined) {
-            relationship = spec.relationship;
-        }
-
-
-        // From things like collect all.
-
-        // May be better to use the select command for the moment.
-
-        // collect.all.declaration
-
-
-
-
-
-
-    }
-}
-
+class JS_AST_Operation_On_Relationship {
+    constructor(spec = {}) {
+
+
+
+        
+        let operation, relationship;
+
+        if (spec.operation !== undefined) {
+            operation = spec.operation;
+        }
+
+        if (spec.relationship !== undefined) {
+            relationship = spec.relationship;
+        }
+
+
+        // From things like collect all.
+
+        // May be better to use the select command for the moment.
+
+        // collect.all.declaration
+
+
+
+
+
+
+    }
+}
+
 module.exports = JS_AST_Operation_On_Relationship;