query-string 4.2.2 → 4.3.2

package/index.js

@@ -2,6 +2,92 @@
 var strictUriEncode = require('strict-uri-encode');
 var objectAssign = require('object-assign');
 
+function encoderForArrayFormat(opts) {
+	switch (opts.arrayFormat) {
+		case 'index':
+			return function (key, value, index) {
+				return value === null ? [
+					encode(key, opts),
+					'[',
+					index,
+					']'
+				].join('') : [
+					encode(key, opts),
+					'[',
+					encode(index, opts),
+					']=',
+					encode(value, opts)
+				].join('');
+			};
+
+		case 'bracket':
+			return function (key, value) {
+				return value === null ? encode(key, opts) : [
+					encode(key, opts),
+					'[]=',
+					encode(value, opts)
+				].join('');
+			};
+
+		default:
+			return function (key, value) {
+				return value === null ? encode(key, opts) : [
+					encode(key, opts),
+					'=',
+					encode(value, opts)
+				].join('');
+			};
+	}
+}
+
+function parserForArrayFormat(opts) {
+	var result;
+
+	switch (opts.arrayFormat) {
+		case 'index':
+			return function (key, value, accumulator) {
+				result = /\[(\d*)\]$/.exec(key);
+
+				key = key.replace(/\[\d*\]$/, '');
+
+				if (!result) {
+					accumulator[key] = value;
+					return;
+				}
+
+				if (accumulator[key] === undefined) {
+					accumulator[key] = {};
+				}
+
+				accumulator[key][result[1]] = value;
+			};
+
+		case 'bracket':
+			return function (key, value, accumulator) {
+				result = /(\[\])$/.exec(key);
+
+				key = key.replace(/\[\]$/, '');
+
+				if (!result || accumulator[key] === undefined) {
+					accumulator[key] = value;
+					return;
+				}
+
+				accumulator[key] = [].concat(accumulator[key], value);
+			};
+
+		default:
+			return function (key, value, accumulator) {
+				if (accumulator[key] === undefined) {
+					accumulator[key] = value;
+					return;
+				}
+
+				accumulator[key] = [].concat(accumulator[key], value);
+			};
+	}
+}
+
 function encode(value, opts) {
 	if (opts.encode) {
 		return opts.strict ? strictUriEncode(value) : encodeURIComponent(value);
@@ -10,11 +96,29 @@ function encode(value, opts) {
 	return value;
 }
 
+function keysSorter(input) {
+	if (Array.isArray(input)) {
+		return input.sort();
+	} else if (typeof input === 'object') {
+		return keysSorter(Object.keys(input)).sort(function (a, b) {
+			return Number(a) - Number(b);
+		}).map(function (key) {
+			return input[key];
+		});
+	}
+
+	return input;
+}
+
 exports.extract = function (str) {
 	return str.split('?')[1] || '';
 };
 
-exports.parse = function (str) {
+exports.parse = function (str, opts) {
+	opts = objectAssign({arrayFormat: 'none'}, opts);
+
+	var formatter = parserForArrayFormat(opts);
+
 	// Create an object with no prototype
 	// https://github.com/sindresorhus/query-string/issues/47
 	var ret = Object.create(null);
@@ -36,32 +140,37 @@ exports.parse = function (str) {
 		var key = parts.shift();
 		var val = parts.length > 0 ? parts.join('=') : undefined;
 
-		key = decodeURIComponent(key);
-
 		// missing `=` should be `null`:
 		// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
 		val = val === undefined ? null : decodeURIComponent(val);
 
-		if (ret[key] === undefined) {
-			ret[key] = val;
-		} else if (Array.isArray(ret[key])) {
-			ret[key].push(val);
+		formatter(decodeURIComponent(key), val, ret);
+	});
+
+	return Object.keys(ret).sort().reduce(function (result, key) {
+		var val = ret[key];
+		if (Boolean(val) && typeof val === 'object' && !Array.isArray(val)) {
+			// Sort object keys, not values
+			result[key] = keysSorter(val);
 		} else {
-			ret[key] = [ret[key], val];
+			result[key] = val;
 		}
-	});
 
-	return ret;
+		return result;
+	}, Object.create(null));
 };
 
 exports.stringify = function (obj, opts) {
 	var defaults = {
 		encode: true,
-		strict: true
+		strict: true,
+		arrayFormat: 'none'
 	};
 
 	opts = objectAssign(defaults, opts);
 
+	var formatter = encoderForArrayFormat(opts);
+
 	return obj ? Object.keys(obj).sort().map(function (key) {
 		var val = obj[key];
 
@@ -81,11 +190,7 @@ exports.stringify = function (obj, opts) {
 					return;
 				}
 
-				if (val2 === null) {
-					result.push(encode(key, opts));
-				} else {
-					result.push(encode(key, opts) + '=' + encode(val2, opts));
-				}
+				result.push(formatter(key, val2, result.length));
 			});
 
 			return result.join('&');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "query-string",
-  "version": "4.2.2",
+  "version": "4.3.2",
   "description": "Parse and stringify URL query strings",
   "license": "MIT",
   "repository": "sindresorhus/query-string",
@@ -38,7 +38,7 @@
     "strict-uri-encode": "^1.0.0"
   },
   "devDependencies": {
-    "ava": "*",
-    "xo": "*"
+    "ava": "^0.17.0",
+    "xo": "^0.16.0"
   }
 }

