@koine/utils 2.0.0-beta.8 → 2.0.0-beta.82

package/matchSorter.mjs

@@ -1,352 +0,0 @@
-/**
- * @file
- *
- * Slightly adapted from Kent C. Dodd's [match-sorter](https://github.com/kentcdodds/match-sorter)
- * differences are:
- * - less exports
- * - smaller output
- * - no external deps
- *
- * TODO: turn objects into arrays for smaller output?
- *
- * @name match-sorter
- * @license MIT license.
- * @copyright (c) 2020 Kent C. Dodds
- * @author Kent C. Dodds <me@kentcdodds.com> (https://kentcdodds.com)
- */ 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 = {}) {
-    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) {
-        const rankingInfo = getHighestRanking(item, keys, value, options);
-        const { rank, keyThreshold = threshold } = rankingInfo;
-        if (rank >= keyThreshold) {
-            matches.push({
-                ...rankingInfo,
-                item,
-                index
-            });
-        }
-        return matches;
-    }
-}
-/**
- * Gets the highest ranking for value for the given item based on its values for the given keys
- * @param {*} item - the item to rank
- * @param {Array} keys - the keys to get values from the item for the ranking
- * @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) {
-    if (!keys) {
-        // if keys is not specified, then we assume the item given is ready to be matched
-        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
-        };
-    }
-    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) {
-            newRank = maxRanking;
-        }
-        if (newRank > rank) {
-            rank = newRank;
-            keyIndex = i;
-            keyThreshold = threshold;
-            newRankedValue = itemValue;
-        }
-        return {
-            rankedValue: newRankedValue,
-            rank,
-            keyIndex,
-            keyThreshold
-        };
-    }, {
-        rankedValue: item,
-        rank: RANKING_NO_MATCH,
-        keyIndex: -1,
-        keyThreshold: options.threshold
-    });
-}
-/**
- * Gives a rankings score based on how well the two strings match.
- * @param {String} testString - the string to test against
- * @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) {
-    testString = prepareValueForComparison(testString, options);
-    stringToRank = prepareValueForComparison(stringToRank, options);
-    // too long
-    if (stringToRank.length > testString.length) {
-        return RANKING_NO_MATCH;
-    }
-    // case sensitive equals
-    if (testString === stringToRank) {
-        return RANKING_CASE_SENSITIVE_EQUAL;
-    }
-    // Lower casing before further comparison
-    testString = testString.toLowerCase();
-    stringToRank = stringToRank.toLowerCase();
-    // case insensitive equals
-    if (testString === stringToRank) {
-        return RANKING_EQUAL;
-    }
-    // starts with
-    if (testString.startsWith(stringToRank)) {
-        return RANKING_STARTS_WITH;
-    }
-    // word starts with
-    if (testString.includes(` ${stringToRank}`)) {
-        return RANKING_WORD_STARTS_WITH;
-    }
-    // contains
-    if (testString.includes(stringToRank)) {
-        return RANKING_CONTAINS;
-    } 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.
-        return RANKING_NO_MATCH;
-    }
-    // acronym
-    if (getAcronym(testString).includes(stringToRank)) {
-        return RANKING_ACRONYM;
-    }
-    // will return a number between RANKING_MATCHES and
-    // RANKING_MATCHES + 1 depending  on how close of a match it is.
-    return getClosenessRanking(testString, stringToRank);
-}
-/**
- * Generates an acronym for a string.
- *
- * @param {String} string the string for which to produce the acronym
- * @returns {String} the acronym
- */ function getAcronym(string) {
-    let acronym = "";
-    const wordsInString = string.split(" ");
-    wordsInString.forEach((wordInString)=>{
-        const splitByHyphenWords = wordInString.split("-");
-        splitByHyphenWords.forEach((splitByHyphenWord)=>{
-            acronym += splitByHyphenWord.substring(0, 1);
-        });
-    });
-    return acronym;
-}
-/**
- * Returns a score based on how spread apart the
- * characters from the stringToRank are within the testString.
- * A number close to RANKING_MATCHES represents a loose match. A number close
- * to RANKING_MATCHES + 1 represents a tighter match.
- * @param {String} testString - the string to test against
- * @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) {
-    let matchingInOrderCharCount = 0;
-    let charNumber = 0;
-    function findMatchingCharacter(matchChar, string, index) {
-        for(let j = index, J = string.length; j < J; j++){
-            const stringChar = string[j];
-            if (stringChar === matchChar) {
-                matchingInOrderCharCount += 1;
-                return j + 1;
-            }
-        }
-        return -1;
-    }
-    function getRanking(spread) {
-        const spreadPercentage = 1 / spread;
-        const inOrderPercentage = matchingInOrderCharCount / stringToRank.length;
-        const ranking = RANKING_MATCHES + inOrderPercentage * spreadPercentage;
-        return ranking;
-    }
-    const firstIndex = findMatchingCharacter(stringToRank[0], testString, 0);
-    if (firstIndex < 0) {
-        return RANKING_NO_MATCH;
-    }
-    charNumber = firstIndex;
-    for(let i = 1, I = stringToRank.length; i < I; i++){
-        const matchChar = stringToRank[i];
-        charNumber = findMatchingCharacter(matchChar, testString, charNumber);
-        const found = charNumber > -1;
-        if (!found) {
-            return RANKING_NO_MATCH;
-        }
-    }
-    const spread = charNumber - firstIndex;
-    return getRanking(spread);
-}
-/**
- * Sorts items that have a rank, index, and keyIndex
- * @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) {
-    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 {
-            return aKeyIndex < bKeyIndex ? aFirst : bFirst;
-        }
-    } else {
-        return aRank > bRank ? aFirst : bFirst;
-    }
-}
-/**
- * Prepares value for comparison by stringifying it, removing diacritics (if specified)
- * @param {String} value - the value to clean
- * @param {Object} options - {keepDiacritics: whether to remove diacritics}
- * @return {String} the prepared value
- */ 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 = `${value}`; // toString
-    if (!keepDiacritics) {
-        value = removeAccents(value);
-    }
-    return value;
-}
-/**
- * Gets value for key in item at arbitrarily nested keypath
- * @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) {
-    if (typeof key === "object") {
-        key = key.key;
-    }
-    let value;
-    if (typeof key === "function") {
-        value = key(item);
-    } else if (item == null) {
-        value = null;
-    } else if (Object.hasOwnProperty.call(item, key)) {
-        value = item[key];
-    } else if (key.includes(".")) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-        return getNestedValues(key, item);
-    } else {
-        value = null;
-    }
-    // because `value` can also be undefined
-    if (value == null) {
-        return [];
-    }
-    if (Array.isArray(value)) {
-        return value;
-    }
-    return [
-        String(value)
-    ];
-}
-/**
- * Given path: "foo.bar.baz"
- * And item: {foo: {bar: {baz: 'buzz'}}}
- *   -> 'buzz'
- * @param path a dot-separated set of keys
- * @param item the item to get the value from
- */ 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)) {
-                const nestedValue = nestedItem[nestedKey];
-                if (nestedValue != null) {
-                    nestedValues.push(nestedValue);
-                }
-            } else if (nestedKey === "*") {
-                // ensure that values is an array
-                nestedValues = nestedValues.concat(nestedItem);
-            }
-        }
-        values = nestedValues;
-    }
-    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
-        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
-    return values;
-}
-/**
- * Gets all the values for the given keys in the given item and returns an array of those values
- * @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) {
-    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
-            });
-        }
-    }
-    return allValues;
-}
-const defaultKeyAttributes = {
-    maxRanking: 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) {
-    if (typeof key === "string") {
-        return defaultKeyAttributes;
-    }
-    return {
-        ...defaultKeyAttributes,
-        ...key
-    };
-}
-export { matchSorter, defaultBaseSortFn };
-export default matchSorter;

package/mbToBytes.js

@@ -1,24 +0,0 @@
-/**
- * Megabytes to bytes
- *
- * @category format
- */ "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

