@koine/utils 1.2.3 → 2.0.0-alpha.2

package/render.mjs

@@ -0,0 +1,165 @@
+var varname = "data";
+var evaluate = /<%([\s\S]+?(\}?)+)%>/g;
+var interpolate = /<%=([\s\S]+?)%>/g;
+var conditional = /<%\?(\?)?\s*([\s\S]*?)\s*%>/g;
+var iterate = /<%~\s*(?:%>|([\s\S]+?)\s*:\s*([\w$]+)\s*(?::\s*([\w$]+))?\s*%>)/g;
+// const encode = /<%!([\s\S]+?)%>/g;
+var use = /<%#([\s\S]+?)%>/g;
+var useParams = /(^|[^\w$])def(?:\.|\[['"])([\w$.]+)(?:['"]\])?\s*:\s*([\w$.]+|"[^"]+"|'[^']+'|\{[^}]+\})/g;
+var define = /<%##\s*([\w.$]+)\s*(:|=)([\s\S]+?)#%>/g;
+var defineParams = /^\s*([\w$]+):([\s\S]+)/;
+var start = "'+(";
+var end = ")+'";
+// const startencode = "'+encodeHTML(";
+var skip = /$^/;
+var resolveDefs = function (block, def) {
+    return (typeof block === "string" ? block : block.toString())
+        .replace(define || skip, function (_, code, assign, value) {
+        if (code.indexOf("def.") === 0) {
+            code = code.substring(4);
+        }
+        if (!(code in def)) {
+            if (assign === ":") {
+                value.replace(defineParams, 
+                // @ts-expect-error nevermind
+                function (_, param, v) {
+                    def[code] = { arg: param, text: v };
+                });
+                // @ts-expect-error nevermind
+                if (!(code in def))
+                    def[code] = value;
+            }
+            else {
+                new Function("def", "def['" + code + "']=" + value)(def);
+            }
+        }
+        return "";
+    })
+        .replace(use || skip, function (_, code) {
+        code = code.replace(useParams, function (_, s, d, param) {
+            if (def[d] && def[d].arg && param) {
+                var 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;
+        });
+        var v = new Function("def", "return " + code)(def);
+        return v ? resolveDefs(v, def) : v;
+    });
+};
+var unescape = function (code) {
+    return code.replace(/\\('|\\)/g, "$1").replace(/[\r\t\n]/g, " ");
+};
+/**
+ * Render template (adapted from doT.js)
+ *
+ * The data made available to the template is always on the `data` key, e.g.:
+ * `renderer({ myVal: "xx" })`
+ * ... will be accessible on
+ * `<%= data.myVal %>`
+ *
+ * The default delimiters are customised to work without conflicts with Blade and Twig:
+ * ```
+ * <% %>	for evaluation
+ * <%= %>	for interpolation
+ * <%? %>	for conditionals
+ * <%~ %>	for array iteration
+ * <%# %>	for compile-time evaluation/includes and partials
+ * <%## #%>	for compile-time defines
+ *
+ * Unsupported:
+ * <%! %>	for interpolation with encoding
+ * ```
+ *
+ * @example
+ *
+ * ```js
+ * import { render } from "...";
+ *
+ * const data = { name: "XYZ" };
+ * const tpl = `Hello <%= data.name %>`;
+ * const renderer = render(tpl);
+ *
+ * console.log(renderer(data)); // outputs 'Hello XYZ'
+ * ```
+ *
+ * @borrows [olado/doT by Laura Doktorova](https://github.com/olado/doT)
+ * @see https://olado.github.io/doT/index.html
+ */
+export var render = function (tmpl, def) {
+    var sid = 0;
+    var indv;
+    var 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, function (_, code) { return start + unescape(code) + end; })
+            // .replace(
+            //   encode || skip,
+            //   (_, code) => cse.startencode + unescape(code) + cse.end
+            // )
+            .replace(conditional || skip, function (_, elseCase, code) {
+            return elseCase
+                ? code
+                    ? "';}else if(" + unescape(code) + "){X+='"
+                    : "';}else{X+='"
+                : code
+                    ? "';if(" + unescape(code) + "){X+='"
+                    : "';}X+='";
+        })
+            .replace(iterate || skip, function (_, 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, function (_, code) { return "';" + unescape(code) + "X+='"; }) +
+        "';return X;")
+        .replace(/\n/g, "\\n")
+        .replace(/\t/g, "\\t")
+        .replace(/\r/g, "\\r")
+        .replace(/(\s|;|\}|^|\{)X\+='';/g, "$1")
+        .replace(/\+''/g, "");
+    //.replace(/(\s|;|\}|^|\{)X\+=''\+/g,'$1X+=');
+    try {
+        return new Function(varname, str);
+    }
+    catch (e) {
+        if (process.env["NODE_ENV"] !== "production") {
+            console.log("Could not create a template function: " + str);
+            throw e;
+        }
+    }
+    return function () { return ""; };
+};
+export default render;

package/split.d.ts

@@ -0,0 +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 function split<T extends string, D extends string>(str: T, delimiter: D): Split<T, D>;
+export default split;

package/split.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.split = void 0;
+function split(str, delimiter) {
+    return str.split(delimiter);
+}
+exports.split = split;
+exports.default = split;

package/split.mjs

@@ -0,0 +1,4 @@
+export function split(str, delimiter) {
+    return str.split(delimiter);
+}
+export default split;

package/types.d.ts

@@ -1,4 +1,28 @@
+import type { Replace } from "type-fest";
 /**
  * Whatever that in javascript returns `false` when checked in an `if` condition
  */
 export type AnythingFalsy = null | undefined | 0 | "";
+/**
+ * Pick the keys of an object `T` that starts with `S`. It produces a mapped type
+ * with a subset of `T` whose keys start with `S`.
+ */
+export type PickStartsWith<T extends object, S extends string> = {
+    [K in keyof T as K extends `${S}${string}` ? K : never]: T[K];
+};
+/**
+ * Returns a union of all the keys of an object `T` which starts with `S`.
+ */
+export type KeysStartsWith<T extends object, S extends string> = keyof PickStartsWith<T, S>;
+/**
+ * Pick the keys of an object `T` that starts with `S`. It produces a mapped type
+ * with a subset of `T` whose keys start with `S` *and have `S`* removed.
+ */
+export type PickStartsWithTails<T extends object, S extends string> = {
+    [K in keyof T as K extends `${S}${string}` ? Replace<K, S, ""> : never]: T[K];
+};
+/**
+ * Returns a union of all the keys of an object `T` which starts with `S`.
+ * The strings in the produced union *have `S` removed*.
+ */
+export type KeysTailsStartsWith<T extends object, S extends string> = keyof PickStartsWithTails<T, S>;