@koine/utils 2.0.0-beta.14 → 2.0.0-beta.15

package/Defer.d.ts

@@ -1,20 +1,6 @@
-/**
- * @category async
- */
 export type Deferred<T> = Promise<T> & {
     resolve: PromiseConstructor["resolve"];
     reject: PromiseConstructor["reject"];
 };
-/**
- * @category async
- * @see https://stackoverflow.com/a/37673534/1938970
- * @example
- *
- * ```ts
- * const deferred = Defer();
- * deferred.resolve();
- * deferred.then(handleSuccess, handleError);
- * ```
- */
 export declare function Defer<T>(): Deferred<T>;
 export default Defer;

package/Defer.js

@@ -0,0 +1,11 @@
+export function Defer() {
+    var self = this || {};
+    var p = (self.promise = new Promise(function (resolve, reject) {
+        self.resolve = resolve;
+        self.reject = reject;
+    }));
+    self.then = p.then.bind(p);
+    self.catch = p.catch.bind(p);
+    return self;
+}
+export default Defer;

package/Emitter.d.ts

@@ -1,27 +1,7 @@
-/**
- * Emitter super simple class
- *
- * Events will be prefixed with the given `namespace` plus a `.` so:
- * `{namespace}.myevent`
- *
- * Adapted from https://github.com/developit/mitt
- *
- * Regarding typescript support see:
- * - https://stackoverflow.com/q/53299743/1938970
- * - https://github.com/Microsoft/TypeScript/pull/26349
- *
- * @category impl
- */
 export declare function Emitter<EventMap extends {
     [key: string]: any;
 }>(namespace: string): {
-    /**
-     * Register an event handler for the given type.
-     */
     on<EventName extends keyof EventMap>(name: EventName, handler: (data?: EventMap[EventName] | undefined) => any): void;
-    /**
-     * Invoke all handlers for the given type.
-     */
     emit<EventName_1 extends keyof EventMap>(name: EventName_1, data?: EventMap[EventName_1] | undefined): void;
 };
 export default Emitter;

package/Emitter.js

@@ -0,0 +1,20 @@
+export function Emitter(namespace) {
+    var all = new Map();
+    return {
+        on: function (name, handler) {
+            var handlers = all.get("".concat(namespace, ".").concat(String(name)));
+            var added = handlers && handlers.push(handler);
+            if (!added) {
+                all.set("".concat(namespace, ".").concat(String(name)), [handler]);
+            }
+        },
+        emit: function (name, data) {
+            (all.get("".concat(namespace, ".").concat(String(name))) || [])
+                .slice()
+                .map(function (handler) {
+                handler(data);
+            });
+        },
+    };
+}
+export default Emitter;

package/accentSets.d.ts

@@ -1,17 +1,3 @@
-/**
- * First value is the `to`, second is `from`, from *which* chars do we translates *to*
- *
- * @category text
- */
 export type AccentsSet = [string, string];
-/**
- * Accent sets
- *
- * @category text
- * @resources
- * - https://gist.github.com/mathewbyrne/1280286#gistcomment-3498021
- * - https://gist.github.com/eek/9c4887e80b3ede05c0e39fee4dce3747 for usage
- * of [normalize](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize)
- */
 export declare const accentsSets: AccentsSet[];
 export default accentsSets;

package/accentSets.js

@@ -0,0 +1,30 @@
+export var accentsSets = [
+    ["a", "ÀÁÂÃÅÆĀĂĄẠẢẤẦẨẪẬẮẰẲẴẶ"],
+    ["ae", "Ä"],
+    ["c", "ÇĆĈČ"],
+    ["d", "ÐĎĐÞ"],
+    ["e", "ÈÉÊËĒĔĖĘĚẸẺẼẾỀỂỄỆ"],
+    ["g", "ĜĞĢǴ"],
+    ["h", "ĤḦ"],
+    ["i", "ÌÍÎÏĨĪĮİỈỊ"],
+    ["j", "Ĵ"],
+    ["ij", "IJ"],
+    ["k", "Ķ"],
+    ["l", "ĹĻĽŁ"],
+    ["m", "Ḿ"],
+    ["n", "ÑŃŅŇ"],
+    ["o", "ÒÓÔÕØŌŎŐỌỎỐỒỔỖỘỚỜỞỠỢǪǬƠ"],
+    ["oe", "΅"],
+    ["p", "ṕ"],
+    ["r", "ŔŖŘ"],
+    ["s", "ŚŜŞŠ"],
+    ["ss", "ß"],
+    ["t", "ŢŤ"],
+    ["u", "ÙÚÛŨŪŬŮŰŲỤỦỨỪỬỮỰƯ"],
+    ["ue", "Ü"],
+    ["w", "ẂŴẀẄ"],
+    ["x", "ẍ"],
+    ["y", "ÝŶŸỲỴỶỸ"],
+    ["z", "ŹŻŽ"],
+];
+export default accentsSets;

