@qikdev/sdk 0.1.14 → 0.1.18

package/src/api/qik.utils.js

@@ -1,17 +1,565 @@
-import _ from 'lodash';
+import _get from 'lodash/get';
+import _isDate from 'lodash/isDate';
+import _startsWith from 'lodash/startsWith';
+import _isObject from 'lodash/isObject';
+import _camelCase from 'lodash/camelCase';
 import axios from 'axios';
 import { isBrowser, isNode } from 'browser-or-node';
 
 
+
 ///////////////////////////////////////////////////////////////////////////////
 
-/**
- * @classdesc A static service that provides useful helper functions and tools for other Qik services
- * @alias utils
- * @class
- * @hideconstructor
- */
-var QikUtils = {};
+var service = {};
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+service.exists = function(value) {
+    var isUndefinedOrNull;
+
+    ////////////////////////
+
+    if (Array.isArray(value)) {
+        return true;
+    }
+
+    ////////////////////////
+
+    if (value === 0) {
+        return true;
+    }
+
+    ////////////////////////
+
+    switch (typeof value) {
+        case 'undefined':
+        case 'null':
+            isUndefinedOrNull = true;
+            break;
+        default:
+            var string = String(value).toLowerCase();
+            switch (string) {
+                case '':
+                case 'undefined':
+                case 'null':
+                    isUndefinedOrNull = true;
+                    break;
+            }
+            break;
+    }
+
+    return !!!isUndefinedOrNull;
+}
+
+//////////////////////////////////
+
+service.parseDate = function(input) {
+
+    if (!input) {
+        return;
+    }
+
+    if (_isDate(input)) {
+        return input;
+    }
+
+    //Attempt to create a date
+    var d = new Date(input);
+    var isValid = d instanceof Date && !isNaN(d);
+
+    if (isValid) {
+        return d;
+    }
+
+    return;
+}
+
+service.parseURL = function(string) {
+
+    if (!string) {
+        return false;
+    }
+
+    if (_startsWith(string, '/')) {
+        return string;
+    }
+
+    if (_startsWith(string, '://')) {
+        return string;
+    }
+
+    if (_startsWith(string, 'mailto:')) {
+        return string;
+    }
+
+    if (_startsWith(string, 'tel:')) {
+        return string;
+    }
+
+    if (_startsWith(string, 'sms:')) {
+        return string;
+    }
+
+    //////////////////////////////////
+    //If someone entered an email by accident
+    var email = service.parseEmail(string);
+    //Convert it to a mailto link
+    if (email && email === string) {
+        return `mailto:${email}`
+    }
+
+    //////////////////////////////////
+
+    const withHttp = string => !/^https?:\/\//i.test(string) ? `http://${string}` : string;
+    string = withHttp(string);
+
+
+
+    var valid = RegExp('(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+@]*)*(\\?[;&a-z\\d%_.~+=-@]*)?(\\#[-a-z\\d_@]*)?$', 'i').test(string);
+
+    if (!valid) {
+        return false;
+    }
+
+
+
+    ///////////////////////////
+
+    return withHttp(string)
+}
+
+
+///////////////////////////////////////////////
+
+service.parseNumber = function(input, decimalPoints) {
+    if (!input) {
+        return 0;
+    }
+
+    input = Number(input);
+    if (isNaN(input)) {
+        return 0;
+    }
+
+    if (decimalPoints) {
+        var str = input.toFixed(decimalPoints);
+        input = service.parseNumber(str);
+    }
+
+    return input;
+}
+
+
+service.isValidEmailAddress = function(email) {
+
+    var tester = /^[-!#$%&'*+\/0-9=?A-Z^_a-z`{|}~](\.?[-!#$%&'*+\/0-9=?A-Z^_a-z`{|}~])*@[a-zA-Z0-9](-*\.?[a-zA-Z0-9])*\.[a-zA-Z](-?[a-zA-Z0-9])+$/;
+
+    if (!email) return false;
+
+    var emailParts = email.split('@');
+
+    if (emailParts.length !== 2) return false
+
+    var account = emailParts[0];
+    var address = emailParts[1];
+
+    if (account.length > 64) return false
+
+    else if (address.length > 255) return false
+
+    var domainParts = address.split('.');
+    if (domainParts.some(function(part) {
+            return part.length > 63;
+        })) return false;
+
+
+    if (!tester.test(email)) return false;
+
+    return true;
+}
+
+
+service.parseEmail = function(input) {
+
+    if (!input) {
+        return false;
+    }
+
+    var lowercase = String(input).toLowerCase();
+    var valid = service.isValidEmailAddress(lowercase);
+
+    if (!valid) {
+        return false;
+    } else {
+        return lowercase;
+    }
+}
+
+//////////////////////////////////
+
+service.parseInt = function(input) {
+    if (!input) {
+        return 0;
+    }
+
+    input = parseInt(input);
+    if (isNaN(input)) {
+        return 0;
+    }
+
+    return input;
+}
+
+
+
+service.cleanValue = function(data, type, options) {
+
+    if (!options) {
+        options = {};
+    }
+
+    ////////////////////////
+
+    var noInputValue = service.exists(data);
+    if (options.strict && noInputValue && type != 'boolean') {
+        return data;
+    }
+
+    ////////////////////////
+
+    switch (type) {
+        case 'reference':
+            return service.id(data, true);
+            break;
+        case 'boolean':
+            return service.parseBoolean(data);
+            break;
+        case 'url':
+            return service.parseURL(data);
+            break;
+        case 'key':
+            return service.machineName(data);
+            break;
+        case 'email':
+            return service.parseEmail(data);
+            break;
+        case 'date':
+            var parsed = service.parseDate(data, options);
+
+            if (parsed === undefined) {
+                return;
+            } else {
+                return parsed;
+            }
+            break;
+        case 'number':
+        case 'decimal':
+        case 'float':
+            var val = service.parseNumber(data);
+            if (String(val) == String(Number(data))) {
+                return val;
+            }
+            return;
+            break;
+        case 'integer':
+            var val = service.parseInt(data);
+            if (String(val) == String(parseInt(data))) {
+                return val;
+            }
+            return;
+            break;
+        case 'group':
+            return data;
+            break;
+        case 'object':
+            if (_isObject(data) && !Array.isArray(data)) {
+                return data
+            }
+            return;
+            break;
+        case 'string':
+
+            if (service.exists(data)) {
+                var stringed = String(data);
+                if (stringed == '[object Object]') {
+                    return;
+                }
+
+                return stringed
+            } else {
+                return;
+            }
+
+            // if(!data) {
+            //     return '';
+            // }
+
+            // if(Array.isArray(data)) {
+            //      return JSON.stringify(data);
+            // }
+
+            // if(Object.isObject(data)) {
+            //     return JSON.stringify(data);
+            // }
+
+            // return String(data);
+
+            // break;
+        default:
+            return String(data)
+            break;
+    }
+}
+
+
+
+service.isValidValue = function(value, dataType, strict) {
+
+    var isValue = service.exists(value);
+    var valueIsNumber = (typeof value == 'number')
+
+    ////////////////////////
+
+    var isValidEntry = false;
+
+    if (!isValue) {
+        return false;
+    }
+
+    ////////////////////////
+
+    switch (dataType) {
+
+        case 'url':
+            if (strict) {
+                isValidEntry = _startsWith(value, '/') || _startsWith(value, '://') || _startsWith(value, 'http://') || _startsWith(value, 'https://');
+            } else {
+                isValidEntry = String(value) === service.parseURL(value);
+            }
+            break;
+        case 'key':
+            isValidEntry = String(value) === service.machineName(value);
+            break;
+        case 'date':
+
+            //If we are being strict
+            if (strict) {
+                //And the input is not a javascript date object
+                if (typeof value != 'object' || !_isDate(value)) {
+                    return false;
+                }
+            }
+
+            ///////////////////////////////
+            var parsed = service.parseDate(value);
+            return parsed !== undefined;
+            break;
+        case 'email':
+
+            if (strict) {
+                isValidEntry = value === service.parseEmail(value);
+            } else {
+                isValidEntry = String(value).toLowerCase() === service.parseEmail(value);
+            }
+
+            break;
+        case 'number':
+        case 'decimal':
+        case 'float':
+            if (strict) {
+                isValidEntry = valueIsNumber && (Number(value) === service.parseNumber(value));
+            } else {
+                isValidEntry = Number(value) === service.parseNumber(value);
+            }
+            break;
+        case 'integer':
+            if (strict) {
+                isValidEntry = valueIsNumber && (Number(value) === service.parseInt(value));
+            } else {
+                isValidEntry = Number(value) === service.parseInt(value);
+            }
+            break;
+        case 'boolean':
+
+            var parsed = service.parseBoolean(value);
+
+            //Only accept true booleans
+            if (strict) {
+                if (value === true || value === false) {
+                    isValidEntry = value === parsed;
+                }
+            } else {
+                isValidEntry = parsed === true || parsed === false;
+            }
+            break;
+        case 'reference':
+            if (strict) {
+                isValidEntry = String(value) === service.id(value);
+            } else {
+                isValidEntry = !!service.id(value);
+            }
+            break;
+        case 'string':
+            var checkString = String(value);
+            if (strict) {
+                if (typeof value != 'string') {
+                    return false;
+                }
+            }
+
+            if (checkString == '[object Object]') {
+                return false;
+            }
+
+            isValidEntry = true;
+            break;
+            // case 'group':
+            //     isValidEntry = _isObject(value);
+            //     break;
+        case 'object':
+            isValidEntry = _isObject(value) && !Array.isArray(value);
+            break;
+        case 'array':
+            isValidEntry = Array.isArray(value);
+            break;
+    }
+
+    ////////////////////////
+
+    return isValidEntry
+}
+
+service.parseBoolean = function(value) {
+    switch (String(value).toLowerCase()) {
+        case 'true':
+        case 'y':
+        case 'yes':
+        case '1':
+        case 't':
+            value = true;
+            break;
+        case 'false':
+        case 'n':
+        case 'no':
+        case '0':
+        case 'f':
+        case 'undefined':
+        case 'null':
+        case '':
+        case '-1':
+            value = false;
+            break;
+    }
+
+    return !!value;
+}
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+service.clone = function(input) {
+    return JSON.parse(JSON.stringify(input));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+service.mapFields = function(fields, options) {
+
+    if (!options) {
+        options = {};
+    }
+
+    //////////////////////////////
+
+    var output = [];
+    var trail = [];
+    var titles = [];
+    var currentDepth = 1;
+    var depthLimit = options.depth;
+
+
+    //Loop through each field
+    fields.forEach(mapField);
+
+    //////////////////////////////
+
+    //Recursively map the fields
+    function mapField(field, i) {
+
+
+        var fieldKey = field.key;
+        var isGroup = field.type == 'group';
+        var singleValue = (field.minimum === field.maximum) && field.minimum === 1;
+        var asObject = field.asObject; // || (isGroup && singleValue);
+        var isLayout = isGroup && !asObject;
+
+        //////////////////////////////////
+
+        var mapped = service.clone(field);
+
+
+        mapped.trail = trail.slice();
+        mapped.trail.push(fieldKey)
+        mapped.path = mapped.trail.join('.');
+
+
+        mapped.titles = titles.slice();
+        mapped.titles.push(field.title || fieldKey)
+
+
+        //If its an actual element or we've asked to include
+        //layout only elements
+        if (!isLayout || options.includeLayout) {
+            //Add it to the mix
+            output.push(mapped);
+        }
+
+        //////////////////////////////////
+
+        //Now see if there are child fields and should we go further
+        var limitHit = depthLimit && (currentDepth >= depthLimit);
+
+
+
+        //If there are child fields for this field
+        if (field.fields && field.fields.length) {
+            //If it's just a group with no extra key
+            if (isLayout) {
+                //Loop through fields as if they are at the same depth
+                field.fields.forEach(mapField)
+            } else {
+
+                //We don't need to traverse any further
+                //because we hit the limit
+                if (limitHit) {
+                    return;
+                }
+
+                //Move down a level and add to the object
+                //Include the key in the path trail
+                currentDepth++;
+                trail.push(fieldKey);
+                titles.push(field.title || fieldKey);
+
+                //Loop through each field
+                field.fields.forEach(mapField)
+
+                //Move back up a level before we go to the next field
+                currentDepth--;
+                trail.pop();
+                titles.pop();
+            }
+
+        }
+
+    }
+
+    return output;
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -24,27 +572,29 @@ var QikUtils = {};
  * //Returns &this=that&hello=world
  * qik.utils.mapParameters({"this":"that", "hello":"world"})
  */
-QikUtils.mapParameters = function(parameters) {
-    return _.chain(parameters)
-        .reduce(function(set, v, k) {
-            if (v === undefined || v === null || v === false) {
-                return set;
-            }
+service.mapParameters = function(parameters) {
 
-            if (_.isArray(v)) {
-                _.each(v, function(value) {
-                    set.push(`${k}=${encodeURIComponent(value)}`);
-                })
+    var array = [];
 
-            } else {
-                set.push(encodeURIComponent(k) + '=' + encodeURIComponent(v));
-            }
+    for (var key in parameters) {
+
+        var value = parameters[key];
+
+        if (value === undefined || value === null || value == false) {
+            return;
+        }
+
+        if (Array.isArray(value)) {
+            value.forEach(function(v) {
+                array.push(`${key}=${encodeURIComponent(v)}`);
+            })
+        } else {
+            array.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));
+        }
+    }
+
+    return array.join('&');
 
-            return set;
-        }, [])
-        .compact()
-        .value()
-        .join('&');
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -64,13 +614,13 @@ QikUtils.mapParameters = function(parameters) {
  * qik.utils.formatCurrency(1000, 'usd');
  * 
  */
-QikUtils.formatCurrency = function(value, currency) {
+service.formatCurrency = function(value, currency) {
 
     if (!value || isNaN(value)) {
         value = 0;
     }
 
-    var currencyPrefix = QikUtils.currencySymbol(currency);
+    var currencyPrefix = service.currencySymbol(currency);
     return `${currencyPrefix}${parseFloat(parseInt(value) / 100).toFixed(2)}`;
 
 }
@@ -90,7 +640,7 @@ QikUtils.formatCurrency = function(value, currency) {
  * qik.utils.currencySymbol('usd');
  * 
  */
-QikUtils.currencySymbol = function(currency) {
+service.currencySymbol = function(currency) {
     //Ensure lowercase currency
     currency = String(currency).toLowerCase();
 
@@ -109,53 +659,53 @@ QikUtils.currencySymbol = function(currency) {
 
 
 
-QikUtils.getAvailableCurrencies = function(defaultCountryCode) {
+service.getAvailableCurrencies = function(DefaultCountryID) {
 
 
     var array = [];
 
     array.push({
-        name: `USD (${QikUtils.currencySymbol("usd")})`,
+        name: `USD (${service.currencySymbol("usd")})`,
         value: "usd",
         countryCode: { 'US': true },
     });
 
     array.push({
-        name: `GBP (${QikUtils.currencySymbol("gbp")})`,
+        name: `GBP (${service.currencySymbol("gbp")})`,
         value: "gbp",
         countryCode: { 'GB': true, 'UK': true },
     });
 
     array.push({
-        name: `CAD (${QikUtils.currencySymbol("cad")})`,
+        name: `CAD (${service.currencySymbol("cad")})`,
         value: "cad",
         countryCode: { 'CA': true },
     });
 
     array.push({
-        name: `AUD (${QikUtils.currencySymbol("aud")})`,
+        name: `AUD (${service.currencySymbol("aud")})`,
         value: "aud",
         countryCode: { 'AU': true },
     });
 
 
     array.push({
-        name: `NZD (${QikUtils.currencySymbol("nzd")})`,
+        name: `NZD (${service.currencySymbol("nzd")})`,
         value: "nzd",
         countryCode: { 'NZ': true },
     });
 
     array.push({
-        name: `SGD (${QikUtils.currencySymbol("sgd")})`,
+        name: `SGD (${service.currencySymbol("sgd")})`,
         value: "sgd",
         countryCode: { 'SG': true },
     });
 
 
-    if (defaultCountryCode) {
+    if (DefaultCountryID) {
 
         var findMatch = array.findIndex(function(currency) {
-            return currency.countryCode[defaultCountryCode];
+            return currency.countryCode[DefaultCountryID];
         })
 
         const moveArrayItem = (array, fromIndex, toIndex) => {
@@ -185,19 +735,22 @@ QikUtils.getAvailableCurrencies = function(defaultCountryCode) {
  * qik.utils.mapReduce([{title:'test', definition:'something'}], 'definition');
  * 
  */
-QikUtils.hash = function(array, key) {
+service.hash = function(array, key) {
     if (!Array.isArray(array)) {
         array = [];
     }
     return array.reduce(function(set, item) {
-        var key = _.get(item, key);
-        set[key] = item;
+
+        var val = _get(item, key);
+
+        set[val] = item;
         return set;
     }, {});
 }
 
 
 
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -208,7 +761,7 @@ QikUtils.hash = function(array, key) {
  * //Returns 20354d7a-e4fe-47af-8ff6-187bca92f3f9
  * qik.utils.guid()
  */
-QikUtils.guid = function() {
+service.guid = function() {
     var u = (new Date()).getTime().toString(16) +
         Math.random().toString(16).substring(2) + "0".repeat(16);
     var guid = u.substr(0, 8) + '-' + u.substr(8, 4) + '-4000-8' +
@@ -239,7 +792,7 @@ QikUtils.guid = function() {
  * qik.utils.extractFromArray([{name:'Jerry', age:26}, {name:'Susan', age:19}], 'age', {sum:true});
  * 
  */
-QikUtils.extractFromArray = function(array, key, sum, flatten, unique, exclude, options) {
+service.extractFromArray = function(array, key, sum, flatten, unique, exclude, options) {
 
     if (!options) {
         options = {}
@@ -264,9 +817,9 @@ QikUtils.extractFromArray = function(array, key, sum, flatten, unique, exclude,
     /////////////////
 
     //Filter the array options by a certain value and operator
-    var matches = _.reduce(array, function(set, entry) {
+    var matches = array.reduce(function(set, entry) {
         //Get the value from the object
-        var retrievedValue = _.get(entry, key);
+        var retrievedValue = _get(entry, key);
 
         ///////////////////////
 
@@ -323,12 +876,12 @@ QikUtils.extractFromArray = function(array, key, sum, flatten, unique, exclude,
  * qik.utils.matchInArray([{name:'Jerry', age:26}, {name:'Susan', age:19}], 'age', 26, '>=');
  * 
  */
-QikUtils.matchInArray = function(array, key, value, operator) {
+service.matchInArray = function(array, key, value, operator) {
 
     //Filter the array options by a certain value and operator
-    var matches = _.filter(array, function(entry) {
+    var matches = array.filter(function(entry) {
         //Get the value from the object
-        var retrievedValue = _.get(entry, key);
+        var retrievedValue = _get(entry, key);
         var isMatch;
 
         ///////////////////////
@@ -348,7 +901,7 @@ QikUtils.matchInArray = function(array, key, value, operator) {
                 isMatch = (retrievedValue <= value);
                 break;
             case 'in':
-                isMatch = _.includes(retrievedValue, value);
+                isMatch = retrievedValue.includes(value);
                 break;
             default:
                 //operator is strict equals
@@ -385,7 +938,7 @@ QikUtils.matchInArray = function(array, key, value, operator) {
  * //Returns 'cat, dog, bird'
  * qik.utils.comma([{title:'cat'}, {title:'dog'}, {title:'bird'}], 'title');
  */
-QikUtils.comma = function(array, path, limit) {
+service.comma = function(array, path, limit) {
 
     if (limit) {
         array = array.slice(0, limit);
@@ -395,14 +948,13 @@ QikUtils.comma = function(array, path, limit) {
         .compact()
         .map(function(item) {
             if (path && path.length) {
-                return _.get(item, path);
+                return _get(item, path);
             }
 
             return item;
         })
         .value()
         .join(', ');
-
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -422,12 +974,12 @@ QikUtils.comma = function(array, path, limit) {
  * qik.utils.id('5cb3d8b3a2219970e6f86927')
  *
  * //Returns true
- * typeof QikUtils.id({_id:'5cb3d8b3a2219970e6f86927', title, ...}) == 'string';
+ * typeof service.id({_id:'5cb3d8b3a2219970e6f86927', title, ...}) == 'string';
 
  * //Returns true
- * typeof QikUtils.id({_id:'5cb3d8b3a2219970e6f86927'}, true) == 'object';
+ * typeof service.id({_id:'5cb3d8b3a2219970e6f86927'}, true) == 'object';
  */
-QikUtils.id = function(source) {
+service.id = function(source) {
 
     if (!source) {
         return;
@@ -465,29 +1017,39 @@ QikUtils.id = function(source) {
  * //Returns ['5cb3d8b3a2219970e6f86927', '5cb3d8b3a2219970e6f86927', '5cb3d8b3a2219970e6f86927']
  * qik.utils.ids([{_id:'5cb3d8b3a2219970e6f86927'}, {_id:'5cb3d8b3a2219970e6f86927'}, null, '5cb3d8b3a2219970e6f86927'])
  */
-QikUtils.ids = function(array) {
-    return _.chain(array)
-        .reduce(function(set, entry) {
 
-            if (!entry) {
-                return set;
-            }
+service.ids = function(array) {
 
-            var cleaned = service.id(entry)
+    if (!array) {
+        return [];
+    }
 
-            if (cleaned) {
-                set[cleaned] = 1;
-            }
+    /////////////////////////////////
+
+    var ids = Object.keys(array.reduce(function(set, entry) {
 
+        if (!entry) {
             return set;
-        }, {})
-        .keys()
-        .value();
+        }
+
+        var cleaned = service.id(entry)
+
+        if (cleaned) {
+            set[cleaned] = 1;
+        }
+
+        return set;
+    }, {}))
+
+    ///////////////////////////////
+
+    return ids;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
 
-QikUtils.isValidID = function(input) {
+service.isValidID = function(input) {
     var checkForHexRegExp = new RegExp("^[0-9a-fA-F]{24}$")
     return checkForHexRegExp.test(String(input));
 
@@ -501,32 +1063,38 @@ QikUtils.isValidID = function(input) {
  * @param  {Object} error The error object to translate    
  * @return {String}     The resulting human readable error message
  */
-QikUtils.errorMessage = function(err) {
+service.errorMessage = function(err) {
+
+    if (!err) {
+        return;
+    }
 
 
-    if (_.isArray(err)) {
-        err = _.first(err);
+    if (Array.isArray(err)) {
+        err = err[0];
     }
 
     ////////////////////////////////////
 
+
     var candidates = [
         'response.data.message',
         'response.data',
         'message',
     ]
 
-    ////////////////////////////////////
+    var message;
 
-    var message = _.chain(candidates)
-        .map(function(path) {
-            return _.get(err, path);
-        })
-        .compact()
-        .first()
-        .value();
+    candidates.forEach(function(path) {
+        if (message) {
+            return;
+        }
 
-    ////////////////////////////////////
+        var m = _get(err, path);
+        if (m) {
+            message = m;
+        }
+    })
 
     if (Array.isArray(message)) {
         message = message[0];
@@ -534,9 +1102,7 @@ QikUtils.errorMessage = function(err) {
 
     ////////////////////////////////////
 
-    if (!message || !message.length) {
-        return String(err);
-    }
+    message = message || JSON.stringify(err);
 
     ////////////////////////////////////
 
@@ -544,10 +1110,6 @@ QikUtils.errorMessage = function(err) {
 }
 
 
-/////////////////////////////////////////////
-/////////////////////////////////////////////
-
-
 
 ////////////////////////////////////
 ////////////////////////////////////
@@ -560,22 +1122,25 @@ QikUtils.errorMessage = function(err) {
  * @return {String}     A cleaned and formatted string eg. (awesomeEvent)
  */
 
-QikUtils.machineName = function(string) {
+service.machineName = function(string) {
 
     if (!string || !string.length) {
         return;
     }
 
+
     var regexp = /[^a-zA-Z0-9-_]+/g;
-    return string.replace(regexp, '');
+    var cleaned = String(string).replace(regexp, ' ');
+    return _camelCase(cleaned);
 }
 
+
 /////////////////////////////////////////////
 /////////////////////////////////////////////
 /////////////////////////////////////////////
 
 
-export default QikUtils;
+export default service;
 
 
 /////////////////////////////////////////////