@koine/utils 2.0.0-beta.72 → 2.0.0-beta.74

package/removeDuplicates.d.ts

@@ -0,0 +1,2 @@
+export declare let removeDuplicates: <T extends any[]>(arr: T) => any[];
+export default removeDuplicates;

package/removeDuplicates.js

@@ -0,0 +1,2 @@
+export let removeDuplicates = (arr) => [...new Set(arr)];
+export default removeDuplicates;

package/removeDuplicatesByKey.d.ts

@@ -1 +1,2 @@
 export declare let removeDuplicatesByKey: <T extends Record<string | number | symbol, any>>(array: T[] | undefined, key: keyof T) => T[];
+export default removeDuplicatesByKey;

package/removeDuplicatesByKey.js

@@ -0,0 +1,13 @@
+export let removeDuplicatesByKey = (array = [], key) => {
+    const keysMap = {};
+    const output = [];
+    for (let i = 0; i < array.length; i++) {
+        const item = array[i];
+        if (!keysMap[item[key]]) {
+            output.push(item);
+            keysMap[item[key]] = true;
+        }
+    }
+    return output;
+};
+export default removeDuplicatesByKey;

package/removeDuplicatesComparing.d.ts

@@ -1 +1,2 @@
 export declare let removeDuplicatesComparing: <T>(from: any[], to: T[]) => T[];
+export default removeDuplicatesComparing;

package/removeDuplicatesComparing.js

@@ -0,0 +1,7 @@
+import { findDuplicatedIndexes } from "./findDuplicatedIndexes";
+import { removeIndexesFromArray } from "./removeIndexesFromArray";
+export let removeDuplicatesComparing = (from, to) => {
+    const indexes = findDuplicatedIndexes(from);
+    return removeIndexesFromArray(to, indexes);
+};
+export default removeDuplicatesComparing;

package/removeIndexesFromArray.d.ts

@@ -1 +1,2 @@
 export declare let removeIndexesFromArray: <T>(arr: T[], indexes: Record<number, true>) => T[];
+export default removeIndexesFromArray;

package/removeIndexesFromArray.js

@@ -0,0 +1,10 @@
+export let removeIndexesFromArray = (arr, indexes) => {
+    const output = [];
+    for (let i = 0; i < arr.length; i++) {
+        if (!indexes.hasOwnProperty(i)) {
+            output.push(arr[i]);
+        }
+    }
+    return output;
+};
+export default removeIndexesFromArray;

package/removeTrailingSlash.d.ts

@@ -1 +1,2 @@
-export declare let removeTralingSlash: (urlLike?: string | null) => string;
+export declare let removeTrailingSlash: (urlLike?: string | null) => string;
+export default removeTrailingSlash;

package/removeTrailingSlash.js

