jsgui3-server 0.0.73 → 0.0.77

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

@@ -0,0 +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-mini');
+// 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

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

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

@@ -0,0 +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.
+
+

package/resources/jsbuilder/JS_AST/JS_AST_Node_Group.js

@@ -0,0 +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
+
+

package/resources/jsbuilder/JS_AST/JS_AST_Operation.js

@@ -0,0 +1,11 @@
+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

@@ -0,0 +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
+
+
+
+
+
+
+    }
+}
+
+module.exports = JS_AST_Operation_On_Relationship;

package/resources/jsbuilder/JS_AST/JS_AST_Ordered_Relationship_Node_To_Group.js

@@ -0,0 +1,38 @@
+const JS_AST_Relationship_Node_To_Group = require('./JS_AST_Relationship_Node_To_Group');
+
+class JS_AST_Ordered_Relationship_Node_To_Group extends JS_AST_Relationship_Node_To_Group {
+    constructor(spec = {}) {
+        super(spec);
+        let index;
+        if (spec.index !== undefined) index = spec.index;
+        
+
+        
+        Object.defineProperty(this, 'index', {
+            get() { 
+                return index;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        // A 'pre' property
+
+        // Could be another group / a subgroup.
+
+        // a previous object.
+        //  seems like a Node_group?
+
+        // .each
+        // .all
+        // 
+
+
+
+
+        // 
+        
+    }
+}
+
+module.exports = JS_AST_Ordered_Relationship_Node_To_Group;

package/resources/jsbuilder/JS_AST/JS_AST_Ordinal.js

@@ -0,0 +1,40 @@
+class JS_AST_Ordinal {
+
+
+    // Not a relationship
+    // First child is an ordinal relationship
+
+
+
+
+    constructor(spec = {}) {
+
+
+
+        
+        let origin, obtainer, number;
+
+        //let relationship_to;
+
+        if (spec.origin) {
+            origin = spec.origin;
+        }
+
+        if (spec.number !== undefined) {
+            number = spec.number;
+        }
+
+        //if (spec.obtainer) {
+        //    obtainer = spec.obtainer;
+        //}
+        //if (spec.relationship_to) {
+        //    relationship_to = spec.relationship_to;
+        //}
+
+        let arr_cached;
+
+
+    }
+}
+
+module.exports = JS_AST_Ordinal;

package/resources/jsbuilder/JS_AST/JS_AST_Ordinal_Relationship.js

@@ -0,0 +1,25 @@
+class JS_AST_Ordinal_Relationship {
+    constructor(spec = {}) {
+        let ordinal, relationship;
+
+        
+
+        if (spec.ordinal !== undefined) ordinal = spec.ordinal;
+        if (spec.relationship !== undefined) relationship = spec.relationship;
+
+        
+        
+        Object.defineProperty(this, 'origin', {
+            get() { 
+                return ordinal.origin;
+
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+    }
+}
+
+module.exports = JS_AST_Ordinal_Relationship;

package/resources/jsbuilder/JS_AST/JS_AST_Relationship_Node_To_Group.js

@@ -0,0 +1,201 @@
+// Change to Group_Relationship?
+const {each} = require('lang-mini');
+const JS_AST_Group_Shared = require('./JS_AST_Group_Shared');
+
+
+
+class JS_AST_Relationship_Node_To_Group {
+    constructor(spec = {}) {
+
+        let name;
+        if (spec.name !== undefined) {
+            name = spec.name;
+        }
+        let origin;
+        if (spec.origin !== undefined) {
+            origin = spec.origin;
+        }
+
+        
+
+
+
+        // eg 'child'
+
+        // Iteration of sibling and ancestor groups here.
+
+        // And a sibling_nodes property.
+
+        // Integrate sibling iteration into the system.
+        //  Will make some queries / other parts of the system easier to write.
+
+        // A version of this that is ordinal as well, with .next and .previous.
+        //  so we start by knowing the ordinal and the origin
+
+
+        // all previous sibling nodes?
+        //  node.sibling.previous.each
+        //  node.each.previous.sibling
+
+
+        const iterate_group = callback => {
+            // available_in_scope
+            //  all previous siblings that are declarations / assignment expressions (of the right sort)
+            //  iterate ancestors
+            //   all child declarations
+            //    (maybe just the ones before current)
+
+            // or something like above
+            //
+
+            if (name === 'post-sibling') {
+                if (origin.parent_node) {
+                    //const postsibs = [];
+                    let i2 = 0;
+                    each(origin.parent_node.child_nodes, (node, idx, stop) => {
+                        if (idx > origin.index) {
+                            callback(node, i2++, stop);
+                        } else {
+                        }
+                    });
+                }
+            } else if (name === 'previous-sibling') {
+                if (origin.parent_node) {
+                    const presibs = [];
+                    each(origin.parent_node.child_nodes, (node, idx, stop) => {
+                        if (idx < origin.index) {
+                            presibs.push(node)
+                        } else {
+                            stop();
+                        }
+                    });
+                    presibs.reverse();
+                    each(presibs, (node, idx, stop) => callback(node, idx, stop));
+                }
+            } else if (name === 'sibling') {
+                if (origin.parent_node) {
+                    each(origin.parent_node.child_nodes, (node, idx, stop) => {
+                        if (node !== origin) {
+                            callback(node, idx, stop);
+                        }
+                    });
+                }
+            } else if (name === 'all') {
+                origin.deep_iterate(callback);
+            } else if (name === 'inner') {
+                origin.inner_deep_iterate(callback);
+            } else if (name === 'child') {
+
+                each(origin.child_nodes, callback);
+                //origin.each_child(callback);
+            } else if (name === 'available_in_scope') {
+                throw 'NYI';
+            } else {
+                console.log('name', name);
+                throw 'stop';
+            }
+        }
+
+        const find = (finder) => {
+            let res;
+            iterate_group((node, idx, stop) => {
+                if (finder(node)) {
+                    if (!res) res = node; // TODO fix stop
+                    //stop();
+                }
+            })
+            return res;
+        }
+
+        const shared = new JS_AST_Group_Shared({
+            group_iterator: iterate_group
+        });
+
+
+        // And collect is still a verb here.
+        //  Use property sugar with a different name.
+        let _collected;
+        const collect = () => {
+            if (!_collected) {
+                _collected = [];
+                iterate_group(node => _collected.push(node));
+            }
+            return _collected;
+        }
+
+
+        // and .all could be like .collect but a property.
+        //  and with groups could be used in a fair few places.
+
+        Object.defineProperty(this, 'all', {
+            get() { 
+                return this.collect();
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        let _count;
+
+        const count = () => {
+            if (_count === undefined) {
+                if (_collected) {
+                    _count = _collected.length;
+                } else {
+
+                    if (name === 'child') {
+                        _count = origin.child_nodes.length;
+                    } else {
+                        _count = 0;
+                        iterate_group(node => _count++);
+                    }
+
+                    
+                }
+            }
+            return _count;
+        }
+
+        Object.defineProperty(this, 'count', {
+            get() { 
+                return count();
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+
+        const select = (fn_select) => {
+            // Could return another group?
+            //  
+
+            const res = [];
+            iterate_group(node => {
+                if (fn_select(node)) res.push(node);
+            });
+            return res;
+        }
+
+
+        Object.assign(this, {
+            select: select,
+            shared: shared,
+            each: iterate_group,
+            find: find,
+            collect: collect
+        });
+        
+        
+        /*
+        this.select = select;
+        this.shared = shared;
+        this.each = iterate_group;
+        this.find = find;
+        this.collect = collect;
+        */
+    }
+}
+
+module.exports = JS_AST_Relationship_Node_To_Group;

package/resources/jsbuilder/JS_AST/JS_AST_Relationship_Node_Within_Group_To_Node.js

@@ -0,0 +1,44 @@
+class JS_AST_Relationship_Node_Within_Group_To_Node {
+    constructor(spec = {}) {
+        let name;
+        if (spec.name !== undefined) {
+            name = spec.name;
+        }
+        let origin;
+        if (spec.origin !== undefined) {
+            origin = spec.origin;
+        }
+        let node;
+        if (spec.node !== undefined) {
+            node = spec.node;
+        }
+        let origin_ordinal_value_within_node;
+        if (spec.origin_ordinal_value_within_node !== undefined) {
+            origin_ordinal_value_within_node = spec.origin_ordinal_value_within_node;
+        }
+
+        
+        
+        Object.defineProperty(this, 'node', {
+            get() { 
+                return node;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'origin', {
+            get() { 
+                return origin;
+            },
+            set(new_value) { 
+                origin = new_value;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        
+        
+    }
+}
+
+module.exports = JS_AST_Relationship_Node_Within_Group_To_Node;