@k-int/stripes-kint-components 5.36.1 → 5.37.0

package/es/lib/utils/buildUrl.js

@@ -17,12 +17,13 @@ function removeEmpty(obj) {
   return cleanObj;
 }
 function buildUrl(location, values, basePath) {
-  const locationQuery = location?.query ?? _queryString.default.parse(location.search);
+  var _location$query;
+  const locationQuery = (_location$query = location === null || location === void 0 ? void 0 : location.query) !== null && _location$query !== void 0 ? _location$query : _queryString.default.parse(location.search);
   let url = values._path || basePath || location.pathname;
   const params = removeEmpty(Object.assign(locationQuery, values));
   (0, _lodash.unset)(params, '_path');
   if (!(0, _lodash.isEmpty)(params)) {
-    url += `?${_queryString.default.stringify(params)}`;
+    url += "?".concat(_queryString.default.stringify(params));
   }
   return url;
 }

package/es/lib/utils/downloadBlob.js

@@ -13,13 +13,17 @@ exports.default = void 0;
  */
 
 const downloadBlob = function (name) {
-  let {
-    fileExt = '',
-    spaceDelimiter = '_',
-    dotDelimiter = '',
-    processWhitespace = true,
-    processDots = false
-  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref$fileExt = _ref.fileExt,
+    fileExt = _ref$fileExt === void 0 ? '' : _ref$fileExt,
+    _ref$spaceDelimiter = _ref.spaceDelimiter,
+    spaceDelimiter = _ref$spaceDelimiter === void 0 ? '_' : _ref$spaceDelimiter,
+    _ref$dotDelimiter = _ref.dotDelimiter,
+    dotDelimiter = _ref$dotDelimiter === void 0 ? '' : _ref$dotDelimiter,
+    _ref$processWhitespac = _ref.processWhitespace,
+    processWhitespace = _ref$processWhitespac === void 0 ? true : _ref$processWhitespac,
+    _ref$processDots = _ref.processDots,
+    processDots = _ref$processDots === void 0 ? false : _ref$processDots;
   let downloadName = name;
   if (processWhitespace) {
     downloadName = downloadName.replaceAll(/\s/g, spaceDelimiter);
@@ -28,7 +32,7 @@ const downloadBlob = function (name) {
     downloadName = downloadName.replaceAll(/\./g, dotDelimiter);
   }
   if (fileExt.length) {
-    downloadName = `${downloadName}.${fileExt}`;
+    downloadName = "".concat(downloadName, ".").concat(fileExt);
   }
   return blob => {
     const url = URL.createObjectURL(blob);

package/es/lib/utils/filterParsers/deparseKiwtQueryFilters.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 exports.deparseKiwtQueryFiltersObject = exports.default = void 0;
 // Does not validate object... make sure you pass it the right thing
 const deparseKiwtQueryFiltersObject = queryObject => {
-  let returnString = `${queryObject.path}${queryObject.comparator}`;
+  let returnString = "".concat(queryObject.path).concat(queryObject.comparator);
   if (queryObject.value) {
-    returnString += `${queryObject.value}`;
+    returnString += "".concat(queryObject.value);
   }
   return returnString;
 };
@@ -20,17 +20,17 @@ const deparseKiwtQueryFilters = queryArray => {
     let returnString = '';
     queryArray.forEach(qa => {
       if (Array.isArray(qa)) {
-        returnString += `(${deparseKiwtQueryFilters(qa)})`;
+        returnString += "(".concat(deparseKiwtQueryFilters(qa), ")");
       } else if (typeof qa === 'string') {
         returnString += qa;
       } else {
         // Assuming object at this stage
-        returnString += `${deparseKiwtQueryFiltersObject(qa)}`;
+        returnString += "".concat(deparseKiwtQueryFiltersObject(qa));
       }
     });
     return returnString.trim();
   } else {
-    throw new Error(`deparseKiwtQuery expects a parameter of type Array, passed: ${queryArray}`);
+    throw new Error("deparseKiwtQuery expects a parameter of type Array, passed: ".concat(queryArray));
   }
 };
 var _default = exports.default = deparseKiwtQueryFilters;

package/es/lib/utils/filterParsers/parseKiwtQueryFilters.js

@@ -21,7 +21,7 @@ const parseKiwtQueryFiltersRecursive = query => {
       return (0, _parseKiwtQueryString.default)(query);
     }
   } else {
-    throw new Error(`Unexpected query type: ${query}`);
+    throw new Error("Unexpected query type: ".concat(query));
   }
 };
 
@@ -33,7 +33,7 @@ const parseKiwtQueryFilters = queryString => {
     const queryGroups = (0, _parseKiwtQueryGroups.default)(queryString);
     return parseKiwtQueryFiltersRecursive(queryGroups);
   } else {
-    throw new Error(`parseKiwtQuery expects a parameter of type String, passed: ${queryString}`);
+    throw new Error("parseKiwtQuery expects a parameter of type String, passed: ".concat(queryString));
   }
 };
 