@@ -0,0 +1,2 @@
+export let removeTrailingSlash = (urlLike) => (urlLike || "").replace(/\/*$/, "");
+export default removeTrailingSlash;

package/removeUrlQueryParams.d.ts

@@ -1 +1,2 @@
 export declare let removeUrlQueryParams: (url: string, paramsToRemove?: string[]) => string;
+export default removeUrlQueryParams;

package/removeUrlQueryParams.js

@@ -0,0 +1,14 @@
+import { buildUrlQueryString } from "./buildUrlQueryString";
+import { getUrlQueryParams } from "./getUrlQueryParams";
+export let removeUrlQueryParams = (url, paramsToRemove = []) => {
+    const parts = url.split("?");
+    const allParams = getUrlQueryParams(url);
+    const params = {};
+    for (const key in allParams) {
+        if (!paramsToRemove.includes(key)) {
+            params[key] = allParams[key];
+        }
+    }
+    return parts[0] + buildUrlQueryString(params);
+};
+export default removeUrlQueryParams;

package/render.d.ts

@@ -10,4 +10,4 @@ type Definitions = {
 } & DefinitionExtended;
 type RenderFunction = (data: object) => string;
 export declare let render: (tmpl: string, def?: Definitions) => RenderFunction;
-export {};
+export default render;

package/render.js

@@ -0,0 +1,113 @@
+let varname = "data";
+let evaluate = /<%([\s\S]+?(\}?)+)%>/g;
+let interpolate = /<%=([\s\S]+?)%>/g;
+let conditional = /<%\?(\?)?\s*([\s\S]*?)\s*%>/g;
+let iterate = /<%~\s*(?:%>|([\s\S]+?)\s*:\s*([\w$]+)\s*(?::\s*([\w$]+))?\s*%>)/g;
+let use = /<%#([\s\S]+?)%>/g;
+let useParams = /(^|[^\w$])def(?:\.|\[['"])([\w$.]+)(?:['"]\])?\s*:\s*([\w$.]+|"[^"]+"|'[^']+'|\{[^}]+\})/g;
+let define = /<%##\s*([\w.$]+)\s*(:|=)([\s\S]+?)#%>/g;
+let defineParams = /^\s*([\w$]+):([\s\S]+)/;
+let start = "'+(";
+let end = ")+'";
+let skip = /$^/;
+let resolveDefs = (block, def) => (typeof block === "string" ? block : block.toString())
+    .replace(define || skip, (_, code, assign, value) => {
+    if (code.indexOf("def.") === 0) {
+        code = code.substring(4);
+    }
+    if (!(code in def)) {
+        if (assign === ":") {
+            value.replace(defineParams, (_, param, v) => {
+                def[code] = { arg: param, text: v };
+            });
+            if (!(code in def))
+                def[code] = value;
+        }
+        else {
+            new Function("def", "def['" + code + "']=" + value)(def);
+        }
+    }
+    return "";
+})
+    .replace(use || skip, (_, code) => {
+    code = code.replace(useParams, (_, s, d, param) => {
+        if (def[d] && def[d].arg && param) {
+            let rw = (d + ":" + param).replace(/'|\\/g, "_");
+            def.__exp = def.__exp || {};
+            def.__exp[rw] = def[d].text.replace(new RegExp("(^|[^\\w$])" + def[d].arg + "([^\\w$])", "g"), "$1" + param + "$2");
+            return s + "def.__exp['" + rw + "']";
+        }
+        return s;
+    });
+    let v = new Function("def", "return " + code)(def);
+    return v ? resolveDefs(v, def) : v;
+});
+let unescape = (code) => code.replace(/\\('|\\)/g, "$1").replace(/[\r\t\n]/g, " ");
+export let render = (tmpl, def) => {
+    let sid = 0;
+    let indv;
+    let str = use || define ? resolveDefs(tmpl, def || {}) : tmpl;
+    str = ("var X='" +
+        str
+            .replace(/(^|\r|\n)\t* +| +\t*(\r|\n|$)/g, " ")
+            .replace(/\r|\n|\t|\/\*[\s\S]*?\*\//g, "")
+            .replace(/'|\\/g, "\\$&")
+            .replace(interpolate || skip, (_, code) => start + unescape(code) + end)
+            .replace(conditional || skip, (_, elseCase, code) => elseCase
+            ? code
+                ? "';}else if(" + unescape(code) + "){X+='"
+                : "';}else{X+='"
+            : code
+                ? "';if(" + unescape(code) + "){X+='"
+                : "';}X+='")
+            .replace(iterate || skip, (_, arr, vName, iName) => {
+            if (!arr)
+                return "';} } X+='";
+            sid++;
+            indv = iName || "i" + sid;
+            arr = unescape(arr);
+            return ("';var arr" +
+                sid +
+                "=" +
+                arr +
+                ";if(arr" +
+                sid +
+                "){var " +
+                vName +
+                "," +
+                indv +
+                "=-1,l" +
+                sid +
+                "=arr" +
+                sid +
+                ".length-1;while(" +
+                indv +
+                "<l" +
+                sid +
+                "){" +
+                vName +
+                "=arr" +
+                sid +
+                "[" +
+                indv +
+                "+=1];X+='");
+        })
+            .replace(evaluate || skip, (_, code) => "';" + unescape(code) + "X+='") +
+        "';return X;")
+        .replace(/\n/g, "\\n")
+        .replace(/\t/g, "\\t")
+        .replace(/\r/g, "\\r")
+        .replace(/(\s|;|\}|^|\{)X\+='';/g, "$1")
+        .replace(/\+''/g, "");
+    try {
+        return new Function(varname, str);
+    }
+    catch (e) {
+        if (process.env["NODE_ENV"] === "development") {
+            console.log("Could not create a template function: " + str);
+            throw e;
+        }
+    }
+    return () => "";
+};
+export default render;

package/round.d.ts

@@ -1,2 +1,3 @@
 import type { AnythingFalsy } from "./types";
 export declare let round: (number: number, decimals?: AnythingFalsy | number, trailingZeroes?: 1 | boolean | AnythingFalsy) => number;
+export default round;

package/round.js

@@ -0,0 +1,4 @@
+export let round = (number, decimals, trailingZeroes) => decimals
+    ? parseFloat(number.toFixed(decimals).replace(trailingZeroes ? "" : /\.+0*$/, ""))
+    : parseInt(number + "", 10);
+export default round;

package/roundTo.d.ts

@@ -1 +1,2 @@
 export declare let roundTo: (num: number, decimals?: number) => string;
+export default roundTo;

package/roundTo.js

@@ -0,0 +1,11 @@
+export let roundTo = (num, decimals = 2) => {
+    if (isFinite(num) && !isNaN(num)) {
+        const multiplicator = Math.pow(10, decimals);
+        return Math.round(num * multiplicator) / multiplicator + "";
+    }
+    if (process.env["NODE_ENV"] === "development") {
+        console.warn("[@koine/utils] math:roundTo -> given not a finite number as first arg");
+    }
+    return "";
+};
+export default roundTo;

package/serializeCookie.d.ts

@@ -1,2 +1,3 @@
 import type { CookieAttributesServer } from "./cookie";
 export declare let serializeCookie: (name: string, val: string, attributes?: CookieAttributesServer) => string;
+export default serializeCookie;

package/serializeCookie.js

@@ -0,0 +1,69 @@
+import { isNumber } from "./isNumber";
+const fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+export let serializeCookie = (name, val, attributes = {}) => {
+    const { encode = encodeURIComponent, domain, path, httpOnly, secure, sameSite, } = attributes;
+    let { maxAge, expires } = attributes;
+    const value = encode(val);
+    if (process.env["NODE_ENV"] === "development") {
+        if (!fieldContentRegExp.test(name)) {
+            throw new TypeError("argument name is invalid");
+        }
+        if (typeof attributes.encode !== "function") {
+            throw new TypeError("option encode is invalid");
+        }
+        if (value && !fieldContentRegExp.test(value)) {
+            throw new TypeError("argument val is invalid");
+        }
+    }
+    let str = name + "=" + value;
+    if (null != maxAge) {
+        maxAge = maxAge - 0;
+        if (isNaN(maxAge) || !isFinite(maxAge)) {
+            throw new TypeError("option maxAge is invalid");
+        }
+        str += "; Max-Age=" + Math.floor(maxAge);
+    }
+    if (domain) {
+        if (process.env["NODE_ENV"] === "development") {
+            if (!fieldContentRegExp.test(domain)) {
+                throw new TypeError("option domain is invalid");
+            }
+        }
+        str += "; Domain=" + domain;
+    }
+    if (path) {
+        if (process.env["NODE_ENV"] === "development") {
+            if (!fieldContentRegExp.test(path)) {
+                throw new TypeError("option path is invalid");
+            }
+        }
+        str += "; Path=" + path;
+    }
+    if (expires) {
+        if (isNumber(expires)) {
+            expires = new Date(Date.now() + expires * 864e5);
+        }
+        str += "; Expires=" + expires.toUTCString();
+    }
+    if (httpOnly) {
+        str += "; HttpOnly";
+    }
+    if (secure) {
+        str += "; Secure";
+    }
+    if (sameSite) {
+        switch (sameSite.toLowerCase()) {
+            case "lax":
+                str += "; SameSite=Lax";
+                break;
+            case "strict":
+                str += "; SameSite=Strict";
+                break;
+            case "none":
+                str += "; SameSite=None";
+                break;
+        }
+    }
+    return str;
+};
+export default serializeCookie;

package/setCookie.d.ts

@@ -1,2 +1,3 @@
 import { type CookieAttributesClient } from "./cookie";
 export declare let setCookie: <T extends string = string>(name: string, value: string | T, attributes?: CookieAttributesClient) => string | undefined;
+export default setCookie;

package/setCookie.js

@@ -0,0 +1,45 @@
+import { defaultAttributesClient } from "./cookie";
+import { isNumber } from "./isNumber";
+import { isUndefined } from "./isUndefined";
+let converterWrite = (value) => {
+    return encodeURIComponent(value).replace(/%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g, decodeURIComponent);
+};
+export let setCookie = (name, value, attributes = {}) => {
+    let { expires, ...restAttrs } = attributes;
+    const cleanedAttrs = {
+        expires: "",
+        ...defaultAttributesClient,
+        ...restAttrs,
+    };
+    if (isUndefined(document)) {
+        if (process.env["NODE_ENV"] === "development") {
+            console.warn("[@koine/utils:setCookie] document is undefined");
+        }
+        return undefined;
+    }
+    if (isNumber(expires)) {
+        expires = new Date(Date.now() + expires * 864e5);
+    }
+    if (expires) {
+        cleanedAttrs.expires = expires.toUTCString();
+    }
+    name = encodeURIComponent(name)
+        .replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent)
+        .replace(/[()]/g, escape);
+    let stringifiedAttributes = "";
+    for (const name in attributes) {
+        const attrName = name;
+        if (!attributes[attrName]) {
+            continue;
+        }
+        stringifiedAttributes += "; " + attrName;
+        if (attributes[attrName] === true) {
+            continue;
+        }
+        stringifiedAttributes +=
+            "=" + String(attributes[attrName]).split(";")[0];
+    }
+    return (document.cookie =
+        name + "=" + converterWrite(value) + stringifiedAttributes);
+};
+export default setCookie;

package/shuffle.d.ts

@@ -1 +1,2 @@
 export declare let shuffle: <T>(array: T[]) => T[];
+export default shuffle;

package/shuffle.js

@@ -0,0 +1,17 @@
+export let shuffle = (array) => {
+    const length = array == null ? 0 : array.length;
+    if (!length) {
+        return [];
+    }
+    let index = -1;
+    const lastIndex = length - 1;
+    const result = [...array];
+    while (++index < length) {
+        const rand = index + Math.floor(Math.random() * (lastIndex - index + 1));
+        const value = result[rand];
+        result[rand] = result[index];
+        result[index] = value;
+    }
+    return result;
+};
+export default shuffle;

package/slugify.d.ts

@@ -1 +1,2 @@
 export declare let slugify: (text: string, separator?: string) => string;
+export default slugify;

package/slugify.js

@@ -0,0 +1,11 @@
+import { accentsSets } from "./accentSets";
+import { removeAccents } from "./removeAccents";
+export let slugify = (text, separator = "-") => removeAccents(text.toString().toLowerCase().trim(), accentsSets.concat([["-", "[·/_,:;']"]]))
+    .replace(/\s+/g, "-")
+    .replace(/&/g, "-and-")
+    .replace(/[^\w-]+/g, "")
+    .replace(/--+/g, "-")
+    .replace(/^-+/, "")
+    .replace(/-+$/, "")
+    .replace(/-/g, separator);
+export default slugify;

package/split.d.ts

@@ -1,2 +1,3 @@
 export type Split<S extends string, D extends string> = string extends S ? string[] : S extends "" ? [] : S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
 export declare let split: <T extends string, D extends string>(string: T, delimiter: D) => Split<T, D>;
+export default split;

package/split.js

@@ -0,0 +1,2 @@
+export let split = (string, delimiter) => string.split(delimiter);
+export default split;

package/splitReverse.d.ts

@@ -2,3 +2,4 @@ import type { Split } from "./split";
 import type { Reverse } from "./types";
 export type SplitReverse<S extends string, D extends string> = Reverse<Split<S, D>>;
 export declare let splitReverse: <T extends string, D extends string>(string: T, delimiter: D) => Reverse<Split<T, D>>;
+export default splitReverse;

package/splitReverse.js

@@ -0,0 +1,2 @@
+export let splitReverse = (string, delimiter) => string.split(delimiter).reverse();
+export default splitReverse;

package/swapMap.d.ts

@@ -1 +1,2 @@
 export declare let swapMap: <T extends Record<string, string | number | symbol> = Record<string, string | number | symbol>>(map?: T) => Record<T[keyof T], keyof T>;
+export default swapMap;

package/swapMap.js

@@ -0,0 +1,8 @@
+export let swapMap = (map = {}) => {
+    const output = {};
+    for (const key in map) {
+        output[map[key]] = key;
+    }
+    return output;
+};
+export default swapMap;

package/throttle.d.ts

@@ -1,2 +1,3 @@
 /// <reference types="node" />
 export declare let throttle: <TFn extends Function, TContext>(fn: TFn, limit: number, context?: TContext | undefined) => (this: TContext, ...args: any[]) => NodeJS.Timeout | undefined;
+export default throttle;

package/throttle.js

@@ -0,0 +1,15 @@
+export let throttle = (fn, limit, context) => {
+    let wait;
+    return function (...args) {
+        context = context || this;
+        if (!wait) {
+            fn.apply(context, ...args);
+            wait = true;
+            return setTimeout(function () {
+                wait = false;
+            }, limit);
+        }
+        return;
+    };
+};
+export default throttle;

package/titleCase.d.ts

@@ -1 +1,2 @@
 export declare let titleCase: (input?: null | string) => string;
+export default titleCase;

package/titleCase.js

@@ -0,0 +1,4 @@
+export let titleCase = (input) => input
+    ? input.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase())
+    : "";
+export default titleCase;

package/toNumber.d.ts

@@ -1 +1,2 @@
 export declare let toNumber: (input?: string | number, fallback?: number) => number;
+export default toNumber;

package/toNumber.js

@@ -0,0 +1,3 @@
+import { isNumber } from "./isNumber";
+export let toNumber = (input, fallback) => isNumber(input) ? input : input ? parseFloat(input) : fallback || 0;
+export default toNumber;

package/toRgba.d.ts

@@ -1 +1,2 @@
 export declare let toRgba: (hex: string, alpha?: number) => string;
+export default toRgba;

package/toRgba.js

@@ -0,0 +1,8 @@
+export let toRgba = (hex, alpha = 1) => {
+    const r = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    if (r) {
+        return `rgba(${parseInt(r[1], 16)},${parseInt(r[2], 16)},${parseInt(r[3], 16)},${alpha})`;
+    }
+    return "";
+};
+export default toRgba;

package/transformToUrlPathname.d.ts

@@ -1 +1,2 @@
 export declare let transformToUrlPathname: (toPathname?: string) => string;
+export default transformToUrlPathname;

package/transformToUrlPathname.js

@@ -0,0 +1,5 @@
+import { isString } from "./isString";
+export let transformToUrlPathname = (toPathname) => isString(toPathname)
+    ? `/${encodeURIComponent(toPathname.replace(/\s/g, "-").toLowerCase())}`
+    : "";
+export default transformToUrlPathname;

package/truncate.d.ts

@@ -1 +1,2 @@
 export declare let truncate: (input: undefined | null | string, length: number) => string;
+export default truncate;

package/truncate.js

@@ -0,0 +1,6 @@
+export let truncate = (input, length) => input
+    ? input.length > length
+        ? input.substring(0, length) + "..."
+        : input
+    : "";
+export default truncate;

package/tryUntil.d.ts

@@ -1 +1,2 @@
 export declare let tryUntil: (test: () => boolean, timeout: number, interval: number, resolve: () => void, reject?: () => void) => void;
+export default tryUntil;

package/tryUntil.js

@@ -0,0 +1,15 @@
+export let tryUntil = (test, timeout, interval, resolve, reject) => {
+    const timeWas = new Date();
+    const wait = setInterval(function () {
+        if (test()) {
+            clearInterval(wait);
+            resolve();
+        }
+        else if (new Date() - timeWas > timeout) {
+            clearInterval(wait);
+            if (reject)
+                reject();
+        }
+    }, interval);
+};
+export default tryUntil;

package/types.js

@@ -0,0 +1 @@
+export {};

package/uid.d.ts

@@ -1 +1,2 @@
 export declare let uid: (prefix?: string) => string;
+export default uid;

package/uid.js

@@ -0,0 +1,6 @@
+let lastId = 0;
+export let uid = (prefix = "id") => {
+    lastId++;
+    return `${prefix}-${lastId}`;
+};
+export default uid;

package/updateLinkParams.d.ts

@@ -1,2 +1,3 @@
 import type { AnyQueryParams } from "./location";
 export declare let updateLinkParams: ($anchor: HTMLAnchorElement, newParams: NonNullable<AnyQueryParams>) => string;
+export default updateLinkParams;

package/updateLinkParams.js

@@ -0,0 +1,7 @@
+import { updateUrlQueryParams } from "./updateUrlQueryParams";
+export let updateLinkParams = ($anchor, newParams) => {
+    const href = updateUrlQueryParams($anchor.href, newParams);
+    $anchor.href = href;
+    return href;
+};
+export default updateLinkParams;

package/updateUrlQueryParams.d.ts

@@ -1,2 +1,3 @@
 import type { AnyQueryParams } from "./location";
 export declare let updateUrlQueryParams: (url: string, newParams?: NonNullable<AnyQueryParams>) => string;
+export default updateUrlQueryParams;

package/updateUrlQueryParams.js

@@ -0,0 +1,11 @@
+import { buildUrlQueryString } from "./buildUrlQueryString";
+import { getUrlQueryParams } from "./getUrlQueryParams";
+import { mergeUrlQueryParams } from "./mergeUrlQueryParams";
+export let updateUrlQueryParams = (url, newParams = {}) => {
+    const parts = url.split("?");
+    const allParams = parts[1]
+        ? mergeUrlQueryParams(getUrlQueryParams(url), newParams)
+        : newParams;
+    return parts[0] + buildUrlQueryString(allParams);
+};
+export default updateUrlQueryParams;

package/uppercase.d.ts

@@ -1 +1,2 @@
 export declare let uppercase: <T extends string>(str?: T | null | undefined) => Uppercase<T>;
+export default uppercase;

package/uppercase.js

@@ -0,0 +1,2 @@
+export let uppercase = (str) => (str || "").toUpperCase();
+export default uppercase;

package/uuid.d.ts

@@ -1 +1,2 @@
 export declare let uuid: () => string;
+export default uuid;

package/uuid.js

@@ -0,0 +1,5 @@
+export let uuid = () => "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0, v = c == "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+});
+export default uuid;

package/uuidNumeric.d.ts

@@ -1 +1,2 @@
 export declare let uuidNumeric: () => number;
+export default uuidNumeric;

package/uuidNumeric.js

@@ -0,0 +1,2 @@
+export let uuidNumeric = () => new Date().valueOf();
+export default uuidNumeric;

package/wait.d.ts

@@ -1 +1,2 @@
 export declare let wait: (milliseconds: number) => Promise<unknown>;
+export default wait;

package/wait.js

@@ -0,0 +1,2 @@
+export let wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+export default wait;

package/without.js

@@ -0,0 +1 @@
+"use strict";