jsgui3-server 0.0.75 → 0.0.77

package/resources/jsbuilder/JS_AST/JS_AST_Abstract_Node.js

@@ -0,0 +1,62 @@
+
+
+// Such as for referencing the inner nodes without / before having to have the actual members.
+
+// Maybe generators would be effective here too?
+
+// origin_node
+//  
+
+
+// relationship to origin node
+//  
+
+class JS_AST_Abstract_Node {
+    constructor(spec = {}) {
+
+        // origin node
+        // function that will be called to obtain the nodes.
+
+        let origin, obtainer;
+
+        let relationship_to, index;
+
+        if (spec.origin) {
+            origin = spec.origin;
+        }
+        if (spec.obtainer) {
+            obtainer = spec.obtainer;
+        }
+        if (spec.relationship_to) {
+            relationship_to = spec.relationship_to;
+        }
+        if (spec.index !== undefined) {
+            index = spec.index;
+        }
+
+        let arr_cached;
+        // so when they do get loaded / we have a ref - does not need to operate only in the abstract.
+
+
+        Object.defineProperty(this, 'origin', {
+            get() { 
+                return origin;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        Object.defineProperty(this, 'index', {
+            get() { 
+                return index;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+
+    }
+}
+
+
+module.exports = JS_AST_Abstract_Node;

package/resources/jsbuilder/JS_AST/JS_AST_Abstract_Node_Group.js

@@ -0,0 +1,42 @@
+
+
+// Such as for referencing the inner nodes without / before having to have the actual members.
+
+// Maybe generators would be effective here too?
+
+// origin_node
+//  
+
+
+// relationship to origin node
+//  
+
+class JS_AST_Abstract_Node_Group {
+    constructor(spec = {}) {
+
+        // origin node
+        // function that will be called to obtain the nodes.
+
+        /*
+        let origin, obtainer;
+
+        let relationship_to;
+
+        if (spec.origin) {
+            origin = spec.origin;
+        }
+        if (spec.obtainer) {
+            obtainer = spec.obtainer;
+        }
+        if (spec.relationship_to) {
+            relationship_to = spec.relationship_to;
+        }
+
+        let arr_cached;
+        // so when they do get loaded / we have a ref - does not need to operate only in the abstract.
+        */
+    }
+}
+
+
+module.exports = JS_AST_Abstract_Node_Group;

package/resources/jsbuilder/JS_AST/JS_AST_Group_Shared.js

@@ -0,0 +1,62 @@
+class JS_AST_Group_Shared {
+    constructor(spec = {}) {
+        
+        let group_iterator;
+
+        if (spec.group_iterator) group_iterator = spec.group_iterator;
+        
+
+        let shared_type;
+        Object.defineProperty(this, 'type', {
+            get() { 
+                if (shared_type === undefined) {
+                    group_iterator((cn, idx, stop) => {
+                        if (shared_type === undefined) {
+                            shared_type = cn.type;
+                        } else {
+                            if (cn.type === shared_type) {
+                                // all good
+                            } else {
+                                shared_type = false;
+                                stop();
+                            }
+                        }
+
+                    })
+                }
+                return shared_type;
+                //return child_nodes.length;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        let shared_category;
+        Object.defineProperty(this, 'category', {
+            get() { 
+                if (shared_category === undefined) {
+                    group_iterator((cn, idx, stop) => {
+                        if (shared_category === undefined) {
+                            shared_category = cn.category;
+                        } else {
+                            if (cn.category === shared_category) {
+                                // all good
+                            } else {
+                                shared_category = false;
+                                stop();
+                            }
+                        }
+
+                    })
+                }
+                return shared_category;
+                //return child_nodes.length;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+    }
+}
+
+module.exports = JS_AST_Group_Shared;

package/resources/jsbuilder/JS_AST/JS_AST_Node.js

@@ -0,0 +1,94 @@
+// Do more to get the mirrored node structure set up earlier.
+
+const {each} = require('lang-mini');
+const JS_AST_Node_Changing = require('./JS_AST_Node_10-Changing');
+
+const babel_node_tools = require('../babel/babel_node_tools');
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+
+// Possibly able to manage a source babel node and different resultant transformations.
+
+const {
+    deep_iterate_babel_node,
+    get_identifier_names,
+    get_babel_child_nodes,
+    get_require_call
+} = babel_node_tools;
+
+// For the moment, do more concerning getting the basic info.
+//  Don't do the signature system yet - it's too complex when done fully.
+//  Work on getting the info about what is required.
+//   In more of a concice fp way.
+
+
+// A separate Babel mirror structure could make sense.
+//  
+
+// A queries layer as well?
+
+
+// Iterator and generator would be better?
+//  Maybe have it attached to a child_nodes object.
+
+class JS_AST_Node extends JS_AST_Node_Changing {
+
+    // Currently they don't maintain themselves in an equivalent tree, and are very disposable.
+    //  Try it that way for the moment.
+
+    constructor(spec = {}) {
+        super(spec);
+
+        // Usage query would be an interesting one.
+        // Part of a variable declaration - if so, what?
+        // Used as a reference?
+
+        // .used_as_reference
+        // .used_in_declaration
+        //   then what it's value gets set to
+
+        // Analysis of the identifiers used in the code will provide a major way to track what comes from where.
+
+
+        let usage;
+
+        const determine_usage = () => {
+            if (this.type === 'Identifier') {
+                
+            } else {
+                throw 'NYI';
+            }
+
+        }
+
+        Object.defineProperty(this, 'usage', {
+            get() { 
+                if (!usage) usage = determine_usage();
+                //if (deep_type_signature) return deep_type_signature;
+                return usage;
+                
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+
+
+    }
+    [inspect]() {
+        // Need the inner part...
+        //console.log('this.dimensions', this.dimensions);
+        //return 'JS_AST_Node(' + this.type_signature + ')';
+        return this.type_signature;
+    }
+    
+}
+
+JS_AST_Node.from_babel_node = (spec) => {
+    return new JS_AST_Node(spec);
+}
+
+JS_AST_Node.from_spec = spec => {
+    return new JS_AST_Node(spec);
+}
+module.exports = JS_AST_Node;

package/resources/jsbuilder/JS_AST/JS_AST_Node_0-Core.js

@@ -0,0 +1,228 @@
+const {each} = require('lang-mini');
+
+class JS_AST_Node_Core {
+    constructor(spec = {}) {
+
+        // When constructered, and given source, is root, and does not already have a babel node in the spec, will parse the source with the babel parser.
+        //  
+
+        // Depth
+        // Path
+
+        // Source
+        let root_node, parent_node, sibling_index;
+        const child_nodes = [];
+
+        let depth, path;
+        let full_source; // only for the root.
+
+        //console.log('JS_AST_Node_Core Object.keys(spec)', Object.keys(spec));
+
+        if (spec.root_node) {
+            if (spec.root_node === true) {
+                root_node = this;
+            } else {
+                root_node = spec.root_node;
+            }
+        }
+        if (spec.parent_node) {
+            parent_node = spec.parent_node;
+        }
+        if (typeof spec.sibling_index === 'number') {
+            sibling_index = spec.sibling_index;
+        }
+
+        if (!parent_node) {
+            root_node = this;
+        }
+
+        if (root_node === this) {
+            if (spec.source) {
+                full_source = spec.source;
+            }
+        }
+
+
+        const idx_named_nodes = {};
+
+        const get_arr_named_node = (name) => {
+            idx_named_nodes[name] = idx_named_nodes[name] || [];
+            return idx_named_nodes[name];
+        }
+
+        const index_named_node = (name, node) => get_arr_named_node(name).push(node);
+        
+        
+
+        let next_sibling_node, previous_sibling_node;
+
+
+
+        Object.defineProperty(this, 'source', {
+            get() { 
+                //console.log('full_source', full_source);
+                if (full_source) {
+                    return full_source;
+                } else {
+                    if (this.root_node && this.root_node !== this) {
+                        const rn = this.root_node;
+
+                        const {babel} = this;
+                        if (babel) {
+                            const {start, end} = babel;
+                            const full_source = this.root_node.source;
+                            //console.log('full_source', full_source);
+                            return full_source.substring(start, end);
+                        }
+                    }
+                }
+
+                //return source;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        if (typeof spec.depth === 'number') {
+            depth = spec.depth;
+            
+        } else {
+            depth = 0;
+        }
+        if (typeof spec.path === 'string') {
+            path = spec.path;
+        } else {
+            path = '/';
+        }
+
+        this.append_child = (js_ast_node) => {
+            child_nodes.push(js_ast_node);
+        }
+        this.create_append_child = (spec) => {
+            const spec2 = {
+                babel_node: spec.babel_node,
+                parent_node: this,
+                root_node: this.root_node,
+                path: spec.path
+            }
+
+            //const res = new this.constructor(spec2);
+            // a from_spec function could load up specific subtypes.
+
+            const res = this.constructor.from_spec(spec2);
+            //console.log('');
+            //console.log('create_append_child res.path', res.path);
+            //console.log('create_append_child res.type', res.type);
+            this.append_child(res);
+            return res;
+        }
+
+        Object.defineProperty(this, 'parent_node', {
+            get() { 
+                return parent_node;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        Object.defineProperty(this, 'root_node', {
+            get() { 
+                return root_node;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'is_root', {
+            get() { 
+                return root_node === this;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        Object.defineProperty(this, 'child_nodes', {
+            get() { 
+                return child_nodes;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'depth', {
+            get() { 
+                return depth;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'path', {
+            get() { 
+                return path;
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        const deep_iterate_INNER = (depth, path, common, callback) => {
+            const {max_depth, stop} = common;
+            let sibling_number = 0;
+
+            callback(this, path, depth, stop);
+            //console.log('max_depth', max_depth);
+
+            //console.log('child_nodes', child_nodes);
+            //console.log('child_nodes.length', child_nodes.length);
+
+            if (child_nodes.length > 0 && max_depth === undefined || max_depth === false || depth <= max_depth) {
+                each(child_nodes, child_node => {
+                    //console.log('child_node', child_node);
+                    child_node.deep_iterate_INNER(depth + 1, path + sibling_number++ + '/', common, callback);
+                });
+            }
+        }
+
+        const deep_iterate = (max_depth, callback) => {
+            if (!callback && typeof max_depth === 'function') {
+                callback = max_depth;
+                max_depth = undefined;
+            }
+
+            const common = {
+                max_depth: max_depth,
+                stopped: false,
+                stop: () => {
+                    common.stopped = true;
+                }
+            }
+
+            
+
+            deep_iterate_INNER(depth, path, common, callback);
+        }
+        this.deep_iterate_INNER = deep_iterate_INNER;
+        this.deep_iterate = deep_iterate;
+
+        // Moved down from Query - these are the basics, makes sense in core???
+
+        const each_child_node = callback => each(this.child_nodes, callback);
+
+        const filter_each_child_node = (filter, callback) => each_child_node(js_ast_node => {
+            if (filter(js_ast_node)) {
+                callback(js_ast_node);
+            }
+        });
+
+        this.each_child_node = each_child_node;
+        this.filter_each_child_node = filter_each_child_node;
+
+        
+
+    }
+}
+
+JS_AST_Node_Core.from_spec = spec => {
+    return new JS_AST_Node_Core(spec);
+}
+
+// from_string?
+
+module.exports = JS_AST_Node_Core;