@radiantabyss/neutralino 1.0.3 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@radiantabyss/neutralino",
-    "version": "1.0.3",
+    "version": "1.2.0",
     "author": "radiantabyss.com",
     "license": "ISC",
     "eslintConfig": {

package/src/Bootstrap.js

@@ -3,21 +3,34 @@ import Invoked from './Invoked.js';
 import Validator from './Validator.js';
 import IPC from './IPC.js';
 
+import Globals from './Support/Globals.js';
 import Config from './Support/Config.js';
-import Env from './Support/Env.js';
+import Storage from './Support/Storage.js';
 import Helpers from './Support/Helpers.js';
+import Item from './Support/Item';
+import Items from './Support/Items';
 
-window.RA.Neu = {};
+window.RA = {};
+
+export default async () => {
+    Neutralino.init();
+
+    window.Config = Config;
+    window.Storage = Storage;
+    window.Item = Item;
+    window.Items = Items;
+
+    //globals
+    let globals = await Globals();
+    for (let key in globals) {
+        window[key] = globals[key];
+    }
 
-export default () => {
     //helpers
     for ( let key in Helpers ) {
         window[key] = Helpers[key];
     }
 
-    window.Config = Config;
-    window.Env = Env;
-
     window.Response = Response;
     window.Invoked = Invoked;
     window.Validator = Validator;

package/src/Command.js

@@ -0,0 +1,41 @@
+let context = import.meta.glob('/app/Domains/**/*.js');
+
+const getMatchedCommand = 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(/Command/) || name == 'Command' ) {
+            continue;
+        }
+
+        let module = await context[files[i]]();
+        let signature_split = module.default.signature.split(' ');
+        if ( signature_split[0] == NL_ARGS[1] ) {
+            return module.default;
+        }
+    }
+
+    return null;
+}
+
+export default async () => {
+    let command = await getMatchedCommand();
+    await Neutralino.os.execCommand('cmd /c echo');
+
+    if ( !command ) {
+        throw `Command with signature "${NL_ARGS[1]}" not found.`;
+    }
+
+    let args = NL_ARGS;
+    args.shift();
+    args.shift();
+    await command.run.apply(this, args);
+}

package/src/Routing/Middleware.js