package/addOrReplaceAtIdx.d.ts

@@ -1,9 +1,2 @@
-/**
- * Add or replace an item in the given array, it returns a new array (immutable).
- * Typescript wise this is meant to keep the same type on the newly returned
- * array, therefore the `newItem` must match the type of the `list` items.
- *
- * @category array
- */
 export declare function addOrReplaceAtIdx<T>(list: T[], newItem: T, newIdx?: number): T[];
 export default addOrReplaceAtIdx;

package/addOrReplaceAtIdx.js

@@ -0,0 +1,16 @@
+import { __spreadArray } from "tslib";
+export function addOrReplaceAtIdx(list, newItem, newIdx) {
+    if (list.length === 0) {
+        return [newItem];
+    }
+    if (typeof newIdx === "undefined" || list.length - 1 < newIdx) {
+        return __spreadArray(__spreadArray([], list, true), [newItem], false);
+    }
+    return list.map(function (item, idx) {
+        if (idx === newIdx) {
+            return newItem;
+        }
+        return item;
+    });
+}
+export default addOrReplaceAtIdx;

package/areEqual.d.ts

@@ -1,19 +1,4 @@
 type ComparablePrimitive = string | number | boolean;
 type Comparable = ComparablePrimitive | object | Record<string, ComparablePrimitive> | Array<ComparablePrimitive>;
-/**
- * A simple and quick deep equal objects utility. This is meant to be used
- * solely to deduplicate requests payload and perform comparison on JSON ready
- * objects made of primitives `string`, `number` and `boolean`s.
- *
- * It support nested `object`s and `array`s only.
- *
- * NB: `undefined` and `null` values do not count in the comparison as they are
- * usually meant to be ignored in JSON requestBody payloads.
- *
- * According to very rudimentary tests this function takes on average between
- * 0.15 ms and 2ms to compare two averaged sizes requet body payloads.
- *
- * @category object
- */
 export declare function areEqual(a: Comparable, b?: Comparable): boolean;
 export default areEqual;

package/areEqual.js

