@koine/utils 1.0.26 → 1.0.29

package/{async.d.ts → Defer.d.ts}

@@ -1,10 +1,13 @@
+/**
+ * @category async
+ */
 export declare type Deferred<T> = Promise<T> & {
     resolve: PromiseConstructor["resolve"];
     reject: PromiseConstructor["reject"];
 };
 /**
+ * @category async
  * @see https://stackoverflow.com/a/37673534/1938970
- *
  * @example
  *
  * ```ts
@@ -14,7 +17,4 @@ export declare type Deferred<T> = Promise<T> & {
  * ```
  */
 export declare function Defer<T>(): Deferred<T>;
-/**
- * A promisified `setTimeout`
- */
-export declare const wait: (milliseconds: number) => Promise<unknown>;
+export default Defer;

package/{async.js → Defer.js}

@@ -1,6 +1,6 @@
 /**
+ * @category async
  * @see https://stackoverflow.com/a/37673534/1938970
- *
  * @example
  *
  * ```ts
@@ -23,9 +23,4 @@ export function Defer() {
     // }
     return self;
 }
-/**
- * A promisified `setTimeout`
- */
-export var wait = function (milliseconds) {
-    return new Promise(function (resolve) { return setTimeout(resolve, milliseconds); });
-};
+export default Defer;

package/{emitter.d.ts → Emitter.d.ts}

@@ -22,3 +22,4 @@ export declare function Emitter<EventMap extends {
      */
     emit<EventName_1 extends keyof EventMap>(name: EventName_1, data?: EventMap[EventName_1] | undefined): void;
 };
+export default Emitter;

package/{emitter.js → Emitter.js}

@@ -35,3 +35,4 @@ export function Emitter(namespace) {
         },
     };
 }
+export default Emitter;

package/accentSets.d.ts

@@ -0,0 +1,16 @@
+/**
+ * First value is the `to`, second is `from`, from *which* chars do we translates *to*
+ *
+ * @category text
+ */
+export declare type AccentsSet = [string, string];
+/**
+ * Accent sets
+ *
+ * @category text
+ * @see https://gist.github.com/mathewbyrne/1280286#gistcomment-3498021
+ * @see 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,38 @@
+/**
+ * Accent sets
+ *
+ * @category text
+ * @see https://gist.github.com/mathewbyrne/1280286#gistcomment-3498021
+ * @see 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 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

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

package/addOrReplaceAtIdx.js

@@ -0,0 +1,19 @@
+import { __spreadArray } from "tslib";
+/**
+ * @category array
+ */
+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/arrayToLookup.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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,13 @@
+/**
+ * Maps a simple flat array to a lookup dictionary object
+ *
+ * @category array
+ */
+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

@@ -0,0 +1,12 @@
+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
+ */
+export declare function buildUrlQueryString(params?: AnyQueryParams): string;
+export default buildUrlQueryString;

package/buildUrlQueryString.js

@@ -0,0 +1,24 @@
+import isNull from "./isNull";
+import isUndefined from "./isUndefined";
+/**
+ * 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
+ */
+export function buildUrlQueryString(params) {
+    if (params === void 0) { params = {}; }
+    var output = "";
+    for (var key in params) {
+        var value = params[key];
+        if (!isNull(value) && !isUndefined(value)) {
+            output += "".concat(key, "=").concat(encodeURIComponent(value + ""), "&");
+        }
+    }
+    // removes the last &
+    return output ? "?".concat(output.replace(/&+$/, "")) : "";
+}
+export default buildUrlQueryString;

package/changeUrlPath.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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,18 @@
+import isBrowser from "./isBrowser";
+import normaliseUrlPathname from "./normaliseUrlPathname";
+/**
+ * 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 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

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

package/chunkByChunks.js

@@ -0,0 +1,37 @@
+/**
+ * TODO: untested
+ * @category array
+ * @see https://stackoverflow.com/a/8189268/1938970
+ */
+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

@@ -0,0 +1,6 @@
+/**
+ * @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,12 @@
+/**
+ * @category array
+ * @see https://stackoverflow.com/a/40682136/1938970
+ */
+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/clamp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a number whose value is limited to the given range.
+ *
+ * @category math
+ * @see https://stackoverflow.com/a/11409944/1938970
+ */
+export declare function clamp(num: number, min: number, max: number): number;
+export default clamp;

package/clamp.js

@@ -0,0 +1,10 @@
+/**
+ * Returns a number whose value is limited to the given range.
+ *
+ * @category math
+ * @see https://stackoverflow.com/a/11409944/1938970
+ */
+export function clamp(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+}
+export default clamp;

package/clsx.d.ts

@@ -0,0 +1,9 @@
+import type { ClassValue } from "clsx";
+/**
+ * Class names utility, embedded from [clsx](https://github.com/lukeed/clsx)
+ *
+ * @see https://github.com/lukeed/clsx
+ * @license [MIT: Luke Edwards](https://github.com/lukeed/clsx/blob/master/license)
+ */
+export declare const clsx: (...args: ClassValue[]) => string;
+export default clsx;

