@radiantabyss/neutralino 1.0.0

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@radiantabyss/neutralino",
+    "version": "1.0.0",
+    "author": "radiantabyss.com",
+    "license": "ISC",
+    "eslintConfig": {
+        "root": true,
+        "env": {
+            "node": true
+        },
+        "extends": [
+            "eslint:recommended"
+        ],
+        "rules": {},
+        "parserOptions": {
+            "parser": "babel-eslint"
+        },
+        "globals": {
+            "Alert": "writable",
+            "Cookie": "writable",
+            "Item": "writable",
+            "Items": "writable",
+            "Request": "writable",
+            "Response": "writable"
+        }
+    },
+    "type": "module",
+    "dependencies": {
+        "axios": "1.7.*",
+        "validatorjs": "3.22.1"
+    }
+}

package/src/Bootstrap.js

@@ -0,0 +1,31 @@
+import Request from './Request.js';
+import Response from './Response.js';
+import Invoke from './Invoke.js';
+import Validator from './Validator.js';
+import IPC from './IPC.js';
+
+import Config from './Support/Config.js';
+import Env from './Support/Env.js';
+import Helpers from './Support/Helpers.js';
+import Item from './Support/Item.js';
+import Items from './Support/Items.js';
+import Str from './Support/Str.js';
+
+export default async () => {
+    //helpers
+    for ( let key in Helpers ) {
+        window[key] = Helpers[key];
+    }
+
+    window.Config = Config;
+    window.Env = Env;
+    window.Item = Item;
+    window.Items = Items;
+    window.Str = Str;
+
+    window.Request = Request;
+    window.Response = Response;
+    window.Invoke = Invoke;
+    window.Validator = Validator;
+    window.IPC = IPC;
+};

package/src/ContextMenu.js

@@ -0,0 +1,18 @@
+let ContextMenuActions = {};
+let context = import.meta.glob('/app/ContextMenu/**/*.js');
+
+//load context menu files
+const loadModules = async () => {
+	const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+		let split = files[i].split('/');
+        let name = split[split.length - 1].replace('.js', '');
+		let module = await context[files[i]]();
+        ContextMenuActions[name] = module.default;
+    }
+}
+
+export default async (list) => {
+    await loadModules();
+};

package/src/IPC.js

@@ -0,0 +1,28 @@
+let self = {
+    handlers: new Map(),
+
+    handle(channel, handler) {
+        self.handlers.set(channel, handler);
+    },
+
+    async invoke(channel, ...args) {
+        const handler = self.handlers.get(channel);
+        if ( !handler ) {
+            throw new Error(`No handler for channel: ${channel}`);
+        }
+        return await handler(...args);
+    },
+
+    send(channel, data) {
+        const event = new CustomEvent(channel, { detail: data });
+        window.dispatchEvent(event);
+    },
+
+    on(channel, callback) {
+        window.addEventListener(channel, (event) => {
+            callback(event.detail);
+        });
+    },
+}
+
+export default self;

package/src/Invoke.js

@@ -0,0 +1,13 @@
+let self = {
+    data: {},
+
+    all() {
+        return self.data;
+    },
+
+    get(param) {
+        return self.data[param];
+    },
+};
+
+export default self;

package/src/Models.js

@@ -0,0 +1,19 @@
+let Model = {};
+let context = import.meta.glob('/app/Models/**/*.js');
+
+//load model files
+const loadModules = async () => {
+	const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+		let split = files[i].split('/');
+        let name = split[split.length - 1].replace('.js', '');
+        let module = await context[files[i]]();
+        Model[name] = module.default;
+    }
+}
+
+export default async () => {
+    await loadModules();
+    return Model;
+};

package/src/Request.js

