jsgui3-server 0.0.75 → 0.0.77

package/resources/jsbuilder/JS_File/JS_File_4.1-Query_Features.js

@@ -0,0 +1,415 @@
+const {each, tof} = require('lang-mini');
+const JS_File_Query = require('./JS_File_4-Query');
+
+const JS_File_Import_References = require('./JS_File_Import_References');
+
+const JS_File_Exports = require('./Feature/JS_File_Exports');
+const JS_AST_Node_Declared_Object = require('../JS_AST/JS_AST_Node_Feature/JS_AST_Node_Declared_Object');
+//const { default: JS_File_JS_AST_Node } = require('./JS_File_2-JS_AST_Node');
+//const { default: Import_References } = require('./JS_File_Import_References');
+// Will extract relevant AST code functionality. Files often import things at the beginning, then have declarations, then export what was declared at the end.
+
+// Understanding the import declarations so they could be localised.
+//  So we can refer to the ast of them, because we have recognised them elsewhere.
+
+// Can build the functions into a js file.
+// Later on - renaming local variables within a scope. 
+
+// JS_File_Writable too...
+//   .imports = ... or requires
+//   .add_platform?
+
+// Or better to create the platform objects out of the functions which have been comprehended from various files.
+// JS_File_Platform?
+// This will be more about understanding the js file. Basic structure will have already been obtained.
+
+// Maybe a Babel level below?
+
+const log = console.log;
+//const log = () => [];
+
+class JS_File_Query_Features extends JS_File_Query {
+    constructor(spec) {
+        super(spec);
+        
+
+        // Not going to use .features for the moment.
+        //  Will have more properties added to the root node that get the things we are likely looking for.
+
+        
+
+
+
+        const made_obselete = () => {
+
+
+            const features = {}; // external interface
+            const map_arr_features_by_name = {};
+
+            // Querying features on a file level
+
+            // Number of imported variables
+            // Number of exported variables
+            //  If it uses module.exports to do this
+            //   the module.exports statement
+            // Number of declarations in the root of the document.
+
+            // Names of these variables
+            // Each of the variables within a JSGUI_Single_Declaration abstraction.
+
+
+            // Queries specific to a type....
+
+            // root_defined_names
+
+            // the export feature.
+            //  Maybe make a 'feature' object. Won't necessarily correspond with specific syntax.
+
+            // an exports property
+
+            //let feature_export;
+            //let arr_features_declared_object = [];
+
+            const get_declared_object_features = () => {
+                //log('get_declared_object_features');
+                const res = [];
+
+                //console.log('this.body.each', this.body.each);
+                //console.log('this.body.each.child', this.body.each.child);
+
+                this.body.each.child.declaration(node_dec => {
+                    //log('');
+                    //log('node_dec', node_dec);
+                    //log('node_dec.source', node_dec.source);
+
+                    // then get the array of features from each declaration.
+
+                    const node_declared_object_features = JS_AST_Node_Declared_Object.arr_from_js_ast_node(node_dec);
+                    //log('node_declared_object_features.length', node_declared_object_features.length);
+                    each(node_declared_object_features, x => res.push(x));
+
+                })
+
+                //throw 'stop';
+                return res;
+
+            }
+
+            const get_feature_export = () => {
+                //let res;
+
+                log('this.body.type', this.body.type);
+
+                const get_exports_statement = () => {
+                    let res_inner;
+
+                    this.body.each.child.expression_statement(child_es => {
+                        //log('child_es', child_es);
+                        //log('child_es.source', child_es.source);
+        
+                        const ase = child_es.child_nodes[0];
+                        if (ase.t === 'AsE') {
+                            if (ase.child_nodes.length === 2) {
+                                const me = ase.child_nodes[0];
+                                if (me.t === 'ME') {
+                                    // then 2 ids.
+        
+                                    if (me.child_nodes.length === 0);
+                                    const names = [me.child_nodes[0].name, me.child_nodes[1].name];
+        
+                                    if (names[0] === 'module' && names[1] === 'exports') {
+                                        res_inner = child_es;
+                                    }
+                                    //log('names', names);
+                                }
+                            }
+                        }
+                        // 
+                    })
+                    return res_inner;
+                }
+                
+
+                const exports_statement = get_exports_statement();
+                log('get_feature_export exports_statement', exports_statement);
+
+                const res = new JS_File_Exports({
+                    ast_node_exports_statement: exports_statement
+                });
+                // Can return undefined.
+
+                return res;
+            }
+
+            Object.defineProperty(this, 'features', {
+                // Using shorthand method names (ES2015 feature).
+                // This is equivalent to:
+                // get: function() { return bValue; },
+                // set: function(newValue) { bValue = newValue; },
+
+
+                get() { 
+                    return features;
+                },
+                //set(newValue) { bValue = newValue; },
+                enumerable: true,
+                configurable: false
+            });
+            // get_declared_object_features
+
+            Object.defineProperty(features, 'declared_objects', {
+                // Using shorthand method names (ES2015 feature).
+                // This is equivalent to:
+                // get: function() { return bValue; },
+                // set: function(newValue) { bValue = newValue; },
+
+
+                get() { 
+                    if (!map_arr_features_by_name['declared_objects']) {
+                        map_arr_features_by_name['declared_objects'] = get_declared_object_features();
+                    }
+                    return map_arr_features_by_name['declared_objects'];
+                    //return features;
+                },
+                //set(newValue) { bValue = newValue; },
+                enumerable: true,
+                configurable: false
+            });
+
+            // features
+
+            Object.defineProperty(features, 'export', {
+                // Using shorthand method names (ES2015 feature).
+                // This is equivalent to:
+                // get: function() { return bValue; },
+                // set: function(newValue) { bValue = newValue; },
+
+
+                get() { 
+                    if (!map_arr_features_by_name['export']) {
+                        map_arr_features_by_name['export'] = get_feature_export();
+                    }
+                    return map_arr_features_by_name['export'];
+                    //return features;
+                },
+                //set(newValue) { bValue = newValue; },
+                enumerable: true,
+                configurable: false
+            });
+
+            let _exported;
+            let _exported_keys;
+
+            const that = this;
+
+            
+
+            Object.defineProperty(this, 'exported', {
+                // Using shorthand method names (ES2015 feature).
+                // This is equivalent to:
+                // get: function() { return bValue; },
+                // set: function(newValue) { bValue = newValue; },
+
+
+                get() { 
+                    if (_exported === undefined) { // can be false
+                        // will lookup the assignment statement
+
+
+                        throw 'NYI';
+
+
+                        // use the map / index of variable names / usage (incl dotted paths)
+                        //this.body.find()
+
+                        _exported = {
+                            
+                        };
+                        Object.defineProperty(_exported, 'keys', {
+                            get() {
+                                if (_exported_keys === undefined) {
+                                    const jsf = that;
+
+                                    const mdecnames = jsf.body.node.map.declaration.identifier.name;
+                                    log('mdecnames', mdecnames);
+
+                                    log('jsf.features.export', jsf.features.export);
+                                    log('jsf.features.export.name', jsf.features.export.name);
+                                    log('jsf.features.export.exported_object_name', jsf.features.export.exported_object_name);
+
+
+                                    // No longer finds the export declaration as a feature
+
+                                    // Probably will have a query-export section specifically for this.
+
+                                    const export_dec = mdecnames.get(jsf.features.export.exported_object_name);
+                                    log('export_dec', export_dec);
+                                    log('export_dec.source', export_dec.source);
+
+                                    //log('export_dec.collect.child.identifier.name', export_dec.collect.child.identifier.name);
+
+                                    // Or some means to collect keys....
+                                    //log('export_dec.child.count', export_dec.child.count);
+                                    //log('export_dec.child.first.child.count', export_dec.child.first.child.count);
+
+                                    //log('export_dec.child.first.collect.child.type()', export_dec.child.first.collect.child.type());
+                                    //log('export_dec.child.first.collect.child.category()', export_dec.child.first.collect.child.category());
+
+                                    // .collect.type
+
+                                    const cats = export_dec.child.first.collect.child.category();
+                                    const types = export_dec.child.first.collect.child.type();
+
+                                    log('cats', cats);
+                                    log('types', types);
+
+                                    let res = false;
+                                    if (cats[0] === 'Identifier' && cats[1] === 'Expression') {
+                                        const expression = export_dec.child.first.child.last;
+                                        if (types[1] === 'ObjectExpression') {
+                                            log('expression', expression);
+                                            log('expression.child.shared.type', expression.child.shared.type);
+                                            // Reading keys out of an object expression like this would be helpful.
+                                            //log('oe.keys', oe.keys);
+
+                                            if (expression.child.shared.type === 'ObjectProperty') {
+                                                //const keys = oe.child.first.collect.child.last.name;
+                                                const ops = expression.child_nodes;
+
+                                                // can't overwrite the 'name' property of a function, so it seems.
+
+                                                // but not what we want here!!!
+                                                //const keys = oe.collect.child.identifier.str_name();
+                                                //const keys = oe.collect.child.first.value();
+
+                                                // oe.keys
+                                                res = [];
+                                                // have it get a keys property?
+                                                //  consider explanding the API in such ways.
+
+                                                
+                                                expression.filter(n => n.type === 'StringLiteral', n => {
+                                                    //log('n', n);
+                                                    //log('n.source', n.source);
+                                                    res.push(n.source.split('\'').join(''));
+                                                })
+                                                //const keys = ow.collect.literal.value;
+                                                //log('ops', ops);
+
+                                                //log('1) keys', keys);
+                                            } else {
+                                                throw 'stop';
+                                            }
+                                            //oe.each.child
+                                        } else {
+
+                                            if (types[1] === 'NewExpression') {
+                                                console.log('expression', expression);
+
+                                                // Current lang-tools:
+
+                                                // A new Evented_Class gets made.
+                                                //  Then various values get assigned to it.
+
+                                                // Let's deal with the case of a class being made, and then Object.assign used to give it properties.
+                                                //  It is a special case, but part of how jsgui is currently put together.
+                                                //   So the jsgui object itself operates eventfully.
+
+                                                // Maybe put special cases in their own file?
+                                                //  There could be quite a lot of them. Want to allow unusual syntax to be understood so that inventive JS can be built effectively too.
+                                                
+                                                // Special case queries.
+                                                //  Make the special cases operate as JS_AST_Nodes.
+                                                //   The special case instance would check that the node it's attempting to wrap fits in with it's suitability test.
+
+                                                // Knowing when to use a special case...
+                                                //  Could be from signature matching, could be from program logic like this.
+
+                                                // However, the special case may be a feature of the whole file.
+                                                //  May also be considered a feature of the root node.
+
+                                                // Root_Node_Feature
+                                                //  So yes it applies to nodes and uses that architecture. Then it can also be easily be applied to files.
+
+
+
+
+
+
+
+
+                                                
+
+
+
+
+
+
+
+
+
+
+                                            } else {
+                                                throw 'stop';
+                                            }
+
+
+                                            
+                                        }
+
+                                    } else {
+                                        throw 'stop';
+                                    }
+                                    //return res;
+
+                                    _exported_keys = res;
+
+                                    
+
+
+                                }
+                                return _exported_keys;
+                            }
+                        })
+
+
+                        //throw 'stop';
+
+
+                    }
+                    return _exported;
+                    //return features;
+                },
+                //set(newValue) { bValue = newValue; },
+                enumerable: true,
+                configurable: false
+            });
+
+            // An 'exported' object would be useful here.
+
+            // exported keys is the main thing we need to know.
+            //  maybe it's false.
+
+            // such as if it exports a class
+
+            // .exported.class
+
+
+
+
+
+
+        }
+
+        // Exports feature.
+
+        //file.root.find_assignment_by_name('module.exports');
+        
+        
+
+
+
+
+    }
+}
+module.exports = JS_File_Query_Features;

