bscript-cli 1.0.0

package/SRC/utils/utils.js

@@ -0,0 +1,63 @@
+const fs = require("fs")
+const path = require("path")
+
+module.exports = {}
+
+module.exports.readDirRecursive = function(dir) {
+    var results = [];
+    var list = fs.readdirSync(dir);
+    list.forEach(function(file) {
+        file = dir + '/' + file;
+        var stat = fs.statSync(file);
+        if (stat && stat.isDirectory()) { 
+            /* Recurse into a subdirectory */
+            results = results.concat(module.exports.readDirRecursive(file));
+        } else { 
+            /* Is a file */
+            results.push(file);
+        }
+    });
+    return results;
+}
+
+module.exports.getLeftWordIndex = (text, index) => {
+    if(index == 0)
+        return 0;
+    var words = text.split(" ");
+    var wordGlobalIndex = 0;
+    for(var i = 0; i < words.length; i++) {
+        if(wordGlobalIndex >= index) {
+            return wordGlobalIndex - words[i-1].length - 1;
+        }
+        wordGlobalIndex += words[i].length + 1;
+    }
+    return wordGlobalIndex - words[words.length-1].length - 1;
+}
+
+module.exports.getRightWordIndex = (text, index) => {
+    var words = text.split(" ");
+    var wordGlobalIndex = 0;
+    for(var i = 0; i < words.length; i++) {
+        if(wordGlobalIndex >= index) {
+            return wordGlobalIndex + words[i].length;
+        }
+        wordGlobalIndex += words[i].length + 1;
+    }
+    return wordGlobalIndex;
+}
+
+module.exports.delay = time => new Promise(res=>setTimeout(res,time))
+
+module.exports.arraysIsEqual = (arr1, arr2) => JSON.stringify(arr1) == JSON.stringify(arr2);
+
+module.exports.insert = function(str, index, string) {
+  if (index > 0)
+  {
+    return str.substring(0, index) + string + str.substring(index, str.length);
+  }
+  return string + str;
+}
+
+module.exports.removeByIndex = function(str, index) {
+    return str.slice(0,index) + str.slice(index+1);
+}

package/TerminalCommandController.js

