@neurospeech/jex 1.0.9

package/.github/workflows/node.yml

@@ -0,0 +1,23 @@
+name: Build
+
+on: 
+  push: 
+    tags:
+      - '*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+      - run: npm install -g typescript
+      - run: npm install
+      - run: tsc
+      - run: npm run test
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/.vscode/settings.json

@@ -0,0 +1,45 @@
+{
+    "terminal.integrated.profiles.windows": {
+        "PowerShell": {
+            "source": "PowerShell",
+            "args": [
+                "-ExecutionPolicy",
+                "Bypass"
+            ]
+        }
+   },
+   "terminal.integrated.defaultProfile.windows": "PowerShell",
+    "cSpell.words": [
+        "Akash",
+        "castas",
+        "Cloner",
+        "DATEDIFF",
+        "DATETIME",
+        "DATETIMEFROMPARTS",
+        "DATETIMEOFFSETFROMPARTS",
+        "FREETEXT",
+        "FROMPARTS",
+        "ISDATE",
+        "ISNUMERIC",
+        "Linq",
+        "navigations",
+        "Neuro",
+        "syslanguages"
+    ],	"eslint.alwaysShowStatus": true,
+	"editor.defaultFormatter": "dbaeumer.vscode-eslint",
+	"eslint.format.enable": true,
+	"emmet.showSuggestionsAsSnippets": false,
+	"emmet.showAbbreviationSuggestions": false,
+	"emmet.excludeLanguages": [
+		"markdown",
+		"typescript",
+		"typescriptreact"
+	],
+	"[typescriptreact]": {
+		"editor.defaultFormatter": "vscode.typescript-language-features"
+	},
+	"[typescript]": {
+		"editor.defaultFormatter": "vscode.typescript-language-features"
+	}
+
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 NeuroSpeech Technologies Pvt Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# jex
+Easy shell scripting with JavaScript and E4X (Similar to JSX)

package/bin/jex

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../index.js')

package/index.js

@@ -0,0 +1 @@
+import "./dist/index.js";

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@neurospeech/jex",
+  "version": "1.0.9",
+  "description": "Easy shell scripting with JavaScript and E4X (Similar to JSX)",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 0",
+    "postversion": "git push --follow-tags"
+  },
+  "bin": {
+    "jex": "bin/jex"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/core": "^7.25.2",
+    "@babel/preset-react": "^7.24.7",
+    "console-log-colors": "^0.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.3.0"
+  }
+}

package/src/core/Batch.ts

@@ -0,0 +1,7 @@
+import XNode from "./XNode.js";
+
+export default async function Batch({}, ... commands: XNode[]) {
+    for (const element of commands) {
+        await element.execute();
+    }
+}

package/src/core/Run.ts

@@ -0,0 +1,43 @@
+import { spawnPromise } from "./spawnPromise.js";
+import XNode from "./XNode.js";
+
+export interface IProcessResult {
+    all: string;
+    pid: number;
+    status: number;
+}
+
+export default async function Run({ path, args,
+    cwd = void 0,
+    detached = false,
+    logCommand = true,
+    logData = false,
+    logError = true,
+    log = void 0 as (data: Buffer) => void,
+    error = void 0 as (data: Buffer) => void,
+    started = void 0 as (pid: number) => void,
+    finished = void 0 as (r: IProcessResult) => void,
+    failed = void 0 as (r: IProcessResult) => void
+}) {
+    const r = await spawnPromise(path, args, {
+        cwd,
+        detached,
+        logCommand,
+        logData,
+        logError,
+        log,
+        error
+    });
+
+    let fxr = void 0;
+
+    if (r.status === 0 && finished) {
+        fxr = finished(r);
+    } else {
+        fxr = failed(r);
+    }
+
+    if (fxr) {
+        await fxr;
+    }
+}

package/src/core/XNode.ts

@@ -0,0 +1,23 @@
+export default class XNode {
+
+    public static create(
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        name: Function,
+        attribs: Record<string, any>,
+        ... nodes: (XNode | string)[]): XNode {
+        return new XNode(name, attribs, nodes);
+    }
+
+    private constructor(
+        public readonly name: Function,
+        public readonly attributes: Record<string, any>,
+        public readonly children: (XNode | string)[]
+    ) {
+
+    }
+
+    async execute() {
+        return this.name(this.attributes, this.children);
+    }
+
+}

package/src/core/babel.ts

@@ -0,0 +1,29 @@
+import { transformFileAsync } from "@babel/core";
+import { writeFile } from "fs/promises";
+import { format, parse } from "path";
+
+const presets = {
+    sourceType: "module",
+    sourceMaps: "inline",
+    compact: false,
+    comments: false,
+    importSource: "jex/dist/XNode.js",
+    pragma: "XNode.create",
+    getModuleId: () => "v",
+    "plugins": [
+    ]
+};
+
+export class Babel {
+
+
+    static async transformJSX(file: string) {
+        const result = await transformFileAsync(file, presets);
+        const path = parse(file);
+        path.base += ".js";
+        const js = format(path);
+        await writeFile(js, result.code, "utf8");
+        return js;
+    }
+
+}

