jsgui3-server 0.0.73 → 0.0.77

package/resources/jsbuilder/Platforms.js

@@ -0,0 +1,70 @@
+// May be irrelevant / directly equivalent with Platform.
+//  Platform should be able to contain multiple platforms.
+
+
+// Acts as an array / collection of platforms. Will use enumerator.
+const {tof, each, Evented_Class} = require('lang-mini');
+
+// A platform can require a variety of other platforms under it.
+
+
+
+class Platforms extends Evented_Class {
+    constructor(spec = {}) {
+        // Each platform has a scope level.
+        super(spec);
+
+        let arr_requires = [];
+        let arr_platforms = [];
+
+        const tsr = tof(spec.requires);
+        if (tsr === 'string') {
+            arr_requires.push(spec.requires);
+        } else {
+            if (tsr === 'array') {
+                each(spec.requires, item => spec.requires.push(item));
+            }
+        }
+        // Platforms is one of the main thing that a project contains.
+
+        
+        // Can require platforms
+        //  Can require single functions???
+        //   In that case it would require the smallest platform that contains it, or it fishes the function out.
+        //    Looks like we need tests for if a function is inline.
+
+        if (spec.platforms) {
+            const t = spec.platforms;
+            if (t === 'array') {
+                each(spec.platforms, platform => arr_platforms.push(platform));
+            }
+        }
+
+        console.log('arr_requires', arr_requires);
+        console.log('arr_platforms', arr_platforms);
+
+        this.push = platform => {
+            const idx = arr_platforms.length;
+            arr_platforms.push(platform);
+            this.raise('change', {
+                'type': 'add',
+                'value': platform
+            });
+        }
+
+
+        // Still need the simple exports info
+        //  despite it possibly being complex to get that info
+        // 
+
+
+
+
+        // A bunch of local variables get defined within each platform.
+
+        // Make a platform about providing variables.
+
+    }
+}
+
+module.exports = Platforms;

package/resources/jsbuilder/Project.js