@@ -1,6 +0,0 @@
-/**
- * Megabytes to bytes
- *
- * @category format
- */ export const mbToBytes = (bytes)=>bytes * 1000 * 1000;
-export default mbToBytes;

package/mergeObjects.js

@@ -1,39 +0,0 @@
-"use strict";
-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;
-    }
-    const source = sources.shift();
-    if (source === undefined) {
-        return target;
-    }
-    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]) {
-                    target[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 mergeObjects(target, ...sources);
-};

package/mergeObjects.mjs

@@ -1,34 +0,0 @@
-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 const mergeObjects = (target, ...sources)=>{
-    if (!sources.length) {
-        return target;
-    }
-    const source = sources.shift();
-    if (source === undefined) {
-        return target;
-    }
-    if (isObject(target) && isObject(source)) {
-        Object.keys(source).forEach((_key)=>{
-            const key = _key;
-            if (isObject(source[key])) {
-                if (!target[key]) {
-                    target[key] = {};
-                }
-                mergeObjects(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(target, ...sources);
-};

package/mergeUrlQueryParams.js

@@ -1,32 +0,0 @@
-"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, {
-    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 {
-            oldParams[key] = value;
-        }
-    }
-    return oldParams;
-}
-const _default = mergeUrlQueryParams;

package/mergeUrlQueryParams.mjs

@@ -1,18 +0,0 @@
-import isNull from "./isNull";
-/**
- * Merge query parameters objects, it *mutates* the first given object argument
- *
- * @category location
- * @pure
- */ export function mergeUrlQueryParams(oldParams = {}, newParams = {}) {
-    for(const key in newParams){
-        const value = newParams[key];
-        if (oldParams[key] && isNull(value)) {
-            delete oldParams[key];
-        } else {
-            oldParams[key] = value;
-        }
-    }
-    return oldParams;
-}
-export default mergeUrlQueryParams;

package/moveSortableArrayItemByKey.js

@@ -1,35 +0,0 @@
-/**
- * Move item from one place to another in a sortable array of objects, re-ordering
- * the array accrodingly (no swapping of position).
- * This is useful for drag and drop functionalities
- *
- * @category arrays, dnd
- */ "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, {
-    moveSortableArrayItemByKey: function() {
-        return moveSortableArrayItemByKey;
-    },
-    default: function() {
-        return _default;
-    }
-});
-function moveSortableArrayItemByKey(items, key, fromItem, toItem) {
-    const itemsKeys = items.map((item)=>item[key]);
-    const idxFrom = itemsKeys.indexOf(fromItem[key]);
-    const idxTo = itemsKeys.indexOf(toItem[key]);
-    const [item] = items.splice(idxFrom, 1);
-    items.splice(idxTo, 0, item);
-    return [
-        ...items
-    ];
-}
-const _default = moveSortableArrayItemByKey;

package/moveSortableArrayItemByKey.mjs

@@ -1,17 +0,0 @@
-/**
- * Move item from one place to another in a sortable array of objects, re-ordering
- * the array accrodingly (no swapping of position).
- * This is useful for drag and drop functionalities
- *
- * @category arrays, dnd
- */ export function moveSortableArrayItemByKey(items, key, fromItem, toItem) {
-    const itemsKeys = items.map((item)=>item[key]);
-    const idxFrom = itemsKeys.indexOf(fromItem[key]);
-    const idxTo = itemsKeys.indexOf(toItem[key]);
-    const [item] = items.splice(idxFrom, 1);
-    items.splice(idxTo, 0, item);
-    return [
-        ...items
-    ];
-}
-export default moveSortableArrayItemByKey;

package/noop.js

@@ -1,24 +0,0 @@
-/**
- * No operation function
- *
- * @category native
- */ "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, {
-    noop: function() {
-        return noop;
-    },
-    default: function() {
-        return _default;
-    }
-});
-const noop = ()=>void 0;
-const _default = noop;