@@ -0,0 +1,55 @@
+import { isArray } from "./isArray.js";
+import { isObject } from "./isObject.js";
+function areEqualArrays(a, b) {
+    if (!b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (var i = 0; i < a.length; i++) {
+        var aValue = a[i];
+        var bValue = b[i];
+        if (!areEqual(aValue, bValue))
+            return false;
+    }
+    return true;
+}
+function areEqualObjects(a, b) {
+    if (!b)
+        return false;
+    var aKeys = Object.keys(a);
+    var bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (var _i = 0, aKeys_1 = aKeys; _i < aKeys_1.length; _i++) {
+        var _key = aKeys_1[_i];
+        var key = _key;
+        var aValue = a[key];
+        var bValue = b[key];
+        if (!areEqual(aValue, bValue)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function areEqual(a, b) {
+    if (!a && !b) {
+        return true;
+    }
+    if (!b && a !== b) {
+        return false;
+    }
+    var areObjects = isObject(a) && isObject(b);
+    if (areObjects && !areEqualObjects(a, b)) {
+        return false;
+    }
+    var areArrays = isArray(a) && isArray(b);
+    if (areArrays && !areEqualArrays(a, b)) {
+        return false;
+    }
+    if (!areObjects && !areArrays && a !== b) {
+        return false;
+    }
+    return true;
+}
+export default areEqual;

package/arrayOfAll.d.ts

@@ -1,27 +1,2 @@
-/**
- * Ensure an array contains all desired values
- *
- * @category array
- * @borrows [SO comment by `CertainPerformance`](https://stackoverflow.com/a/60132060/1938970)
- *
- * @usage
- * ```ts
- * type Fruit = "pear" | "apple" | "orange";
- *
- * const arrayOfAllFruits = arrayOfAll<Fruit>();
- *
- * const allFruits = arrayOfAllFruits([
- *  "pear",
- *  "apple",
- *  "orange"
- * ]); // ts compiler ok
- *
- * const allFruits = arrayOfAllFruits([
- *  "pear",
- *  "apple",
- * ]); // ts compiler fails
- * ```
- *
- */
 export declare const arrayOfAll: <T>() => <U extends T[]>(array: U & ([T] extends [U[number]] ? unknown : "Invalid")) => U & ([T] extends [U[number]] ? unknown : "Invalid");
 export default arrayOfAll;

package/arrayOfAll.js

@@ -0,0 +1,6 @@
+export var arrayOfAll = function () {
+    return function (array) {
+        return array;
+    };
+};
+export default arrayOfAll;

package/arraySum.d.ts

@@ -1,8 +1,2 @@
-/**
- * Sum array of numbers
- *
- * @category array
- * @category math
- */
 export declare const arraySum: (numbers: number[]) => number;
 export default arraySum;

package/arraySum.js

@@ -0,0 +1,4 @@
+export var arraySum = function (numbers) {
+    return numbers.reduce(function (sum, current) { return sum + current; }, 0);
+};
+export default arraySum;

package/arrayToLookup.d.ts

@@ -1,7 +1,2 @@
-/**
- * Maps a simple flat array to a lookup dictionary object
- *
- * @category array
- */
 export declare function arrayToLookup<T extends string | number | symbol>(array?: T[]): Record<T, 1>;
 export default arrayToLookup;

package/arrayToLookup.js

@@ -0,0 +1,8 @@
+export function arrayToLookup(array) {
+    if (array === void 0) { array = []; }
+    return array.reduce(function (obj, item) {
+        obj[item] = 1;
+        return obj;
+    }, {});
+}
+export default arrayToLookup;

package/buildUrlQueryString.d.ts

@@ -1,12 +1,3 @@
-import { type AnyQueryParams } from "./location";
-/**
- * Get clean query string for URL
- *
- * It returns the query string **with** the initial `?`
- *
- * TODO: at some point replace with `URLSearchParams`, @see [caniuse](https://caniuse.com/?search=URLSearchParams)
- *
- * @category location
- */
+import { type AnyQueryParams } from "./location.js";
 export declare function buildUrlQueryString<T extends AnyQueryParams>(params: T): string;
 export default buildUrlQueryString;

package/buildUrlQueryString.js

@@ -0,0 +1,21 @@
+import isArray from "./isArray.js";
+import isNull from "./isNull.js";
+import isUndefined from "./isUndefined.js";
+export function buildUrlQueryString(params) {
+    var output = "";
+    if (!params)
+        return output;
+    for (var key in params) {
+        var value = params[key];
+        if (isArray(value)) {
+            for (var i = 0; i < value.length; i++) {
+                output += "".concat(key, "=").concat(encodeURIComponent(value[i] + ""), "&");
+            }
+        }
+        else if (!isNull(value) && !isUndefined(value)) {
+            output += "".concat(key, "=").concat(encodeURIComponent(value + ""), "&");
+        }
+    }
+    return output ? "?".concat(output.replace(/&+$/, "")) : "";
+}
+export default buildUrlQueryString;

package/capitalize.d.ts

@@ -1,9 +1,2 @@
-/**
- * Capitalize first letter of the given string.
- *
- * @category text
- * @resources
- * - https://stackoverflow.com/a/11409944/1938970
- */
 export declare function capitalize<T extends string>(string?: null | T): Capitalize<T>;
 export default capitalize;

package/capitalize.js

@@ -0,0 +1,6 @@
+export function capitalize(string) {
+    var ensuredString = string || "";
+    return (ensuredString.charAt(0).toUpperCase() +
+        ensuredString.slice(1));
+}
+export default capitalize;

package/changeUrlPath.d.ts

@@ -1,10 +1,2 @@
-/**
- * Change URL path, ensures initial and ending slashes and normalise eventual
- * consecutive slashes, it uses `history`.
- *
- * @category location
- * @param replace Replace URL instead of pushing it in the history stack. By default it pushes it.
- * @returns {string} The new cleaned pathname
- */
 export declare function changeUrlPath(pathname: string, state?: object, replace?: boolean): string;
 export default changeUrlPath;

package/changeUrlPath.js

@@ -0,0 +1,10 @@
+import isBrowser from "./isBrowser.js";
+import normaliseUrlPathname from "./normaliseUrlPathname.js";
+export function changeUrlPath(pathname, state, replace) {
+    var path = normaliseUrlPathname("/".concat(pathname, "/"));
+    if (isBrowser) {
+        history[replace ? "replaceState" : "pushState"](state, "", path);
+    }
+    return path;
+}
+export default changeUrlPath;

package/chunkByChunks.d.ts

@@ -1,7 +1,2 @@
-/**
- * @category array
- * @see https://stackoverflow.com/a/8189268/1938970
- * @experimental TODO: untested
- */
 export declare function chunkByChunks<T>(arr: T[], nrOfChunks: number, balanced?: boolean): T[][];
 export default chunkByChunks;

package/chunkByChunks.js

@@ -0,0 +1,32 @@
+export function chunkByChunks(arr, nrOfChunks, balanced) {
+    if (nrOfChunks < 2)
+        return [arr];
+    var len = arr.length;
+    var output = [];
+    var i = 0;
+    var size;
+    if (len % nrOfChunks === 0) {
+        size = Math.floor(len / nrOfChunks);
+        while (i < len) {
+            output.push(arr.slice(i, (i += size)));
+        }
+    }
+    else if (balanced) {
+        while (i < len) {
+            size = Math.ceil((len - i) / nrOfChunks--);
+            output.push(arr.slice(i, (i += size)));
+        }
+    }
+    else {
+        nrOfChunks--;
+        size = Math.floor(len / nrOfChunks);
+        if (len % size === 0)
+            size--;
+        while (i < size * nrOfChunks) {
+            output.push(arr.slice(i, (i += size)));
+        }
+        output.push(arr.slice(size * nrOfChunks));
+    }
+    return output;
+}
+export default chunkByChunks;

package/chunkBySize.d.ts

@@ -1,6 +1,2 @@
-/**
- * @category array
- * @see https://stackoverflow.com/a/40682136/1938970
- */
 export declare function chunkBySize<T>(arr: T[], size: number): T[][];
 export default chunkBySize;

package/chunkBySize.js

@@ -0,0 +1,8 @@
+export function chunkBySize(arr, size) {
+    var output = [];
+    for (var i = 0; i < arr.length; i += size) {
+        output.push(arr.slice(i, i + size));
+    }
+    return output;
+}
+export default chunkBySize;

package/cjs/Defer.d.ts

@@ -0,0 +1,6 @@
+export type Deferred<T> = Promise<T> & {
+    resolve: PromiseConstructor["resolve"];
+    reject: PromiseConstructor["reject"];
+};
+export declare function Defer<T>(): Deferred<T>;
+export default Defer;

package/cjs/Defer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Defer = void 0;
+function Defer() {
+    var self = this || {};
+    var p = (self.promise = new Promise(function (resolve, reject) {
+        self.resolve = resolve;
+        self.reject = reject;
+    }));
+    self.then = p.then.bind(p);
+    self.catch = p.catch.bind(p);
+    return self;
+}
+exports.Defer = Defer;
+exports.default = Defer;

package/cjs/Emitter.d.ts

@@ -0,0 +1,7 @@
+export declare function Emitter<EventMap extends {
+    [key: string]: any;
+}>(namespace: string): {
+    on<EventName extends keyof EventMap>(name: EventName, handler: (data?: EventMap[EventName] | undefined) => any): void;
+    emit<EventName_1 extends keyof EventMap>(name: EventName_1, data?: EventMap[EventName_1] | undefined): void;
+};
+export default Emitter;

package/cjs/Emitter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emitter = void 0;
+function Emitter(namespace) {
+    var all = new Map();
+    return {
+        on: function (name, handler) {
+            var handlers = all.get("".concat(namespace, ".").concat(String(name)));
+            var added = handlers && handlers.push(handler);
+            if (!added) {
+                all.set("".concat(namespace, ".").concat(String(name)), [handler]);
+            }
+        },
+        emit: function (name, data) {
+            (all.get("".concat(namespace, ".").concat(String(name))) || [])
+                .slice()
+                .map(function (handler) {
+                handler(data);
+            });
+        },
+    };
+}
+exports.Emitter = Emitter;
+exports.default = Emitter;

package/cjs/accentSets.d.ts

@@ -0,0 +1,3 @@
+export type AccentsSet = [string, string];
+export declare const accentsSets: AccentsSet[];
+export default accentsSets;

package/cjs/accentSets.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accentsSets = void 0;
+exports.accentsSets = [
+    ["a", "ÀÁÂÃÅÆĀĂĄẠẢẤẦẨẪẬẮẰẲẴẶ"],
+    ["ae", "Ä"],
+    ["c", "ÇĆĈČ"],
+    ["d", "ÐĎĐÞ"],
+    ["e", "ÈÉÊËĒĔĖĘĚẸẺẼẾỀỂỄỆ"],
+    ["g", "ĜĞĢǴ"],
+    ["h", "ĤḦ"],
+    ["i", "ÌÍÎÏĨĪĮİỈỊ"],
+    ["j", "Ĵ"],
+    ["ij", "IJ"],
+    ["k", "Ķ"],
+    ["l", "ĹĻĽŁ"],
+    ["m", "Ḿ"],
+    ["n", "ÑŃŅŇ"],
+    ["o", "ÒÓÔÕØŌŎŐỌỎỐỒỔỖỘỚỜỞỠỢǪǬƠ"],
+    ["oe", "΅"],
+    ["p", "ṕ"],
+    ["r", "ŔŖŘ"],
+    ["s", "ŚŜŞŠ"],
+    ["ss", "ß"],
+    ["t", "ŢŤ"],
+    ["u", "ÙÚÛŨŪŬŮŰŲỤỦỨỪỬỮỰƯ"],
+    ["ue", "Ü"],
+    ["w", "ẂŴẀẄ"],
+    ["x", "ẍ"],
+    ["y", "ÝŶŸỲỴỶỸ"],
+    ["z", "ŹŻŽ"],
+];
+exports.default = exports.accentsSets;

package/cjs/addOrReplaceAtIdx.d.ts

@@ -0,0 +1,2 @@
+export declare function addOrReplaceAtIdx<T>(list: T[], newItem: T, newIdx?: number): T[];
+export default addOrReplaceAtIdx;

package/cjs/addOrReplaceAtIdx.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOrReplaceAtIdx = void 0;
+var tslib_1 = require("tslib");
+function addOrReplaceAtIdx(list, newItem, newIdx) {
+    if (list.length === 0) {
+        return [newItem];
+    }
+    if (typeof newIdx === "undefined" || list.length - 1 < newIdx) {
+        return tslib_1.__spreadArray(tslib_1.__spreadArray([], list, true), [newItem], false);
+    }
+    return list.map(function (item, idx) {
+        if (idx === newIdx) {
+            return newItem;
+        }
+        return item;
+    });
+}
+exports.addOrReplaceAtIdx = addOrReplaceAtIdx;
+exports.default = addOrReplaceAtIdx;

package/cjs/areEqual.d.ts

@@ -0,0 +1,4 @@
+type ComparablePrimitive = string | number | boolean;
+type Comparable = ComparablePrimitive | object | Record<string, ComparablePrimitive> | Array<ComparablePrimitive>;
+export declare function areEqual(a: Comparable, b?: Comparable): boolean;
+export default areEqual;

package/cjs/areEqual.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areEqual = void 0;
+var isArray_1 = require("./isArray");
+var isObject_1 = require("./isObject");
+function areEqualArrays(a, b) {
+    if (!b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (var i = 0; i < a.length; i++) {
+        var aValue = a[i];
+        var bValue = b[i];
+        if (!areEqual(aValue, bValue))
+            return false;
+    }
+    return true;
+}
+function areEqualObjects(a, b) {
+    if (!b)
+        return false;
+    var aKeys = Object.keys(a);
+    var bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (var _i = 0, aKeys_1 = aKeys; _i < aKeys_1.length; _i++) {
+        var _key = aKeys_1[_i];
+        var key = _key;
+        var aValue = a[key];
+        var bValue = b[key];
+        if (!areEqual(aValue, bValue)) {
+            return false;
+        }
+    }
+    return true;
+}
+function areEqual(a, b) {
+    if (!a && !b) {
+        return true;
+    }
+    if (!b && a !== b) {
+        return false;
+    }
+    var areObjects = (0, isObject_1.isObject)(a) && (0, isObject_1.isObject)(b);
+    if (areObjects && !areEqualObjects(a, b)) {
+        return false;
+    }
+    var areArrays = (0, isArray_1.isArray)(a) && (0, isArray_1.isArray)(b);
+    if (areArrays && !areEqualArrays(a, b)) {
+        return false;
+    }
+    if (!areObjects && !areArrays && a !== b) {
+        return false;
+    }
+    return true;
+}
+exports.areEqual = areEqual;
+exports.default = areEqual;

package/cjs/arrayOfAll.d.ts

@@ -0,0 +1,2 @@
+export declare const arrayOfAll: <T>() => <U extends T[]>(array: U & ([T] extends [U[number]] ? unknown : "Invalid")) => U & ([T] extends [U[number]] ? unknown : "Invalid");
+export default arrayOfAll;

package/cjs/arrayOfAll.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayOfAll = void 0;
+var arrayOfAll = function () {
+    return function (array) {
+        return array;
+    };
+};
+exports.arrayOfAll = arrayOfAll;
+exports.default = exports.arrayOfAll;

package/cjs/arraySum.d.ts

@@ -0,0 +1,2 @@
+export declare const arraySum: (numbers: number[]) => number;
+export default arraySum;