package/resources/jsbuilder/JS_File/JS_File_5-Planning.js

@@ -0,0 +1,59 @@
+const JS_File_Query_Features = require('./JS_File_4.1-Query_Features.js');
+const Variable_Name_Provider = require('../Variable_Name_Provider');
+const { each } = require('lang-mini');
+class JS_File_Planning extends JS_File_Query_Features {
+    constructor(spec) {
+        super(spec);
+
+        // string path of the variable within the ast.
+        //  can use that path to find the position at a later stage.
+        //  Need to keep the planning stage separate for the moment.
+
+        // Want a way to access the paths of the nodes too.
+
+        // (node, path)
+
+        // propose_local_variable_name_remapping
+
+        const get_proposed_root_definitions_inner_name_remappings = this.get_proposed_root_definitions_inner_name_remappings = () => {
+            const res = {};
+            this.each_root_declaration(node => {
+                //console.log('node', node);
+                const idns = node.inner_declaration_names;
+                //throw 'stop';
+
+                if (idns.length > 0) {
+                    //console.log('');
+                    //console.log('node.own_declaration_names', node.own_declaration_names);
+
+                    if (node.own_declaration_names.length === 1) {
+                        const own_name = node.own_declaration_names[0];
+                        //console.log('idns', idns);
+
+                        const l_max = 2;
+
+                        const arr_names_for_shortening = idns.filter(x => x.length > l_max);
+                        //console.log('arr_names_for_shortening', arr_names_for_shortening);
+
+                        if (arr_names_for_shortening.length > 0) {
+                            const namer = new Variable_Name_Provider();
+                            const map_renames = {};
+                            each(arr_names_for_shortening, name => {
+                                const new_name = namer.get_l();
+                                map_renames[name] = new_name;
+                            });
+                            //console.log('map_renames', map_renames);
+                            res[own_name] = map_renames;
+                        }
+                    } else {
+                        console.log('node', node);
+                        throw 'stop';
+                    }
+                }
+            });
+            return res;
+        }
+    }
+}
+
+module.exports = JS_File_Planning;