@@ -0,0 +1,193 @@
+const { getLeftWordIndex, getRightWordIndex, removeByIndex, insert } = require('./SRC/utils/utils');
+const BScriptHistory = require('./SRC/BScriptHistory')
+
+// Terminal Command Controller
+module.exports = class TCC {
+	constructor({ ...args }) {
+		this.stdinVal = args?.defaultCommandPrefix??0;
+		this.col = args?.col??0;
+		this.defaultCommandPrefix = args?.defaultCommandPrefix??"";
+		this.CMD = args?.CMD;
+
+
+		this.stdinEmmiter = args?.stdinEmmiter;
+		this.BScriptHistory = new BScriptHistory();
+		if(this.CMD) {		
+			this.CMD.commandHistory = this.BScriptHistory.history;
+
+			process.on('exit', () => {
+				this.BScriptHistory.history = this.CMD.commandHistory;
+				this.BScriptHistory.save();
+			});
+			process.on('SIGINT', () => {
+				this.BScriptHistory.history = this.CMD.commandHistory;
+			    this.BScriptHistory.save();
+			    process.exit(0);
+			});
+			process.on('SIGTERM', () => {
+				this.BScriptHistory.history = this.CMD.commandHistory;
+			    this.BScriptHistory.save();
+			    process.exit(0);
+			});
+		}
+	}
+	ClearConsole() {
+		console.clear()
+	}
+	InitInput(rawMode) {
+		process.stdin.setRawMode(rawMode);
+		process.stdin.resume();
+		process.stdin.setEncoding('utf-8');
+	}
+	ClearLine() {
+		process.stdout.write("\r\x1b[K");
+	}
+	WriteCommand(cmd) {
+		process.stdout.write( `${this.defaultCommandPrefix}${cmd }`)
+	}
+	Write(text) {
+		process.stdout.write(text)
+	}
+	CursorTo(pos) {
+		process.stdout.cursorTo(pos);
+	}
+	Print(...text) {
+		console.log(...text);
+	}
+	SetStdinListener(lName, func) {
+		this.stdinEmmiter.on(lName, func);
+	}
+	RemoveStdinListener(lName, func) {
+		this.stdinEmmiter.removeListener(lName, func);
+	}
+	commandRender(inputStdin) {
+		let setCommand = (cmd) => {
+			this.col = cmd.length;
+			this.ClearLine();
+			this.WriteCommand(cmd);
+			this.stdinVal = cmd;
+		}
+		function toUnicode(theString) {
+		  var unicodeString = '';
+		  for (var i=0; i < theString.length; i++) {
+		    var theUnicode = theString.charCodeAt(i).toString(16).toUpperCase();
+		    while (theUnicode.length < 4) {
+		      theUnicode = '0' + theUnicode;
+		    }
+		    theUnicode = '\\u' + theUnicode;
+		    unicodeString += theUnicode;
+		  }
+		  return unicodeString;
+		}
+
+		switch(inputStdin) {
+			case "\u0003":
+				process.stdout.write("\n");
+				process.exit();
+				return 1;
+			case "\u000D":
+				this.CursorTo(this.stdinVal.length-1);
+				this.Write("\n");
+				this.col = 0;
+				this.CMD._historyPos = -1;
+				return 1;
+			case "\u001B\u004F\u004D":
+				break;
+			case "\u001b[A":
+				if(this.CMD._historyPos != this.CMD.commandHistory.length-1) {					
+					this.CMD._historyPos += 1;
+					setCommand(this.CMD.commandHistory[this.CMD.commandHistory.length-1 - this.CMD._historyPos]??"")
+				}
+				break;
+			case "\u001b[B":
+				if(this.CMD._historyPos != -1){
+					this.CMD._historyPos -= 1;
+					setCommand(this.CMD.commandHistory[this.CMD.commandHistory.length-1 - this.CMD._historyPos]??"")
+				}
+				break;
+			case "\u001b[C":
+				if(this.col < this.stdinVal.length) {
+					this.col += 1;
+					process.stdout.write("\u001b[C");
+				}
+				break;
+			case "\u001b[D":
+				if(this.col == 0){
+					process.stdout.cursorTo(this.defaultCommandPrefix.length);
+					return 0;
+				}
+				this.col -= 1;
+				process.stdout.write("\u001b[D");
+				break;
+			case "\u001b[3~":
+				this.stdinVal = removeByIndex(this.stdinVal, this.col);
+				this.ClearLine();
+				this.WriteCommand(this.stdinVal.replace("\r", "").replace("\n", ""));
+				process.stdout.cursorTo(this.col + this.defaultCommandPrefix.length);
+				break;	
+			case "\x7F":
+				if(this.col == 0) {
+					break;
+				}
+				this.stdinVal = removeByIndex(this.stdinVal, this.col-1);
+				this.ClearLine();
+				this.WriteCommand(this.stdinVal.replace("\r", "").replace("\n", ""));
+
+				this.col -= 1;
+				process.stdout.cursorTo(this.col + this.defaultCommandPrefix.length);
+				break;
+			case "\\x7F":
+			break;						
+			case "\b":
+				(()=> {
+					const delCount = this.col - (getLeftWordIndex(this.stdinVal, this.col)-1 > 0? getLeftWordIndex(this.stdinVal, this.col)-1: 0);
+					this.stdinVal = this.stdinVal.slice(0, (getLeftWordIndex(this.stdinVal, this.col)-1 > 0? getLeftWordIndex(this.stdinVal, this.col)-1: 0)) + this.stdinVal.slice(this.col, this.stdinVal.length);
+					this.col -= delCount;
+					this.ClearLine();
+					this.WriteCommand(this.stdinVal.replace("\r", "").replace("\n", ""));
+				})()
+				process.stdout.cursorTo(this.col + this.defaultCommandPrefix.length);
+			break;				
+			case "\x1B[3;5~":
+				// (()=> {
+				// 	const delCount = (getLeftWordIndex(this.stdinVal, this.col)-1 > 0? getLeftWordIndex(this.stdinVal, this.col)-1: 0) - this.col;
+				// 	this.stdinVal = this.stdinVal.slice(0, this.col) + this.stdinVal.slice(getRightWordIndex(this.stdinVal, this.col), this.stdinVal.length);
+				// 	this.col -= delCount;
+				// 	process.stdout.write("\r\x1b[K");
+				// 	process.stdout.write( `${this.defaultCommandPrefix}${this.stdinVal.replace("\r", "").replace("\n", "")}` );
+				// 	process.stdout.cursorTo(this.col + this.defaultCommandPrefix.length);
+				// })()
+			break;
+			case "\x1B[1;5D":
+				this.col = getLeftWordIndex(this.stdinVal, this.col)-1 > 0? getLeftWordIndex(this.stdinVal, this.col)-1: 0;
+				process.stdout.cursorTo(this.col + this.defaultCommandPrefix.length);
+			break; 
+			case "\x1B[1;5C":
+				if(this.col < this.stdinVal.length) {					
+					this.col = getRightWordIndex(this.stdinVal, this.col);
+					process.stdout.cursorTo(this.col + this.defaultCommandPrefix.length);
+				}
+				// this.col += this.col - ;
+				// process.stdout.cursorTo(wordIndexByTextIndex(this.stdinVal.split(" "), this.col, 1) + this.defaultCommandPrefix.length);
+			break; 
+			default:
+				if(this.col == this.stdinVal.length) {
+					this.col += inputStdin.length;
+					this.stdinVal += inputStdin;
+					this.ClearLine();
+					this.WriteCommand(this.stdinVal.replace("\r", "").replace("\n", ""));
+				} else {
+					this.stdinVal = insert(this.stdinVal, this.col, inputStdin);
+					this.col += inputStdin.length;
+					this.ClearLine();
+					this.WriteCommand(this.stdinVal.replace("\r", "").replace("\n", ""));
+					process.stdout.cursorTo(this.col + this.defaultCommandPrefix.length);
+				}
+			break;
+		}
+		return 0
+	}
+	OnData(inputStdin) {
+		return this.commandRender(inputStdin);
+	}
+}