package/noop.mjs

@@ -1,6 +0,0 @@
-/**
- * No operation function
- *
- * @category native
- */ export const noop = ()=>void 0;
-export default noop;

package/normaliseUrl.js

@@ -1,24 +0,0 @@
-"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, {
-    normaliseUrl: function() {
-        return normaliseUrl;
-    },
-    default: function() {
-        return _default;
-    }
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _removeTrailingSlash = /*#__PURE__*/ _interop_require_default._(require("./removeTrailingSlash"));
-function normaliseUrl(absoluteUrl = "") {
-    return (0, _removeTrailingSlash.default)(absoluteUrl.replace(/(:\/\/)|(\/)+/g, "$1$2"));
-}
-const _default = normaliseUrl;

package/normaliseUrl.mjs

@@ -1,13 +0,0 @@
-import removeTralingSlash from "./removeTrailingSlash";
-/**
- * Normalise URL, it works both for absolute and relative URLs
- *
- * - replaces too many consecutive slashes (except `http{s}://`)
- * - removes the trailing slash
- *
- * @category location
- * @see https://stackoverflow.com/a/40649435/1938970
- */ export function normaliseUrl(absoluteUrl = "") {
-    return removeTralingSlash(absoluteUrl.replace(/(:\/\/)|(\/)+/g, "$1$2"));
-}
-export default normaliseUrl;

package/normaliseUrlPathname.js

@@ -1,24 +0,0 @@
-"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, {
-    normaliseUrlPathname: function() {
-        return normaliseUrlPathname;
-    },
-    default: function() {
-        return _default;
-    }
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _removeTrailingSlash = /*#__PURE__*/ _interop_require_default._(require("./removeTrailingSlash"));
-function normaliseUrlPathname(pathname = "") {
-    return (0, _removeTrailingSlash.default)(pathname.replace(/\/+/g, "/"));
-}
-const _default = normaliseUrlPathname;

package/normaliseUrlPathname.mjs

@@ -1,12 +0,0 @@
-import removeTralingSlash from "./removeTrailingSlash";
-/**
- * Normalise URL pathname (relative URL)
- *
- * - replaces too many consecutive slashes
- * - removes the trailing slash
- *
- * @category location
- */ export function normaliseUrlPathname(pathname = "") {
-    return removeTralingSlash(pathname.replace(/\/+/g, "/"));
-}
-export default normaliseUrlPathname;