@@ -0,0 +1,173 @@
+import axios from 'axios';
+
+const formatErrors = function(response) {
+    let errors = [];
+    if ( response && response.errors ) {
+        for ( let i in response.errors ) {
+            if ( typeof response.errors[i] === 'object' ) {
+                for (let j in response.errors[i]) {
+                    errors.push(response.errors[i][j]);
+                }
+            }
+            else {
+                errors.push(response.errors[i]);
+            }
+        }
+    }
+    else if ( response.statusText ) {
+        errors.push(response.statusText);
+    }
+
+    return errors;
+};
+
+const serializeToURLEncoded = (obj, prefix) => {
+    const str = [];
+    for ( let p in obj ) {
+        if ( obj.hasOwnProperty(p) ) {
+            const key = prefix ? `${prefix}[${p}]` : p;
+            const value = obj[p];
+
+            if ( typeof value === "object" ) {
+                str.push(serializeToURLEncoded(value, key));
+            }
+            else {
+                str.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
+            }
+        }
+    }
+    return str.join("&");
+};
+
+const appendFormData = (formData, key, value) => {
+    if ( value instanceof Blob ) {
+        formData.append(key, value);
+    }
+    else if ( Array.isArray(value) ) {
+        value.forEach((v) => formData.append(`${key}[]`, v));
+    }
+    else if ( typeof value === 'object' && value !== null ) {
+        for ( let subKey in value ) {
+            appendFormData(formData, `${key}[${subKey}]`, value[subKey]);
+        }
+    }
+    else {
+        formData.append(key, value);
+    }
+};
+
+axios.interceptors.request.use((request) => {
+    if (request.data ) {
+        if ( request.headers['Content-Type'] === 'application/x-www-form-urlencoded' ) {
+            request.data = serializeToURLEncoded(request.data).replace(/\&+$/, '');
+        }
+        else if ( request.headers['Content-Type'] === 'application/json' ) {
+            request.data = JSON.stringify(request.data);
+            request.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+        }
+    }
+    return request;
+});
+
+const request = function(method, edge, payload = {}, display_errors = false, base_url = null, auth_token = null, headers = {}, upload_progress = null) {
+    return new Promise((resolve, reject) => {
+        if ( !base_url ) {
+            base_url = process.env.BACK_URL;
+        }
+
+        if ( !auth_token ) {
+            auth_token = JWT_TOKEN;
+        }
+
+        if ( !Object.keys(headers).length ) {
+            headers = {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            };
+        }
+
+        let data;
+        let url = base_url + edge;
+
+        if ( method === 'GET' ) {
+            url += '?' + new URLSearchParams(payload).toString();
+        }
+        else if ( method === 'POST' ) {
+            if ( headers['Content-Type'] === 'multipart/form-data' ) {
+                data = new FormData();
+
+                for (let key in payload) {
+                    appendFormData(data, key, payload[key]);
+                }
+
+                delete headers['Content-Type'];
+            }
+            else if ( headers['Content-Type'] === 'application/x-www-form-urlencoded' ) {
+                data = serializeToURLEncoded(payload).replace(/\&+$/, '');
+            }
+            else {
+                data = JSON.stringify(payload);
+                headers['Content-Type'] = 'application/x-www-form-urlencoded';
+            }
+        }
+
+        if ( auth_token ) {
+            if ( typeof auth_token !== 'object' ) {
+                auth_token = { jwt_token: auth_token };
+            }
+            for ( let key in auth_token ) {
+                if ( auth_token[key] !== '' && auth_token[key] !== null ) {
+                    url += url.includes('?') ? '&' : '?';
+                    url += `${key}=${auth_token[key]}`;
+                }
+            }
+        }
+
+        axios(url, {
+            headers,
+            method,
+            url,
+            data,
+        })
+        .then((request_response) => {
+            let response = request_response.data;
+
+            if ( response.success ) {
+                return resolve(response.data);
+            }
+
+            let errors = formatErrors(response);
+
+            if ( display_errors ) {
+                ipc_send('request:error', errors.join('<br/>'));
+            }
+
+            reject(response.data.errors);
+        })
+        .catch((error) => {
+            let errors = [error.message];
+
+            if ( display_errors ) {
+                ipc_send('request:error', errors.join('<br/>'));
+            }
+
+            reject(errors);
+        });
+    });
+};
+
+let self = {
+    get(edge, payload = {}, display_errors = false, base_url = null, auth_token = null, headers = {}) {
+        return request('GET', edge, payload, display_errors, base_url, auth_token, headers);
+    },
+
+    post(edge, payload = {}, display_errors = true, base_url = null, auth_token = null, headers = {}) {
+        return request('POST', edge, payload, display_errors, base_url, auth_token, headers);
+    },
+
+    upload(edge, payload = {}, display_errors = true, upload_progress, base_url = null, auth_token = null, headers = {}) {
+        headers['Content-Type'] = 'multipart/form-data';
+        return request('POST', edge, payload, display_errors, base_url, auth_token, headers, upload_progress);
+    },
+};
+
+export default self;

package/src/Response.js

@@ -0,0 +1,15 @@
+let self = {
+    success(data) {
+        return data;
+    },
+
+    error(error) {
+        if ( Array.isArray(error) ) {
+            error = error.join('\n');
+        }
+
+        throw error;
+    },
+}
+
+export default self;

package/src/Routing/Actions.js

