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

package/render.js

@@ -0,0 +1,112 @@
+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 () => "";
+};

package/round.js

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

package/roundTo.js

@@ -0,0 +1,10 @@
+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 "";
+};

package/serializeCookie.js

@@ -0,0 +1,68 @@
+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;
+};

package/setCookie.js

@@ -0,0 +1,44 @@
+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);
+};

package/shuffle.js

@@ -0,0 +1,16 @@
+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;
+};

package/slugify.js

@@ -0,0 +1,10 @@
+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);

package/split.js

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

package/splitReverse.js

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

package/swapMap.js

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

package/throttle.js

@@ -0,0 +1,14 @@
+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;
+    };
+};

package/titleCase.js

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

package/toNumber.js

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

package/toRgba.js

@@ -0,0 +1,7 @@
+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 "";
+};

package/transformToUrlPathname.js

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

package/truncate.js

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

package/tryUntil.js

@@ -0,0 +1,14 @@
+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);
+};

package/types.js

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

package/uid.js

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

package/updateLinkParams.js

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

package/updateUrlQueryParams.js

@@ -0,0 +1,10 @@
+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);
+};

package/uppercase.js

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

package/uuid.js

@@ -0,0 +1,4 @@
+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);
+});

package/uuidNumeric.js

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

package/wait.js

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

package/without.js

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