@radiantabyss/neutralino 1.0.2 → 1.0.3

package/package.json

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

package/src/Bootstrap.js

@@ -1,5 +1,5 @@
 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';
 
@@ -7,18 +7,19 @@ import Config from './Support/Config.js';
 import Env from './Support/Env.js';
 import Helpers from './Support/Helpers.js';
 
+window.RA.Neu = {};
+
 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/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,7 +20,7 @@ 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.Neu.Actions, split[split.length - 1], namespace, action_name);
     }
     catch(e) {
         if ( throw_error ) {
@@ -30,7 +29,7 @@ function addRoute(method, path, action, middleware, name, throw_error) {
         return;
     }
 
-    window.RA.RouteFiles[__neutralino_route_file].push({
+    window.RA.Neu.RouteFiles[window.RA.Neu.__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

@@ -4,9 +4,9 @@ import RouteFiles from './RouteFiles.js';
 import Route from './Route.js';
 import RouteCrud from './RouteCrud.js';
 
-window.RA.RouteFiles = RouteFiles;
-window.RA.Route = Route;
-window.RA.RouteCrud = RouteCrud;
+window.RA.Neu.RouteFiles = RouteFiles;
+window.RA.Neu.Route = Route;
+window.RA.Neu.RouteCrud = RouteCrud;
 
 let Routes = [];
 
@@ -14,15 +14,15 @@ let Routes = [];
 let context = import.meta.glob('/app/Routes/**/*.js');
 
 const loadModules = async () => {
-    window.RA.Actions = await Actions();
+    window.RA.Neu.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.__neutralino_route_file = file;
+        window.RA.Neu.__neutralino_route_file = file;
 
-        if ( !RouteFiles[window.RA.__neutralino_route_file] ) {
-            RouteFiles[window.RA.__neutralino_route_file] = [];
+        if ( !window.RA.Neu.RouteFiles[window.RA.Neu.__neutralino_route_file] ) {
+            window.RA.Neu.RouteFiles[window.RA.Neu.__neutralino_route_file] = [];
         }
 
         await context[files[i]]();
@@ -69,10 +69,12 @@ const match = async(args, event) => {
             for (let i = 1; i < match.length; i++) {
                 params.push(match[i]);
             }
+
+            break;
         }
     }
 
-    Invoke.data = args.payload;
+    Invoked.data = args.payload;
     params.push(event);
 
     return {

package/src/Support/Config.js

@@ -7,33 +7,33 @@ 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) {
+        return await self.read(config);
     },
 
-    getKey(config, key) {
-        let data = self.read(config);
+    async getKey(config, key) {
+        let data = await self.read(config);
         return data[key];
     },
 
-    set(config, data) {
-        self.write(config, data);
+    async set(config, data) {
+        await self.write(config, data);
     },
 
-    setKey(config, key, value) {
-        let data = self.read(config);
+    async setKey(config, key, value) {
+        let data = await self.read(config);
         data[key] = value;
-        self.write(config, data);
+        await self.write(config, data);
     },
 
-    deleteKey(config, key) {
-        let data = self.read(config);
+    async deleteKey(config, key) {
+        let data = await self.read(config);
         delete data[key];
-        self.write(config, data);
+        await self.write(config, data);
     },
 
-    clear(config) {
-        self.write(config, {});
+    async clear(config) {
+        await self.write(config, {});
     },
 };
 

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;