@vandenberghinc/volt 1.2.6 → 1.2.8

package/backend/dist/cjs/backend/src/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+import * as vlib from "@vandenberghinc/vlib";
+export declare namespace Utils {
+    function fill_templates(data: string, templates: Record<string, any>, curly_style?: boolean): string;
+    /** Get the mime type by file extension. */
+    function mime_type(extension: string): string | null;
+    /** Check if a file extension is compressed. */
+    function is_compressed_extension(extension: string): boolean;
+    /** Check if a content type is compressed. */
+    function is_compressed_content_type(content_type: string): boolean;
+    function get_currency_symbol(currency: string): string | null;
+    function get_compiled_cache(domain: string, method: string, endpoint: string): {
+        cache_path: vlib.Path;
+        cache_hash: any;
+        cache_data: any;
+    };
+    function set_compiled_cache(path: vlib.Path, data: string, hash: string): void;
+}
+export { Utils as utils };

package/backend/dist/cjs/backend/src/utils.js

@@ -0,0 +1,626 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  Utils: () => Utils,
+  utils: () => Utils
+});
+module.exports = __toCommonJS(stdin_exports);
+var vlib = __toESM(require("@vandenberghinc/vlib"));
+var Utils;
+(function(Utils2) {
+  function fill_templates(data, templates, curly_style = true) {
+    if (templates == null) {
+      return data;
+    }
+    const keys = Object.keys(templates);
+    if (keys.length > 0) {
+      for (let i = 0; i < data.length; i++) {
+        if (curly_style && data.charAt(i) === "{" && data.charAt(i + 1) === "{") {
+          for (let k = 0; k < keys.length; k++) {
+            if (data.charAt(i + keys[k].length + 2) === "}" && data.charAt(i + keys[k].length + 3) === "}" && data.startsWith(keys[k], i + 2)) {
+              const end_index = i + keys[k].length + 4;
+              if (templates[keys[k]] != null && typeof templates[keys[k]] === "object") {
+                data = vlib.String.replace_indices(data, JSON.stringify(templates[keys[k]]), i, end_index);
+              } else {
+                data = vlib.String.replace_indices(data, templates[keys[k]], i, end_index);
+              }
+              i = end_index - 1;
+            }
+          }
+        } else if (!curly_style && data.charAt(i) === "$") {
+          for (let k = 0; k < keys.length; k++) {
+            if (data.startsWith(keys[k], i + 1)) {
+              const end_index = i + keys[k].length + 1;
+              if (templates[keys[k]] != null && typeof templates[keys[k]] === "object") {
+                data = vlib.String.replace_indices(data, JSON.stringify(templates[keys[k]]), i, end_index);
+              } else {
+                data = vlib.String.replace_indices(data, templates[keys[k]], i, end_index);
+              }
+              i = end_index - 1;
+            }
+          }
+        }
+      }
+    }
+    return data;
+  }
+  Utils2.fill_templates = fill_templates;
+  const content_type_mimes = /* @__PURE__ */ new Map([
+    [".html", "text/html"],
+    [".htm", "text/html"],
+    [".shtml", "text/html"],
+    [".css", "text/css"],
+    [".xml", "application/xml"],
+    [".gif", "image/gif"],
+    [".jpeg", "image/jpeg"],
+    [".jpg", "image/jpeg"],
+    [".js", "application/javascript"],
+    [".ts", "application/typescript"],
+    [".atom", "application/atom+xml"],
+    [".rss", "application/rss+xml"],
+    [".mml", "text/mathml"],
+    [".txt", "text/plain"],
+    [".jad", "text/vnd.sun.j2me.app-descriptor"],
+    [".wml", "text/vnd.wap.wml"],
+    [".htc", "text/x-component"],
+    [".png", "image/png"],
+    [".tif", "image/tiff"],
+    [".tiff", "image/tiff"],
+    [".wbmp", "image/vnd.wap.wbmp"],
+    [".ico", "image/x-icon"],
+    [".jng", "image/x-jng"],
+    [".bmp", "image/x-ms-bmp"],
+    [".svg", "image/svg+xml"],
+    [".svgz", "image/svg+xml"],
+    [".webp", "image/webp"],
+    [".woff", "font/woff"],
+    [".woff2", "font/woff2"],
+    [".jar", "application/java-archive"],
+    [".war", "application/java-archive"],
+    [".ear", "application/java-archive"],
+    [".json", "application/json"],
+    [".hqx", "application/mac-binhex40"],
+    [".doc", "application/msword"],
+    [".pdf", "application/pdf"],
+    [".ps", "application/postscript"],
+    [".eps", "application/postscript"],
+    [".ai", "application/postscript"],
+    [".rtf", "application/rtf"],
+    [".m3u8", "application/vnd.apple.mpegurl"],
+    [".xls", "application/vnd.ms-excel"],
+    [".eot", "application/vnd.ms-fontobject"],
+    [".ppt", "application/vnd.ms-powerpoint"],
+    [".wmlc", "application/vnd.wap.wmlc"],
+    [".kml", "application/vnd.google-earth.kml+xml"],
+    [".kmz", "application/vnd.google-earth.kmz"],
+    [".7z", "application/x-7z-compressed"],
+    [".cco", "application/x-cocoa"],
+    [".jardiff", "application/x-java-archive-diff"],
+    [".jnlp", "application/x-java-jnlp-file"],
+    [".run", "application/x-makeself"],
+    [".pl", "application/x-perl"],
+    [".pm", "application/x-perl"],
+    [".prc", "application/x-pilot"],
+    [".pdb", "application/x-pilot"],
+    [".rar", "application/x-rar-compressed"],
+    [".rpm", "application/x-redhat-package-manager"],
+    [".sea", "application/x-sea"],
+    [".swf", "application/x-shockwave-flash"],
+    [".sit", "application/x-stuffit"],
+    [".tcl", "application/x-tcl"],
+    [".tk", "application/x-tcl"],
+    [".der", "application/x-x509-ca-cert"],
+    [".pem", "application/x-x509-ca-cert"],
+    [".crt", "application/x-x509-ca-cert"],
+    [".xpi", "application/x-xpinstall"],
+    [".xhtml", "application/xhtml+xml"],
+    [".xspf", "application/xspf+xml"],
+    [".zip", "application/zip"],
+    [".bin", "application/octet-stream"],
+    [".exe", "application/octet-stream"],
+    [".dll", "application/octet-stream"],
+    [".deb", "application/octet-stream"],
+    [".dmg", "application/octet-stream"],
+    [".iso", "application/octet-stream"],
+    [".img", "application/octet-stream"],
+    [".msi", "application/octet-stream"],
+    [".msp", "application/octet-stream"],
+    [".msm", "application/octet-stream"],
+    [".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"],
+    [".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"],
+    [".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"],
+    [".mid", "audio/midi"],
+    [".midi", "audio/midi"],
+    [".kar", "audio/midi"],
+    [".mp3", "audio/mpeg"],
+    [".ogg", "audio/ogg"],
+    [".m4a", "audio/x-m4a"],
+    [".ra", "audio/x-realaudio"],
+    [".3gpp", "video/3gpp"],
+    [".3gp", "video/3gpp"],
+    // [".ts", "video/mp2t"],
+    [".mp4", "video/mp4"],
+    [".mpeg", "video/mpeg"],
+    [".mpg", "video/mpeg"],
+    [".mov", "video/quicktime"],
+    [".webm", "video/webm"],
+    [".flv", "video/x-flv"],
+    [".m4v", "video/x-m4v"],
+    [".mng", "video/x-mng"],
+    [".asx", "video/x-ms-asf"],
+    [".asf", "video/x-ms-asf"],
+    [".wmv", "video/x-ms-wmv"],
+    [".avi", "video/x-msvideo"]
+  ]);
+  function mime_type(extension) {
+    const ext = extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`;
+    if (content_type_mimes.has(ext)) {
+      return content_type_mimes.get(ext);
+    }
+    return null;
+  }
+  Utils2.mime_type = mime_type;
+  const compressed_extensions = /* @__PURE__ */ new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".bmp",
+    ".tiff",
+    ".ico",
+    // ".svg",
+    ".svgz",
+    ".mng",
+    ".apng",
+    ".jfif",
+    ".jp2",
+    ".jpx",
+    ".j2k",
+    ".jpm",
+    ".jpf",
+    ".heif",
+    ".mp3",
+    ".ogg",
+    ".wav",
+    ".flac",
+    ".m4a",
+    ".aac",
+    ".wma",
+    ".ra",
+    ".mid",
+    ".mp4",
+    ".webm",
+    ".mkv",
+    ".mov",
+    ".avi",
+    ".wmv",
+    ".mpg",
+    ".mpeg",
+    ".flv"
+  ]);
+  function is_compressed_extension(extension) {
+    const ext = extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`;
+    return compressed_extensions.has(ext);
+  }
+  Utils2.is_compressed_extension = is_compressed_extension;
+  const compressed_content_types = /* @__PURE__ */ new Set([
+    // Image formats (often already compressed)
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+    "image/bmp",
+    "image/tiff",
+    "image/vnd.microsoft.icon",
+    // ICO
+    // Audio formats (usually compressed)
+    "audio/mpeg",
+    // MP3
+    "audio/mp3",
+    "audio/ogg",
+    "audio/wav",
+    "audio/x-wav",
+    "audio/flac",
+    "audio/aac",
+    "audio/midi",
+    // Video formats (typically compressed)
+    "video/mp4",
+    "video/mpeg",
+    "video/ogg",
+    "video/webm",
+    "video/x-msvideo",
+    // AVI
+    "video/quicktime",
+    // MOV
+    // Archive / Compressed file formats
+    "application/zip",
+    "application/x-7z-compressed",
+    "application/x-rar-compressed",
+    "application/x-tar",
+    "application/gzip",
+    "application/x-gzip",
+    "application/x-bzip",
+    "application/x-bzip2",
+    "application/x-xz",
+    // Documents that are usually compressed internally
+    "application/pdf",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    // Font files
+    "font/woff",
+    "font/woff2",
+    "application/font-sfnt",
+    "application/vnd.ms-fontobject",
+    // Other binary data
+    "application/octet-stream"
+  ]);
+  function is_compressed_content_type(content_type) {
+    return compressed_content_types.has(content_type.toLowerCase().split(";")[0]);
+  }
+  Utils2.is_compressed_content_type = is_compressed_content_type;
+  function get_currency_symbol(currency) {
+    switch (currency.toLowerCase()) {
+      case "aed":
+        return "\u062F.\u0625";
+      case "afn":
+        return "Af";
+      case "all":
+        return "L";
+      case "amd":
+        return "\u058F";
+      case "ang":
+        return "\u0192";
+      case "aoa":
+        return "Kz";
+      case "ars":
+        return "$";
+      case "aud":
+        return "$";
+      case "awg":
+        return "\u0192";
+      case "azn":
+        return "\u20BC";
+      case "bam":
+        return "KM";
+      case "bbd":
+        return "Bds$";
+      case "bdt":
+        return "\u09F3";
+      case "bgn":
+        return "\u043B\u0432";
+      case "bhd":
+        return ".\u062F.\u0628";
+      case "bif":
+        return "FBu";
+      case "bmd":
+        return "BD$";
+      case "bnd":
+        return "B$";
+      case "bob":
+        return "Bs";
+      case "brl":
+        return "R$";
+      case "bsd":
+        return "B$";
+      case "btn":
+        return "Nu.";
+      case "bwp":
+        return "P";
+      case "byn":
+        return "Br";
+      case "bzd":
+        return "BZ$";
+      case "cad":
+        return "$";
+      case "cdf":
+        return "FC";
+      case "chf":
+        return "Fr";
+      case "clf":
+        return "UF";
+      case "clp":
+        return "$";
+      case "cny":
+        return "\xA5";
+      case "cop":
+        return "$";
+      case "crc":
+        return "\u20A1";
+      case "cuc":
+        return "CUC$";
+      case "cup":
+        return "CUP$";
+      case "cve":
+        return "$";
+      case "czk":
+        return "K\u010D";
+      case "djf":
+        return "Fdj";
+      case "dkk":
+        return "kr";
+      case "dop":
+        return "RD$";
+      case "dzd":
+        return "\u062F\u062C";
+      case "egp":
+        return "E\xA3";
+      case "ern":
+        return "Nfk";
+      case "etb":
+        return "Br";
+      case "eur":
+        return "\u20AC";
+      case "fjd":
+        return "FJ$";
+      case "fkp":
+        return "\xA3";
+      case "fok":
+        return "F$";
+      case "gbp":
+        return "\xA3";
+      case "gel":
+        return "\u20BE";
+      case "ghc":
+        return "\u20B5";
+      case "gip":
+        return "\xA3";
+      case "gmd":
+        return "D";
+      case "gnf":
+        return "FG";
+      case "gtq":
+        return "Q";
+      case "gyd":
+        return "GY$";
+      case "hkd":
+        return "HK$";
+      case "hnl":
+        return "L";
+      case "hrk":
+        return "kn";
+      case "htg":
+        return "G";
+      case "huf":
+        return "Ft";
+      case "idr":
+        return "Rp";
+      case "ils":
+        return "\u20AA";
+      case "inr":
+        return "\u20B9";
+      case "iqd":
+        return "\u062F.\u0639";
+      case "irr":
+        return "\uFDFC";
+      case "isk":
+        return "kr";
+      case "jmd":
+        return "J$";
+      case "jod":
+        return "JD";
+      case "jpy":
+        return "\xA5";
+      case "kes":
+        return "Ksh";
+      case "kgs":
+        return "\u0441";
+      case "khr":
+        return "\u17DB";
+      case "kmf":
+        return "CF";
+      case "kpw":
+        return "\u20A9";
+      case "krw":
+        return "\u20A9";
+      case "kwd":
+        return "KD";
+      case "kyd":
+        return "CI$";
+      case "kzt":
+        return "\u20B8";
+      case "lak":
+        return "\u20AD";
+      case "lbp":
+        return "L\xA3";
+      case "lkr":
+        return "Rs";
+      case "lrd":
+        return "L$";
+      case "lsl":
+        return "L";
+      case "lyd":
+        return "\u0644.\u062F";
+      case "mad":
+        return "\u062F.\u0645.";
+      case "mdl":
+        return "L";
+      case "mnt":
+        return "\u20AE";
+      case "mop":
+        return "MOP$";
+      case "mur":
+        return "Rs";
+      case "mvr":
+        return "Rf";
+      case "mwk":
+        return "MK";
+      case "mxn":
+        return "$";
+      case "myr":
+        return "RM";
+      case "mzn":
+        return "MTn";
+      case "nad":
+        return "N$";
+      case "ngn":
+        return "\u20A6";
+      case "nio":
+        return "C$";
+      case "nok":
+        return "kr";
+      case "npr":
+        return "\u0930\u0942";
+      case "nzd":
+        return "$";
+      case "omr":
+        return "\u0631.\u0639.";
+      case "pab":
+        return "B/.";
+      case "pen":
+        return "S/.";
+      case "pgk":
+        return "K";
+      case "php":
+        return "\u20B1";
+      case "pkr":
+        return "Rs";
+      case "pln":
+        return "z\u0142";
+      case "pyg":
+        return "\u20B2";
+      case "qar":
+        return "\u0631.\u0642";
+      case "ron":
+        return "lei";
+      case "rsd":
+        return "din.";
+      case "rub":
+        return "\u20BD";
+      case "rwf":
+        return "FRw";
+      case "sar":
+        return "\u0631.\u0633";
+      case "sbd":
+        return "SI$";
+      case "scr":
+        return "Sr";
+      case "sdg":
+        return "\u062C.\u0633.";
+      case "sek":
+        return "kr";
+      case "sgd":
+        return "S$";
+      case "shp":
+        return "\xA3";
+      case "sll":
+        return "Le";
+      case "sos":
+        return "S";
+      case "srd":
+        return "SRD$";
+      case "ssp":
+        return "\xA3";
+      case "std":
+        return "Db";
+      case "sek":
+        return "kr";
+      case "syp":
+        return "S\xA3";
+      case "szl":
+        return "L";
+      case "thb":
+        return "\u0E3F";
+      case "tjs":
+        return "\u0405\u041C";
+      case "tmt":
+        return "m";
+      case "tnd":
+        return "\u062F.\u062A";
+      case "top":
+        return "T$";
+      case "try":
+        return "\u20BA";
+      case "ttd":
+        return "TT$";
+      case "twd":
+        return "NT$";
+      case "tzs":
+        return "TSh";
+      case "uah":
+        return "\u20B4";
+      case "ugx":
+        return "USh";
+      case "usd":
+        return "$";
+      case "uyu":
+        return "$U";
+      case "uzs":
+        return "\u043B\u0432";
+      case "ves":
+        return "Bs.S.";
+      case "vnd":
+        return "\u20AB";
+      case "vuv":
+        return "VT";
+      case "wst":
+        return "WS$";
+      case "xaf":
+        return "FCFA";
+      case "xcd":
+        return "EC$";
+      case "xof":
+        return "CFA";
+      case "xpf":
+        return "CFP";
+      case "yer":
+        return "\uFDFC";
+      case "zar":
+        return "R";
+      case "zmw":
+        return "ZK";
+    }
+    return null;
+  }
+  Utils2.get_currency_symbol = get_currency_symbol;
+  function get_compiled_cache(domain, method, endpoint) {
+    const cache_path = new vlib.Path(`/tmp/${domain.replaceAll("/", "")}:${method}:${endpoint.replaceAll("/", "_")}`);
+    let cache_data, cache_hash;
+    if (cache_path.exists()) {
+      cache_data = cache_path.load_sync();
+      cache_hash = new vlib.Path(cache_path.str() + ".hash").load_sync();
+    }
+    return { cache_path, cache_hash, cache_data };
+  }
+  Utils2.get_compiled_cache = get_compiled_cache;
+  function set_compiled_cache(path, data, hash) {
+    path.save_sync(data);
+    new vlib.Path(path.str() + ".hash").save_sync(hash);
+  }
+  Utils2.set_compiled_cache = set_compiled_cache;
+})(Utils || (Utils = {}));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Utils,
+  utils
+});