@@ -0,0 +1,47 @@
+let Actions = {};
+let context = import.meta.glob('/app/Domains/**/*.js');
+
+const loadModules = async () => {
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let split = files[i].split('/');
+        split.shift();
+        let name = split[split.length - 1].replace('.js', '');
+        split.pop();
+        split.pop();
+        split.shift();
+        split.shift();
+
+        if ( !name.match(/Action$/) || name == 'Action' ) {
+            continue;
+        }
+
+        let module = await context[files[i]]();
+        setNamespace(Actions, name, split, module);
+    }
+}
+
+function setNamespace(Actions, name, namespace, module) {
+    if ( !namespace.length ) {
+        Actions[name] = module.default;
+        return;
+    }
+
+    let first = namespace[0].replace(/-/g, ' ').replace(/_/g, ' ').replace(/(^([a-zA-Z\p{M}]))|([ -][a-zA-Z\p{M}])/g,function(s) {
+        return s.toUpperCase();
+    }).replace(/ /g, '');
+
+    namespace.shift();
+
+    if ( !Actions[first] ) {
+        Actions[first] = {};
+    }
+
+    setNamespace(Actions[first], name, namespace, module);
+}
+
+export default async () => {
+    await loadModules();
+    return Actions;
+}

package/src/Routing/Middleware.js

@@ -0,0 +1,45 @@
+// MIDDLEWARE IS NOT USED AT THE MOMENT
+//
+//
+//
+let Middleware = {};
+let context = import.meta.glob('/app/Http/Middleware/**/*.js');
+
+const loadModules = async () => {
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let split = files[i].split('/');
+        let name = split[split.length - 1].replace('.js', '').replace('Middleware', '');
+        let module = await context[files[i]]();
+        Middleware[name] = module.default;
+    }
+}
+
+let runMiddleware = async (to, from, i = 0) => {
+    //reached end, then everything passed
+    if ( i == to.meta.middleware.length ) {
+        return;
+    }
+
+    //middleware doesnt exist
+    if ( !Middleware[to.meta.middleware[i]] ) {
+        throw new Error(`${to.meta.middleware[i]} Middleware not found.`);
+    }
+
+    //run middleware
+    await Middleware[to.meta.middleware[i]](to, from);
+    await runMiddleware(to, from, i + 1);
+}
+
+export default async () => {
+    await loadModules();
+
+    return async (to, from) => {
+        if ( !to.meta || !to.meta.middleware ) {
+            return;
+        }
+
+        return runMiddleware(to, from);
+    };
+}

package/src/Routing/Route.js