package/bin/bscript.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env -S node --no-warnings
+
+const BScript = require("../BScript");
+
+const args = process.argv.slice(2);
+
+const options = {};
+const positional = [];
+
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg.startsWith("--")) {
+        const key = arg.substring(2);
+
+        switch (key) {
+            case "eval":
+                options.eval = args[++i];
+                break;
+
+            case "help":
+                options.help = true;
+                break;
+
+            case "version":
+                options.version = true;
+                break;
+
+            default:
+                options[key] = true;
+                break;
+        }
+    }
+    else if (arg.startsWith("-")) {
+        const key = arg.substring(1);
+
+        switch (key) {
+            case "e":
+                options.eval = args[++i];
+                break;
+
+            case "h":
+                options.help = true;
+                break;
+
+            case "v":
+                options.version = true;
+                break;
+
+            default:
+                options[key] = true;
+                break;
+        }
+    }
+    else {
+        positional.push(arg);
+    }
+}
+
+const cmd = new BScript();
+cmd.cmdRootPermissions = [
+    cmd.perrmissionsKeys.default,
+    cmd.perrmissionsKeys.script
+];
+cmd.updateCommands();
+
+if (options.help) {
+    console.log(`
+Usage:
+  bscript <file>
+  bscript -e "<script>"
+
+Options:
+  -e, --eval      Execute script text
+  -h, --help      Show help
+  -v, --version   Show version
+`);
+    process.exit(0);
+}
+
+if (options.version) {
+    console.log(require("../package.json").version);
+    process.exit(0);
+}
+
+if (options.eval) {
+    cmd.bscript(options.eval)();
+}
+else if (positional.length > 0) {
+    cmd.bscript(`script ${positional[0]}`)();
+}
+else {
+    cmd.Start();
+}

package/commands/.default/BScript/$arg.js

@@ -0,0 +1,9 @@
+module.exports = {
+	name: '$arg',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(argNumber) {
+		return this.getScope().$arg[argNumber.val]
+	}
+}

package/commands/.default/BScript/$val.js

