jsgui3-server 0.0.75 → 0.0.79

package/resources/jsbuilder/JS_AST/JS_AST_Node_8-Features.js

@@ -0,0 +1,65 @@
+//const babel_node_tools = require('../babel/babel_node_tools');
+
+//const { each } = require('lang-mini');
+const JS_AST_Node_Query = require('./JS_AST_Node_7-Query');
+
+
+
+
+
+
+
+
+
+class JS_AST_Node_Features extends JS_AST_Node_Query {
+    constructor(spec = {}) {
+        super(spec);
+        // Getting the assigned values also seems important.
+        // Possibly will be made into some kind of autoquery? Or may be better to do queries lazily, and store the results.
+        
+        // Declared Object features inside a node.
+
+        // If a node 'features' declared objects, then the syntax in which they are declared is not so important.
+        //  This is an abstraction level above that.
+
+        // Want to keep it faitrly generic at this stage
+        //  Will do more with root node interpretation for the moment I expect.
+        //  First priority is to get everything linking together properly in an output file.
+        //  
+        const arr_features_declared_object = [];
+        const features = [];
+        const map_arr_features_by_feature_name = {
+            
+        }
+        Object.defineProperty(this, 'features', {
+            get() { 
+                //if (!features) {
+                //    features = [];
+                //}
+                return features;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        // get literal names
+        //  or is it value
+
+        // // Assignment Feature?
+
+
+        // Document features make the most sense to work on from the API point of view.
+        //  Or root node features really.
+
+        // Will try loading up and querying an interpreted root node.
+        //  Or jsgui root node interpreted?
+        // Even with that Object.assign trick, we can make it aware, keep that in the general purpose code.
+
+
+        // The imports and exports features are important for linking together the documents.
+        
+    }
+}
+
+module.exports = JS_AST_Node_Features;

package/resources/jsbuilder/JS_AST/JS_AST_Node_9-Planning.js

@@ -0,0 +1,32 @@
+const JS_AST_Node_Index = require('./JS_AST_Node_8-Features');
+
+class JS_AST_Node_Planning extends JS_AST_Node_Index {
+    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.
+
+        // plan_variable_name_remapping
+
+        // Will be fastest to carry out multiple changes at once in one iteration.
+        //  May use quite standard babel transform syntax once I have the changes arranged in a nice object that makes them clear.
+
+        // Set up more ctrl-alt-\ then a letter remappings.
+        //  Can use that to quickly type a varierty of snippets.
+
+        
+        
+
+    }
+    plan_variable_name_remapping() {
+        this.each_inner_declaration_declarator_identifier()
+    }
+}
+
+module.exports = JS_AST_Node_Planning;

package/resources/jsbuilder/JS_AST/JS_AST_Node_Arrangement.js

@@ -0,0 +1,15 @@
+// A way / structure in which JS_AST_Node objects are arranged.
+
+//  Specifying conditions on the item and on the parents.
+
+// A feature could use different optional arrangements.
+
+// Getting more out of syntax matching with trees and signatures would be of use.
+
+// Arrangement of nodes
+
+// Maybe do this work on it later on.
+//  It gets into some further objects and algorithms involving trees.
+
+
+

package/resources/jsbuilder/JS_AST/JS_AST_Node_Feature/JS_AST_Node_Declared_Object.js

@@ -0,0 +1,306 @@
+const JS_AST_Node_Feature = require('./JS_AST_Node_Feature');
+
+// Maybe getting this working will be best done with focused attention on separate declaration statements.
+//  Definitely want this to be a powerful abstraction, well defined in what it does.
+
+// It will need flexibility and complexity to bridge the gap between declaration syntax in js, and what is in abstract theory a declared programmatic object, which in this
+//  case will be linked to the the ast nodes.
+
+// The declared object abstraction will be used on a higher level still.
+//  In projects it will be used to understand what is referred to in the input to a module, as that module / file gets imported / loaded into the project.
+
+
+
+
+
+
+class JS_AST_Node_Declared_Object extends JS_AST_Node_Feature {
+    constructor(spec = {}) {
+
+        //console.log('JS_AST_Node_Declared_Object constructor');
+        //console.log('Object.keys(spec)', Object.keys(spec));
+
+
+        spec.type = 'DeclaredObject';
+        super(spec);
+
+        const {js_ast_node, index_in_js_ast_node} = this;
+
+
+        /*
+        let js_ast_node_value;
+
+        Object.defineProperty(this, 'js_ast_node_value', {
+            get() {
+                return js_ast_node_value;
+            },
+            set(v) { js_ast_node_value = v; },
+            enumerable: true,
+            configurable: false
+        });
+        */
+
+
+        if (js_ast_node) {
+
+            //console.log('js_ast_node', js_ast_node);
+
+            // go through it, extracting the declarators.
+
+            const have_vdr = vdr => {
+
+                if (vdr.type === 'VariableDeclarator') {
+
+                    if (vdr.child_nodes.length === 2) {
+                        const [id, exp_or_lit] = vdr.child_nodes;
+                        if (id.type === 'Identifier') {
+                            //console.log('exp_or_lit', exp_or_lit);
+                            //console.log('exp_or_lit.is_literal', exp_or_lit.is_literal);
+                            if (exp_or_lit.is_expression || exp_or_lit.is_literal) {
+
+                                this.name = id.name;
+                                this.js_ast_node_value = exp_or_lit;
+
+                                //throw 'NYI';
+                            } else {
+
+                                if (exp_or_lit.type === 'Identifier') {
+                                    // it's being set by reference using another identifier.
+
+                                    const id2 = exp_or_lit;
+
+                                    this.name = id.name;
+                                    this.value_name = id2.name;
+
+                                } else {
+                                    throw 'stop';
+                                }
+
+                                // It's OK if it's an identifier.
+
+                                //  Not so sure though.
+                                //console.log('js_ast_node.source', js_ast_node.source);
+                                //console.log('vdr', vdr);
+
+                                //throw 'stop';
+                            }
+
+                        } else {
+                            throw 'stop';
+                        }
+                    } else {
+
+                        //console.log('vdr.child_nodes.length', vdr.child_nodes.length);
+                        //console.log('vdr.child_nodes', vdr.child_nodes);
+
+                        if (vdr.child_nodes.length === 1) {
+                            const id = vdr.child_nodes[0];
+                            if (id.type === 'Identifier') {
+                                this.name = id.name;
+                            } else {
+                                throw 'stop';
+                            }
+                        } else {
+                            throw 'stop';
+                        }
+
+                        //throw 'stop';
+                    }
+
+                    //const [id, ]
+
+                    
+                } else {
+
+
+
+                    throw 'stop';
+                }
+            }
+
+            if (js_ast_node.child_nodes.length === 1) {
+
+                const vdr = js_ast_node.child_nodes[0];
+
+                if (vdr.type === 'VariableDeclarator') {
+                    //console.log('vdr', vdr);
+                    have_vdr(vdr);
+                } else {
+
+                    if (vdr.type === 'Identifier') {
+                        const id = vdr;
+                        //console.log('js_ast_node.source', js_ast_node.source);
+                        //console.log('id', id);
+                        //console.log('id.name', id.name);
+
+                        this.name = id.name;
+
+                        //throw 'stop';
+                    } else {
+                        throw 'stop';
+                    }
+                }
+                
+            } else {
+
+                //console.log('index_in_js_ast_node', index_in_js_ast_node);
+                const vdr = js_ast_node.child_nodes[index_in_js_ast_node];
+                have_vdr(vdr);
+
+                //throw 'NYI';
+            }
+        }
+        // .object_name
+        // .referenced_node (often the object is set after the =)
+        //   cases like if it is a function call result.
+        //let referenced_node;
+        
+    }
+}
+
+JS_AST_Node_Declared_Object.arr_from_js_ast_node = (js_ast_node) => {
+    // An ast node can have multiple items defined within it.
+
+    // consider 'let a;' where the value does not get set.
+    //  it is still declared. just does not have a value / value is undefined.
+
+
+    if (js_ast_node.type === 'ClassDeclaration') {
+        return [new JS_AST_Node_Declared_Object({
+            js_ast_node: js_ast_node
+        })];
+    } else if (js_ast_node.type === 'VariableDeclaration') {
+        //
+
+        // Can have multiple declarators.
+        //  Interested in getting each of them.
+        //   But the array deconstruction case? Object deconstrucion?
+        //    May need to do separate work on testing ast_node features.
+        //     Features are a higher level abstraction.
+        //      They will need to be able to handle different syntax for the same feature.
+
+        // These declared objects will themselves be usable as units.
+        //  We will have the inner ast for what it's been declared as.
+        //   Ability to look up references? May be better outside of here, at least for the moment.
+        const res = [];
+
+
+
+        if (js_ast_node.child_nodes.length === 1) {
+            const vdr = js_ast_node.child_nodes[0];
+            if (vdr.type === 'VariableDeclarator') {
+
+                if (vdr.child_nodes.length === 2) {
+                    const id = vdr.child_nodes[0];
+                    if (id.type === 'Identifier') {
+                        //console.log('id.name', id.name);
+                        const fdec = new JS_AST_Node_Declared_Object({
+                            js_ast_node: js_ast_node
+                        })
+                        res.push(fdec);
+                    } else {
+                        throw 'stop';
+                    }
+                } else {
+                    throw 'stop';
+                }
+
+
+                //throw 'nyi stop';
+            } else {
+                console.log('js_ast_node.child_nodes.length', js_ast_node.child_nodes.length);
+                throw 'stop';
+            }
+        } else {
+            //console.log('js_ast_node.source', js_ast_node.source);
+            let index = 0;
+            js_ast_node.each.child(vdr => {
+                if (vdr.type === 'VariableDeclarator') {
+                    if (vdr.child_nodes.length === 1) {
+                        // just the identifier, no value set.
+                        const id = vdr.child_nodes[0];
+                        if (id.type === 'Identifier') {
+                            const fdec = new JS_AST_Node_Declared_Object({
+                                js_ast_node: js_ast_node,
+                                index_in_js_ast_node: index
+                            });
+                            res.push(fdec);
+                        } else {
+                            throw 'stop';
+                        }
+
+                    } else {
+                        //console.log('vdr', vdr);
+
+                        // a var declarator can have both the id as well as the object expression.
+                        //  or presumably any other expression.
+
+                        if (vdr.child_nodes.length === 2) {
+
+                            const [id, exp] = vdr.child_nodes;
+
+
+
+                            if (id.type === 'Identifier') {
+                                if (exp.is_expression) {
+                                    const fdec = new JS_AST_Node_Declared_Object({
+                                        js_ast_node: js_ast_node,
+                                        index_in_js_ast_node: index
+                                    });
+                                    res.push(fdec);
+                                } else {
+                                    // could be an identifier.
+                                    //  presumably could be a boolean expression too.
+
+                                    if (exp.type === 'Identifier') {
+                                        const id2 = exp;
+                                        const fdec = new JS_AST_Node_Declared_Object({
+                                            js_ast_node: js_ast_node,
+                                            index_in_js_ast_node: index
+                                        });
+                                        res.push(fdec);
+                                    } else {
+                                        throw 'stop';
+                                    }
+
+
+                                    
+                                }
+
+                            } else {
+                                throw 'stop';
+                            }
+                        } else {
+                            throw 'stop';
+                        }
+
+                        //throw 'NYI';
+                    }
+
+                } else {
+                    throw 'stop';
+                }
+                index++;
+            })
+
+            //throw 'NYI';
+        }
+        return res;
+
+
+
+
+
+
+        //if ()
+
+        
+        
+
+    } else {
+        throw 'stop';
+    }
+
+}
+
+module.exports = JS_AST_Node_Declared_Object;

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

@@ -0,0 +1,78 @@
+class JS_AST_Node_Feature {
+
+    // Feature_Declaration subclass too?
+    //  
+
+
+    constructor(spec = {}) {
+        //let name, type;
+
+        let node, value_name;
+
+        if (spec.name) {
+            name = spec.name;
+        }
+        //if (spec.type) {
+        //    type = spec.type;
+        //}
+
+        if (spec.js_ast_node) { //check / confirm type?
+            node = spec.js_ast_node;
+        } else if (spec.node) { //check / confirm type?
+            node = spec.node;
+        }
+
+        /*
+        if (spec.index_in_js_ast_node !== undefined) {
+            index_in_node = spec.index_in_js_ast_node;
+        } else if (spec.index_in_node !== undefined) {
+            index_in_node = spec.index_in_node;
+        }
+        */
+
+        /*
+        Object.defineProperty(this, 'name', {
+            get() {
+                return name;
+            },
+            set(v) { name = v; },
+            enumerable: true,
+            configurable: false
+        });
+        */
+
+        /*
+        Object.defineProperty(this, 'value_name', {
+            get() {
+                return value_name;
+            },
+            set(v) { value_name = v; },
+            enumerable: true,
+            configurable: false
+        });
+        */
+        Object.defineProperty(this, 'node', {
+            get() { 
+                return node;
+            },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        // Maybe don't need this, with improved sibling and index property in the node itself.
+
+        /*
+        Object.defineProperty(this, 'index_in_node', {
+            get() { 
+                return index_in_js_ast_node;
+            },
+            set(v) { index_in_js_ast_node = v; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+        */
+    }
+}
+module.exports = JS_AST_Node_Feature;