@@ -0,0 +1,109 @@
+
+// Will be a space where a load of JS can be loaded within.
+//  Loaded from different places.
+
+// Load JS file into the project.
+//  Be able to then reference functions from that file.
+//   Or then load the functions individually?
+//   Could load a whole load of them / category.
+//   Or 
+
+const {each, Evented_Class} = require('lang-mini');
+
+//const JS_File = require('./JS_File_Core');
+const Platforms = require('./Platforms');
+
+class Project extends Evented_Class {
+
+    // This will act as an overall library of JS functions.
+    //  A project can have multiple builds?
+
+    // Or a build is basically the output of a platform. The platform gets put together, has the code ordering, can do things internally too.
+    //  platform.build
+
+    // or it's a platform that meets conditions.
+
+    // A project could have different output files.
+    //  For the moment, focus more on bringing together input.
+    //  Arrange inputs to get output.
+
+    // Project-wide list / index of variable names
+    //  The variable names inside classes too.
+
+    // Project-wide substitution of variable names for shorter ones
+    //  Ongoing calculations of savings.
+
+    // Main thing will be to go further on code extraction - have the system able to deal with pieces of code, that it knows are required by something, to be
+    //  dealt with in abstract ways.
+
+    // Named platforms make sense.
+    //  Combining multiple platforms into one platform.
+    //   Application code sits on top of those platforms.
+
+    // Moving closer towards a project system where JavaScript code gets put together.
+    //  Want the jsgui build project to be really simple, much / most of it done using the structures built into the system.
+    //   Maybe this is where structure definitions will be loaded.
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+    //  The platform that is used as 
+
+    constructor(spec) {
+        super(spec = {});
+        
+        // The most outer layer.
+
+        // Load files into here...?
+        //  Files exist independently within the project space.
+
+        // map of files by path?
+
+        // or by name, its equivalent.
+
+        const platforms = new Platforms();
+
+        platforms.on('change', e_change => {
+            console.log('platforms e_change', e_change);
+        });
+
+        Object.defineProperty(this, 'platforms', {
+            get() { return platforms; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+    }
+    //add_js_file(js_file) {
+
+    //}
+    //remove_js_file(js_file) {
+        
+    //}
+
+}
+
+// load_js_file
+//  then it knows the names of the root level functions.
+
+// when loading JS files, it should be able to tell how they relate to each other.
+
+
+
+
+module.exports = Project;
+
+
+
+

package/resources/jsbuilder/Reference.js

@@ -0,0 +1 @@
+// A reference within a file

package/resources/jsbuilder/Reference_Sequence.js

@@ -0,0 +1,16 @@
+// A sequence / set of references. Often / should be at the beginning of the file.
+
+// Should correspond to named functions - but would start out as references to the files.
+
+
+class Reference_Sequence {
+    constructor(spec) {
+        
+
+
+
+    }
+}
+
+module.exports = Reference_Sequence;
+

package/resources/jsbuilder/Scope.js

@@ -0,0 +1,30 @@
+const {each, Evented_Class} = require('lang-mini');
+const Declaration_Sequence = require('./Abstract_Single_Declaration_Sequence');
+
+class Scope extends Evented_Class {
+
+    // Generally will be a block scope.
+
+
+    // Declarations are within scope.
+    // Only Declarations?
+
+    // Declarations are what matter for the moment.
+
+    constructor(spec) {
+
+
+        const declarations = new Declaration_Sequence();
+
+        Object.defineProperty(this, 'declarations', {
+            get() { return declarations; },
+            enumerable: true,
+            configurable: false
+        });
+
+    }
+
+
+}
+
+module.exports = Scope;

package/resources/jsbuilder/Variable_Name_Provider.js

@@ -0,0 +1,43 @@
+class Variable_Name_Provider { //Namer
+    constructor(spec = {}) {
+        
+        const reserved = {};
+
+        Object.defineProperty(this, 'reserved', {
+            get() { return reserved; },
+            //set(newValue) { bValue = newValue; },
+            enumerable: true,
+            configurable: false
+        });
+
+        // for the moment, x, and then a letter.
+
+        const map_counts = {
+            'l': 0,
+            'x': 0,
+            'p': 0,
+            'a': 0
+        }
+
+
+        // l as well for local
+
+        this.get_l = () => {
+            return 'l' + map_counts['l']++
+        }
+
+        this.get_x = () => {
+            return 'x' + map_counts['x']++
+        }
+        this.get_p = () => {
+            return 'p' + map_counts['p']++
+        }
+        this.get_a = () => {
+            return 'a' + map_counts['a']++
+        }
+
+
+    }
+}
+
+module.exports = Variable_Name_Provider;

package/resources/jsbuilder/_JS_File.js

@@ -0,0 +1,226 @@
+// Could do this in a simpler way than full AST manipulation.
+
+// Want to write out jsgui in such a way that the lower levels are all accessed as local functions and objects within an inner scope.
+
+const {each, Evented_Class} = require('lang-mini');
+//const { default: JS_Builder } = require('./JS_Builder');
+
+// Interpret / arrange a file in terms of the other objects within this system.
+
+// References at the beginning - will also work in terms of references to declarations, platforms, and declaration sequences.
+
+// Make it operate in a streaming way?
+//  Event driven too?
+//   So it can have events as it goes through the file or the stream.
+
+
+const whitespace_chars = {
+    '32': true
+}
+
+const get_char_type = e_rlc => {
+    const {char, char_code} = e_rlc;
+
+    if (char_code === 32 || char_code === 9) return 'whitespace';
+    if (char === '0' || char === '1' || char === '2' || char === '3' || char === '4' || char === '5' || char === '6' || char === '7' || char === '8' || char === '9') return 'digit'
+    if (char === '<' || char === '>' || char === '(' || char === ')' || char === '{' || 
+        char === '}' || char === ':' || char === ';' || char === '?' || char === '!' || char === '.' ||
+        char === '"' || char === '\'' || char === '|' || char === '~' || char === '#' ||  
+        char === '+' || char === '*' || char === '/' || char === '\\' || char === '-') return 'punctuation'
+    if (char_code >= 65 && char_code <= 90) return 'letter' // ucase
+    if (char_code >= 97 && char_code <= 122) return 'letter' // lcase
+
+
+    throw 'unknown';
+}
+
+
+// token types: number
+
+// May be best to use an existing full AST tokeniser and parser.
+
+
+
+
+
+
+class JS_File extends Evented_Class {
+    constructor(spec = {}) {
+        super();
+
+        const rs = (() => spec.rs || undefined)();
+        const line_break_hex = (() => spec.line_break_hex || '0A')();
+
+
+
+        //this.on('readline', e_readline => {
+
+        //});
+
+        if (rs) {
+            // Interpret it in chunks.
+            // Read it line by line, after character by character.
+            //  Very event driven parser, or partial parser at least.
+
+            //let buf1;
+
+            const ta_line_buffer = new Uint8Array(1024);
+            let byte_in_line_num = 0;
+
+            let line_num = 0;
+            let last_recieved_byte;
+            let recieved_byte;
+            // Separate the chunks and the raise an event for each line.
+            //  Charactrer by character???
+
+            // Array or something of the tokens?
+
+            //let first_token_of_line_char_pos = -1;
+            let began_first_token_of_line = false;
+
+            // An array of tokens as strings???
+
+            //  Or just be able to identify the first tokens?
+            //   The part before the equals sign?
+
+            // Best to creat OO oprogrammatic objects from these.
+            //  But maybe best to use an existing parsing tool.
+
+            // Identifying all variable declarations may be possible.
+            //   All function calls too...
+
+            // Identifying all local variable references.
+            //  Putting it into JS objects would make sense.
+            //   Into highly OO JS objects in the right structure.
+
+            // Could raise an event whenever it finds a token.
+            //  Then will need to make sense of these tokens.
+
+            // Being able to get a list of which declarations were made where in the code would helo.
+
+            // block, conditional, switch, loop
+
+            // Maybe an existing parser would make a lot more sense.
+            //  Be better able to identify 
+
+            // https://esprima.org/
+            // 
+
+
+
+
+
+
+            this.on('recieve-line-char', e_rlc => {
+                console.log('e_rlc', e_rlc);
+                const char_type = get_char_type(e_rlc)
+                console.log('char_type', char_type);
+                /*
+                if (!began_first_token_of_line) {
+                    if (whitespace_chars[e_rlc.char_code]) {
+
+                    } else {
+                        began_first_token_of_line = true;
+                    }
+                }
+                */
+
+            })
+
+
+            this.on('recieve-line', e_recieve_line => {
+                console.log('e_recieve_line', e_recieve_line);
+
+                // and strip the tabs and whitespace.
+
+                // process the line character by character.
+                
+                //console.log('e_recieve_linestr', str);
+
+                // And break up the line into statements;
+
+                const s = e_recieve_line.str, l = s.length;
+                for (let c = 0; c < l; c++) {
+                    const ch = s[c];
+                    this.raise('recieve-line-char', {
+                        line_num: line_num,
+                        char: ch,
+                        char_code: s.charCodeAt(c)
+                    })
+                }
+            });
+
+
+
+            console.log('rs', rs);
+            this.on('recieve-byte', e_receive_byte => {
+                last_recieved_byte = recieved_byte;
+                recieved_byte = e_receive_byte.byte_value;
+                ta_line_buffer[byte_in_line_num++] = recieved_byte;
+                //console.log('e_receive_byte', e_receive_byte);
+
+                
+
+                if (recieved_byte === 10) {
+                    // lf
+                    if (last_recieved_byte === 13) {
+                        // cr, for windows
+
+                        const line_until_crlf = new Uint8Array(ta_line_buffer.subarray(0, byte_in_line_num - 2));
+
+                        this.raise('recieve-line', {
+                            ta_line: line_until_crlf,
+                            bytes_length: byte_in_line_num,
+                            str: String.fromCharCode.apply(null, line_until_crlf)
+                        })
+
+                    } else {
+
+                        const line_until_lf = new Uint8Array(ta_line_buffer.subarray(0, byte_in_line_num - 1));
+                        this.raise('recieve-line', {
+                            ta_line: line_until_lf,
+                            bytes_length: byte_in_line_num,
+                            str: String.fromCharCode.apply(null, line_until_lf)
+                        })
+                    }
+                    ta_line_buffer.fill(0);
+                    line_num++;
+                    byte_in_line_num = 0;
+                }
+
+
+                
+            });
+
+            rs.on('data', chunk => {
+                //if (!buf1) {buf1 = chunk} else {
+                   // buf1 = Buffer.concat([buf1, chunk]);
+                const l = chunk.length;
+                console.log('l', l);
+                for (let c = 0; c < l; c++) {
+                    this.raise('recieve-byte', {
+                        byte_value: chunk.readUInt8(c)
+                    });
+                }
+                //}
+                
+            });
+
+            // then divide by line break character?
+            //  not sure of the formating, probably unicode.
+
+
+
+
+
+        }
+    }
+}
+JS_File.load_from_stream = (rs) => {
+    const res = new JS_File({rs: rs});
+}
+JS_File.load_from_path = (path) => {
+
+}
+
+module.exports = JS_File;

package/resources/jsbuilder/ast_query.js

@@ -0,0 +1,21 @@
+/*
+
+const ast_query = function() {
+    const a = arguments;
+
+
+
+}
+
+*/
+
+// babel node tools.
+
+
+// get_identifier_names
+
+
+
+const has_require_call = (babel_node) => {
+
+}

package/resources/jsbuilder/babel/babel_consts.js

@@ -0,0 +1,150 @@
+
+const type_abbreviations = {
+    //'ArrowFunctionExpression': 'AFE',
+    'ArrowFunctionExpression': 'AFE',
+    'AssignmentExpression': 'AsE',
+    'AssignmentPattern': 'AsP',
+    'ArrayExpression': 'ArE',
+    'ArrayPattern': 'ArP',
+    'BinaryExpression': 'BE',
+    'BlockStatement': 'BS',
+    'BooleanLiteral': 'BL',
+    'CallExpression': 'CE', // change to CaE? Need to change sigs being looked for.
+    'ClassBody': 'CB',
+    'ClassDeclaration': 'CD',
+    'ClassMethod': 'CM',
+    'ConditionalExpression': 'CoE',
+    'EmptyStatement': '__',
+    'ExpressionStatement': 'ES',
+    'File': 'F',
+    'ForStatement': 'FS',
+    'FunctionExpression': 'FE',
+    'Identifier': 'ID',
+    'IfStatement': 'IS',
+    'LogicalExpression': 'LE',
+    'MemberExpression': 'ME',
+    'NullLiteral': 'null',
+    'NumericLiteral': 'NumL',
+    'NewExpression': 'NE',
+    'ObjectExpression': 'OE',
+    'ObjectMethod': 'OM',
+    'ObjectPattern': 'OPa',
+    'ObjectProperty': 'OPr',
+    'Program': 'P',
+    'ReturnStatement': 'RS',
+    'StringLiteral': 'SL',
+    'Super': 'S',
+    'ThisExpression': 'TE',
+    'ThrowStatement': 'TS',
+    'UnaryExpression': 'UnE',
+    'UpdateExpression': 'UpE',
+    'VariableDeclaration': 'VDn',
+    'VariableDeclarator': 'VDr',
+    'WhileStatement': 'WS'
+}
+
+// ArrowFunctionExpression
+
+const map_expression_categories = {
+    'ArrowFunctionExpression': true,
+    'AssignmentExpression': true,
+    'ArrayExpression': true,
+    'BinaryExpression': true,
+    'CallExpression': true,
+    'ConditionalExpression': true,
+    // ExpressionStatement false because it's a statement
+    'FunctionExpression': true,
+    'LogicalExpression': true,
+    'MemberExpression': true,
+    'NewExpression': true,
+    'ObjectExpression': true,
+    'ThisExpression': true,
+    'UnaryExpression': true,
+    'UpdateExpression': true
+}
+
+const map_literal_categories = {
+    'BooleanLiteral': true,
+    
+
+    'NullLiteral': true,
+    'NumericLiteral': true,
+    'StringLiteral': true
+
+    // Must be more
+
+    // ExpressionStatement false because it's a statement
+    /*
+    'FunctionExpression': true,
+    'LogicalExpression': true,
+    'MemberExpression': true,
+    'NewExpression': true,
+    'ObjectExpression': true,
+    'ThisExpression': true,
+    'UnaryExpression': true,
+    'UpdateExpression': true
+    */
+
+}
+
+const map_statement_categories = {
+    BlockStatement: true,
+    EmptyStatement: true,
+    ExpressionStatement: true,
+    ForStatement: true,
+    ReturnStatement: true,
+    ThrowStatement: true,
+    WhileStatement: true
+}
+
+const map_categories = {
+    //'ArrowFunctionExpression': 'AFE',
+    'ArrowFunctionExpression': 'Expression',
+    'AssignmentExpression': 'Expression',
+    'AssignmentPattern': 'Pattern',
+    'ArrayExpression': 'Expression',
+    'ArrayPattern': 'APPattern',
+    'BinaryExpression': 'Expression',
+    'BlockStatement': 'Statement',
+    'BooleanLiteral': 'Literal',
+    'CallExpression': 'Expression',
+    'ClassBody': 'Body',
+    'ClassDeclaration': 'Declaration',
+    'ClassMethod': 'Method',
+    'ConditionalExpression': 'Expression',
+    'EmptyStatement': 'Statement',
+    'ExpressionStatement': 'Statement',
+    'ForStatement': 'Statement',
+    'File': 'File',
+    'FunctionExpression': 'Expression',
+    'Identifier': 'Identifier',
+    'IfStatement': 'Statement',
+    'LogicalExpression': 'Expression',
+    'MemberExpression': 'Expression',
+    'NullLiteral': 'Literal',
+    'NumericLiteral': 'Literal',
+    'NewExpression': 'Expression',
+    'ObjectExpression': 'Expression',
+    'ObjectMethod': 'Method',
+    'ObjectPattern': 'Pattern',
+    'ObjectProperty': 'Property',
+    'Program': 'Program',
+    'ReturnStatement': 'Statement',
+    'StringLiteral': 'Literal',
+    'Super': 'Super',
+    'ThisExpression': 'Expression',
+    'ThrowStatement': 'Statement',
+    'UnaryExpression': 'Expression',
+    'UpdateExpression': 'Expression',
+    'VariableDeclaration': 'Declaration',
+    'VariableDeclarator': 'Declarator',
+    'WhileStatement': 'Statement'
+}
+
+module.exports = {
+    type_abbreviations: type_abbreviations,
+    map_expression_categories: map_expression_categories,
+    map_literal_categories: map_literal_categories,
+    map_categories: map_categories,
+    map_statement_categories: map_statement_categories
+}