jsgui3-server 0.0.75 → 0.0.79

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.0.99-Basics_Last.js

@@ -0,0 +1,92 @@
+
+
+const JS_AST_Node_Basics_Second = require('./JS_AST_Node_3.0.1-Basics_Second');
+
+const JS_AST_Abstract_Node = require('./JS_AST_Abstract_Node');
+const JS_AST_Ordinal = require('./JS_AST_Ordinal');
+//const JS_AST_Relationship = require('./JS_AST_Relationship_Node_To_Group');
+const JS_AST_Ordinal_Relationship = require('./JS_AST_Ordinal_Relationship');
+
+// Could make a more specific feature extraction part.
+//  Will come up with more:
+
+// 2.1 Identify
+// 2.2 ??? - Extract_Feature?
+
+// Will identify more information about what JS is contained.
+//  Eg if it's a recognised code library structure that can be extracted.
+//   Identify the main block of declarations in a (library or framework) file.
+//    Identify the variable definitions in there.
+
+// Need more capability here to find and match specified features.
+
+// Asking questions about a piece of code - questions to later determine what it is and how to use it.
+
+// .matches_type_signature(signature)
+
+// . but using a tree is better for checking multiple signatures at once.
+
+// basically 'deep iterate', though could apply to .child or .ancestor
+
+class JS_AST_Node_Basics_Last extends JS_AST_Node_Basics_Second {
+    constructor(spec = {}) {
+        super(spec);
+
+        // An abstract JS AST node
+
+        //const index = 'last'; // or -0 meaning last?
+
+
+        const {child_nodes} = this;
+
+
+
+        // first.child.declaration
+        //  meaning it's not 'first.child'.
+
+
+
+        // First is a node condition?
+        //  or short for get first?
+
+        // .first.child
+        //   will need to be first.child.node
+
+        // .first.declaration
+        // .first.child.declaration
+        //   want it to operate as read in English.
+
+        // maybe function chaining is the way?
+
+        // JS_AST_Ordinal
+
+        const ordinal = this.last = new JS_AST_Ordinal({
+            origin: this,
+            //relationship_to: 'first',
+            //number: 'last'
+        });
+
+        const {child} = this;
+        // JS_AST_Ordinal_Relationship
+        // Abstract node with a specified type?
+        //  Or something else?
+
+        // Relationship of node to node.
+
+        const ordinal_child = ordinal.child = new JS_AST_Ordinal_Relationship({
+            ordinal: ordinal,
+            relationship: child
+        });
+
+        Object.defineProperty(ordinal_child, 'node', {
+            get() { 
+                return child_nodes[child_nodes.length - 1];
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+    }
+}
+
+module.exports = JS_AST_Node_Basics_Last;

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.1-Basics_Each.js

@@ -0,0 +1,137 @@
+
+const JS_AST_Node_Basics_Last = require('./JS_AST_Node_3.0.99-Basics_Last');
+const JS_AST_Operation = require('./JS_AST_Operation');
+const JS_AST_Relationship = require('./JS_AST_Relationship_Node_To_Group');
+
+const JS_AST_Operation_On_Relationship = require('./JS_AST_Operation_On_Relationship');
+
+
+// Operation_On_Relationship
+
+// Could make a more specific feature extraction part.
+//  Will come up with more:
+
+// 2.1 Identify
+// 2.2 ??? - Extract_Feature?
+
+// Will identify more information about what JS is contained.
+//  Eg if it's a recognised code library structure that can be extracted.
+//   Identify the main block of declarations in a (library or framework) file.
+//    Identify the variable definitions in there.
+
+// Need more capability here to find and match specified features.
+
+// Asking questions about a piece of code - questions to later determine what it is and how to use it.
+
+// .matches_type_signature(signature)
+
+// . but using a tree is better for checking multiple signatures at once.
+
+// basically 'deep iterate', though could apply to .child or .ancestor
+
+
+// More about traversal than query?
+
+class JS_AST_Node_Basics_Each extends JS_AST_Node_Basics_Last {
+    constructor(spec = {}) {
+        super(spec);
+        const {each_child_node, filter_each_child_node} = this;
+
+        const myeach = new JS_AST_Operation({name: 'each'});
+
+        ////const myeach = cb => deep_iterate(cb);
+               
+        Object.assign(this, {
+            each: myeach
+        });
+
+        // .child
+        // .inner
+        // .node (seems like we need this now rather than just calling each)
+        //  now each is an operation, we need to explicitly tell it what to operate on.
+
+        /*
+        const child = new JS_AST_Relationship({
+            name: 'child'
+        });
+        */
+
+        // each.identifier is another relationship?
+        //  is_within??? or the within relationship?
+
+
+
+
+
+
+        // And an Operation_Relationship?   
+        //  each child
+
+        // Operation_Relationship_Node?
+        //  Since it's each child node, or some kind of node here, we can make use of that somehow.
+
+
+        /*
+        const each_child = new JS_AST_Operation_On_Relationship({
+            operation: myeach,
+            related: child
+        }); // But incomplete without being told what to operate on.
+
+
+        myeach.child = each_child;
+
+
+        // each.identifier
+        //  has to be a function for the nicest syntax.
+
+        myeach.identifier = callback => {
+            this.filter_deep_iterate(node => node.is_identifier, callback);
+        }
+        myeach.declaration = callback => {
+            this.filter_deep_iterate(node => node.is_declaration, callback);
+        }
+        myeach.statement = callback => {
+            this.filter_deep_iterate(node => node.is_statement, callback);
+        }
+
+        */
+
+
+
+
+
+        //child.each = each_child;
+
+
+        /*
+        const each_child_assignment_expression = (callback) => filter_each_child_node(node => node.type === 'AssignmentExpression', callback);
+        const each_child_expression_statement = (callback) => filter_each_child_node(node => node.type === 'ExpressionStatement', callback);
+        //const each_child_declaration = (callback) => filter_each_child_node(node => node.is_declaration, callback);
+        //const each_declaration_child_node = (callback) => filter_each_child_node(js_ast_node => js_ast_node.is_declaration, callback);
+        const each_assignment_expression_child_node = callback => filter_each_child_node(node => node.type === "AssignmentExpression");
+
+        const each_inner_declaration = (callback) => {
+            filter_inner_deep_iterate(node => node.is_declaration, node => {
+                callback(node);
+            })
+        }
+        
+        const each_inner_variable_declarator = callback => each_inner_node_of_type('VariableDeclarator', callback);
+        const each_inner_identifier = callback => each_inner_node_of_type('Identifier', callback);
+
+        //each_child.node = cb => each_child_node(callback);
+
+        //const mechild = myeach.child = cb => each_child_node(cb);
+        
+        //mechild.expression_statement = cb => each_child_expression_statement(cb);
+        //mechild.assignment_expression = cb => each_child_assignment_expression(cb);
+        //mechild.declaration = cb => each_child_declaration(cb);
+        */
+        this.each = myeach;
+        //this.each_child_declaration = each_child_declaration;
+
+
+    }
+}
+
+module.exports = JS_AST_Node_Basics_Each

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.1.5-Basics_Count.js

@@ -0,0 +1,74 @@
+
+const JS_AST_Node_Basics_Each = require('./JS_AST_Node_3.1-Basics_Each');
+
+const JS_AST_Operation = require('./JS_AST_Operation');
+const JS_AST_Relationship = require('./JS_AST_Relationship');
+const JS_AST_Operation_On_Relationship = require('./JS_AST_Operation_On_Relationship');
+
+
+// Could make a more specific feature extraction part.
+//  Will come up with more:
+
+// 2.1 Identify
+// 2.2 ??? - Extract_Feature?
+
+// Will identify more information about what JS is contained.
+//  Eg if it's a recognised code library structure that can be extracted.
+//   Identify the main block of declarations in a (library or framework) file.
+//    Identify the variable definitions in there.
+
+// Need more capability here to find and match specified features.
+
+// Asking questions about a piece of code - questions to later determine what it is and how to use it.
+
+// .matches_type_signature(signature)
+
+// . but using a tree is better for checking multiple signatures at once.
+
+// basically 'deep iterate', though could apply to .child or .ancestor
+
+// Currently not used anyway. Will make the more advanced .query system.
+
+
+
+class JS_AST_Node_Basics_Count extends JS_AST_Node_Basics_Each {
+    constructor(spec = {}) {
+        super(spec);
+
+        const {each_child_node, filter_each_child_node} = this;
+
+        // JS_AST_Property_Operation rather than JS_AST_Function_Operation perhaps
+
+        const count = new JS_AST_Operation({name: count});
+
+        const {child} = this;
+        //const child = new JS_AST_Relationship({
+        //    name: 'child'
+        //});
+
+        const count_child = new JS_AST_Operation_On_Relationship({
+            operation: count,
+            relationship: child
+        });
+        count.child = count_child;
+
+        //child.count = count_child;
+
+        // .count.child.node
+
+
+        Object.defineProperty(count_child, 'node', {
+            get() { 
+                return this.child_nodes.length;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        this.count = count;
+
+    }
+}
+
+module.exports = JS_AST_Node_Basics_Count

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.2-Basics_Filter.js

@@ -0,0 +1,40 @@
+
+
+const JS_AST_Node_Basics_Each = require('./JS_AST_Node_3.1-Basics_Each');
+const JS_AST_Operation = require('./JS_AST_Operation');
+const JS_AST_Relationship_Node_To_Group = require('./JS_AST_Relationship_Node_To_Group');
+
+const JS_AST_Operation_On_Relationship = require('./JS_AST_Operation_On_Relationship');
+
+class JS_AST_Node_Basics_Filter extends JS_AST_Node_Basics_Each {
+
+
+    constructor(spec = {}) {
+        super(spec);
+        const filter = new JS_AST_Operation({name: 'filter'});
+
+        const {child, inner, all} = this;
+        const {inner_deep_iterate, each_child_node, deep_iterate} = this;
+
+        const filter_deep_iterate = (fn_filter, callback) => deep_iterate((node) => fn_filter(node) ? callback(node) : undefined)
+        const filter_inner_deep_iterate = (fn_filter, callback) => inner_deep_iterate((node) => fn_filter(node) ? callback(node) : undefined)
+        const filter_each_child_node = (fn_filter, callback) => each_child_node(js_ast_node => {
+            if (fn_filter(js_ast_node)) {
+                callback(js_ast_node);
+            }
+        });
+
+        const filter_child_nodes_by_type = (type, callback) => filter_each_child_node(n => n.type === type, callback);
+
+
+        this.filter = filter;
+        this.filter_deep_iterate = filter_deep_iterate;
+        this.filter_inner_deep_iterate = filter_inner_deep_iterate;
+        this.filter_each_child_node = filter_each_child_node;
+        this.filter_child_nodes_by_type = filter_child_nodes_by_type;
+
+    }
+
+}
+
+module.exports = JS_AST_Node_Basics_Filter

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.3-Basics_Collect.js

@@ -0,0 +1,86 @@
+
+
+const JS_AST_Node_Basics_Filter = require('./JS_AST_Node_3.2-Basics_Filter');
+
+const JS_AST_Operation = require('./JS_AST_Operation');
+const JS_AST_Relationship = require('./JS_AST_Relationship_Node_To_Group');
+
+const JS_AST_Operation_On_Relationship = require('./JS_AST_Operation_On_Relationship');
+
+
+
+// Collect is still a verb.
+// Maybe all verbs should be functions.
+//  Some values with different syntax could be properties.
+
+
+class JS_AST_Node_Basics_Collect extends JS_AST_Node_Basics_Filter {
+    constructor(spec = {}) {
+        super(spec);
+
+        const collect = new JS_AST_Operation({name: 'collect'});
+        
+        
+        // or 'deep'? Or just know that 'all' does not include ancestors.
+        const {child, inner, all} = this;
+        const {inner_deep_iterate, deep_iterate, filter_deep_iterate} = this;
+
+
+        //const collect_child_nodes = () => this.child_nodes;
+        //const collect_child_identifiers = () => this.child_nodes.filter(node => node.is_identifier);
+        //const collect_child_declarations = () => this.child_nodes.filter(node => node.is_declaration);
+
+        /*
+        let _collected_inner_nodes;
+        const collect_inner_nodes = () => {
+            if (!_collected_inner_nodes) {
+                _collected_inner_nodes = [];
+                inner_deep_iterate(node => _collected_inner_nodes.push(node));
+            }
+            return _collected_inner_nodes;
+        }
+
+        const _collect_all = () => {
+            const res = [];
+            deep_iterate(node => res.push(node));
+            return res;
+        }
+        const _collect_child = () => {
+            return this.child_nodes; // maybe into a new array?
+        }
+        const _collect_inner = () => {
+            const res = [];
+            inner_deep_iterate(node => {
+                if (node !== this) {
+                    res.push(node);
+                }
+            });
+            return res;
+        }
+        */
+
+        /*
+        let fn_collect_all, fn_collect_child, fn_collect_inner;
+
+
+        const _collect_all_identifiers = () => {
+            const res = [];
+            filter_deep_iterate(node => node.is_identifier, node => res.push(node));
+            return res;
+        }
+
+        const _select_inner = (fn_select) => {
+            const res = [];
+            inner_deep_iterate(node => {
+                if (node !== this && fn_select(node)) {
+                    res.push(node);
+                }
+            });
+            return res;
+        }
+        */
+        this.collect = collect;
+    }
+}
+
+module.exports = JS_AST_Node_Basics_Collect

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.4-Basics_Select.js

@@ -0,0 +1,43 @@
+
+
+const JS_AST_Node_Basics_Collect = require('./JS_AST_Node_3.3-Basics_Collect');
+const JS_AST_Operation = require('./JS_AST_Operation');
+const JS_AST_Relationship_Node_To_Group = require('./JS_AST_Relationship_Node_To_Group');
+const JS_AST_Operation_On_Relationship = require('./JS_AST_Operation_On_Relationship');
+
+const enable_array_as_queryable = require('./query/enable_array_as_queryable');
+
+class JS_AST_Node_Basics_Select extends JS_AST_Node_Basics_Collect {
+    constructor(spec = {}) {
+        super(spec);
+
+        const {filter_deep_iterate, filter_each_child_node, inner_deep_iterate} = this;
+        const select_all = (fn_select) => {
+            const res = [];
+            filter_deep_iterate(fn_select, node => res.push(node));
+            enable_array_as_queryable(res);
+
+            return res;
+        }
+        const select_child = (fn_select) => {
+            const res = [];
+            filter_each_child_node(fn_select, node => res.push(node));
+            return res;
+        }
+        const select_inner = (fn_select) => {
+            const res = [];
+            inner_deep_iterate(node => {
+                if (node !== this && fn_select(node)) {
+                    res.push(node);
+                }
+            });
+            return res;
+        }
+
+        this.select_all = select_all;
+        this.select_child = select_child;
+        this.select_inner = select_inner;
+    }
+}
+
+module.exports = JS_AST_Node_Basics_Select

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.5-Basics_Find.js

@@ -0,0 +1,41 @@
+
+
+const JS_AST_Node_Basics_Select = require('./JS_AST_Node_3.4-Basics_Select');
+
+const JS_AST_Operation = require('./JS_AST_Operation');
+const JS_AST_Relationship = require('./JS_AST_Relationship_Node_To_Group');
+const JS_AST_Operation_On_Relationship = require('./JS_AST_Operation_On_Relationship');
+
+class JS_AST_Node_Basics_Find extends JS_AST_Node_Basics_Select {
+    constructor(spec = {}) {
+        super(spec);
+        const {deep_iterate} = this;
+
+
+        // Not so sure we need this kind of operation object now.
+        //  .query is how queries will be done in the future. 
+
+        //const find = new JS_AST_Operation({name: 'find'});
+        
+        const find_node = (fn_match) => {
+            let res;
+            deep_iterate((js_ast_node, path, depth, stop) => {
+                if (fn_match(js_ast_node)) {
+                    if (!res) res = js_ast_node;
+                    stop();
+                    
+                }
+            });
+            return res;
+        };
+
+        // find.child.node?
+        // 
+        
+        
+        //find.node = fn_match => find_node(fn_match);
+        this.find_node = find_node;
+    }
+}
+
+module.exports = JS_AST_Node_Basics_Find

package/resources/jsbuilder/JS_AST/JS_AST_Node_3.6-Basics_Callmap.js

@@ -0,0 +1,55 @@
+//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_Find = require('./JS_AST_Node_3.5-Basics_Find');
+const JS_AST_Node_Indexes = require('./JS_AST_Node_4.0-Index_Indexes');
+
+class JS_AST_Node_Index extends JS_AST_Node_Basics_Find {
+    constructor(spec = {}) {
+        super(spec);
+        const {deep_iterate, each_child_node, inner, child} = this;
+
+        //const callmap = {};
+
+        const callmap = (fntostring, map_handlers, default_handler) => {
+            const str = fntostring(this);
+            // such as get the signature
+            let res;
+            if (map_handlers[str]) {
+                res = map_handlers[str](this);
+            } else {
+                res = default_handler(this);
+            }
+            return res;
+        }
+
+        const callmap_deep_iterate = (fntostring, map_handlers, default_handler) => {
+            deep_iterate(node => {
+                node.callmap(fntostring, map_handlers, default_handler);
+            })
+        }
+        const callmap_child_nodes = (fntostring, map_handlers, default_handler) => {
+            each_child_node(node => {
+                node.callmap(fntostring, map_handlers, default_handler);
+            })
+        }
+
+        const signature_callmap_deep_iterate = (map_handlers, default_handler) => callmap_deep_iterate(node => node.sugnature, map_handlers, default_handler);
+        const signature_callmap_child_nodes = (map_handlers, default_handler) => callmap_child_nodes(node => node.sugnature, map_handlers, default_handler);
+        // 
+
+        this.callmap = callmap;
+        this.callmap_deep_iterate = callmap_deep_iterate;
+        this.callmap_child_nodes = callmap_child_nodes;
+        this.signature_callmap_deep_iterate = signature_callmap_deep_iterate;
+        this.signature_callmap_child_nodes = signature_callmap_child_nodes;
+    }
+}
+module.exports = JS_AST_Node_Index;

package/resources/jsbuilder/JS_AST/JS_AST_Node_4.0-Index_Indexes.js

@@ -0,0 +1,46 @@
+// Indexes because it keeps multiple indexes, ie an index of indexes.
+
+class JS_AST_Node_Indexes {
+    // Not a type of JS_AST_Node! Change the name?
+    constructor(spec = {}) {
+        const map_indexes = new Map();
+
+        const get_index = index_name => {
+            if (!map_indexes.has(index_name)) {
+                map_indexes.set(index_name, new Map());
+            }
+            const map_index = map_indexes.get(index_name);
+            return map_index;
+        }
+
+        const set = (index_name, key, value) => {
+            const index = get_index(index_name);
+            ////const arr = 
+            if (!index.has(key)) {
+                index.set(key, []);
+            }
+            const arr = index.get(key);
+            arr.push(value);
+        }
+
+        const get = (index_name, key) => {
+            const map_idx = map_indexes.get(index_name);
+            if (map_idx) {
+                const arr_items = map_idx.get(key);
+                return arr_items;
+            } else {
+                throw 'stop';
+            }
+        }
+
+        const has_index = (index_name) => map_indexes.has(index_name);
+
+        Object.assign(this, {
+            set: set,
+            get: get,
+            has_index: has_index
+        });
+    }
+}
+
+module.exports = JS_AST_Node_Indexes;