feat: initial implement

Author: whtsky

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true

.gitignore

@@ -57,3 +57,5 @@ typings/
 # dotenv environment variables file
 .env
 
+*.js
+*.map

.npmrc

@@ -0,0 +1 @@
+registry=https://registry.npmjs.org/

.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - "6"
+
+

README.md

@@ -1,2 +1,2 @@
 # querystring
-Parse and stringify URL query strings
+Parse and stringify URL query strings. Forked from [query-string](https://github.com/sindresorhus/query-string)

index.ts

@@ -0,0 +1,119 @@
+export type QueryStringValue = string | null;
+export type QueryStringInputValue = QueryStringValue | undefined | number;
+export interface IParseReturn {
+  [key: string]: QueryStringValue | QueryStringValue[];
+}
+export interface IParseInput {
+  [key: string]: QueryStringInputValue | QueryStringInputValue[];
+}
+
+export interface IStringifyOptions {
+  sort?: false | ((a: string, b: string) => number);
+}
+
+function decodeUriComponent(input: string) {
+  try {
+    return decodeURIComponent(input);
+  } catch (e) {
+    return "";
+  }
+}
+
+export function encodeRFC3986ValueChars(str: string): string {
+  return encodeURIComponent(str).replace(
+    /[!'()*]/g,
+    x =>
+      `%${x
+        .charCodeAt(0)
+        .toString(16)
+        .toUpperCase()}`
+  );
+}
+
+export function arrayFormatEncoder(
+  key: string,
+  value: QueryStringValue
+): string {
+  return value === null
+    ? encodeRFC3986ValueChars(key)
+    : `${encodeRFC3986ValueChars(key)}=${encodeRFC3986ValueChars(value)}`;
+}
+
+export function arrayFormatParser(
+  key: string,
+  value: string,
+  ret: IParseReturn
+): IParseReturn {
+  if (ret[key] === undefined) {
+    ret[key] = value;
+    return;
+  }
+  ret[key] = [].concat(ret[key], value);
+}
+
+export function parse(input: string): IParseReturn {
+  const ret: IParseReturn = {};
+
+  input = input.trim().replace(/^[?#&]/, "");
+
+  if (!input) {
+    return ret;
+  }
+
+  for (const param of input.split("&")) {
+    const [key, value] = param.replace(/\+/g, " ").split("=");
+
+    // Missing `=` should be `null`:
+    // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+    arrayFormatParser(
+      decodeUriComponent(key),
+      value === undefined ? null : decodeUriComponent(value),
+      ret
+    );
+  }
+
+  return ret;
+}
+
+export function stringify(
+  obj?: IParseInput,
+  options: IStringifyOptions = {}
+): string {
+  if (!obj) {
+    return "";
+  }
+  const keys = Object.keys(obj);
+  if (options.sort !== false) {
+    keys.sort(options.sort);
+  }
+  return keys
+    .map(key => {
+      const value = obj[key];
+
+      if (value === undefined) {
+        return "";
+      }
+
+      if (value === null) {
+        return encodeRFC3986ValueChars(key);
+      }
+
+      if (Array.isArray(value)) {
+        return value
+          .filter(v => v !== undefined)
+          .map(v => {
+            if (typeof v === "number") {
+              v = v.toString();
+            }
+            return arrayFormatEncoder(key, v);
+          })
+          .join("&");
+      }
+
+      return `${encodeRFC3986ValueChars(key)}=${encodeRFC3986ValueChars(
+        value.toString()
+      )}`;
+    })
+    .filter(x => x.length > 0)
+    .join("&");
+}

package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@chaitin/querystring",
+  "version": "1.0.0",
+  "description": "Parse and stringify URL query strings",
+  "main": "index.js",
+  "scripts": {
+    "precommit": "lint-staged",
+    "test": "tsc && ava"
+  },
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chaitin/querystring"
+  },
+  "lint-staged": {
+    "linters": {
+      "*.ts": ["prettier --write", "tslint --fix", "git add"],
+      "*.json": ["prettier --write", "git add"],
+      "**/*.ts": ["prettier --write", "tslint --fix", "git add"]
+    },
+    "concurrent": false
+  },
+  "devDependencies": {
+    "ava": "^0.25.0",
+    "husky": "^0.14.3",
+    "lint-staged": "^7.0.4",
+    "prettier": "^1.12.0",
+    "tslint": "^5.9.1",
+    "tslint-config-prettier": "^1.10.0",
+    "typescript": "^2.8.1"
+  },
+  "dependencies": {}
+}

test/test_array.ts

@@ -0,0 +1,9 @@
+import test from 'ava'
+
+import {arrayFormatEncoder, arrayFormatParser} from '..'
+
+test('encode', t => {
+  t.is(arrayFormatEncoder('a', null), 'a')
+  t.is(arrayFormatEncoder('a', 'ddd'), 'a=ddd')
+  t.is(arrayFormatEncoder('!233!', '!@#"**abc'), '%21233%21=%21%40%23%22%2A%2Aabc')
+})

test/test_parse.ts

@@ -0,0 +1,108 @@
+import test from "ava";
+
+import { parse, stringify } from "..";
+
+test("query strings starting with a `?`", t => {
+  t.deepEqual(parse("?foo=bar"), { foo: "bar" });
+});
+
+test("query strings starting with a `#`", t => {
+  t.deepEqual(parse("#foo=bar"), { foo: "bar" });
+});
+
+test("query strings starting with a `&`", t => {
+  t.deepEqual(parse("&foo=bar&foo=baz"), { foo: ["bar", "baz"] });
+});
+
+test("parse a query string", t => {
+  t.deepEqual(parse("foo=bar"), { foo: "bar" });
+});
+
+test("parse multiple query string", t => {
+  t.deepEqual(parse("foo=bar&key=val"), {
+    foo: "bar",
+    key: "val"
+  });
+});
+
+test("parse query string without a value", t => {
+  t.deepEqual(parse("foo"), { foo: null });
+  t.deepEqual(parse("foo&key"), {
+    foo: null,
+    key: null
+  });
+  t.deepEqual(parse("foo=bar&key"), {
+    foo: "bar",
+    key: null
+  });
+  t.deepEqual(parse("a&a"), { a: [null, null] });
+  t.deepEqual(parse("a=&a"), { a: ["", null] });
+});
+
+test("return empty object if no qss can be found", t => {
+  t.deepEqual(parse("?"), {});
+  t.deepEqual(parse("&"), {});
+  t.deepEqual(parse("#"), {});
+  t.deepEqual(parse(" "), {});
+});
+
+test("handle `+` correctly", t => {
+  t.deepEqual(parse("foo+faz=bar+baz++"), { "foo faz": "bar baz  " });
+});
+
+test("handle multiple of the same key", t => {
+  t.deepEqual(parse("foo=bar&foo=baz"), { foo: ["bar", "baz"] });
+});
+
+test("handle multiple values and preserve appearence order", t => {
+  t.deepEqual(parse("a=value&a="), { a: ["value", ""] });
+  t.deepEqual(parse("a=&a=value"), { a: ["", "value"] });
+});
+
+test("query strings params including embedded `=`", t => {
+  t.deepEqual(parse("?param=https%3A%2F%2Fsomeurl%3Fid%3D2837"), {
+    param: "https://someurl?id=2837"
+  });
+});
+
+test("query strings having indexed arrays", t => {
+  t.deepEqual(parse("foo[0]=bar&foo[1]=baz"), {
+    "foo[0]": "bar",
+    "foo[1]": "baz"
+  });
+});
+
+test("query strings having brackets arrays", t => {
+  t.deepEqual(parse("foo[]=bar&foo[]=baz"), { "foo[]": ["bar", "baz"] });
+});
+
+test("query strings having indexed arrays keeping index order", t => {
+  t.deepEqual(parse("foo[1]=bar&foo[0]=baz"), {
+    "foo[0]": "baz",
+    "foo[1]": "bar"
+  });
+});
+
+test("circuit parse -> stringify", t => {
+  const original = "foo=foo&foo&foo=one&foo=&bat=buz";
+  const sortedOriginal = "bat=buz&foo=foo&foo&foo=one&foo=";
+  const expected = { bat: "buz", foo: ["foo", null, "one", ""] };
+  t.deepEqual(parse(original), expected);
+
+  t.is(stringify(expected), sortedOriginal);
+});
+
+test("circuit original -> parse - > stringify -> sorted original", t => {
+  const original =
+    "foo[21474836471]=foo&foo[21474836470]&foo[1]=one&foo[0]=&bat=buz";
+  const sortedOriginal =
+    "bat=buz&foo%5B0%5D=&foo%5B1%5D=one&foo%5B21474836470%5D&foo%5B21474836471%5D=foo";
+  t.deepEqual(stringify(parse(original)), sortedOriginal);
+});
+
+test("decode keys and values", t => {
+  t.deepEqual(parse("st%C3%A5le=foo"), { ståle: "foo" });
+  t.deepEqual(parse("foo=%7B%25ab%25%7C%25de%25%7D%20%25%7Bst%C3%A5le%7D%25"), {
+    foo: "{%ab%|%de%} %{ståle}%"
+  });
+});

test/test_stringify.ts

@@ -0,0 +1,92 @@
+import test from 'ava'
+
+import { stringify } from '..'
+
+test('stringify', t => {
+  t.is(stringify({foo: 'bar'}), 'foo=bar');
+	t.is(stringify({
+		foo: 'bar',
+		bar: 'baz'
+	}), 'bar=baz&foo=bar');
+	t.is(stringify({'foo bar': 'baz faz'}), 'foo%20bar=baz%20faz');
+	t.is(stringify({'foo bar': 'baz\'faz'}), 'foo%20bar=baz%27faz');
+})
+
+test('handle number', t => {
+  t.is(stringify({a: 1}), 'a=1')
+})
+
+test('handle array value', t => {
+  t.is(stringify({
+    page: "10",
+    pageSize: 200,
+    filter: ["aaa", "bbb", "ccc", 255]
+  }), 'filter=aaa&filter=bbb&filter=ccc&filter=255&page=10&pageSize=200')
+});
+
+test('no sort', t => {
+  t.is(stringify({
+    page: "10",
+    pageSize: 200,
+    filter: ["aaa", "bbb", "ccc", 255]
+  }, {sort: false}), 'page=10&pageSize=200&filter=aaa&filter=bbb&filter=ccc&filter=255')
+})
+
+test('handle empty array value', t => {
+	t.is(stringify({
+		abc: 'abc',
+		foo: []
+	}), 'abc=abc');
+});
+
+test('handle null', t => {
+  t.is(stringify({
+    pdd: null
+  }), 'pdd')
+  t.is(stringify({
+    c: '1',
+    d: null,
+    e: ['1', 2, null, 4]
+  }), 'c=1&d&e=1&e=2&e&e=4')
+})
+
+test('should not encode undefined values', t => {
+	t.is(stringify({
+		abc: undefined,
+		foo: 'baz'
+	}), 'foo=baz');
+});
+
+test('should encode null values as just a key', t => {
+	t.is(stringify({
+		'x y z': null,
+		abc: null,
+		foo: 'baz'
+	}), 'abc&foo=baz&x%20y%20z');
+});
+
+test('handle null values in array', t => {
+	t.is(stringify({
+		foo: null,
+		bar: [null, 'baz']
+	}), 'bar&bar=baz&foo');
+});
+
+test('handle undefined values in array', t => {
+	t.is(stringify({
+		foo: null,
+		bar: [undefined, 'baz']
+	}), 'bar=baz&foo');
+});
+
+test('handle undefined and null values in array', t => {
+	t.is(stringify({
+		foo: null,
+		bar: [null, 'baz']
+	}), 'bar&bar=baz&foo');
+});
+
+test('strict encoding', t => {
+	t.is(stringify({foo: '\'bar\''}), 'foo=%27bar%27');
+	t.is(stringify({foo: ["'bar'", "!baz"]}), 'foo=%27bar%27&foo=%21baz');
+});