package/readme.md

@@ -2,6 +2,12 @@
 
 > Parse and stringify URL [query strings](http://en.wikipedia.org/wiki/Query_string)
 
+---
+
+<p align="center"><b>🔥 Want to strengthen your core JavaScript skills and master ES6?</b><br>I would personally recommend this awesome <a href="https://ES6.io/friend/AWESOME">ES6 course</a> by Wes Bos. You might also like his <a href="https://ReactForBeginners.com/friend/AWESOME">React course</a>.</p>
+
+---
+
 
 ## Install
 
@@ -32,8 +38,11 @@ console.log(parsedHash);
 parsed.foo = 'unicorn';
 parsed.ilike = 'pizza';
 
-location.search = queryString.stringify(parsed);
+const stringified = queryString.stringify(parsed);
+//=> 'foo=unicorn&ilike=pizza'
 
+location.search = stringified;
+// note that `location.search` automatically prepends a question mark
 console.log(location.search);
 //=> '?foo=unicorn&ilike=pizza'
 ```
@@ -41,19 +50,47 @@ console.log(location.search);
 
 ## API
 
-### .parse(*string*)
+### .parse(*string*, *[options]*)
 
 Parse a query string into an object. Leading `?` or `#` are ignored, so you can pass `location.search` or `location.hash` directly.
 
 The returned object is created with [`Object.create(null)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create) and thus does not have a `prototype`.
 
+#### arrayFormat
+
+Type: `string`<br>
+Default: `'none'`
+
+Supports both `index` for an indexed array representation or `bracket` for a *bracketed* array representation.
+
+- `bracket`: stands for parsing correctly arrays with bracket representation on the query string, such as:
+
+```js
+queryString.parse('foo[]=1&foo[]=2&foo[]=3', {arrayFormat: 'bracket'});
+//=> foo: [1,2,3]
+```
+
+- `index`: stands for parsing taking the index into account, such as:
+
+```js
+queryString.parse('foo[0]=1&foo[1]=2&foo[3]=3', {arrayFormat: 'index'});
+//=> foo: [1,2,3]
+```
+
+- `none`: is the **default** option and removes any bracket representation, such as:
+
+```js
+queryString.parse('foo=1&foo=2&foo=3');
+//=> foo: [1,2,3]
+```
+
 ### .stringify(*object*, *[options]*)
 
 Stringify an object into a query string, sorting the keys.
 
 #### strict
 
-Type: `boolean`<br />
+Type: `boolean`<br>
 Default: `true`
 
 Strictly encode URI components with [strict-uri-encode](https://github.com/kevva/strict-uri-encode). It uses [encodeURIComponent](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent)
@@ -66,6 +103,34 @@ Default: `true`
 
 [URL encode](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent) the keys and values.
 
+#### arrayFormat
+
+Type: `string`<br>
+Default: `'none'`
+
+Supports both `index` for an indexed array representation or `bracket` for a *bracketed* array representation.
+
+- `bracket`: stands for parsing correctly arrays with bracket representation on the query string, such as:
+
+```js
+queryString.stringify({foo: [1,2,3]}, {arrayFormat: 'bracket'});
+// => foo[]=1&foo[]=2&foo[]=3
+```
+
+- `index`: stands for parsing taking the index into account, such as:
+
+```js
+queryString.stringify({foo: [1,2,3]}, {arrayFormat: 'index'});
+// => foo[0]=1&foo[1]=2&foo[3]=3
+```
+
+- `none`: is the __default__ option and removes any bracket representation, such as:
+
+```js
+queryString.stringify({foo: [1,2,3]});
+// => foo=1&foo=2&foo=3
+```
+
 ### .extract(*string*)
 
 Extract a query string from a URL that can be passed into `.parse()`.