package/src/core/spawnPromise.ts

@@ -0,0 +1,71 @@
+/* eslint-disable no-console */
+import { SpawnOptionsWithoutStdio, spawn } from "node:child_process";
+
+import { color } from "console-log-colors";
+
+export const spawnPromise = (path, args?: string[], options?: SpawnOptionsWithoutStdio & {
+    logCommand?: boolean,
+    logData?: boolean,
+    logError?: boolean,
+    log?: (data: Buffer) => void,
+    error?: (data: Buffer) => void,
+    throwOnFail?: boolean }) => new Promise<{
+    get all(): string;
+    pid: number;
+    status: number;
+}>((resolve, reject) => {
+    const all = [];
+    const { logCommand = true, throwOnFail = false, logData = true, logError = true, log, error } = options ?? {};
+    const cd = spawn(path, args, options);
+    const pid = cd.pid;
+    cd.stdout.on("data", (data) => {
+        if (log) {
+            log(data);
+        }
+        if (logData) {
+            data = data.toString("utf8");
+            all.push(data);
+        }
+    });
+    cd.stderr.on("data", (data) => {
+        if (error) {
+            log(data);
+        }
+        if(logError) {
+            data = data.toString("utf8");
+            all.push(color.red(data));
+        }
+    });
+
+    cd.on("error", (error) => {
+        const errorText = color.red(error.stack ?? error.toString());
+        all.push(error.stack ?? error.toString());
+        if (logData || logError) {
+            console.error(errorText);
+        }
+        reject(error);
+    });
+    cd.on("close", (status) => {
+        if (status>0) {
+            if (throwOnFail) {
+                if (logError) {
+                    console.error(all);
+                }
+                reject(new Error(all.join("\n")));
+                return;
+            }
+        }
+        if (logCommand) {
+            console.log(`Spawn: ${path} ${JSON.stringify(args, undefined, 2)}`);
+            if (logData) {
+                console.log(all.join("\n"));
+            }
+        }
+        resolve({
+            get all() {
+                return all.join("\n");
+            },
+            pid,
+            status });
+    });
+});

package/src/index.ts

@@ -0,0 +1,71 @@
+// load and execute script...
+
+import { unlinkSync } from "fs";
+import { Babel } from "./core/babel.js";
+import XNode from "./core/XNode.js";
+
+export { default as XNode } from "./core/XNode.js";
+
+export { default as Batch } from "./core/Batch.js";
+
+export { default as Run } from "./core/Run.js";
+
+// execute passed script...
+
+export const invoke = async (name: string , args: string[]) => {
+    let js = "";
+
+    try {
+        if (name.endsWith(".jsx")) {
+            js = await Babel.transformJSX(name);
+            name = js;
+        }
+
+        const {default: fx} = await import(name);
+        const options: any = {
+        };
+
+        for (let index = 0; index < args.length; index++) {
+            let element = args[index];
+            let key = element;
+            if (element.startsWith("--")) {
+                element = element.substring(2);
+                key = element;
+                index++;
+                options[key] = args[index];
+            }
+        }
+
+        let node = fx;
+        if (!(node instanceof XNode)) {
+            node = fx(options);
+        } else {
+            for (const key in options) {
+                if (Object.prototype.hasOwnProperty.call(options, key)) {
+                    const element = options[key];
+                    node.children[key] = element;
+                }
+            }
+        }
+        await node.execute();
+    } catch (error) {
+        console.error(error);
+    }
+
+    if (js) {
+        unlinkSync(js);
+    }
+
+}
+
+if (process.argv.length) {
+    // check passed script arguments...
+
+    // first arg will be the node
+    // second arg will be the jex runner script
+
+    // third arg onwards should be the batch that we would like to execute...
+    const [program, script, ... args] = process.argv;
+
+    
+}

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+    "compilerOptions": {
+        "jsx": "react",
+        "target": "ES2021",
+        "module":"NodeNext",
+        "incremental": true,
+        "sourceMap": true,
+        "declaration": true,
+        "declarationMap": true,
+        "outDir": "dist",
+        "skipDefaultLibCheck": true,
+        "skipLibCheck": true,
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "jsxFactory": "XNode.create",
+        "lib": [
+            "ES2018",
+            "ES2021.WeakRef",
+            "esnext.disposable",
+            "ES2021.String",
+            "ES2022.Object"
+        ]
+    },
+    "include": [
+        "src/**/*"
+   ],
+    "exclude": [
+		"node_modules",
+		"tests"
+    ]
+}