@@ -0,0 +1,84 @@
+let group_middleware = null;
+
+function addRoute(method, path, action, middleware, name, throw_error) {
+    if ( !action ) {
+        throw `Action missing for ${path}`;
+    }
+
+    //format path
+    path = path.replace(/\{([\s\S]+?)\}/g, ':$1');
+
+    //get action
+    action = action.replace(/\\/g, '.').replace(/\//g, '.');
+    let split = action.split('.');
+    let namespace = split.slice(0, -1);
+    let action_name = name || split[split.length - 1];
+    let domain = namespace.length ? Str.slug(namespace[0]) : '';
+
+    if ( namespace.length ) {
+        action_name = namespace.join('/') + '/' + action_name;
+    }
+
+    let component;
+    try {
+        component = getAction(Actions, split[split.length - 1], namespace, action_name);
+    }
+    catch(e) {
+        if ( throw_error ) {
+            throw `Action ${action_name} doesn't exist.`;
+        }
+        return;
+    }
+
+    RouteFiles[__route_file].push({
+        name: action_name,
+        component,
+        path,
+        method,
+        meta: {
+            domain,
+            middleware,
+            settings: component.settings ? component.settings : {},
+        },
+    });
+}
+
+function getAction(Actions, name, namespace, action_name) {
+    if ( !namespace.length ) {
+        let action = Actions[name];
+
+        action.name = action_name.replace(/\\/g, '.');
+        return action;
+    }
+
+    let first = namespace[0];
+    namespace.shift();
+
+    return getAction(Actions[first], name, namespace, action_name);
+}
+
+let self = {
+    get(path, action, middleware = [], name = '', throw_error = true) {
+        if ( group_middleware ) {
+            middleware = middleware.concat(group_middleware);
+        }
+
+        addRoute('GET', path, action, middleware, name, throw_error);
+    },
+
+    post(path, action, middleware = [], name = '', throw_error = true) {
+        if ( group_middleware ) {
+            middleware = middleware.concat(group_middleware);
+        }
+
+        addRoute('POST', path, action, middleware, name, throw_error);
+    },
+
+    group(middleware, callback) {
+        group_middleware = middleware;
+        callback();
+        group_middleware = null;
+    },
+}
+
+export default self;

package/src/Routing/RouteCrud.js

@@ -0,0 +1,19 @@
+import Str from './../Support/Str';
+
+let self = {
+    run(domain) {
+        domain = domain.replace(/\\/g, '.').replace(/\//g, '.');
+        let prefix = Str.kebab(domain).replace(/\./g, '/');
+
+        Route.get(`/${prefix}`, `${domain}/ListAction`, [], '', false);
+        Route.get(`/${prefix}/single/{id}`, `${domain}/SingleAction`, [], '', false);
+        Route.post(`/${prefix}/create`, `${domain}/CreateAction`, [], '', false);
+        Route.get(`/${prefix}/edit/{id}`, `${domain}/EditAction`, [], '', false);
+        Route.post(`/${prefix}/update/{id}`, `${domain}/UpdateAction`, [], '', false);
+        Route.post(`/${prefix}/patch/{id}`, `${domain}/PatchAction`, [], '', false);
+        Route.get(`/${prefix}/delete/{id}`, `${domain}/DeleteAction`, [], '', false);
+        Route.get(`/${prefix}/search`, `${domain}/SearchAction`, [], '', false);
+    }
+}
+
+export default self;

package/src/Routing/RouteFiles.js

@@ -0,0 +1 @@
+export default {};

package/src/Routing/Router.js

@@ -0,0 +1,109 @@
+import Actions from './Actions.js';
+import Middleware from './Middleware.js';
+import RouteFiles from './RouteFiles.js';
+import Route from './Route.js';
+import RouteCrud from './RouteCrud.js';
+
+window.RouteFiles = RouteFiles;
+window.Route = Route;
+window.RouteCrud = RouteCrud;
+
+let Routes = [];
+
+//load route files
+let context = import.meta.glob('/app/Routes/**/*.js');
+
+const loadModules = async () => {
+    window.Actions = await Actions();
+    const files = Object.keys(context);
+
+    for ( let i = 0; i < files.length; i++ ) {
+        let file = files[i].replace('/app/Routes/', '').replace(/\.js$/, '');
+        window.__route_file = file;
+
+        if ( !RouteFiles[__route_file] ) {
+            RouteFiles[__route_file] = [];
+        }
+
+        await context[files[i]]();
+    }
+}
+
+const match = async(args, event) => {
+    let matched = null;
+    let params = [];
+
+    //check for exact matches
+    for ( let Route of Routes ) {
+        if ( Route.path == args.path && Route.method == args.method ) {
+            matched = Route;
+            break;
+        }
+    }
+
+    //check for routes with params
+    if ( !matched ) {
+        for ( let Route of Routes ) {
+            if ( !Route.path.match(/\{.*\}/) ) {
+                continue;
+            }
+
+            //check if route matches
+            let regex_string = Route.path.replace(/\{(.*?)\}/g, '([^\/]*?)') + '\/$';
+            let regex = new RegExp(regex_string, 'g');
+
+            //add trailing slash to path for regex
+            let path = args.path.replace(/\/$/, '') + '/';
+            let match = regex.exec(path);
+            if ( !match ) {
+                continue;
+            }
+
+            //check method
+            if ( Route.method != args.method ) {
+                continue;
+            }
+
+            matched = Route;
+
+            for (let i = 1; i < match.length; i++) {
+                params.push(match[i]);
+            }
+        }
+    }
+
+    Invoke.data = args.payload;
+    params.push(event);
+
+    return {
+        Route: matched,
+        params,
+        path: args.path,
+        payload: args.payload,
+    };
+}
+
+export default async () => {
+    // let runMiddleware = await Middleware();
+    await loadModules();
+
+    //handle route matching
+    window.IPC.handle('invoke', async (event, args) => {
+        args.payload = JSON.parse(args.payload);
+
+        let matched = await match(args, event);
+        if ( !matched.Route ) {
+            throw `Route ${matched.path} not found.`;
+        }
+
+        return await matched.Route.component.run(...matched.params);
+    });
+
+    let Router = {
+        addRoute(Route) {
+            Routes.push(Route);
+        },
+    };
+
+    return { Router, RouteFiles };
+};

package/src/Support/Config.js

@@ -0,0 +1,40 @@
+const self = {
+    async read(config) {
+        return JSON.parse(await Neutralino.filesystem.readFile(`${APP_PATH}/configs/${config}.json`));
+    },
+
+    async write(config, data) {
+        await Neutralino.filesystem.writeFile(`${APP_PATH}/configs/${config}.json`, JSON.stringify(data, null, 4));
+    },
+
+    get(config) {
+        return self.read(config);
+    },
+
+    getKey(config, key) {
+        let data = self.read(config);
+        return data[key];
+    },
+
+    set(config, data) {
+        self.write(config, data);
+    },
+
+    setKey(config, key, value) {
+        let data = self.read(config);
+        data[key] = value;
+        self.write(config, data);
+    },
+
+    deleteKey(config, key) {
+        let data = self.read(config);
+        delete data[key];
+        self.write(config, data);
+    },
+
+    clear(config) {
+        self.write(config, {});
+    },
+};
+
+export default self;