@@ -0,0 +1,19 @@
+module.exports = {
+	name: '$val',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute(bsarg0, bsarg1) {
+		if(bsarg0?.type == "ref") {
+			const refVal = bsarg0.get();
+			return refVal;
+		}
+		if(bsarg0.val == "exist"){
+			return { type: "bool", val: this.getScope().$val[bsarg1.val] ? 1 : 0 }
+		}
+
+		bsarg0 = this.getScope().$val[bsarg0.val];
+
+		return bsarg0? !bsarg0.type && !bsarg0.val? new this.Type(bsarg0) : bsarg0 : null;
+	}
+}

package/commands/.default/BScript/Input.js

@@ -0,0 +1,10 @@
+module.exports = {
+	name: 'Input',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(prefix) {
+		const test = await this.cmdEnviroment.Input(prefix.val);
+		return test
+	}
+}

package/commands/.default/BScript/bool.js

@@ -0,0 +1,9 @@
+const Helpers = require('@beiser/bscript-runner').Helpers;
+
+module.exports = {
+	name: 'bool',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: ({ val }) => Helpers.Boolean(val)
+}

package/commands/.default/BScript/delay.js

@@ -0,0 +1,10 @@
+const { delay } = require("./SRC/utils/utils.js")
+module.exports = {
+	name: 'delay',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(ms) {
+		return await delay(ms);
+	}
+}

package/commands/.default/BScript/eval.js

@@ -0,0 +1,9 @@
+module.exports = {
+	name: ['eval', 'evaluate'],
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(code) {
+		return eval(code.val);
+	}
+}

package/commands/.default/BScript/import.js

@@ -0,0 +1,17 @@
+const fs = require('fs')
+const path = require('path')
+const Runner = require('@beiser/bscript-runner').Runner;
+
+module.exports = {
+	name: 'import',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute({ val: scriptPath }) {
+		const imported = fs.readFileSync(path.join(this.__baseDir, scriptPath), { encoding: 'utf8', flag: 'r' });
+		const bScriptRunner = new Runner(this.cmdEnviroment)
+    	bScriptRunner.Create(imported)
+		await bScriptRunner.executer()
+		return await bScriptRunner.commandExecute({ commandName: "$val", args: [new this.Type("export")], options: bScriptRunner.options })
+	}
+}

package/commands/.default/BScript/js_new.js

@@ -0,0 +1,9 @@
+module.exports = {
+	name: 'js_new',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: (jsTypeClass, ...args) => {
+		return new jsTypeClass.val(...args.map(x=>x?.val??x))
+	}
+}

package/commands/.default/BScript/js_require.js

@@ -0,0 +1,9 @@
+module.exports = {
+	name: 'js',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: (req) => {
+		return require(req.val)
+	}
+}

package/commands/.default/BScript/jstype.js

@@ -0,0 +1,9 @@
+module.exports = {
+	name: 'jstype',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: (bsval) => {
+		return { type: "jstype", val: bsval?.type == "ref" ? bsval.get() : bsval.val}
+	}
+}

package/commands/.default/BScript/num.js

@@ -0,0 +1,9 @@
+const Helpers = require('@beiser/bscript-runner').Helpers;
+
+module.exports = {
+	name: 'num',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: ({ val }) => Helpers.Number(val)
+}

package/commands/.default/BScript/object.js

@@ -0,0 +1,19 @@
+const Helpers = require('@beiser/bscript-runner').Helpers;
+
+module.exports = {
+	name: 'object',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute(bsval) {
+		const obj = {}
+		if(bsval?.type == 'array') {
+			bsval.val.map(x => {
+				obj[x.name] = x.val;
+			})
+		} else {
+			obj[bsval.name] = bsval.val
+		}
+		return Helpers.Object(obj)
+	}
+}

package/commands/.default/BScript/print.js

@@ -0,0 +1,9 @@
+module.exports = {
+	name: 'print',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute(...args) {
+		this.cmdEnviroment.commandController.Print(...args.map(x=>x.GetDisplayType()))
+	}
+}

package/commands/.default/BScript/raw.js

@@ -0,0 +1,9 @@
+module.exports = {
+	name: 'raw',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute(bsval) {
+		return new this.Type(bsval.val)
+	}
+}

package/commands/.default/BScript/ref.js

