bscript-cli 1.0.0

package/commands/snapshot.md

@@ -0,0 +1,421 @@
+# Project Snapshot
+
+## Structure
+
+```
+.
+```
+
+## ./.default/BScript/$arg.js
+
+```javascript
+module.exports = {
+	name: '$arg',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(argNumber) {
+		return this.getScope().$arg[argNumber.val]
+	}
+}
+```
+
+## ./.default/BScript/$val.js
+
+```javascript
+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;
+	}
+}
+```
+
+## ./.default/BScript/bool.js
+
+```javascript
+const Helpers = require('@beiser/bscript-runner').Helpers;
+
+module.exports = {
+	name: 'bool',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: ({ val }) => Helpers.Boolean(val)
+}
+```
+
+## ./.default/BScript/delay.js
+
+```javascript
+const { delay } = require("./SRC/utils/utils.js")
+module.exports = {
+	name: 'delay',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(ms) {
+		return await delay(ms);
+	}
+}
+```
+
+## ./.default/BScript/eval.js
+
+```javascript
+module.exports = {
+	name: ['eval', 'evaluate'],
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(code) {
+		return eval(code.val);
+	}
+}
+```
+
+## ./.default/BScript/import.js
+
+```javascript
+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 })
+	}
+}
+```
+
+## ./.default/BScript/Input.js
+
+```javascript
+module.exports = {
+	name: 'Input',
+	description: '',
+	syntax: '',
+	perms: [999],
+	async execute(prefix) {
+		const test = await this.cmdEnviroment.Input(prefix.val);
+		return test
+	}
+}
+```
+
+## ./.default/BScript/js_new.js
+
+```javascript
+module.exports = {
+	name: 'js_new',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: (jsTypeClass, ...args) => {
+		return new jsTypeClass.val(...args.map(x=>x?.val??x))
+	}
+}
+```
+
+## ./.default/BScript/js_require.js
+
+```javascript
+module.exports = {
+	name: 'js',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: (req) => {
+		return require(req.val)
+	}
+}
+```
+
+## ./.default/BScript/jstype.js
+
+```javascript
+module.exports = {
+	name: 'jstype',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: (bsval) => {
+		return { type: "jstype", val: bsval?.type == "ref" ? bsval.get() : bsval.val}
+	}
+}
+```
+
+## ./.default/BScript/num.js
+
+```javascript
+const Helpers = require('@beiser/bscript-runner').Helpers;
+
+module.exports = {
+	name: 'num',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute: ({ val }) => Helpers.Number(val)
+}
+```
+
+## ./.default/BScript/object.js
+
+```javascript
+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)
+	}
+}
+```
+
+## ./.default/BScript/print.js
+
+```javascript
+module.exports = {
+	name: 'print',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute(...args) {
+		this.cmdEnviroment.commandController.Print(...args.map(x=>x.GetDisplayType()))
+	}
+}
+```
+
+## ./.default/BScript/raw.js
+
+```javascript
+module.exports = {
+	name: 'raw',
+	description: '',
+	syntax: '',
+	perms: [999],
+	execute(bsval) {
+		return new this.Type(bsval.val)
+	}
+}
+```
+
+## ./.default/BScript/ref.js
+
+```javascript
+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;
+    }
+};
+```
+
+## ./.default/BScript/run.js
+
+```javascript
+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));
+		}
+	}
+}
+```
+
+## ./.default/BScript/run-with-await.js
+
+```javascript
+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)
+		} 
+	}
+}
+```
+
+## ./.default/BScript/script.js
+
+```javascript
+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)()
+	}
+}
+```
+
+## ./.default/BScript/str.js
+
+```javascript
+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(""))
+}
+```
+
+## ./.default/DebugOnly/clear.js
+
+```javascript
+module.exports = {
+	name: 'clear',
+	description: 'Очищает комадную строку.',
+	syntax: 'clear',
+	execute() {
+		this.cmdEnviroment.commandController.ClearConsole();
+	}
+}
+```
+
+## ./.default/DebugOnly/update-commands.js
+
+```javascript
+module.exports = {
+	name: 'update-commands',
+	description: 'Обновить все команды.',
+	syntax: 'update-commands',
+	async execute() {
+		this.cmdEnviroment._updateCommands();
+	}
+}
+```
+
+## ./.default/help.js
+
+```javascript
+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")
+		);
+	}
+}
+```
+

package/index.js

@@ -0,0 +1,8 @@
+const BScript = require("./BScript")
+const TerminalCommandController = require("./TerminalCommandController")
+const utils = require("./SRC/utils/utils")
+module.exports = {
+	BScript,
+	TCC: TerminalCommandController,
+	utils
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "bscript-cli",
+  "version": "1.0.0",
+  "main": "index.js",
+  "license": "MIT",
+  "dependencies": {
+    "@beiser/bscript-runner": "^1.0.1"
+  },
+  "bin": {
+    "bscript": "./bin/bscript.js"
+  }
+}

package/postinstall.js

@@ -0,0 +1,12 @@
+// const saveFile = require('fs').writeFileSync;
+
+// const pkgJsonPath = process.argv[2] + "/package.json";
+
+// const json = require(pkgJsonPath);
+// if (!json.hasOwnProperty('scripts')) {
+//   json.scripts = {};
+// }
+
+// json.scripts['cmd'] = "node " + process.cwd() + "/RunCMD.js";
+
+// saveFile(pkgJsonPath, JSON.stringify(json, null, 2));