@radiantabyss/neutralino 1.0.2 → 1.1.0

package/package.json

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

package/src/Bootstrap.js

@@ -1,24 +1,38 @@
 import Response from './Response.js';
-import Invoke from './Invoke.js';
+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 = {};
+
+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.RA = {};
-    window.Config = Config;
-    window.Env = Env;
-
     window.Response = Response;
-    window.Invoke = Invoke;
+    window.Invoked = Invoked;
     window.Validator = Validator;
     window.IPC = IPC;
 };

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

@@ -1,3 +1,5 @@
+import Str from './../Support/Str';
+
 let group_middleware = null;
 
 function addRoute(method, path, action, middleware, name, throw_error) {
@@ -5,9 +7,6 @@ function addRoute(method, path, action, middleware, name, throw_error) {
         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('.');
@@ -21,16 +20,16 @@ function addRoute(method, path, action, middleware, name, throw_error) {
 
     let component;
     try {
-        component = getAction(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.RouteFiles[__neutralino_route_file].push({
+    window.RA.RouteFiles[window.RA.__neutralino_route_file].push({
         name: action_name,
         component,
         path,

package/src/Routing/RouteCrud.js

@@ -1,3 +1,5 @@
+import Str from './../Support/Str';
+
 let self = {
     run(domain) {
         domain = domain.replace(/\\/g, '.').replace(/\//g, '.');

package/src/Routing/Router.js

@@ -21,15 +21,15 @@ const loadModules = async () => {
         let file = files[i].replace('/app/Routes/', '').replace(/\.js$/, '');
         window.RA.__neutralino_route_file = file;
 
-        if ( !RouteFiles[window.RA.__neutralino_route_file] ) {
-            RouteFiles[window.RA.__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 = [];
 
@@ -69,11 +69,12 @@ const match = async(args, event) => {
             for (let i = 1; i < match.length; i++) {
                 params.push(match[i]);
             }
+
+            break;
         }
     }
 
-    Invoke.data = args.payload;
-    params.push(event);
+    Invoked.data = args.payload;
 
     return {
         Route: matched,
@@ -88,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/Support/Config.js

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

@@ -0,0 +1,209 @@
+let self = {
+    /*helpers from https://github.com/validatorjs/validator.js*/
+    ltrim(str, chars) {
+        const pattern = chars ? new RegExp(`^[${chars.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}]+`, 'g') : /^\s+/g;
+        return `${str}`.replace(pattern, '');
+    },
+
+    rtrim(str, chars) {
+        const pattern = chars ? new RegExp(`[${chars.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}]+$`, 'g') : /(\s)+$/g;
+        return `${str}`.replace(pattern, '');
+    },
+
+    trim(str, chars) {
+        return self.rtrim(self.ltrim(`${str}`, chars), chars);
+    },
+    /*end helpers from https://github.com/validatorjs/validator.js*/
+
+    urlencode(str) {
+        return encodeURIComponent(str);
+    },
+
+    slug(str) {
+        str = str.replace(/^\s+|\s+$/g, ''); // trim
+        str = str.toLowerCase();
+
+        // remove accents, swap ñ for n, etc
+        var from = "àáãäâèéëêìíïîòóöôùúüûñç·/_,:;";
+        var to   = "aaaaaeeeeiiiioooouuuunc------";
+
+        for (var i=0, l=from.length ; i<l ; i++) {
+            str = str.replace(new RegExp(from.charAt(i), 'g'), to.charAt(i));
+        }
+
+        str = str.replace(/[^a-z0-9 -]/g, '') // remove invalid chars
+            .replace(/\s+/g, '-') // collapse whitespace and replace by -
+            .replace(/-+/g, '-'); // collapse dashes
+
+        return str;
+    },
+
+    dash(str) {
+        return str.split('').map((letter, idx) => {
+            return letter.toUpperCase() === letter
+            ? `${idx !== 0 ? '-' : ''}${letter.toLowerCase()}`
+            : letter;
+        }).join('');
+    },
+
+    snake(string) {
+        return string
+            .replace(/\s+(?=\d)/g, '')
+            .replace(/\s+/g, '_')
+            .replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+            .toLowerCase();
+    },
+
+    camel(str) {
+        return str.replace(/-/g, ' ').replace(/_/g, ' ').replace(/(^([a-zA-Z\p{M}]))|([ -][a-zA-Z\p{M}])/g,function(s) {
+            return s.toUpperCase();
+        }).replace(/\s+/g, '');
+    },
+
+    pascal(str) {
+        return `${str}`
+            .toLowerCase()
+            .replace(new RegExp(/[-_]+/, 'g'), ' ')
+            .replace(new RegExp(/[^\w\s]/, 'g'), '')
+            .replace(new RegExp(/\s+(.)(\w*)/, 'g'), ($1, $2, $3) => `${$2.toUpperCase() + $3}`)
+            .replace(new RegExp(/\w/), s => s.toUpperCase());
+    },
+
+    kebab(str) {
+        return `${str}`.replace(/([a-z])([A-Z])/g, "$1-$2")
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase();
+    },
+
+    camel2space(str) {
+        if ( !str ) {
+            return '';
+        }
+
+        return str.split('').map((letter, idx) => {
+            return letter.toUpperCase() === letter
+            ? `${idx !== 0 ? ' ' : ''}${letter}`
+            : letter;
+        }).join('');
+    },
+
+    ucfirst(string) {
+        return string.charAt(0).toUpperCase() + string.slice(1);
+    },
+
+    ucwords(str) {
+        if ( !str ) {
+            str = '';
+        }
+
+        //ensure string
+        str = str + '';
+
+        return str.replace(/-/g, ' ').replace(/_/g, ' ').replace(/(^([a-zA-Z\p{M}]))|([ -][a-zA-Z\p{M}])/g,function(s) {
+            return s.toUpperCase();
+        });
+    },
+
+    ordinal_suffix(i) {
+        var j = i % 10,
+            k = i % 100;
+        if (j == 1 && k != 11) {
+            return i + "st";
+        }
+        if (j == 2 && k != 12) {
+            return i + "nd";
+        }
+        if (j == 3 && k != 13) {
+            return i + "rd";
+        }
+
+        return i + "th";
+    },
+
+    number_to_month(number) {
+        let months = {
+            1: 'January',
+            2: 'February',
+            3: 'March',
+            4: 'April',
+            5: 'May',
+            6: 'June',
+            7: 'July',
+            8: 'August',
+            9: 'September',
+            10: 'October',
+            11: 'November',
+            12: 'December',
+        };
+
+        return months[`${number}`.replace(/^0/, '')];
+    },
+
+    nl2br(str) {
+        if ( !str || !str.length ) {
+            return '';
+        }
+
+        return str.replace(/(\r\n|\n\r|\r|\n)/g, '<br/>' + '$1');
+    },
+
+    strip_tags(str) {
+        var div = document.createElement("div");
+        div.innerHTML = str;
+        var text = div.textContent || div.innerText || "";
+        return text;
+    },
+
+    ensure_https(string) {
+        if (!string.match(/^[a-zA-Z]+:\/\//)) {
+            string = 'https://' + string;
+        }
+
+        return string;
+    },
+
+    add_commas(number) {
+        if ( number === undefined || number === null ) {
+            return '';
+        }
+
+        number = parseFloat(number).toFixed(2).toLocaleString('en-US');
+
+        return number;
+    },
+
+    leading_zero(number) {
+        return number < 10 ? `0${number}` : number;
+    },
+
+    to_percetange(number) {
+        if ( number === undefined || !number ) {
+            return '0%';
+        }
+
+        return (number / 10)+'%';
+    },
+
+    plural(str) {
+        if ( str.match(/y$/) ) {
+            return str.replace(/y$/, 'ies');
+        }
+
+        if ( str.match(/s$/) ) {
+            return `${str}es`;
+        }
+
+        return `${str}s`;
+    },
+
+    truncate(str, length) {
+        if (str.length > length) {
+            return str.slice(0, length) + '...';
+        }
+
+        return str;
+    },
+}
+
+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;
-};