@@ -0,0 +1,65 @@
+function setValue(obj, path, value) {
+    const parts = Array.isArray(path)
+        ? path
+        : path.split(".");
+
+    parts.shift();
+
+    let current = obj;
+
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+
+        if (current.val[key] == null)
+            current.val[key] = {};
+
+        current = current.val[key];
+    }
+
+    current.val[parts.at(-1)] = value;
+}
+
+function deepValue(obj, path) {
+    for (const key of path) {
+        if (obj == null)
+            return undefined;
+
+        obj = obj.val?.[key];
+    }
+
+    return obj;
+}
+
+module.exports = {
+    name: "ref",
+    description: "",
+    syntax: "",
+    perms: [999],
+
+    execute: function (bsarg, ...props) {
+        const path =
+            (bsarg?.type === "object" || bsarg?.type === "jstype")
+                ? props.flatMap(x => x.val.split("."))
+                : [bsarg, ...props].flatMap(x => x.val.split("."));
+
+        const root =
+            (bsarg?.type === "object" || bsarg?.type === "jstype")
+                ? bsarg
+                : this;
+
+        const bsref = new this.Type({
+            type: "ref",
+
+            prop: path,
+
+            get: () => deepValue(root, path),
+
+            set: value => {
+                if (root?.val)
+                    setValue(root, path, value);
+            }
+        });
+
+        return bsref;
+    }
+};

package/commands/.default/BScript/run-with-await.js

@@ -0,0 +1,13 @@
+module.exports = {
+	name: 'await',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(arg1, arg2) {
+		if(arg1?.type == 'promise') {
+			return await arg1.val
+		} if(arg1?.val == "run") {
+			return await await this.commandExecute.bind(this)({ commandName: "run", args: [arg2] }).then(x => x?.val)
+		} 
+	}
+}

package/commands/.default/BScript/run.js

@@ -0,0 +1,11 @@
+module.exports = {
+	name: 'run',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(func, ...args) {
+		if(func.type == this.Type.FuncionType){
+			return func.isAsync ? new this.Type({ type: this.Type.PromiseType, val: func.val(...args.map(arg=>arg.val)) }) : await func.val(...args.map(arg=>arg.val));
+		}
+	}
+}

package/commands/.default/BScript/script.js

@@ -0,0 +1,13 @@
+const fs = require('fs')
+const path = require('path')
+
+module.exports = {
+	name: 'script',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute({ val: scriptPath }) {
+		const imported = fs.readFileSync(path.join(this.__baseDir, scriptPath), { encoding: 'utf8', flag: 'r' });
+		await this.cmdEnviroment.bscript(imported)()
+	}
+}

package/commands/.default/BScript/str.js

@@ -0,0 +1,9 @@
+const Helpers = require('@beiser/bscript-runner').Helpers;
+
+module.exports = {
+	name: 'str',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: (...bsvals) => Helpers.Text(bsvals.filter(x=>x).map(x=>x.val).join(""))
+}

package/commands/.default/DebugOnly/clear.js

@@ -0,0 +1,8 @@
+module.exports = {
+	name: 'clear',
+	description: 'Очищает комадную строку.',
+	syntax: 'clear',
+	execute() {
+		this.cmdEnviroment.commandController.ClearConsole();
+	}
+}

package/commands/.default/DebugOnly/update-commands.js

@@ -0,0 +1,8 @@
+module.exports = {
+	name: 'update-commands',
+	description: 'Обновить все команды.',
+	syntax: 'update-commands',
+	async execute() {
+		this.cmdEnviroment._updateCommands();
+	}
+}

package/commands/.default/help.js

@@ -0,0 +1,20 @@
+var descriptions = {
+
+}
+
+module.exports = {
+	name: 'help',
+	description: 'Выводит все команды одним списком.',
+	syntax: 'help',
+	execute() {
+		this.cmdEnviroment.commandController.Print(
+					Object.keys(this.cmdEnviroment.commandController.CMD._commands).map(key => 
+		`\n\
+Command: ${key}\n\
+Desciption: ${this.cmdEnviroment.commandController.CMD._commands[key].description}\n\
+Declaration: ${this.cmdEnviroment.commandController.CMD._commands[key].syntax}\n\
+		`
+						).join("\n")
+		);
+	}
+}