package/es/lib/utils/filterParsers/parseKiwtQueryGroups.js

@@ -44,7 +44,8 @@ const parseKiwtQueryGroups = query => {
     let nestLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
     const group = [];
     // Iterate over each element in the array, recursively calling this when hitting parens
-    parseArray?.every((element, index) => {
+    parseArray === null || parseArray === void 0 || parseArray.every((element, index) => {
+      var _skipCount;
       if (skipCount[nestLevel] > 0) {
         skipCount[nestLevel] -= 1;
         return true; // Equivalent to BREAK -- move onto next element
@@ -56,14 +57,14 @@ const parseKiwtQueryGroups = query => {
       }
 
       // At the levels below all of the following will need
-      skipCount = skipCount?.map((n, i) => {
+      skipCount = (_skipCount = skipCount) === null || _skipCount === void 0 ? void 0 : _skipCount.map((n, i) => {
         if (i < nestLevel) {
           return n + 1;
         }
         return n;
       });
       if (element !== '(' && element !== ')') {
-        group?.push(element);
+        group === null || group === void 0 || group.push(element);
       } else if (element === ')') {
         // Remove the corresponding skipCount level because we're going down a nesting level
         skipCount.pop();
@@ -73,7 +74,7 @@ const parseKiwtQueryGroups = query => {
         // Add next index to skipcount for the nesting
         skipCount.push(0);
         unclosedParens += 1;
-        group.push(groupParser(parseArray.slice(index + 1, parseArray?.length), nestLevel + 1));
+        group.push(groupParser(parseArray.slice(index + 1, parseArray === null || parseArray === void 0 ? void 0 : parseArray.length), nestLevel + 1));
       }
 
       // If all is well, continue on parsing

package/es/lib/utils/filterParsers/parseKiwtQueryString.js

@@ -17,7 +17,7 @@ const FIRST = 0;
 const SECOND = 1;
 const THIRD = 2;
 const parseKiwtQueryString = queryString => {
-  const comparatorMatch = new RegExp(`(${_comparators.default.join('|')})`);
+  const comparatorMatch = new RegExp("(".concat(_comparators.default.join('|'), ")"));
   // See parseKiwtQueryGroups for breakdown of why this filter is needed
   const splitString = queryString.split(comparatorMatch).filter(Boolean);
 

package/es/lib/utils/generateKiwtQueryParams/generateKiwtQueryParams.js

@@ -4,6 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+const _excluded = ["searchKey", "filterConfig", "filterKeys", "sortKeys", "stats", "sort", "filters"];
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _toArray(r) { return _arrayWithHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
 const conditionalEncodeURIComponent = function (str) {
   let encode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
   if (encode) {
@@ -17,36 +28,40 @@ const conditionalEncodeURIComponent = function (str) {
 const buildFilterOptionBlock = function (opf) {
   let isNested = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   let encode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  if (opf?.groupValues) {
+  if (opf !== null && opf !== void 0 && opf.groupValues) {
     const groupValues = opf.groupValues;
 
     // Small utility function to add negation and brackets to the options block where necessary
-    const negationAndNesting = str => `${groupValues?.NOT ? '!' : ''}${isNested || groupValues?.NOT ? '(' : ''}${str}${isNested || groupValues?.NOT ? ')' : ''}`;
+    const negationAndNesting = str => "".concat(groupValues !== null && groupValues !== void 0 && groupValues.NOT ? '!' : '').concat(isNested || groupValues !== null && groupValues !== void 0 && groupValues.NOT ? '(' : '').concat(str).concat(isNested || groupValues !== null && groupValues !== void 0 && groupValues.NOT ? ')' : '');
 
     // First check whether groupValues is ANDed or ORed together
-    if (groupValues?.AND && Array.isArray(groupValues.AND) || groupValues?.OR && Array.isArray(groupValues.OR)) {
+    if (groupValues !== null && groupValues !== void 0 && groupValues.AND && Array.isArray(groupValues.AND) || groupValues !== null && groupValues !== void 0 && groupValues.OR && Array.isArray(groupValues.OR)) {
+      var _groupValues$OR;
       // AND takes precedence
       if (groupValues.AND) {
-        return negationAndNesting(groupValues?.AND?.map(gvo => buildFilterOptionBlock(gvo, true, encode))?.join('&&'));
+        var _groupValues$AND;
+        return negationAndNesting(groupValues === null || groupValues === void 0 || (_groupValues$AND = groupValues.AND) === null || _groupValues$AND === void 0 || (_groupValues$AND = _groupValues$AND.map(gvo => buildFilterOptionBlock(gvo, true, encode))) === null || _groupValues$AND === void 0 ? void 0 : _groupValues$AND.join('&&'));
       }
-      return negationAndNesting(groupValues?.OR?.map(gvo => buildFilterOptionBlock(gvo, true, encode))?.join('||'));
+      return negationAndNesting(groupValues === null || groupValues === void 0 || (_groupValues$OR = groupValues.OR) === null || _groupValues$OR === void 0 || (_groupValues$OR = _groupValues$OR.map(gvo => buildFilterOptionBlock(gvo, true, encode))) === null || _groupValues$OR === void 0 ? void 0 : _groupValues$OR.join('||'));
     }
     // If neither valid OR nor AND exist, ignore the block
-  } else if (opf?.values) {
+  } else if (opf !== null && opf !== void 0 && opf.values) {
     // Build the values filter block
     const innerFilters = [];
     opf.values.forEach(opfv => {
       if (opf.path) {
-        innerFilters.push(`${opf.path}${opf.comparator ?? '=='}${opfv}`);
+        var _opf$comparator;
+        innerFilters.push("".concat(opf.path).concat((_opf$comparator = opf.comparator) !== null && _opf$comparator !== void 0 ? _opf$comparator : '==').concat(opfv));
       } else {
         innerFilters.push(opfv);
       }
     });
     return conditionalEncodeURIComponent(innerFilters.join('||'), encode);
-  } else if (opf?.value) {
+  } else if (opf !== null && opf !== void 0 && opf.value) {
     // If no value OR values, then ignore
     if (opf.path) {
-      const filterString = `${opf.path}${opf.comparator ?? '=='}${opf.value}`;
+      var _opf$comparator2;
+      const filterString = "".concat(opf.path).concat((_opf$comparator2 = opf.comparator) !== null && _opf$comparator2 !== void 0 ? _opf$comparator2 : '==').concat(opf.value);
       return conditionalEncodeURIComponent(filterString, encode);
     }
     return conditionalEncodeURIComponent(opf.value, encode);
@@ -67,80 +82,28 @@ const buildFilterOptionBlock = function (opf) {
 const keysToIgnore = ['totalRecords'];
 const generateKiwtQueryParams = function (options, nsValues) {
   let encode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  const {
-    qindex,
-    query,
-    filters,
-    sort
-  } = nsValues;
-  const {
-    searchKey = '',
-    /*
-     * Array of objects to configure how filters coming from `nsValues.filters` are mapped into KIWT filter strings.
-     *
-     * Example structure:
-     * [
-     *   {
-     *     name: 'status', // Matches filter key in URL (e.g., filters=status.active)
-     *     filterPrefix: 'filters=', // Optional, defaults to 'filters='
-     *     // Optional function to entirely customize how the array of values is mapped to a string.
-     *     // (e.g., ['active', 'cancelled'] => 'is:active and is:cancelled')
-     *     // Defaults to constructing from `values` map below
-     *     // valuesMapping: (filterValues) => string,
-     *     values: [ // Optional: Specific configuration for individual filter values
-     *       {
-     *         name: 'active', // Matches filter value in URL
-     *         value: 'activeValue', // Actual value to use in the KIWT query (defaults to name)
-     *         comparator: '==' // Optional comparator override (defaults to '==')
-     *       },
-     *       // ... other values
-     *     ]
-     *   }
-     * ]
-     */
-    filterConfig = [],
-    /* Assumtion made that if no filterKey is provided then the given filterValues for that key are standalaone, ie require no comparator or key */
-    filterKeys = {},
-    sortKeys = {},
-    stats = true,
-    /* Of the form [{ path: 'this.is.some.path', direction: 'asc'/'desc', value: 'someOverrideValue'}, ...]
-     * If only path is passed then assume asc.
-     * If value is passed then we ignore path/direction and append "sort=${value}" directly
-     */
-    sort: optionsSort,
-    /* Of the form
-      [
-        {
-          path: 'this.is.some.path'
-          comparator: '=='
-          value: 'this is a value' //OR
-          values: ['value1', 'value2'] //OR
-          groupValues: { // This is an object containing objects either in groups of AND or OR. AND takes precedence
-            AND: [
-              // Objects of the same shape as an individual filters object, recursively.
-            ],
-            NOT: true // When this is set to true, the entire group is negated
-          }
-        },
-        ...
-      ]
-     * This (with value instead of values) will construct a query param: "filters=this.is.some.path==this is a value"
-     * If only value is passed, then it will construct directly: "filters=value"
-     * If no comparator is passed, it assumes '=='
-     * Values overwrites value and will construct "filters=this.is.some.path==value1||this.is.some.path==value2"
-     * Values WITHOUT path will construct "filters=value1||value2"
-     *
-     * GroupValues will override everything above, and group into brackets.
-     *
-     * If more complex query building is desired, this should be done externally and passed in as a standalone 'value'
-     */
-    filters: optionsFilters,
-    ...rest
-  } = options;
+  const qindex = nsValues.qindex,
+    query = nsValues.query,
+    filters = nsValues.filters,
+    sort = nsValues.sort;
+  const _options$searchKey = options.searchKey,
+    searchKey = _options$searchKey === void 0 ? '' : _options$searchKey,
+    _options$filterConfig = options.filterConfig,
+    filterConfig = _options$filterConfig === void 0 ? [] : _options$filterConfig,
+    _options$filterKeys = options.filterKeys,
+    filterKeys = _options$filterKeys === void 0 ? {} : _options$filterKeys,
+    _options$sortKeys = options.sortKeys,
+    sortKeys = _options$sortKeys === void 0 ? {} : _options$sortKeys,
+    _options$stats = options.stats,
+    stats = _options$stats === void 0 ? true : _options$stats,
+    optionsSort = options.sort,
+    optionsFilters = options.filters,
+    rest = _objectWithoutProperties(options, _excluded);
   const paramsArray = [];
   if (query) {
-    paramsArray.push(...((qindex || searchKey)?.split(',') ?? []).map(m => `match=${conditionalEncodeURIComponent(m, encode)}`));
-    paramsArray.push(`term=${conditionalEncodeURIComponent(query, encode)}`);
+    var _split, _ref;
+    paramsArray.push(...((_split = (_ref = qindex || searchKey) === null || _ref === void 0 ? void 0 : _ref.split(',')) !== null && _split !== void 0 ? _split : []).map(m => "match=".concat(conditionalEncodeURIComponent(m, encode))));
+    paramsArray.push("term=".concat(conditionalEncodeURIComponent(query, encode)));
   }
 
   // Actually build the optionsFilters block (Moved logic to its own function to allow recursion)
@@ -148,61 +111,71 @@ const generateKiwtQueryParams = function (options, nsValues) {
     optionsFilters.forEach(opf => {
       const optionsBlock = buildFilterOptionBlock(opf, false, encode);
       if (optionsBlock) {
-        paramsArray.push(`filters=${optionsBlock}`);
+        paramsArray.push("filters=".concat(optionsBlock));
       }
     });
   }
   if (filters) {
     const filterMap = {};
     filters.split(',').forEach(filter => {
-      const [filterName, ...filterRest] = filter.trim()?.split('.') ?? [];
+      var _filter$trim$split, _filter$trim;
+      const _ref2 = (_filter$trim$split = (_filter$trim = filter.trim()) === null || _filter$trim === void 0 ? void 0 : _filter$trim.split('.')) !== null && _filter$trim$split !== void 0 ? _filter$trim$split : [],
+        _ref3 = _toArray(_ref2),
+        filterName = _ref3[0],
+        filterRest = _arrayLikeToArray(_ref3).slice(1);
       const filterValue = filterRest.join('.');
       if (filterMap[filterName] === undefined) filterMap[filterName] = [];
       filterMap[filterName].push(filterValue);
     });
 
     // We now have a filterMap of shape { status: ['active', 'cancelled'], type: ['local'] }
-    Object.entries(filterMap).forEach(_ref => {
-      let [filterName, filterValues] = _ref;
+    Object.entries(filterMap).forEach(_ref4 => {
+      let _ref5 = _slicedToArray(_ref4, 2),
+        filterName = _ref5[0],
+        filterValues = _ref5[1];
       const filterConfigEntry = filterConfig.find(conf => conf.name === filterName);
       const filterKey = filterKeys[filterName];
       if (filterConfigEntry) {
+        var _filterConfigEntry$fi;
         // We have a direct mapping instruction, use it
 
         // Do we have a specific way to map values to a string?
         const filterString = filterConfigEntry.valuesMapping ? filterConfigEntry.valuesMapping(filterValues) : filterValues.map(v => {
-          const fcValueEntry = filterConfigEntry?.values?.find(fce => fce.name === v) ?? {};
-          const fceValue = fcValueEntry.value ?? v;
+          var _filterConfigEntry$va, _filterConfigEntry$va2, _fcValueEntry$value, _fcValueEntry$compara;
+          const fcValueEntry = (_filterConfigEntry$va = filterConfigEntry === null || filterConfigEntry === void 0 || (_filterConfigEntry$va2 = filterConfigEntry.values) === null || _filterConfigEntry$va2 === void 0 ? void 0 : _filterConfigEntry$va2.find(fce => fce.name === v)) !== null && _filterConfigEntry$va !== void 0 ? _filterConfigEntry$va : {};
+          const fceValue = (_fcValueEntry$value = fcValueEntry.value) !== null && _fcValueEntry$value !== void 0 ? _fcValueEntry$value : v;
           // This is especially useful where comparator acts strangely for a single value, such as `filters=foo isNotSet`
-          const fceComparator = fcValueEntry.comparator ?? '==';
-          return `${filterKey ?? filterName}${fceComparator}${fceValue ?? v}`;
+          const fceComparator = (_fcValueEntry$compara = fcValueEntry.comparator) !== null && _fcValueEntry$compara !== void 0 ? _fcValueEntry$compara : '==';
+          return "".concat(filterKey !== null && filterKey !== void 0 ? filterKey : filterName).concat(fceComparator).concat(fceValue !== null && fceValue !== void 0 ? fceValue : v);
         }).join('||');
 
         // This will NOT be url encoded by this component
-        const filterPrefix = filterConfigEntry.filterPrefix ?? 'filters=';
-        paramsArray.push(`${filterPrefix}${conditionalEncodeURIComponent(filterString, encode)}`);
+        const filterPrefix = (_filterConfigEntry$fi = filterConfigEntry.filterPrefix) !== null && _filterConfigEntry$fi !== void 0 ? _filterConfigEntry$fi : 'filters=';
+        paramsArray.push("".concat(filterPrefix).concat(conditionalEncodeURIComponent(filterString, encode)));
       } else if (!filterKey) {
         // These filters have no key mapping so we just pass the values to the backend as-is.
-        paramsArray.push(...(filterValues ?? []).map(f => `filters=${conditionalEncodeURIComponent(f, encode)}`));
+        paramsArray.push(...(filterValues !== null && filterValues !== void 0 ? filterValues : []).map(f => "filters=".concat(conditionalEncodeURIComponent(f, encode))));
       } else {
-        const filterString = filterValues.map(v => `${filterKey}==${v}`).join('||');
-        paramsArray.push(`filters=${conditionalEncodeURIComponent(filterString, encode)}`);
+        const filterString = filterValues.map(v => "".concat(filterKey, "==").concat(v)).join('||');
+        paramsArray.push("filters=".concat(conditionalEncodeURIComponent(filterString, encode)));
       }
     });
   }
   if (optionsSort && optionsSort.length > 0) {
     optionsSort.forEach(os => {
       if (os.value) {
-        paramsArray.push(`sort=${conditionalEncodeURIComponent(os.value, encode)}`);
+        paramsArray.push("sort=".concat(conditionalEncodeURIComponent(os.value, encode)));
       } else if (os.path) {
+        var _os$direction;
         // If no path then ignore
-        const sortString = `${os.path};${os.direction ?? 'asc'}`;
-        paramsArray.push(`sort=${conditionalEncodeURIComponent(sortString, encode)}`);
+        const sortString = "".concat(os.path, ";").concat((_os$direction = os.direction) !== null && _os$direction !== void 0 ? _os$direction : 'asc');
+        paramsArray.push("sort=".concat(conditionalEncodeURIComponent(sortString, encode)));
       }
     });
   }
   if (sort) {
-    paramsArray.push(...(sort.trim()?.split(',') ?? []).map(sortKey => {
+    var _sort$trim$split, _sort$trim;
+    paramsArray.push(...((_sort$trim$split = (_sort$trim = sort.trim()) === null || _sort$trim === void 0 ? void 0 : _sort$trim.split(',')) !== null && _sort$trim$split !== void 0 ? _sort$trim$split : []).map(sortKey => {
       const reverse = sortKey.startsWith('-');
       let term = sortKey.replace('-', '');
       if (term in sortKeys) {
@@ -215,8 +188,8 @@ const generateKiwtQueryParams = function (options, nsValues) {
         const descending = field.startsWith('-');
         const sortField = field.replace('-', '');
         const sortOrder = reverse && !descending || !reverse && descending ? 'desc' : 'asc';
-        const sortString = `${sortField};${sortOrder}`;
-        return `sort=${conditionalEncodeURIComponent(sortString, encode)}`;
+        const sortString = "".concat(sortField, ";").concat(sortOrder);
+        return "sort=".concat(conditionalEncodeURIComponent(sortString, encode));
       });
       return sortStrings.join('&');
     }));
@@ -224,9 +197,12 @@ const generateKiwtQueryParams = function (options, nsValues) {
   if (stats) {
     paramsArray.push('stats=true');
   }
-  for (const [key, value] of Object.entries(rest)) {
+  for (const _ref6 of Object.entries(rest)) {
+    var _ref7 = _slicedToArray(_ref6, 2);
+    const key = _ref7[0];
+    const value = _ref7[1];
     if (!keysToIgnore.includes(key)) {
-      paramsArray.push(`${key}=${conditionalEncodeURIComponent(value, encode)}`);
+      paramsArray.push("".concat(key, "=").concat(conditionalEncodeURIComponent(value, encode)));
     }
   }
   return paramsArray;