1 | 'use strict';
|
2 |
|
3 | var utils = require('./utils');
|
4 |
|
5 | var has = Object.prototype.hasOwnProperty;
|
6 |
|
7 | var defaults = {
|
8 | allowDots: false,
|
9 | allowPrototypes: false,
|
10 | arrayLimit: 20,
|
11 | decoder: utils.decode,
|
12 | delimiter: '&',
|
13 | depth: 5,
|
14 | parameterLimit: 1000,
|
15 | plainObjects: false,
|
16 | strictNullHandling: false
|
17 | };
|
18 |
|
19 | var parseValues = function parseQueryStringValues(str, options) {
|
20 | var obj = {};
|
21 | var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
|
22 | var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
|
23 | var parts = cleanStr.split(options.delimiter, limit);
|
24 |
|
25 | for (var i = 0; i < parts.length; ++i) {
|
26 | var part = parts[i];
|
27 |
|
28 | var bracketEqualsPos = part.indexOf(']=');
|
29 | var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;
|
30 |
|
31 | var key, val;
|
32 | if (pos === -1) {
|
33 | key = options.decoder(part, defaults.decoder);
|
34 | val = options.strictNullHandling ? null : '';
|
35 | } else {
|
36 | key = options.decoder(part.slice(0, pos), defaults.decoder);
|
37 | val = options.decoder(part.slice(pos + 1), defaults.decoder);
|
38 | }
|
39 | if (has.call(obj, key)) {
|
40 | obj[key] = [].concat(obj[key]).concat(val);
|
41 | } else {
|
42 | obj[key] = val;
|
43 | }
|
44 | }
|
45 |
|
46 | return obj;
|
47 | };
|
48 |
|
49 | var parseObject = function (chain, val, options) {
|
50 | var leaf = val;
|
51 |
|
52 | for (var i = chain.length - 1; i >= 0; --i) {
|
53 | var obj;
|
54 | var root = chain[i];
|
55 |
|
56 | if (root === '[]') {
|
57 | obj = [];
|
58 | obj = obj.concat(leaf);
|
59 | } else {
|
60 | obj = options.plainObjects ? Object.create(null) : {};
|
61 | var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
|
62 | var index = parseInt(cleanRoot, 10);
|
63 | if (
|
64 | !isNaN(index)
|
65 | && root !== cleanRoot
|
66 | && String(index) === cleanRoot
|
67 | && index >= 0
|
68 | && (options.parseArrays && index <= options.arrayLimit)
|
69 | ) {
|
70 | obj = [];
|
71 | obj[index] = leaf;
|
72 | } else {
|
73 | obj[cleanRoot] = leaf;
|
74 | }
|
75 | }
|
76 |
|
77 | leaf = obj;
|
78 | }
|
79 |
|
80 | return leaf;
|
81 | };
|
82 |
|
83 | var parseKeys = function parseQueryStringKeys(givenKey, val, options) {
|
84 | if (!givenKey) {
|
85 | return;
|
86 | }
|
87 |
|
88 |
|
89 | var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
|
90 |
|
91 |
|
92 |
|
93 | var brackets = /(\[[^[\]]*])/;
|
94 | var child = /(\[[^[\]]*])/g;
|
95 |
|
96 |
|
97 |
|
98 | var segment = brackets.exec(key);
|
99 | var parent = segment ? key.slice(0, segment.index) : key;
|
100 |
|
101 |
|
102 |
|
103 | var keys = [];
|
104 | if (parent) {
|
105 |
|
106 |
|
107 | if (!options.plainObjects && has.call(Object.prototype, parent)) {
|
108 | if (!options.allowPrototypes) {
|
109 | return;
|
110 | }
|
111 | }
|
112 |
|
113 | keys.push(parent);
|
114 | }
|
115 |
|
116 |
|
117 |
|
118 | var i = 0;
|
119 | while ((segment = child.exec(key)) !== null && i < options.depth) {
|
120 | i += 1;
|
121 | if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
|
122 | if (!options.allowPrototypes) {
|
123 | return;
|
124 | }
|
125 | }
|
126 | keys.push(segment[1]);
|
127 | }
|
128 |
|
129 |
|
130 |
|
131 | if (segment) {
|
132 | keys.push('[' + key.slice(segment.index) + ']');
|
133 | }
|
134 |
|
135 | return parseObject(keys, val, options);
|
136 | };
|
137 |
|
138 | module.exports = function (str, opts) {
|
139 | var options = opts ? utils.assign({}, opts) : {};
|
140 |
|
141 | if (options.decoder !== null && options.decoder !== undefined && typeof options.decoder !== 'function') {
|
142 | throw new TypeError('Decoder has to be a function.');
|
143 | }
|
144 |
|
145 | options.ignoreQueryPrefix = options.ignoreQueryPrefix === true;
|
146 | options.delimiter = typeof options.delimiter === 'string' || utils.isRegExp(options.delimiter) ? options.delimiter : defaults.delimiter;
|
147 | options.depth = typeof options.depth === 'number' ? options.depth : defaults.depth;
|
148 | options.arrayLimit = typeof options.arrayLimit === 'number' ? options.arrayLimit : defaults.arrayLimit;
|
149 | options.parseArrays = options.parseArrays !== false;
|
150 | options.decoder = typeof options.decoder === 'function' ? options.decoder : defaults.decoder;
|
151 | options.allowDots = typeof options.allowDots === 'boolean' ? options.allowDots : defaults.allowDots;
|
152 | options.plainObjects = typeof options.plainObjects === 'boolean' ? options.plainObjects : defaults.plainObjects;
|
153 | options.allowPrototypes = typeof options.allowPrototypes === 'boolean' ? options.allowPrototypes : defaults.allowPrototypes;
|
154 | options.parameterLimit = typeof options.parameterLimit === 'number' ? options.parameterLimit : defaults.parameterLimit;
|
155 | options.strictNullHandling = typeof options.strictNullHandling === 'boolean' ? options.strictNullHandling : defaults.strictNullHandling;
|
156 |
|
157 | if (str === '' || str === null || typeof str === 'undefined') {
|
158 | return options.plainObjects ? Object.create(null) : {};
|
159 | }
|
160 |
|
161 | var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
|
162 | var obj = options.plainObjects ? Object.create(null) : {};
|
163 |
|
164 |
|
165 |
|
166 | var keys = Object.keys(tempObj);
|
167 | for (var i = 0; i < keys.length; ++i) {
|
168 | var key = keys[i];
|
169 | var newObj = parseKeys(key, tempObj[key], options);
|
170 | obj = utils.merge(obj, newObj, options);
|
171 | }
|
172 |
|
173 | return utils.compact(obj);
|
174 | };
|