152 lines
3.2 KiB
JavaScript
152 lines
3.2 KiB
JavaScript
// Load modules
|
|
|
|
var Utils = require('./utils');
|
|
|
|
|
|
// Declare internals
|
|
|
|
var internals = {
|
|
depth: 5,
|
|
arrayLimit: 20,
|
|
parametersLimit: 1000
|
|
};
|
|
|
|
|
|
internals.parseValues = function (str) {
|
|
|
|
var obj = {};
|
|
var parts = str.split('&').slice(0, internals.parametersLimit);
|
|
|
|
for (var i = 0, il = parts.length; i < il; ++i) {
|
|
var part = parts[i];
|
|
var pos = part.indexOf(']=') === -1 ? part.indexOf('=') : part.indexOf(']=') + 1;
|
|
|
|
if (pos === -1) {
|
|
obj[Utils.decode(part)] = '';
|
|
}
|
|
else {
|
|
var key = Utils.decode(part.slice(0, pos));
|
|
var val = Utils.decode(part.slice(pos + 1));
|
|
|
|
if (!obj[key]) {
|
|
obj[key] = val;
|
|
}
|
|
else {
|
|
obj[key] = [].concat(obj[key]).concat(val);
|
|
}
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
|
|
internals.parseObject = function (chain, val) {
|
|
|
|
if (!chain.length) {
|
|
return val;
|
|
}
|
|
|
|
var root = chain.shift();
|
|
|
|
var obj = {};
|
|
if (root === '[]') {
|
|
obj = [];
|
|
obj = obj.concat(internals.parseObject(chain, val));
|
|
}
|
|
else {
|
|
var cleanRoot = root[0] === '[' && root[root.length - 1] === ']' ? root.slice(1, root.length - 1) : root;
|
|
var index = parseInt(cleanRoot, 10);
|
|
if (!isNaN(index) &&
|
|
root !== cleanRoot &&
|
|
index <= internals.arrayLimit) {
|
|
|
|
obj = [];
|
|
obj[index] = internals.parseObject(chain, val);
|
|
}
|
|
else {
|
|
obj[cleanRoot] = internals.parseObject(chain, val);
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
};
|
|
|
|
|
|
internals.parseKeys = function (key, val, depth) {
|
|
|
|
if (!key) {
|
|
return;
|
|
}
|
|
|
|
depth = typeof depth === 'undefined' ? internals.depth : depth;
|
|
|
|
// The regex chunks
|
|
|
|
var parent = /^([^\[\]]*)/;
|
|
var child = /(\[[^\[\]]*\])/g;
|
|
|
|
// Get the parent
|
|
|
|
var segment = parent.exec(key);
|
|
|
|
// Don't allow them to overwrite object prototype properties
|
|
|
|
if (Object.prototype.hasOwnProperty(segment[1])) {
|
|
return;
|
|
}
|
|
|
|
// Stash the parent if it exists
|
|
|
|
var keys = [];
|
|
if (segment[1]) {
|
|
keys.push(segment[1]);
|
|
}
|
|
|
|
// Loop through children appending to the array until we hit depth
|
|
|
|
var i = 0;
|
|
while ((segment = child.exec(key)) !== null && i < depth) {
|
|
|
|
++i;
|
|
if (!Object.prototype.hasOwnProperty(segment[1].replace(/\[|\]/g, ''))) {
|
|
keys.push(segment[1]);
|
|
}
|
|
}
|
|
|
|
// If there's a remainder, just add whatever is left
|
|
|
|
if (segment) {
|
|
keys.push('[' + key.slice(segment.index) + ']');
|
|
}
|
|
|
|
return internals.parseObject(keys, val);
|
|
};
|
|
|
|
|
|
module.exports = function (str, depth) {
|
|
|
|
if (str === '' ||
|
|
str === null ||
|
|
typeof str === 'undefined') {
|
|
|
|
return {};
|
|
}
|
|
|
|
var tempObj = typeof str === 'string' ? internals.parseValues(str) : Utils.clone(str);
|
|
var obj = {};
|
|
|
|
// Iterate over the keys and setup the new object
|
|
|
|
for (var key in tempObj) {
|
|
if (tempObj.hasOwnProperty(key)) {
|
|
var newObj = internals.parseKeys(key, tempObj[key], depth);
|
|
obj = Utils.merge(obj, newObj);
|
|
}
|
|
}
|
|
|
|
return Utils.compact(obj);
|
|
};
|
|
|
|
|