package/clsx.js

@@ -0,0 +1,49 @@
+// import _clsx from "clsx";
+// export const clsx = _clsx;
+function toVal(mix) {
+    var k, y, str = "";
+    if (typeof mix === "string" || typeof mix === "number") {
+        str += mix;
+    }
+    else if (typeof mix === "object") {
+        if (Array.isArray(mix)) {
+            for (k = 0; k < mix.length; k++) {
+                if (mix[k]) {
+                    if ((y = toVal(mix[k]))) {
+                        str && (str += " ");
+                        str += y;
+                    }
+                }
+            }
+        }
+        else {
+            for (k in mix) {
+                if (mix[k]) {
+                    str && (str += " ");
+                    str += k;
+                }
+            }
+        }
+    }
+    return str;
+}
+/**
+ * Class names utility, embedded from [clsx](https://github.com/lukeed/clsx)
+ *
+ * @see https://github.com/lukeed/clsx
+ * @license [MIT: Luke Edwards](https://github.com/lukeed/clsx/blob/master/license)
+ */
+export var clsx = function () {
+    var i = 0, tmp, x, str = "";
+    while (i < arguments.length) {
+        // eslint-disable-next-line prefer-rest-params
+        if ((tmp = arguments[i++])) {
+            if ((x = toVal(tmp))) {
+                str && (str += " ");
+                str += x;
+            }
+        }
+    }
+    return str;
+};
+export default clsx;

package/convertRange.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Convert range of a number
+ *
+ * e.g. converting number 5 in a scale/range from 0 10 to a scale/range from 50
+ * to 100 would return 75
+ * ```
+ * convertRange(5, [0, 10], [50, 100]);
+ * ```
+ *
+ * @category math
+ * @see https://stackoverflow.com/a/14224813
+ */
+export declare function convertRange(num: number, r1: number[], r2: number[]): number;
+export default convertRange;

package/convertRange.js

@@ -0,0 +1,16 @@
+/**
+ * Convert range of a number
+ *
+ * e.g. converting number 5 in a scale/range from 0 10 to a scale/range from 50
+ * to 100 would return 75
+ * ```
+ * convertRange(5, [0, 10], [50, 100]);
+ * ```
+ *
+ * @category math
+ * @see https://stackoverflow.com/a/14224813
+ */
+export function convertRange(num, r1, r2) {
+    return ((num - r1[0]) * (r2[1] - r2[0])) / (r1[1] - r1[0]) + r2[0];
+}
+export default convertRange;

package/cookie.d.ts

@@ -1,30 +1,12 @@
 /**
  * @file
  *
- * Inspired and adapted from
+ * @category cookie
  *
+ * All cookie related code is inspired and adapted from:
  * - [js-cookie](https://github.com/js-cookie/js-cookie)
- * @see https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/js-cookie/index.d.ts
  * - [cookie](https://github.com/jshttp/cookie)
- *
  */
-/**
- * Parse a cookie header.
- *
- * Parse the given cookie header string into an object
- * The object has the various cookies as keys(names) => values
- */
-export declare function parseCookie<T extends Record<string, unknown> = Record<string, string>>(str: string, attributes?: CookieAttributesServer): T;
-/**
- * Serialize data into a cookie header.
- *
- * Serialize the a name value pair into a cookie string suitable for
- * http headers. An optional attributes object specified cookie parameters.
- *
- * serialize('foo', 'bar', { httpOnly: true })
- *   => "foo=bar; httpOnly"
- */
-export declare function serializeCookie(name: string, val: string, attributes?: CookieAttributesServer): string;
 declare type CookieAttributes = {
     /**
      * Define when the cookie will be removed. Value can be a Number
@@ -59,15 +41,14 @@ declare type CookieAttributes = {
      */
     sameSite?: "strict" | "Strict" | "lax" | "Lax" | "none" | "None" | undefined;
 };
-declare type CookieAttributesServer = CookieAttributes & {
+export declare type CookieAttributesServer = CookieAttributes & {
     maxAge?: number;
     httpOnly?: boolean;
     encode?: (input: string) => string;
     decode?: (input: string) => string;
 };
-declare type CookieAttributesClient = CookieAttributes;
-export declare function readCookie<T extends Record<string, unknown> = Record<string, string>>(name?: null): T;
-export declare function readCookie<T extends Record<string, unknown> = Record<string, string>, N extends keyof T = keyof T>(name: N): T[N];
-export declare function setCookie<T extends string = string>(name: string, value: string | T, attributes?: CookieAttributesClient): string | undefined;
-export declare function removeCookie(name: string, attributes?: CookieAttributesClient): void;
+export declare type CookieAttributesClient = CookieAttributes;
+export declare const defaultAttributesClient: {
+    path: string;
+};
 export {};