package/resources/jsbuilder/JS_File/JS_File_6-Changing.js

@@ -0,0 +1,24 @@
+const JS_File_Planning = require('./JS_File_5-Planning');
+const Variable_Name_Provider = require('../Variable_Name_Provider');
+const { each } = require('lang-mini');
+
+const {transform} = require("@babel/core");
+// import { transform } from "@babel/core";
+const generate = require("@babel/generator").default;
+//import generate from "@babel/generator";
+//console.log('generate', generate);
+//throw 'stop';
+
+class JS_File_Changing extends JS_File_Planning {
+    constructor(spec) {
+        super(spec);
+
+        
+
+    }
+}
+JS_File_Changing.load_from_stream = (rs, path) => {
+    const res = new JS_File_Changing({rs: rs, path: path});
+    return res;
+}
+module.exports = JS_File_Changing;

package/resources/jsbuilder/JS_File/JS_File_Export_Reference.js

@@ -0,0 +1,12 @@
+
+// Has to be a single object.
+//  But that single object can be expressed inline too.
+//   Shouldn't be so hard.
+
+// Just a single object gets exported - but may help with some syntax that exports multiple objects.
+//  Eg libraries of utility functions.
+
+// Spot class non prototype functions too?
+
+// Maybe make JSGUI_Module_Exports declaration.
+

