jsgui3-server 0.0.75 → 0.0.79

package/resources/jsbuilder/JS_AST/JS_AST_Node_1-Babel.js

@@ -0,0 +1,338 @@
+const babel_node_tools = require('../babel/babel_node_tools');
+const {each} = require('lang-mini');
+const {deep_iterate_babel_node} = babel_node_tools;
+const parser = require('@babel/parser');
+const JS_AST_Node_Core = require('./JS_AST_Node_0-Core');
+const { resolvePlugin } = require('@babel/core');
+
+const {type_abbreviations, map_expression_categories, map_literal_categories, map_statement_categories, map_categories} = require('../babel/babel_consts');
+/*
+
+module.exports = {
+    type_abbreviations: type_abbreviations,
+    map_expression_categories: map_expression_categories,
+    map_literal_categories: map_literal_categories,
+    map_categories: map_categories
+}
+
+*/
+
+const get_category = (type) => {
+
+    const res = map_categories[type];
+    if (!res) {
+        console.log('type');
+        throw 'NYI';
+    }
+    return res;
+
+
+    // Literal
+
+    // Declaration
+
+    // Declarator
+
+    // Expression
+
+    // Statement
+
+    // Pattern
+
+    // Identifier - Seem not to fit a category, or be one of its own.
+}
+class JS_AST_Node_Babel extends JS_AST_Node_Core {
+    constructor(spec = {}) {
+        super(spec);
+        // sets the childnodes here.
+        //  will also make available the relevant bable properties.
+        // .babel.type
+        let babel_ast; // only for the root node. A root node of JS_AST can have a babel as
+        let babel_node, babel_node_file, babel_node_program;
+        const babel = {
+            // Maybe a parse function here.
+            //  and a .parsed property.
+        }
+        if (spec.babel_node) {
+            babel_node = babel.node = spec.babel_node;
+            // Then it needs to parse it within its own system.
+            //  
+            //const {type} = babel_node;
+            //console.log('type', type);
+            // Don't do this automatically here.
+            //
+            // Iterate through the babel node, building a structure that mirrors it and links back to it.
+        }
+
+        const filter_deep_iterate_babel_node = (babel_node, fn_filter, callback) => deep_iterate_babel_node(babel_node, (bn, path, depth) => fn_filter(bn) ? callback(bn, path, depth) : undefined)
+        const inner_deep_iterate_babel_node = (babel_node, callback) => filter_deep_iterate_babel_node(babel_node, bn => bn !== babel_node, callback)
+
+        const get_parent_path = path => {
+            let res = path.split('/');
+            let res2 = res.slice(0, res.length - 2);
+            return res2.join('/') + '/';
+        }
+
+        /*
+        const get_babel_node_child_nodes = (babel_node) => {
+            const {type} = babel_node;
+            if (type === 'VariableDeclaration') {
+                return babel_node.declarations;
+            } else if (type === 'VariableDeclarator') {
+                return [babel_node.id, babel_node.init];
+            } else if (type === 'Identifier') {
+                return [];
+            } else if (type === 'NumericLiteral') {
+                return [];
+            } else if (type === 'ArrayExpression') {
+                return babel_node.elements;
+            } else {
+                console.log('type', type);
+                throw 'NYI';
+            }
+        }
+        */
+
+
+        const load_mirror_structure = () => {
+            if (this.root_node === this) {
+                const map_nodes_by_path = {};
+                const map_babel_nodes_by_path = {};
+                const map_js_ast_nodes_by_path = {
+                    '/': this
+                };
+                deep_iterate_babel_node(babel_node, (inner_babel_node, path, depth, stop) => {
+                    //console.log('node.name', node.id?.name);
+                    //console.log('depth', depth);
+
+                    if (babel_node === inner_babel_node) {
+                        //throw 'stop';
+                    } else {
+                        //console.log('1) path', path);
+                        //console.log('babel_node.type', babel_node.type);
+                        const parent_path = get_parent_path(path);
+                        //console.log('parent_path', parent_path);
+                        map_babel_nodes_by_path[path] = inner_babel_node;
+                        const parent_babel_node = map_babel_nodes_by_path[parent_path];
+                        const parent_js_ast_node = map_js_ast_nodes_by_path[parent_path];
+                        const new_node = parent_js_ast_node.create_append_child({
+                            babel_node: inner_babel_node,
+                            path: path
+                        });
+                        map_js_ast_nodes_by_path[path] = new_node;
+                    }
+                })
+            } else {
+                throw 'stop';
+            }
+        }
+
+        Object.defineProperty(this, 'babel', {
+
+
+            get() { 
+                //console.log('babel object requested');
+                return babel; 
+            },
+            enumerable: true,
+            configurable: false
+        });
+        
+        //if (spec.full_source) {
+        //    full_source = spec.full_source;
+        //}
+        
+        
+
+        // Abbreviated_type....
+
+        
+
+        //const 
+
+        // May use something (new) from lang-mini or lang-tools to parse the tree easily.
+        //  Signature_Tree object. Will be abstract in that it's not closely integrated with the AST tree functionality, could be reused elsewhere.
+
+
+        
+
+        Object.defineProperty(babel, 'start', {
+            get() { return babel_node.start; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(babel, 'end', {
+            get() { return babel_node.end; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(babel, 'name', {
+            get() { return babel_node.name; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: true
+        });
+
+
+        // only for identifiers.
+
+        
+
+        Object.defineProperty(babel, 'node', {
+            get() { 
+                return babel_node; 
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(babel, 'type', {
+            get() { 
+                //console.log('babel', babel);
+                //console.log('babel_node', babel_node);
+                //console.log('babel.node', babel.node);
+                return babel_node.type; 
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        //let category;
+        Object.defineProperty(babel, 'category', {
+            get() { 
+                //console.log('babel', babel);
+                //console.log('babel_node', babel_node);
+                //console.log('babel.node', babel.node);
+                //category = ;
+                return get_category(babel_node.type); 
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        
+
+        Object.defineProperty(babel, 'is_identifier', {
+            get() { 
+                return babel.type === 'Identifier';
+            },
+            enumerable: true,
+            configurable: false
+        });
+
+        Object.defineProperty(babel, 'is_declaration', {
+            get() { 
+                return babel.type === 'VariableDeclaration' || babel.type === 'ClassDeclaration';
+            },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(babel, 'is_expression', {
+            get() { 
+                return !!map_expression_categories[babel.type];
+            },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(babel, 'is_statement', {
+            get() { 
+                return !!map_statement_categories[babel.type];
+            },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(babel, 'is_literal', {
+            get() { 
+                return !!map_literal_categories[babel.type];
+            },
+            enumerable: true,
+            configurable: false
+        });
+        
+        
+        
+        
+        
+        Object.defineProperty(babel, 'ast', {
+            get() { 
+
+                if (this.root === this) {
+
+                } else {
+                    // will return undefined, for the moment
+                }
+            },
+            set(val) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        if (this.root_node === this) {
+
+            //console.log('babel_node', babel_node);
+
+            if (!babel_node) {
+                const {source} = this;
+                //console.log('source', source);
+                const babel_ast = parser.parse(source, {
+                    sourceType: 'module',
+                    plugins: [
+                        'asyncGenerators',
+                        'bigInt',
+                        'classPrivateMethods',
+                        'classPrivateProperties',
+                        'classProperties',
+                        'doExpressions',
+                        //'exportDefaultFrom',
+                        'nullishCoalescingOperator',
+                        'numericSeparator',
+                        'objectRestSpread',
+                        'optionalCatchBinding',
+                        'optionalChaining',
+                    ]});
+
+                //console.log('babel_ast', babel_ast);
+
+                babel_node_file = babel_ast;
+                babel_node_program = babel_ast.program;
+
+                //console.log('babel_node_program', babel_node_program);
+
+                const {body} = babel_node_program;
+
+                if (body.length === 1) {
+                    const node0 = body[0];
+
+                    babel_node = node0;
+                } else {
+                    throw 'NYI';
+                }
+                //throw 'stop';
+            }
+            //throw 'stop';
+            if (babel_node) {
+                //console.log('1) babel_node', babel_node);
+                const {type} = babel_node;
+                //if (true || type === 'File') {
+                load_mirror_structure({
+                    root_node: this.root_node
+                });
+                //}
+            } else {
+    
+                
+            }
+            
+        }
+        
+    }
+}
+JS_AST_Node_Babel.from_babel_node = (spec) => {
+    return new JS_AST_Node_Babel(spec);
+}
+
+
+module.exports = JS_AST_Node_Babel;

package/resources/jsbuilder/JS_AST/JS_AST_Node_10-Changing.js

@@ -0,0 +1,40 @@
+
+// Coming up with a new version based on the plan.
+//  Want to hold the compressed version. Hold a reference to the new version which has has the compression run.
+
+const JS_AST_Node_Planning = require('./JS_AST_Node_9-Planning');
+
+class JS_AST_Node_Changing extends JS_AST_Node_Planning {
+    constructor(spec = {}) {
+        super(spec);
+
+        // sets the childnodes here.
+        //  will also make available the relevant bable properties.
+
+        // Use the lower level tools to kind of understand the node.
+        //  Provide property getters that will do this.
+
+        // Seeing what pattern / recognised object / pattern it is.
+
+        let compressed_version;
+
+        const get_compressed_version = () => {
+            // Compress the inner local variables.
+            //  
+
+            // Will compare original and compressed source.
+        }
+
+        Object.defineProperty(this, 'compressed_version', {
+            get() { 
+                if (!compressed_version) compressed_version = get_compressed_version();
+                return compressed_version;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+    }
+}
+
+module.exports = JS_AST_Node_Changing;

package/resources/jsbuilder/JS_AST/JS_AST_Node_2.1.1-Child.js

@@ -0,0 +1,97 @@
+
+
+const JS_AST_Node_Basics_Babel = require('./JS_AST_Node_1-Babel');
+
+const JS_AST_Relationship_Node_To_Group = require('./JS_AST_Relationship_Node_To_Group');
+
+const JS_AST_Group_Shared = require('./JS_AST_Group_Shared');
+
+class JS_AST_Node_Child extends JS_AST_Node_Basics_Babel {
+    constructor(spec = {}) {
+        super(spec);
+        const {each_child_node} = this;
+
+        const select_child_nodes = fn_select => {
+            const res = [];
+            filter_each_child_node(fn_select, cn => res.push(cn));
+            return res;
+        }
+
+        // Make it a Relationship_Group.
+        // Node_To_Group_Relationship
+
+        // JS_AST_Relationship_Node_To_Group
+
+        const child = new JS_AST_Relationship_Node_To_Group({
+            origin: this,
+            name: 'child'//,
+            //obtainer: () => this.child_nodes,
+            //iterator: callback => each(this.child_nodes, callback),
+            //each: callback => each(this.child_nodes, callback)//,
+            //select: fn_select => select_child_nodes(fn_select)
+        });
+
+        // Group properties....
+
+        /*
+        let child_shared_type;
+
+        // Could benefit from making some kind of group shared class
+        //  so the shared type property definition would work on multiple different groups.
+        //  as would a find function.
+
+
+
+
+        //child.shared = {
+            
+        //}
+
+        Object.defineProperty(child.shared, 'type', {
+            get() { 
+                if (child_shared_type === undefined) {
+                    each_child_node((cn, idx, stop) => {
+                        if (child_shared_type === undefined) {
+                            child_shared_type = cn.type;
+                        } else {
+                            if (cn.type === child_shared_type) {
+                                // all good
+                            } else {
+                                child_shared_type = false;
+                                stop();
+                            }
+                        }
+
+                    })
+                }
+                return child_shared_type;
+                //return child_nodes.length;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        */
+
+
+        /*
+        const find_child_node = (finder, callback) => {
+            let res;
+            each_child_node((cn, idx, stop) => {
+                if (finder(cn)) {
+                    res = cn;
+                    stop();
+                }
+            });
+            return res;
+        }
+        */
+
+
+        
+        let arr_child_types;
+        let arr_child_categories;
+        this.child = child;
+    }
+}
+
+module.exports = JS_AST_Node_Child

package/resources/jsbuilder/JS_AST/JS_AST_Node_2.1.2-Parent.js

@@ -0,0 +1,38 @@
+
+
+const JS_AST_Node_Basics_Child = require('./JS_AST_Node_2.1.1-Child');
+
+const JS_AST_Relationship_Node_Within_Group_To_Node = require('./JS_AST_Relationship_Node_Within_Group_To_Node');
+
+class JS_AST_Node_Parent extends JS_AST_Node_Basics_Child {
+    constructor(spec = {}) {
+        super(spec);
+        const {each_inner_node} = this;
+
+
+        // Make it a Relationship_Group.
+        // Node_To_Group_Relationship
+
+        // JS_AST_Relationship_Node_To_Group
+
+        // Do we have the index within parent?
+        //  Could change the construction algo lower down so it's given - it's useful.
+        
+
+        const parent = new JS_AST_Relationship_Node_Within_Group_To_Node({
+            origin: this,
+            name: 'parent',
+            node: this.parent_node
+            //obtainer: () => this.child_nodes,
+            //iterator: callback => each(this.child_nodes, callback),
+            //each: callback => each(this.child_nodes, callback)//,
+            //select: fn_select => select_child_nodes(fn_select)
+        });
+
+        // Group properties....
+
+        this.parent = parent;
+    }
+}
+
+module.exports = JS_AST_Node_Parent

package/resources/jsbuilder/JS_AST/JS_AST_Node_2.1.3-Ancestor.js

@@ -0,0 +1,62 @@
+
+
+const JS_AST_Node_Basics_Parent = require('./JS_AST_Node_2.1.2-Parent');
+
+const JS_AST_Relationship_Node_To_Group = require('./JS_AST_Relationship_Node_To_Group');
+
+class JS_AST_Node_Ancestor extends JS_AST_Node_Basics_Parent {
+    constructor(spec = {}) {
+        super(spec);
+        const {each_inner_node} = this;
+
+
+        // Make it a Relationship_Group.
+        // Node_To_Group_Relationship
+
+        // JS_AST_Relationship_Node_To_Group
+
+        // index (of ancestors)
+
+        const ancestor = new JS_AST_Relationship_Node_To_Group({
+            origin: this,
+            name: 'ancestor'//,
+            //obtainer: () => this.child_nodes,
+            //iterator: callback => each(this.child_nodes, callback),
+            //each: callback => each(this.child_nodes, callback)//,
+            //select: fn_select => select_child_nodes(fn_select)
+        });
+
+        // Group properties....
+
+
+        const parent = this.parent;
+        let gparent, ggparent;
+        if (parent.node) {
+            gparent = parent.node.parent;
+            if (gparent && gparent.node) {
+                ggparent = gparent.node.parent;
+            }
+
+        }
+        
+        
+        
+         
+
+
+        
+
+        Object.assign(this, {
+            ancestor: ancestor,
+            gparent: gparent,
+            ggparent: ggparent
+        });
+        
+
+        this.ancestor = ancestor;
+        this.gparent = gparent;
+        this.ggparent = ggparent;
+    }
+}
+
+module.exports = JS_AST_Node_Ancestor

package/resources/jsbuilder/JS_AST/JS_AST_Node_2.2-Inner.js

@@ -0,0 +1,44 @@
+
+
+const JS_AST_Node_Ancestor = require('./JS_AST_Node_2.1.3-Ancestor');
+
+const JS_AST_Relationship_Node_To_Group = require('./JS_AST_Relationship_Node_To_Group');
+
+class JS_AST_Node_Inner extends JS_AST_Node_Ancestor {
+    constructor(spec = {}) {
+        super(spec);
+        const {each_inner_node} = this;
+
+
+        // Make it a Relationship_Group.
+        // Node_To_Group_Relationship
+
+        // JS_AST_Relationship_Node_To_Group
+
+        const inner = new JS_AST_Relationship_Node_To_Group({
+            origin: this,
+            name: 'inner'//,
+            //obtainer: () => this.child_nodes,
+            //iterator: callback => each(this.child_nodes, callback),
+            //each: callback => each(this.child_nodes, callback)//,
+            //select: fn_select => select_child_nodes(fn_select)
+        });
+
+        // Group properties....
+
+        // Make a shared property class?
+        //  Group_Shared_Properties class
+
+
+        // Group_Shared_Property type possibly?
+
+        //inner.shared = {
+            
+        //}
+
+        
+        this.inner = inner;
+    }
+}
+
+module.exports = JS_AST_Node_Inner

package/resources/jsbuilder/JS_AST/JS_AST_Node_2.3-All.js

@@ -0,0 +1,73 @@
+
+
+const JS_AST_Node_Inner = require('./JS_AST_Node_2.2-Inner');
+
+const JS_AST_Relationship_Node_To_Group = require('./JS_AST_Relationship_Node_To_Group');
+
+class JS_AST_Node_All extends JS_AST_Node_Inner {
+    constructor(spec = {}) {
+        super(spec);
+        const {deep_iterate} = this;
+
+
+        // Make it a Relationship_Group.
+        // Node_To_Group_Relationship
+
+        // JS_AST_Relationship_Node_To_Group
+
+        const all = new JS_AST_Relationship_Node_To_Group({
+            origin: this,
+            name: 'all'//,
+            //obtainer: () => this.child_nodes,
+            //iterator: callback => each(this.child_nodes, callback),
+            //each: callback => each(this.child_nodes, callback)//,
+            //select: fn_select => select_child_nodes(fn_select)
+        });
+
+        // Group properties....
+
+        /*
+
+        let all_shared_type;
+
+        // Make a shared property class?
+        //  Group_Shared_Properties class
+
+        // Just a group_shared class for the moment.
+
+
+
+
+        all.shared = {
+            
+        }
+
+        Object.defineProperty(all.shared, 'type', {
+            get() { 
+                if (all_shared_type === undefined) {
+                    deep_iterate((cn, idx, stop) => {
+                        if (all_shared_type === undefined) {
+                            all_shared_type = cn.type;
+                        } else {
+                            if (cn.type === all_shared_type) {
+                                // all good
+                            } else {
+                                all_shared_type = false;
+                                stop();
+                            }
+                        }
+
+                    })
+                }
+                return child_shared_type;
+                //return child_nodes.length;
+            },
+            enumerable: true,
+            configurable: false
+        });
+        */
+        this.all = all;
+    }
+}
+
+module.exports = JS_AST_Node_All