@@ -24,7 +24,7 @@ let runMiddleware = async (to, from, i = 0) => {
 
     //middleware doesnt exist
     if ( !Middleware[to.meta.middleware[i]] ) {
-        throw new Error(`${to.meta.middleware[i]} Middleware not found.`);
+        throw new Error(`Middleware "${to.meta.middleware[i]}" not found.`);
     }
 
     //run middleware

package/src/Routing/Route.js

@@ -20,16 +20,16 @@ function addRoute(method, path, action, middleware, name, throw_error) {
 
     let component;
     try {
-        component = getAction(window.RA.Neu.Actions, split[split.length - 1], namespace, action_name);
+        component = getAction(window.RA.Actions, split[split.length - 1], namespace, action_name);
     }
     catch(e) {
         if ( throw_error ) {
-            throw `Action ${action_name} doesn't exist.`;
+            throw `Action "${action_name}" doesn't exist.`;
         }
         return;
     }
 
-    window.RA.Neu.RouteFiles[window.RA.Neu.__neutralino_route_file].push({
+    window.RA.RouteFiles[window.RA.__neutralino_route_file].push({
         name: action_name,
         component,
         path,

package/src/Routing/Router.js

@@ -4,9 +4,9 @@ import RouteFiles from './RouteFiles.js';
 import Route from './Route.js';
 import RouteCrud from './RouteCrud.js';
 
-window.RA.Neu.RouteFiles = RouteFiles;
-window.RA.Neu.Route = Route;
-window.RA.Neu.RouteCrud = RouteCrud;
+window.RA.RouteFiles = RouteFiles;
+window.RA.Route = Route;
+window.RA.RouteCrud = RouteCrud;
 
 let Routes = [];
 
@@ -14,22 +14,22 @@ let Routes = [];
 let context = import.meta.glob('/app/Routes/**/*.js');
 
 const loadModules = async () => {
-    window.RA.Neu.Actions = await Actions();
+    window.RA.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.RA.Neu.__neutralino_route_file = file;
+        window.RA.__neutralino_route_file = file;
 
-        if ( !window.RA.Neu.RouteFiles[window.RA.Neu.__neutralino_route_file] ) {
-            window.RA.Neu.RouteFiles[window.RA.Neu.__neutralino_route_file] = [];
+        if ( !window.RA.RouteFiles[window.RA.__neutralino_route_file] ) {
+            window.RA.RouteFiles[window.RA.__neutralino_route_file] = [];
         }
 
         await context[files[i]]();
     }
 }
 
-const match = async(args, event) => {
+const match = async(args) => {
     let matched = null;
     let params = [];
 
@@ -75,7 +75,6 @@ const match = async(args, event) => {
     }
 
     Invoked.data = args.payload;
-    params.push(event);
 
     return {
         Route: matched,
@@ -90,12 +89,12 @@ export default async () => {
     await loadModules();
 
     //handle route matching
-    IPC.handle('invoke', async (event, args) => {
+    IPC.handle('invoke', async (args) => {
         args.payload = JSON.parse(args.payload);
 
-        let matched = await match(args, event);
+        let matched = await match(args);
         if ( !matched.Route ) {
-            throw `Route ${matched.path} not found.`;
+            throw `Route "${matched.path}" not found.`;
         }
 
         return await matched.Route.component.run(...matched.params);

package/src/SingleInstance.js

@@ -0,0 +1,56 @@
+export default async function() {
+    if ( !IS_PACKAGED ) {
+        return;
+    }
+
+    let command = `powershell -Command "Get-CimInstance Win32_Process -Filter \"name='${NL_APPID}.exe'\" | Select-Object name"`;
+    let result = await Neutralino.os.execCommand(command);
+    let regex = new RegExp(`${NL_APPID}\.exe`, 'g');
+    let matches = result.stdOut.match(regex);
+
+    if ( matches && matches.length > 1 ) {
+        let command = `powershell -Command "
+            Add-Type \"
+            using System;
+            using System.Runtime.InteropServices;
+
+            public class WinApi {
+                [DllImport(\"user32.dll\")]
+                public static extern bool EnumWindows(EnumWindowsProc enum_proc, IntPtr l_param);
+
+                public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+                [DllImport(\"user32.dll\")]
+                public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint process_id);
+
+                [DllImport(\"user32.dll\")]
+                public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+            }
+            \";
+            $process_name = 'ramp.exe';
+            $process_list = Get-CimInstance Win32_Process -Filter \"name='$process_name'\";
+            if (-not $process_list) {
+                Write-Host \"Process '$process_name' not found.\";
+                exit;
+            }
+            $pids = $process_list.ProcessId;
+            $found_windows = @();
+            $callback = {
+                param($hwnd, $lparam)
+                [uint32]$window_pid = 0;
+                [WinApi]::GetWindowThreadProcessId($hwnd, [ref]$window_pid);
+                if ($pids -contains $window_pid) {
+                    $script:found_windows += $hwnd;
+                }
+                return $true;
+            };
+            [WinApi]::EnumWindows($callback, [IntPtr]::Zero);
+            foreach ($hwnd in $found_windows) {
+                [WinApi]::ShowWindow($hwnd, 9);
+            }
+            "`;
+
+        await Neutralino.os.execCommand(command);
+        await Neutralino.app.exit();
+    }
+}

package/src/Support/Config.js

@@ -7,33 +7,36 @@ const self = {
         await Neutralino.filesystem.writeFile(`${APP_PATH}/configs/${config}.json`, JSON.stringify(data, null, 4));
     },
 
-    async get(config) {
-        return await self.read(config);
-    },
-
-    async getKey(config, key) {
+    async get(config, key = null) {
         let data = await self.read(config);
-        return data[key];
-    },
 
-    async set(config, data) {
-        await self.write(config, data);
-    },
+        if ( key !== null ) {
+            return data[key];
+        }
 
-    async setKey(config, key, value) {
-        let data = await self.read(config);
-        data[key] = value;
-        await self.write(config, data);
+        return data;
     },
 
-    async deleteKey(config, key) {
-        let data = await self.read(config);
-        delete data[key];
+    async set(config, value, key = null) {
+        let data = value;
+
+        if ( key !== null ) {
+            data = await self.read(config);
+            data[key] = value;
+        }
+
         await self.write(config, data);
     },
 
-    async clear(config) {
-        await self.write(config, {});
+    async remove(config, key = null) {
+        let data = {};
+
+        if ( key !== null ) {
+            data = await self.read(config);
+            delete data[key];
+        }
+
+        await self.write(config, data);
     },
 };
 

package/src/Support/Globals.js

@@ -0,0 +1,29 @@
+export default async function() {
+    let APP_PATH = await Neutralino.filesystem.getAbsolutePath('.');
+    let IS_PACKAGED = NL_RESMODE == 'bundle';
+    let STATIC_PATH = `${APP_PATH}/static`;
+
+    //set window type
+    let WINDOW_TYPE = 'main';
+    for ( let arg of NL_ARGS ) {
+        if ( arg.match(/--window-type/) ) {
+            WINDOW_TYPE = arg.replace(/--window-type=/, '');
+        }
+    }
+
+    //set display profile
+    let DISPLAY_PROFILE = '';
+    for ( let display of await Neutralino.computer.getDisplays() ) {
+        DISPLAY_PROFILE += `${display.resolution.width}_${display.resolution.height}_${window.devicePixelRatio}_`;
+    }
+
+    return {
+        APP_PATH,
+        STATIC_PATH,
+        IS_PACKAGED,
+        WINDOW_TYPE,
+        DISPLAY_PROFILE,
+        MAIN_WINDOW: null,
+        UPDATE_WINDOW: null,
+    }
+}

package/src/Support/Helpers.js

@@ -1,4 +1,9 @@
 let self = {
+    dmp(text) {
+        // eslint-disable-next-line
+        console.log(text);
+    },
+    
     decode_json(string) {
         if ( typeof string == 'string') {
             return JSON.parse(string);

package/src/Support/Item.js

@@ -0,0 +1,63 @@
+let self = {
+	patch(item, data) {
+		return self.setKeys(item, Object.keys(data), Object.values(data));
+	},
+
+    setKey(item, key, value) {
+        return self.setKeys(item, key, value);
+    },
+
+    setKeys(item, keys, values) {
+        let not_empty = window.handleEmpty(item);
+        if ( not_empty !== true ) {
+            item = {};
+        }
+
+		if ( Array.isArray(keys) && !Array.isArray(values) ) {
+			let array_values = [];
+			for ( let key of keys ) {
+				array_values.push(values);
+			}
+			values = array_values;
+        }
+
+        if ( !Array.isArray(keys) ) {
+            keys = [keys];
+			values = [values];
+        }
+
+        for ( let i = 0; i < keys.length; i++ ) {
+            item[keys[i]] = values[i];
+        }
+
+        return {...item};
+    },
+
+	removeEmptyKeys(item) {
+		let new_item = Array.isArray(item) ? [] : {};
+        let count = Array.isArray(item) ? item.length : Object.keys(item).length;
+		for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(item) ? i : Object.keys(item)[i];
+
+            if ( item[index] !== '' ) {
+                new_item[index] = item[index];
+            }
+        }
+
+        return new_item;
+	},
+
+    deleteKeys(item, keys) {
+		for ( let key of keys ) {
+	        delete item[key];
+		}
+
+		return {...item};
+    },
+
+    deleteKey(item, key) {
+		return self.deleteKeys(item, [key]);
+    },
+};
+
+export default self;

package/src/Support/Items.js

@@ -0,0 +1,363 @@
+const self = {
+    pluck(items, key = 'id') {
+        let plucked = [];
+        for (let i = 0; i < items.length; i++) {
+            plucked.push(items[i][key]);
+        }
+
+        return plucked;
+    },
+
+    spread(items) {
+        return JSON.parse(JSON.stringify(items));
+    },
+
+    keyBy(items, key = 'id') {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        let new_items = {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+            new_items[items[index][key]] = items[index];
+        }
+
+        return new_items;
+    },
+
+    groupBy(items, key = 'id') {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if (typeof new_items[items[index][key]] === 'undefined') {
+                new_items[items[index][key]] = [];
+            }
+
+            new_items[items[index][key]].push(items[index]);
+        }
+
+        return new_items;
+    },
+
+    find(items, ids) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return false;
+        }
+
+        let single = false;
+        if ( !Array.isArray(ids) ) {
+            if ( typeof ids === 'string' ) {
+                ids = parseInt(ids);
+            }
+
+            ids = [ids];
+            single = true;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( ids.includes(parseInt(items[index].id)) ) {
+                if ( Array.isArray(items) ) {
+                    new_items.push(items[index]);
+                }
+                else {
+                    new_items[index] = items[index];
+                }
+            }
+        }
+
+        if ( single ) {
+            if ( Array.isArray(new_items) && new_items.length ) {
+                return new_items[0];
+            }
+            else if ( !Array.isArray(new_items) && Object.keys(new_items).length ) {
+                return new_items[Object.keys(new_items)[0]];
+            }
+
+            return false;
+        }
+
+        return new_items;
+    },
+
+    findByKey(items, key, value = true, single = false) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return false;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( items[index][key] == value ) {
+                if ( Array.isArray(items) ) {
+                    new_items.push(items[index]);
+                }
+                else {
+                    new_items[index] = items[index];
+                }
+            }
+        }
+
+        if ( single ) {
+            if ( Array.isArray(new_items) && new_items.length ) {
+                return new_items[0];
+            }
+            else if ( !Array.isArray(new_items) && Object.keys(new_items).length ) {
+                return new_items[Object.keys(new_items)[0]];
+            }
+
+            return false;
+        }
+
+        return new_items;
+    },
+
+    add(items, item, at_first_position = false) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            items = [];
+        }
+
+        if ( at_first_position ) {
+            items.unshift(item);
+        }
+        else {
+            items.push(item);
+        }
+
+        return items;
+    },
+
+    addMany(items, added, at_first_position = false) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            items = [];
+        }
+
+        if ( at_first_position ) {
+            return added.concat(items);
+        }
+        else {
+            return items.concat(added);
+        }
+    },
+
+    patch(items, data) {
+        if ( !data.id ) {
+            throw 'ID is required.';
+        }
+
+        let id = data.id;
+        delete data.id;
+
+        return self.setKeys(items, id, Object.keys(data), Object.values(data));
+    },
+
+    replace(items, item) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( items[index].id == item.id ) {
+                new_items[index] = item;
+            }
+            else {
+                new_items[index] = items[index];
+            }
+        }
+
+        return new_items;
+    },
+
+    delete(items, ids) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        if ( !Array.isArray(ids) ) {
+            if ( typeof ids === 'string' ) {
+                ids = parseInt(ids);
+            }
+
+            ids = [ids];
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( ids.includes(parseInt(items[index].id)) ) {
+                continue;
+            }
+
+            if ( Array.isArray(items) ) {
+                new_items.push(items[index]);
+            }
+            else {
+                new_items[index] = items[index];
+            }
+        }
+
+        return new_items;
+    },
+
+    deleteByKey(items, key, value) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        let new_items = Array.isArray(items) ? [] : {};
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( items[index][key] != value ) {
+                new_items[index] = items[index];
+            }
+        }
+
+        return new_items;
+    },
+
+    setKey(items, id, key, value) {
+        return self.setKeys(items, id, key, value);
+    },
+
+    setKeys(items, ids, keys, values) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        if ( !Array.isArray(ids) ) {
+            if ( typeof ids === 'string' ) {
+                ids = parseInt(ids);
+            }
+
+            ids = [ids];
+        }
+
+        if ( Array.isArray(keys) && !Array.isArray(values) ) {
+			let array_values = [];
+			for ( let key of keys ) {
+				array_values.push(values);
+			}
+			values = array_values;
+        }
+
+        if ( !Array.isArray(keys) ) {
+            keys = [keys];
+			values = [values];
+        }
+
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( ids.includes(parseInt(items[index].id)) ) {
+                for ( let j = 0; j < keys.length; j++ ) {
+                    items[i][keys[j]] = values[j];
+                }
+            }
+        }
+
+        return items;
+    },
+
+    toggleKey(items, id, key) {
+        return self.toggleKeys(items, id, key);
+    },
+
+    toggleKeys(items, ids, keys) {
+        let not_empty = window.handleEmpty(items);
+        if ( not_empty !== true ) {
+            return not_empty;
+        }
+
+        if ( !Array.isArray(ids) ) {
+            if ( typeof ids === 'string' ) {
+                ids = parseInt(ids);
+            }
+
+            ids = [ids];
+        }
+
+        if ( !Array.isArray(keys) ) {
+            keys = [keys];
+        }
+
+        let count = Array.isArray(items) ? items.length : Object.keys(items).length;
+        for ( let i = 0; i < count; i++ ) {
+            let index = Array.isArray(items) ? i : Object.keys(items)[i];
+
+            if ( ids.includes(parseInt(items[index].id)) ) {
+                for ( let j = 0; j < keys.length; j++ ) {
+                    items[index][keys[j]] = !items[index][keys[j]];
+                }
+            }
+        }
+
+        return items;
+    },
+
+    sort(items, from, to) {
+        const copy = [...items];
+        const valueToMove = copy.splice(from, 1)[0];
+        copy.splice(to, 0, valueToMove);
+
+        return copy;
+    },
+
+    next(items, current, key = 'id')  {
+        for ( let i = 0; i < items.length; i++ ) {
+            if ( items[i][key] == current[key] && i < items.length - 1 ) {
+                return items[i + 1];
+            }
+        }
+
+        return false;
+    },
+
+    prev(items, current, key = 'id')  {
+        for ( let i = items.length - 1; i >= 0; i-- ) {
+            if ( items[i][key] == current[key] && i > 0 ) {
+                return items[i - 1];
+            }
+        }
+
+        return false;
+    },
+};
+
+window.pluck = self.pluck;
+window.spread = self.spread;
+window.keyBy = self.keyBy;
+window.groupBy = self.groupBy;
+
+export default self;

package/src/Support/Storage.js

@@ -0,0 +1,23 @@
+const self = {
+    async get(key) {
+        try {
+            return JSON.parse(await Neutralino.storage.getData(key));
+        }
+        catch (e) {
+            return null;
+        }
+    },
+    async set(key, value) {
+        await Neutralino.storage.setData(key, JSON.stringify(value));
+    },
+
+    async remove(key) {
+        await Neutralino.storage.setData(key, null);
+    },
+
+    async clear() {
+        await Neutralino.filsystem.remove(`${APP_PATH}/.storage`);
+    },
+};
+
+export default self;

package/src/Tray.js

@@ -0,0 +1,47 @@
+let TrayActions = {};
+let context = import.meta.glob('/app/Tray/**/*.js');
+let inited = false;
+
+//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]]();
+        TrayActions[name] = module.default;
+    }
+}
+
+export default async (tray) => {
+	if ( tray.for_window != WINDOW_TYPE ) {
+		return;
+	}
+
+	if ( !inited ) {
+	    await loadModules();
+
+		for ( let item of tray.menuItems ) {
+			if ( !item.id ) {
+				continue;
+			}
+
+			let split = item.id.split('/');
+			if ( !TrayActions[split[0]] ) {
+				throw `Tray Action "${item.id}" not found.`;
+			}
+		}
+
+		Neutralino.events.on('trayMenuItemClicked', (e) => {
+			let split = e.detail.id.split('/');
+			let action_name = split[0];
+			split.shift();
+			TrayActions[action_name].run.apply(this, split);
+	    });
+
+		inited = true;
+	}
+
+    Neutralino.os.setTray(tray);
+};

package/src/Validator.js

@@ -1,4 +1,4 @@
-import * as ValidatorJS from 'validatorjs';
+import * as ValidatorJS from 'validatorjs/dist/validator.js';
 
 let self = {
     make(data, rules, messages) {

package/src/Models.js

@@ -1,19 +0,0 @@
-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;
-};