package/resources/jsbuilder/JS_File/JS_File_Import_Reference.js

@@ -0,0 +1,24 @@
+
+class Import_Reference {
+    constructor(spec = {}) {
+
+        // name and value pair.
+
+        let name, value;
+
+        Object.defineProperty(this, 'name', {
+            set: function(v) { name = v; },
+            get() { return name; },
+            enumerable: true,
+            configurable: false
+        });
+        Object.defineProperty(this, 'value', {
+            set: function(v) { value = v; },
+            get() { return value; },
+            enumerable: true,
+            configurable: false
+        });
+    }
+}
+
+module.exports = Import_Reference;

package/resources/jsbuilder/JS_File/JS_File_Import_References.js

@@ -0,0 +1,32 @@
+// May be removed / a changed version made.
+//  Possibly a more general version, not just for JS files (in theory)
+
+// But this could be useful for understanding what the import references are and matching the code for them.
+
+// An abstraction that represents an understanding of the references that get imported into a JS_File.
+//   Likely to be:
+//    Generated when a js file is loaded
+//    Used to understand where in the working and therefore output structure the functionality goes (if it is treated as a block).
+
+
+
+
+
+
+class Import_References {
+    constructor(spec = {}) {
+
+        const arr = [];
+        Object.defineProperty(this, 'arr', {
+            //set: function(v) { arr = v; },
+            get() { return arr; },
+            enumerable: true,
+            configurable: false
+        });
+
+        this.push = value => arr.push(value);
+
+    }
+}
+
+module.exports = Import_References;

package/resources/jsbuilder/JS_File/JS_File_Processor.js

@@ -0,0 +1,16 @@
+// Don't use? Use planning and changing instead?
+//  Come up with the course of action. Then carry it out.
+
+
+const JS_File_Comprehension = require('./JS_File_4-Queryjs');
+
+class JS_FIle_Processor extends JS_File_Comprehension {
+    constructor(spec) {
+        super(spec);
+
+        
+
+    }
+}
+
+module.exports = JS_FIle_Processor;

package/resources/jsbuilder/JS_File/JS_Files.js

@@ -0,0 +1,16 @@
+const {each, Evented_Class} = require('lang-mini');
+
+class JS_Files extends Evented_Class {
+    constructor(spec) {
+
+        const arr_files = [];
+        const map_files = {}; // by full path if provided, otherwise name.
+
+
+
+        super(spec);
+    }
+    
+}
+
+module.exports = JS_Files;

package/resources/jsbuilder/Module.js

@@ -0,0 +1,14 @@
+// Corresponds to an npm module, JS code in a directory and with the package.json standard.
+
+// Will be able to get data about what it imports and exports.
+
+// Want a fairly simple API.
+
+// Like load, get_compressed
+
+// Some kind of categorisation / signature / signature match of the structure of the module.
+
+// Want to do things such as load a file as a module, and it has information about what the module exports.
+
+
+