qs-like/qs-like.iife.js

A tiny query string parsing and stringifying library

/*
 * qs-like.js v1.0.1
 * (c) 2018-2019 Jesse Feng
 * Released under the MIT License.
 */
var qsLike = (function (exports) {
  'use strict';

  /*
   * celia.js v6.1.4
   * (c) 2018-2019 Jesse Feng
   * Released under the MIT License.
   */

  function append (arr, obj) {
    arr[arr.length] = obj;
    return arr;
  }

  var _append = append;

  /*
   * celia.js v6.1.4
   * (c) 2018-2019 Jesse Feng
   * Released under the MIT License.
   */

  function isString (value) {
    return typeof value === 'string';
  }

  var isString_1 = isString;

  /*
   * celia.js v6.1.4
   * (c) 2018-2019 Jesse Feng
   * Released under the MIT License.
   */

  function isUndefined (value) {
    return typeof value === 'undefined';
  }

  var isUndefined_1 = isUndefined;

  /*
   * celia.js v6.1.4
   * (c) 2018-2019 Jesse Feng
   * Released under the MIT License.
   */

  function bindContext (iterator, context) {
    return context ? iterator.bind(context) : iterator;
  }

  var _bindContext = bindContext;

  function forSlice (value, start, end, iterator, context) {
    iterator = _bindContext(iterator, context);
    for (var i = start; i < end; i++) {
      iterator(value[i], i, value) === false && (i = end);
    }
  }

  var _forSlice = forSlice;

  function forEach (value, iterator, context) {
    _forSlice(value, 0, value.length, iterator, context);
  }

  var _forEach = forEach;

  function unescape (str) {
    return decodeURIComponent(str);
  }

  function parse(str, sep, eq, cb) {
    var matchedKey = '';
    var matchedValue = '';
    var hasEq = false;
    _forEach(str, function (c) {
      switch (c) {
        case '?':
          matchedKey = '';
          matchedValue = '';
          return;
        case sep:
          hasEq && matchedKey &&
            cb(matchedKey, matchedValue);
          hasEq = false;
          matchedKey = '';
          matchedValue = '';
          return;
        case eq:
          hasEq = true;
          matchedValue = '';
          return;
        case '#':
          return false;
        default:
          !hasEq
            ? (matchedKey += c)
            : (matchedValue += c);
      }
    });
    hasEq && matchedKey &&
      cb(matchedKey, matchedValue);
  }

  var isArray = Array.isArray;

  function parse$1 (str, sep, eq, options) {
    var result = {};
    if (isString_1(str)) {
      sep = sep || '&';
      eq = eq || '=';
      options = options || {};
      var decode = options.decodeURIComponent || unescape;

      parse(str, sep, eq, function (key, value) {
        value = decode(value);
        var last = result[key];
        // 没有相同的key值
        if (isUndefined_1(last)) {
          result[key] = value;
        } else if (isArray(last)) { // 继续追加
          _append(last, value);
        } else { // 已存在key
          result[key] = [last, value];
        }
      });
    }
    return result;
  }

  /*
   * celia.js v6.1.4
   * (c) 2018-2019 Jesse Feng
   * Released under the MIT License.
   */

  function isObject (value) {
    return value !== null && typeof value === 'object';
  }

  var isObject_1 = isObject;

  // import hasOwn from './hasOwn';

  function forOwn (value, iterator, context) {
    iterator = _bindContext(iterator, context);
    var keys = Object.keys(value);
    var len = keys.length;
    for (var i = 0, key = (void 0); i < len; i++) {
      key = keys[i];
      iterator(value[key], key, value) === false && (i = len);
    }
    // for (let key in value) {
    //   if (hasOwn(value, key) && iterator(value[key], key, value) === false) {
    //     break;
    //   }
    // }
  }

  var _forOwn = forOwn;

  // rfc3986
  var encodeReserveRE = /[!'()*]/g;

  function encodeReserveReplacer(c) {
    return '%' + c.charCodeAt(0).toString(16).toUpperCase();
  }

  function escape (str) {
    return encodeURIComponent(str)
      .replace(encodeReserveRE, encodeReserveReplacer);
  }

  var stringify = JSON.stringify;

  function convert(value, encode) {
    switch (typeof value) {
      case 'string':
        return encode(value);
      case 'number':
        if (isNaN(value)) {
          return '';
        }
      case 'boolean':
        return value.toString();
      case 'object':
        return value === null ? '' : encode(stringify(value));
      case 'undefined':
        return '';
      // case 'function':
      //   return encode(value.toString());
      default:
        return encode(value.toString());
    }
  }

  var isArray$1 = Array.isArray;
  function stringify$1 (obj, sep, eq, options) {
    if (isObject_1(obj)) {
      sep = sep || '&';
      eq = eq || '=';
      options = options || {};

      var encode = options.encodeURIComponent || escape;
      var arr = [];

      _forOwn(obj, function (value, key) {
        if (key) {
          if (isArray$1(value)) {
            value.forEach(function (val) {
              _append(arr, key + eq + convert(val, encode));
            });
          } else {
            _append(arr, key + eq + convert(value, encode));
          }
        }
      });

      return arr.join(sep);
    }
    return '';
  }

  function prefix (str, prefix) {
    prefix = prefix || '?';
    return str
      ? str.indexOf(prefix) === 0
        ? str
        : (prefix + str)
      : str;
  }

  exports.decode = parse$1;
  exports.encode = stringify$1;
  exports.escape = escape;
  exports.parse = parse$1;
  exports.prefix = prefix;
  exports.stringify = stringify$1;
  exports.unescape = unescape;

  return exports;

}({}));