@koine/utils 2.0.0-beta.2 → 2.0.0-beta.4

package/matchSorter.mjs

@@ -1,4 +1,3 @@
-import { __assign } from "tslib";
 /**
  * @file
  *
@@ -14,41 +13,35 @@ import { __assign } from "tslib";
  * @license MIT license.
  * @copyright (c) 2020 Kent C. Dodds
  * @author Kent C. Dodds <me@kentcdodds.com> (https://kentcdodds.com)
- */
-import removeAccents from "./removeAccents";
-var RANKING_CASE_SENSITIVE_EQUAL = 7;
-var RANKING_EQUAL = 6;
-var RANKING_STARTS_WITH = 5;
-var RANKING_WORD_STARTS_WITH = 4;
-var RANKING_CONTAINS = 3;
-var RANKING_ACRONYM = 2;
-var RANKING_MATCHES = 1;
-var RANKING_NO_MATCH = 0;
-var defaultBaseSortFn = function (a, b) {
-    return String(a.rankedValue).localeCompare(String(b.rankedValue));
-};
+ */ import removeAccents from "./removeAccents";
+const RANKING_CASE_SENSITIVE_EQUAL = 7;
+const RANKING_EQUAL = 6;
+const RANKING_STARTS_WITH = 5;
+const RANKING_WORD_STARTS_WITH = 4;
+const RANKING_CONTAINS = 3;
+const RANKING_ACRONYM = 2;
+const RANKING_MATCHES = 1;
+const RANKING_NO_MATCH = 0;
+const defaultBaseSortFn = (a, b)=>String(a.rankedValue).localeCompare(String(b.rankedValue));
 /**
  * Takes an array of items and a value and returns a new array with the items that match the given value
  * @param {Array} items - the items to sort
  * @param {String} value - the value to use for ranking
  * @param {Object} options - Some options to configure the sorter
  * @return {Array} - the new sorted array
- */
-function matchSorter(items, value, options) {
-    if (options === void 0) { options = {}; }
-    var keys = options.keys, _a = options.threshold, threshold = _a === void 0 ? RANKING_MATCHES : _a, _b = options.baseSort, baseSort = _b === void 0 ? defaultBaseSortFn : _b, _c = options.sorter, sorter = _c === void 0 ? function (matchedItems) {
-        return matchedItems.sort(function (a, b) { return sortRankedValues(a, b, baseSort); });
-    } : _c;
-    var matchedItems = items.reduce(reduceItemsToRanked, []);
-    return sorter(matchedItems).map(function (_a) {
-        var item = _a.item;
-        return item;
-    });
+ */ function matchSorter(items, value, options = {}) {
+    const { keys, threshold = RANKING_MATCHES, baseSort = defaultBaseSortFn, sorter = (matchedItems)=>matchedItems.sort((a, b)=>sortRankedValues(a, b, baseSort)) } = options;
+    const matchedItems = items.reduce(reduceItemsToRanked, []);
+    return sorter(matchedItems).map(({ item })=>item);
     function reduceItemsToRanked(matches, item, index) {
-        var rankingInfo = getHighestRanking(item, keys, value, options);
-        var rank = rankingInfo.rank, _a = rankingInfo.keyThreshold, keyThreshold = _a === void 0 ? threshold : _a;
+        const rankingInfo = getHighestRanking(item, keys, value, options);
+        const { rank, keyThreshold = threshold } = rankingInfo;
         if (rank >= keyThreshold) {
-            matches.push(__assign(__assign({}, rankingInfo), { item: item, index: index }));
+            matches.push({
+                ...rankingInfo,
+                item,
+                index
+            });
         }
         return matches;
     }
@@ -60,30 +53,26 @@ function matchSorter(items, value, options) {
  * @param {String} value - the value to rank against
  * @param {Object} options - options to control the ranking
  * @return {{rank: Number, keyIndex: Number, keyThreshold: Number}} - the highest ranking
- */
-function getHighestRanking(item, keys, value, options) {
+ */ function getHighestRanking(item, keys, value, options) {
     if (!keys) {
         // if keys is not specified, then we assume the item given is ready to be matched
-        var stringItem = item;
+        const stringItem = item;
         return {
             // ends up being duplicate of 'item' in matches but consistent
             rankedValue: stringItem,
             rank: getMatchRanking(stringItem, value, options),
             keyIndex: -1,
-            keyThreshold: options.threshold,
+            keyThreshold: options.threshold
         };
     }
-    var valuesToRank = getAllValuesToRank(item, keys);
-    return valuesToRank.reduce(function (_a, _b, i) {
-        var rank = _a.rank, rankedValue = _a.rankedValue, keyIndex = _a.keyIndex, keyThreshold = _a.keyThreshold;
-        var itemValue = _b.itemValue, attributes = _b.attributes;
-        var newRank = getMatchRanking(itemValue, value, options);
-        var newRankedValue = rankedValue;
-        var minRanking = attributes.minRanking, maxRanking = attributes.maxRanking, threshold = attributes.threshold;
+    const valuesToRank = getAllValuesToRank(item, keys);
+    return valuesToRank.reduce(({ rank, rankedValue, keyIndex, keyThreshold }, { itemValue, attributes }, i)=>{
+        let newRank = getMatchRanking(itemValue, value, options);
+        let newRankedValue = rankedValue;
+        const { minRanking, maxRanking, threshold } = attributes;
         if (newRank < minRanking && newRank >= RANKING_MATCHES) {
             newRank = minRanking;
-        }
-        else if (newRank > maxRanking) {
+        } else if (newRank > maxRanking) {
             newRank = maxRanking;
         }
         if (newRank > rank) {
@@ -92,12 +81,17 @@ function getHighestRanking(item, keys, value, options) {
             keyThreshold = threshold;
             newRankedValue = itemValue;
         }
-        return { rankedValue: newRankedValue, rank: rank, keyIndex: keyIndex, keyThreshold: keyThreshold };
+        return {
+            rankedValue: newRankedValue,
+            rank,
+            keyIndex,
+            keyThreshold
+        };
     }, {
         rankedValue: item,
         rank: RANKING_NO_MATCH,
         keyIndex: -1,
-        keyThreshold: options.threshold,
+        keyThreshold: options.threshold
     });
 }
 /**
@@ -106,8 +100,7 @@ function getHighestRanking(item, keys, value, options) {
  * @param {String} stringToRank - the string to rank
  * @param {Object} options - options for the match (like keepDiacritics for comparison)
  * @returns {Number} the ranking for how well stringToRank matches testString
- */
-function getMatchRanking(testString, stringToRank, options) {
+ */ function getMatchRanking(testString, stringToRank, options) {
     testString = prepareValueForComparison(testString, options);
     stringToRank = prepareValueForComparison(stringToRank, options);
     // too long
@@ -130,14 +123,13 @@ function getMatchRanking(testString, stringToRank, options) {
         return RANKING_STARTS_WITH;
     }
     // word starts with
-    if (testString.includes(" ".concat(stringToRank))) {
+    if (testString.includes(` ${stringToRank}`)) {
         return RANKING_WORD_STARTS_WITH;
     }
     // contains
     if (testString.includes(stringToRank)) {
         return RANKING_CONTAINS;
-    }
-    else if (stringToRank.length === 1) {
+    } else if (stringToRank.length === 1) {
         // If the only character in the given stringToRank
         //   isn't even contained in the testString, then
         //   it's definitely not a match.
@@ -156,13 +148,12 @@ function getMatchRanking(testString, stringToRank, options) {
  *
  * @param {String} string the string for which to produce the acronym
  * @returns {String} the acronym
- */
-function getAcronym(string) {
-    var acronym = "";
-    var wordsInString = string.split(" ");
-    wordsInString.forEach(function (wordInString) {
-        var splitByHyphenWords = wordInString.split("-");
-        splitByHyphenWords.forEach(function (splitByHyphenWord) {
+ */ function getAcronym(string) {
+    let acronym = "";
+    const wordsInString = string.split(" ");
+    wordsInString.forEach((wordInString)=>{
+        const splitByHyphenWords = wordInString.split("-");
+        splitByHyphenWords.forEach((splitByHyphenWord)=>{
             acronym += splitByHyphenWord.substring(0, 1);
         });
     });
@@ -177,13 +168,12 @@ function getAcronym(string) {
  * @param {String} stringToRank - the string to rank
  * @returns {Number} the number between RANKING_MATCHES and
  * RANKING_MATCHES + 1 for how well stringToRank matches testString
- */
-function getClosenessRanking(testString, stringToRank) {
-    var matchingInOrderCharCount = 0;
-    var charNumber = 0;
+ */ function getClosenessRanking(testString, stringToRank) {
+    let matchingInOrderCharCount = 0;
+    let charNumber = 0;
     function findMatchingCharacter(matchChar, string, index) {
-        for (var j = index, J = string.length; j < J; j++) {
-            var stringChar = string[j];
+        for(let j = index, J = string.length; j < J; j++){
+            const stringChar = string[j];
             if (stringChar === matchChar) {
                 matchingInOrderCharCount += 1;
                 return j + 1;
@@ -192,25 +182,25 @@ function getClosenessRanking(testString, stringToRank) {
         return -1;
     }
     function getRanking(spread) {
-        var spreadPercentage = 1 / spread;
-        var inOrderPercentage = matchingInOrderCharCount / stringToRank.length;
-        var ranking = RANKING_MATCHES + inOrderPercentage * spreadPercentage;
+        const spreadPercentage = 1 / spread;
+        const inOrderPercentage = matchingInOrderCharCount / stringToRank.length;
+        const ranking = RANKING_MATCHES + inOrderPercentage * spreadPercentage;
         return ranking;
     }
-    var firstIndex = findMatchingCharacter(stringToRank[0], testString, 0);
+    const firstIndex = findMatchingCharacter(stringToRank[0], testString, 0);
     if (firstIndex < 0) {
         return RANKING_NO_MATCH;
     }
     charNumber = firstIndex;
-    for (var i = 1, I = stringToRank.length; i < I; i++) {
-        var matchChar = stringToRank[i];
+    for(let i = 1, I = stringToRank.length; i < I; i++){
+        const matchChar = stringToRank[i];
         charNumber = findMatchingCharacter(matchChar, testString, charNumber);
-        var found = charNumber > -1;
+        const found = charNumber > -1;
         if (!found) {
             return RANKING_NO_MATCH;
         }
     }
-    var spread = charNumber - firstIndex;
+    const spread = charNumber - firstIndex;
     return getRanking(spread);
 }
 /**
@@ -218,23 +208,20 @@ function getClosenessRanking(testString, stringToRank) {
  * @param {Object} a - the first item to sort
  * @param {Object} b - the second item to sort
  * @return {Number} -1 if a should come first, 1 if b should come first, 0 if equal
- */
-function sortRankedValues(a, b, baseSort) {
-    var aFirst = -1;
-    var bFirst = 1;
-    var aRank = a.rank, aKeyIndex = a.keyIndex;
-    var bRank = b.rank, bKeyIndex = b.keyIndex;
-    var same = aRank === bRank;
+ */ function sortRankedValues(a, b, baseSort) {
+    const aFirst = -1;
+    const bFirst = 1;
+    const { rank: aRank, keyIndex: aKeyIndex } = a;
+    const { rank: bRank, keyIndex: bKeyIndex } = b;
+    const same = aRank === bRank;
     if (same) {
         if (aKeyIndex === bKeyIndex) {
             // use the base sort function as a tie-breaker
             return baseSort(a, b);
-        }
-        else {
+        } else {
             return aKeyIndex < bKeyIndex ? aFirst : bFirst;
         }
-    }
-    else {
+    } else {
         return aRank > bRank ? aFirst : bFirst;
     }
 }
@@ -243,12 +230,10 @@ function sortRankedValues(a, b, baseSort) {
  * @param {String} value - the value to clean
  * @param {Object} options - {keepDiacritics: whether to remove diacritics}
  * @return {String} the prepared value
- */
-function prepareValueForComparison(value, _a) {
-    var keepDiacritics = _a.keepDiacritics;
+ */ function prepareValueForComparison(value, { keepDiacritics }) {
     // value might not actually be a string at this point (we don't get to choose)
     // so part of preparing the value for comparison is ensure that it is a string
-    value = "".concat(value); // toString
+    value = `${value}`; // toString
     if (!keepDiacritics) {
         value = removeAccents(value);
     }
@@ -259,26 +244,21 @@ function prepareValueForComparison(value, _a) {
  * @param {Object} item - the item
  * @param {Object|Function} key - the potentially nested keypath or property callback
  * @return {Array} - an array containing the value(s) at the nested keypath
- */
-function getItemValues(item, key) {
+ */ function getItemValues(item, key) {
     if (typeof key === "object") {
         key = key.key;
     }
-    var value;
+    let value;
     if (typeof key === "function") {
         value = key(item);
-    }
-    else if (item == null) {
+    } else if (item == null) {
         value = null;
-    }
-    else if (Object.hasOwnProperty.call(item, key)) {
+    } else if (Object.hasOwnProperty.call(item, key)) {
         value = item[key];
-    }
-    else if (key.includes(".")) {
+    } else if (key.includes(".")) {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         return getNestedValues(key, item);
-    }
-    else {
+    } else {
         value = null;
     }
     // because `value` can also be undefined
@@ -288,7 +268,9 @@ function getItemValues(item, key) {
     if (Array.isArray(value)) {
         return value;
     }
-    return [String(value)];
+    return [
+        String(value)
+    ];
 }
 /**
  * Given path: "foo.bar.baz"
@@ -296,24 +278,23 @@ function getItemValues(item, key) {
  *   -> 'buzz'
  * @param path a dot-separated set of keys
  * @param item the item to get the value from
- */
-function getNestedValues(path, item) {
-    var keys = path.split(".");
-    var values = [item];
-    for (var i = 0, I = keys.length; i < I; i++) {
-        var nestedKey = keys[i];
-        var nestedValues = [];
-        for (var j = 0, J = values.length; j < J; j++) {
-            var nestedItem = values[j];
-            if (nestedItem == null)
-                continue;
+ */ function getNestedValues(path, item) {
+    const keys = path.split(".");
+    let values = [
+        item
+    ];
+    for(let i = 0, I = keys.length; i < I; i++){
+        const nestedKey = keys[i];
+        let nestedValues = [];
+        for(let j = 0, J = values.length; j < J; j++){
+            const nestedItem = values[j];
+            if (nestedItem == null) continue;
             if (Object.hasOwnProperty.call(nestedItem, nestedKey)) {
-                var nestedValue = nestedItem[nestedKey];
+                const nestedValue = nestedItem[nestedKey];
                 if (nestedValue != null) {
                     nestedValues.push(nestedValue);
                 }
-            }
-            else if (nestedKey === "*") {
+            } else if (nestedKey === "*") {
                 // ensure that values is an array
                 nestedValues = nestedValues.concat(nestedItem);
             }
@@ -323,8 +304,8 @@ function getNestedValues(path, item) {
     if (Array.isArray(values[0])) {
         // keep allowing the implicit wildcard for an array of strings at the end of
         // the path; don't use `.flat()` because that's not available in node.js v10
-        var result = [];
-        return result.concat.apply(result, values);
+        const result = [];
+        return result.concat(...values);
     }
     // Based on our logic it should be an array of strings by now...
     // assuming the user's path terminated in strings
@@ -335,36 +316,37 @@ function getNestedValues(path, item) {
  * @param item - the item from which the values will be retrieved
  * @param keys - the keys to use to retrieve the values
  * @return objects with {itemValue, attributes}
- */
-function getAllValuesToRank(item, keys) {
-    var allValues = [];
-    for (var j = 0, J = keys.length; j < J; j++) {
-        var key = keys[j];
-        var attributes = getKeyAttributes(key);
-        var itemValues = getItemValues(item, key);
-        for (var i = 0, I = itemValues.length; i < I; i++) {
+ */ function getAllValuesToRank(item, keys) {
+    const allValues = [];
+    for(let j = 0, J = keys.length; j < J; j++){
+        const key = keys[j];
+        const attributes = getKeyAttributes(key);
+        const itemValues = getItemValues(item, key);
+        for(let i = 0, I = itemValues.length; i < I; i++){
             allValues.push({
                 itemValue: itemValues[i],
-                attributes: attributes,
+                attributes
             });
         }
     }
     return allValues;
 }
-var defaultKeyAttributes = {
+const defaultKeyAttributes = {
     maxRanking: Infinity,
-    minRanking: -Infinity,
+    minRanking: -Infinity
 };
 /**
  * Gets all the attributes for the given key
  * @param key - the key from which the attributes will be retrieved
  * @return object containing the key's attributes
- */
-function getKeyAttributes(key) {
+ */ function getKeyAttributes(key) {
     if (typeof key === "string") {
         return defaultKeyAttributes;
     }
-    return __assign(__assign({}, defaultKeyAttributes), key);
+    return {
+        ...defaultKeyAttributes,
+        ...key
+    };
 }
 export { matchSorter, defaultBaseSortFn };
 export default matchSorter;

package/mbToBytes.js

@@ -1,11 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mbToBytes = void 0;
 /**
  * Megabytes to bytes
  *
  * @category format
- */
-var mbToBytes = function (bytes) { return bytes * 1000 * 1000; };
-exports.mbToBytes = mbToBytes;
-exports.default = exports.mbToBytes;
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    mbToBytes: function() {
+        return mbToBytes;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const mbToBytes = (bytes)=>bytes * 1000 * 1000;
+const _default = mbToBytes;

package/mbToBytes.mjs

@@ -2,6 +2,5 @@
  * Megabytes to bytes
  *
  * @category format
- */
-export var mbToBytes = function (bytes) { return bytes * 1000 * 1000; };
+ */ export const mbToBytes = (bytes)=>bytes * 1000 * 1000;
 export default mbToBytes;

package/mergeObjects.d.ts

@@ -4,4 +4,4 @@
  * @category objects
  * @see https://stackoverflow.com/a/46973278/1938970
  */
-export declare const mergeObjects: <T extends object = object>(target: T, ...sources: T[]) => T;
+export declare const mergeObjects: <T extends object = object>(target: T, ...sources: Partial<T>[]) => T;

package/mergeObjects.js

@@ -1,41 +1,39 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeObjects = void 0;
-var tslib_1 = require("tslib");
-var isObject_1 = require("./isObject");
-/**
- * Merge two or more objects together. It mutates the target object.
- *
- * @category objects
- * @see https://stackoverflow.com/a/46973278/1938970
- */
-var mergeObjects = function (target) {
-    var sources = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        sources[_i - 1] = arguments[_i];
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "mergeObjects", {
+    enumerable: true,
+    get: function() {
+        return mergeObjects;
     }
+});
+const _isObject = require("./isObject");
+const _isUndefined = require("./isUndefined");
+const mergeObjects = (target, ...sources)=>{
     if (!sources.length) {
         return target;
     }
-    var source = sources.shift();
+    const source = sources.shift();
     if (source === undefined) {
         return target;
     }
-    if ((0, isObject_1.isObject)(target) && (0, isObject_1.isObject)(source)) {
-        Object.keys(source).forEach(function (_key) {
-            var key = _key;
-            if ((0, isObject_1.isObject)(source[key])) {
+    if ((0, _isObject.isObject)(target) && (0, _isObject.isObject)(source)) {
+        Object.keys(source).forEach((_key)=>{
+            const key = _key;
+            if ((0, _isObject.isObject)(source[key])) {
                 if (!target[key]) {
-                    // @ts-expect-error FIXME: ...
                     target[key] = {};
                 }
-                (0, exports.mergeObjects)(target[key], source[key]);
-            }
-            else {
-                target[key] = source[key];
+                mergeObjects(target[key], source[key]);
+            } else {
+                if (!(0, _isUndefined.isUndefined)(source[key])) {
+                    // FIXME: assertion here should not be needed but isUndefined does not
+                    // seem to narrow the type correctly for some reason
+                    target[key] = source[key];
+                }
             }
         });
     }
-    return exports.mergeObjects.apply(void 0, tslib_1.__spreadArray([target], sources, false));
+    return mergeObjects(target, ...sources);
 };
-exports.mergeObjects = mergeObjects;

package/mergeObjects.mjs

@@ -1,37 +1,34 @@
-import { __spreadArray } from "tslib";
 import { isObject } from "./isObject";
+import { isUndefined } from "./isUndefined";
 /**
  * Merge two or more objects together. It mutates the target object.
  *
  * @category objects
  * @see https://stackoverflow.com/a/46973278/1938970
- */
-export var mergeObjects = function (target) {
-    var sources = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        sources[_i - 1] = arguments[_i];
-    }
+ */ export const mergeObjects = (target, ...sources)=>{
     if (!sources.length) {
         return target;
     }
-    var source = sources.shift();
+    const source = sources.shift();
     if (source === undefined) {
         return target;
     }
     if (isObject(target) && isObject(source)) {
-        Object.keys(source).forEach(function (_key) {
-            var key = _key;
+        Object.keys(source).forEach((_key)=>{
+            const key = _key;
             if (isObject(source[key])) {
                 if (!target[key]) {
-                    // @ts-expect-error FIXME: ...
                     target[key] = {};
                 }
                 mergeObjects(target[key], source[key]);
-            }
-            else {
-                target[key] = source[key];
+            } else {
+                if (!isUndefined(source[key])) {
+                    // FIXME: assertion here should not be needed but isUndefined does not
+                    // seem to narrow the type correctly for some reason
+                    target[key] = source[key];
+                }
             }
         });
     }
-    return mergeObjects.apply(void 0, __spreadArray([target], sources, false));
+    return mergeObjects(target, ...sources);
 };

package/mergeUrlQueryParams.js

@@ -1,27 +1,32 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeUrlQueryParams = void 0;
-var tslib_1 = require("tslib");
-var isNull_1 = tslib_1.__importDefault(require("./isNull"));
-/**
- * Merge query parameters objects, it *mutates* the first given object argument
- *
- * @category location
- * @pure
- */
-function mergeUrlQueryParams(oldParams, newParams) {
-    if (oldParams === void 0) { oldParams = {}; }
-    if (newParams === void 0) { newParams = {}; }
-    for (var key in newParams) {
-        var value = newParams[key];
-        if (oldParams[key] && (0, isNull_1.default)(value)) {
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    mergeUrlQueryParams: function() {
+        return mergeUrlQueryParams;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
+const _isNull = /*#__PURE__*/ _interop_require_default._(require("./isNull"));
+function mergeUrlQueryParams(oldParams = {}, newParams = {}) {
+    for(const key in newParams){
+        const value = newParams[key];
+        if (oldParams[key] && (0, _isNull.default)(value)) {
             delete oldParams[key];
-        }
-        else {
+        } else {
             oldParams[key] = value;
         }
     }
     return oldParams;
 }
-exports.mergeUrlQueryParams = mergeUrlQueryParams;
-exports.default = mergeUrlQueryParams;
+const _default = mergeUrlQueryParams;

package/mergeUrlQueryParams.mjs

@@ -4,16 +4,12 @@ import isNull from "./isNull";
  *
  * @category location
  * @pure
- */
-export function mergeUrlQueryParams(oldParams, newParams) {
-    if (oldParams === void 0) { oldParams = {}; }
-    if (newParams === void 0) { newParams = {}; }
-    for (var key in newParams) {
-        var value = newParams[key];
+ */ export function mergeUrlQueryParams(oldParams = {}, newParams = {}) {
+    for(const key in newParams){
+        const value = newParams[key];
         if (oldParams[key] && isNull(value)) {
             delete oldParams[key];
-        }
-        else {
+        } else {
             oldParams[key] = value;
         }
     }