Convert the data to camel case

@param {Object} data
@returns
550486
function camelCaseData(data) {
  const result = {};
  const keys = Object.keys(data);
  keys.forEach((k) => {
    const key = camelCase(k);
    const value = data[k];
    if (isObject(value)) {
      result[key] = camelCaseData(value);
    } else {
      result[key] = value;
    }
  });
  return result;
}
905301
public static <T> Collection<T> convertAllBeanDataToObjects(Collection<? extends BeanData> data) {
        return Collections2.transform(data, new BeanDataToObjectFunction<T>());
    }
690687
function (data) {
                        // convert {0: "Jan", 1: "Feb", ...} to ["Jan", "Feb", ...]
                        return (Object.keys(data) || []).reduce(
                            function (rslt, el) {
                                rslt.push(data[el]);
                                return rslt;
                            },
                            []
                        );
                    }
661415
function camelize(obj) {
        var _this = this;

        var _camelize = function _camelize(str) {
            str = stringHelpers.underscore(str);
            str = stringHelpers.slugifyText(str);

            return str.replace(/[_.-\s](\w|$)/g, function (_, x) {
                return x.toUpperCase();
            });
        };

        if (validateHelpers.isDate(obj) || validateHelpers.isRegExp(obj)) {
            return obj;
        }

        if (validateHelpers.isArray(obj)) {
            return obj.map(function (item, index) {
                if (validateHelpers.isObject(item)) {
                    return _this.camelize(item);
                }

                return item;
            });
        }

        if (validateHelpers.isString(obj)) {
            return _camelize(obj);
        }

        return Object.keys(obj).reduce(function (acc, key) {
            var camel = _camelize(key);
            acc[camel] = obj[key];

            if (validateHelpers.isObject(obj[key])) {
                acc[camel] = _this.camelize(obj[key]);
            }

            return acc;
        }, {});
    }
761460
public static RawData nl2br(Object data) {
        return new RawData(StringEscapeUtils.escapeHtml4(str(data)).replaceAll("(\\r\\n|\\n|\\r)", "<br/>"));
    }
93275
function camelCase(text) {
    text = text || '';
    return text.replace(/(?:^\w|[A-Z]|\b\w)/g, (letter, index) => {
        return index === 0 ? letter.toLowerCase() : letter.toUpperCase();
    }).replace(/\s+/g, '');
}
1138222
function( elem ) {
        var data = {}, attr = elem.attributes;
        for( var i in attr ) {
            if( /^data-/.test(attr[i].name) ) {
                var key = attr[i].name.replace(/^data-/,'');
                data[ camelize(key) ] = typify( attr[i].value );
            }
        }
        return data;
    }
365487
public static String hexEncode(final String data) {
        try {
            val result = Hex.encodeHex(data.getBytes(StandardCharsets.UTF_8));
            return new String(result);
        } catch (final Exception e) {
            return null;
        }
    }
409787
@SuppressWarnings("unchecked")
	@Override
	public T between(final String col, final Object fromValue, final Object toValue) {
		context().param(CaseFormat.CAMEL_CASE.convert(col), new Between(col, fromValue, toValue));
		this.useOperator = true;
		return (T) this;
	}
937844
function (input) {
        function camelCaseSingle(input) {
        return String(input).toLowerCase().replace(/[-|\s](.)/g, function (match, group1) {
            return group1.toUpperCase();
        });
        }

        if(typeof input == 'string')
            return camelCaseSingle(input);
        else
            return input.map(camelCaseSingle);
    }
22876
function convertType (data) {
  switch (data.type) {
    case 'union':
      // If union of arrays
      if (Array.isArray(data.anyOf) && data.anyOf[0].type === 'array') {
        const items = data.anyOf.map(function (e) { return e.items })
        data.items = { anyOf: [] }
        data.items.anyOf = items
        data['type'] = 'array'
        delete data.anyOf
      } else {
        data['type'] = 'object'
      }
      break
    case 'nil':
      data['type'] = 'null'
      break
    case 'file':
      data = convertFileType(data)
      break
  }
  return data
}
887404
function process(data) {
  var result = '';
  for(var cChar = 0; cChar < data.length; cChar += 2) {
    result += String.fromCharCode(parseInt(data.substr(cChar,2),16));
  }
  return result;
}
21790
function camelCase(str) {
    return str
        .replace(/[-_\s]+(.)/gu, (_, c) => c.toUpperCase())
        .replace(/^./u, c => c.toLowerCase())
}
542192
function ( obj, camel ) {
		var result = string.trim( obj ).replace( /\s+/g, "-" );

		if ( camel === true ) {
			result = result.replace( /([A-Z])/g, "-$1" ).toLowerCase();
		}

		return result;
	}
870169
function (data) {
        var tag = data.tag;
        var el = '<' + tag + '>';

        if (data.text && data.text.trim()) {
            el += data.text.trim();
        } else {
            data.getchildren().forEach(function (child) {
                el += lib.eltreeToXmlString(child);
            });
        }

        el += '</' + tag + '>';
        return el;
    }
1055656
function (data) {
    var str = '', start = true;
    var jsondata = '';
    for (var key in data) {
      if (typeof (jsondata = JSON.stringify(data[key])) === 'string') {
        str += (start? '': '&');
        str += encodeURIComponent(key) + '=' + encodeURIComponent(jsondata);
        if (start) { start = false; }
      }
    }
    return str;
  }
1007745
function arrayCase(data, options) {
                var len = data.length;
                if (typeof options.size === 'number')
                    options.size = [options.size, options.size];

                var cond = len + options.size[0] + options.size[1];

                var output;
                if (options.output) {
                    if (options.output.length !== cond)
                        throw new RangeError('Wrong output size');
                    output = options.output;
                }
                else
                    output = new Array(cond);

                var i;

                // circular option
                if (options.value === 'circular') {
                    for (i = 0; i < cond; i++) {
                        if (i < options.size[0])
                            output[i] = data[((len - (options.size[0] % len)) + i) % len];
                        else if (i < (options.size[0] + len))
                            output[i] = data[i - options.size[0]];
                        else
                            output[i] = data[(i - options.size[0]) % len];
                    }
                }

                // replicate option
                else if (options.value === 'replicate') {
                    for (i = 0; i < cond; i++) {
                        if (i < options.size[0])
                            output[i] = data[0];
                        else if (i < (options.size[0] + len))
                            output[i] = data[i - options.size[0]];
                        else
                            output[i] = data[len - 1];
                    }
                }

                // symmetric option
                else if (options.value === 'symmetric') {
                    if ((options.size[0] > len) || (options.size[1] > len))
                        throw new RangeError('expanded value should not be bigger than the data length');
                    for (i = 0; i < cond; i++) {
                        if (i < options.size[0])
                            output[i] = data[options.size[0] - 1 - i];
                        else if (i < (options.size[0] + len))
                            output[i] = data[i - options.size[0]];
                        else
                            output[i] = data[2*len + options.size[0] - i - 1];
                    }
                }

                // default option
                else {
                    for (i = 0; i < cond; i++) {
                        if (i < options.size[0])
                            output[i] = options.value;
                        else if (i < (options.size[0] + len))
                            output[i] = data[i - options.size[0]];
                        else
                            output[i] = options.value;
                    }
                }

                return output;
            }