btrz-liquid-templates 1.0.0

package/src/escp.js

@@ -0,0 +1,133 @@
+
+// const escInitQzTray = "\x1B\x69\x61\x00\x1B\x40"; // set printer to ESC/P mode and clear memory buffer ; Inicializa la impresora
+// const lineSpacing = "\x1B\x33\x18"; // Espaciado de línea (1/6 de pulgada)
+// const lineSpacing2 = "\x1B\x33\x24"; // ESC 3 n (1/9 de pulgada)
+// const fontSelection = "\x1B\x4D"; // Fuente pequeña (Condensed)
+// const escBold = "\x1B\x45"; // Activa negrita
+// const escCancelBold = "\x1B\x46"; // Cancela negrita
+// const escNewLine = "\n"; // Nueva línea
+// const escCut = "\x1D\x56\x00"; // Corte de papel
+// const escEject = "\x0C"; // Form Feed (FF) - Expulsa la hoja
+// const escCondensed = "\x1B\x0F"; // Modo comprimido (17 cpi)
+
+function escInitQzTray(engine) {
+  this.registerTag("escInitQzTray", {
+    parse: function(tagToken, remainTokens) {
+    },
+    render: async function(ctx) {
+      return "\\x1B\\x69\\x61\\x00\\x1B\\x40";
+    }
+  });
+}
+
+function lineSpacing(engine) {
+  this.registerTag("lineSpacing", {
+    parse: function(tagToken, remainTokens) {
+
+    },
+    render: async function(ctx) {
+      return "\\x1B\\x33\\x18";
+    }
+  });
+}
+
+function lineSpacing2(engine) {
+  this.registerTag("lineSpacing2", {
+    parse: function(tagToken, remainTokens) {
+
+    },
+    render: async function(ctx) {
+      return "\\x1B\\x33\\x24";
+    }
+  });
+}
+
+function fontSelection(engine) {
+  this.registerTag("fontSelection", {
+    parse: function(tagToken, remainTokens) {
+
+    },
+    render: async function(ctx) {
+      return "\\x1B\\x4D";
+    }
+  });
+}
+
+function escBold(engine) {
+  this.registerTag("escBold", {
+    parse: function(tagToken, remainTokens) {
+
+    },
+    render: async function(ctx) {
+      return "\\x1B\\x45";
+    }
+  });
+}
+
+function escCancelBold(engine) {
+  this.registerTag("escCancelBold", {
+    parse: function(tagToken, remainTokens) {
+
+    },
+    render: async function(ctx) {
+      return "\\x1B\\x46";
+    }
+  });
+}
+
+function escNewLine(engine) {
+  this.registerTag("escNewLine", {
+    parse: function(tagToken, remainTokens) {
+
+    },
+    render: async function(ctx) {
+      return "\\n";
+    }
+  });
+}
+
+function escCut(engine) {
+  this.registerTag("escCut", {
+    parse: function(tagToken, remainTokens) {
+
+    },
+    render: async function(ctx) {
+      return "\\x1D\\x56\\x00";
+    }
+  });
+}
+
+function escEject(engine) {
+  this.registerTag("escEject", {
+    parse: function(tagToken, remainTokens) {
+
+    },
+    render: async function(ctx) {
+      return "\\x0C";
+    }
+  });
+}
+
+function escCondensed(engine) {
+  this.registerTag("escCondensed", {
+    parse: function(tagToken, remainTokens) {
+
+    },
+    render: async function(ctx) {
+      return "\\x1B\\x0F";
+    }
+  });
+}
+
+module.exports = {
+  escInitQzTray,
+  lineSpacing,
+  lineSpacing2,
+  fontSelection,
+  escBold,
+  escCancelBold,
+  escNewLine,
+  escCut,
+  escEject,
+  escCondensed
+}

package/src/html.js

@@ -0,0 +1,97 @@
+function getBoldToken(token) {
+  const txt = token.replace(/<\/b>/ig, '<b>').replace(/<b>/ig, '').replace(/"/ig, '``');
+  return `{"bold": true, "text": "${txt}"}`;
+}
+
+function getItalicToken(token) {
+  const txt = token.replace(/<\/i>/ig, '<i>').replace(/<i>/ig, '').replace(/"/ig, '``');
+  return `{"italics": true, "text": "${txt}"}`;
+}
+
+function getHeaderToken(token, size) {
+  const txt = token.replace(/<\/h1>/ig, '<h>')
+    .replace(/<\/h2>/ig, '<h>')
+    .replace(/<\/h3>/ig, '<h>')
+    .replace(/<h1>/ig, '<h>')
+    .replace(/<h2>/ig, '<h>')
+    .replace(/<h3>/ig, '<h>')
+    .replace(/<h>/ig, '')
+    .replace(/"/ig, '``');
+  if (size === '1') {
+    return `{"style": "header", "text": "${txt}"}`;
+  }
+  if (size === '2') {
+    return `{"style": "subheader", "text": "${txt}"}`;
+  }
+  if (size === '3') {
+    return `{"style": "innerheader", "text": "${txt}"}`;
+  }
+  return `{"text": "${txt}"}`;
+}
+
+function getTokenInfo(token) {
+  if (token.indexOf('<b>') !== -1) { return getBoldToken(token); }
+  if (token.indexOf('<i>') !== -1) { return getItalicToken(token); }
+  if (token.indexOf('<h1>') !== -1) { return getHeaderToken(token, '1'); }
+  if (token.indexOf('<h2>') !== -1) { return getHeaderToken(token, '2'); }
+  if (token.indexOf('<h3>') !== -1) { return getHeaderToken(token, '3'); }
+  return `{"text": "${token.trim().replace(/"/ig, '``')}"}`;
+}
+
+function parseLine(line) {
+  if (!line) { return [getTokenInfo(line || "")]; }
+  const htmls = line.match(/<.>.*?<\/.>/ig);
+  const parsed = [];
+  let parts = [];
+
+  if (htmls) {
+    htmls.forEach((token) => {
+      parts = line.split(token);
+      parsed.push(getTokenInfo(parts[0] || ""));
+      parsed.push(getTokenInfo(token || ""));
+      if (parts.length > 1) {
+        line = parts[1];
+      }
+    });
+  }
+  if (line) {
+    parsed.push(getTokenInfo(line || ""));
+  }
+  return parsed;
+}
+
+function getLines(str) {
+  if (str && str.replace) {
+    const lines = str.replace(/\r\n/g, '<br/>')
+      .replace(/\n/g, '<br/>')
+      .replace(/\r/g, '<br/>')
+      .replace(/<br>/ig, '<br/>')
+      .split('<br/>');
+    return lines.map((line) => {
+      return parseLine(line);
+    }).join(",");
+  }
+  return `{"text": ""}`;
+}
+
+function Html(engine) {
+  this.registerTag("h", {
+    parse: function(tagToken, remainTokens) {
+      this.str = tagToken.args;
+    },
+    render: async function(ctx) {
+      let str = await this.liquid.evalValue(this.str, ctx);
+      
+      if (ctx && ctx.environments && ctx.environments.localizer && ctx.environments.localizer.get) {
+        return getLines(ctx.environments.localizer.get(str).replace(/[\t]/g, '\\t'));
+      }
+      return getLines(str);
+    }
+});
+}
+
+module.exports = {
+  Html
+};
+
+

package/src/httpimg.js

@@ -0,0 +1,34 @@
+const axios = require("axios");
+
+function getPrefix(url) {
+  const extention = url.split(".").pop();
+  if (extention.toLowerCase() === "png") {
+    return "data:image/png;base64,";
+  }
+  return "data:image/jpeg;base64,";
+}
+
+function HttpImg(engine) {
+  this.registerTag("httpImg", {
+    parse: function(tagToken, remainTokens) {
+      this.str = tagToken.args
+    },
+    render: async function(ctx) {
+      const url = await this.liquid.evalValue(this.str, ctx);
+      try {
+        const response = await axios.get(url, {
+          responseType: "arraybuffer"
+        });
+        return `${getPrefix(url)}${Buffer.from(response.data, "binary").toString("base64")}`;
+      } catch (e) {
+        console.log(e);
+        return "";
+      }
+    }
+});
+}
+
+module.exports = {
+  HttpImg
+};
+

package/src/index.js

@@ -0,0 +1,121 @@
+const {Liquid} = require("liquidjs");
+const {Localizer} = require("./localizer.js");
+const {HorizontalLine} = require("./lines.js");
+const {Barcode} = require("./barcode.js");
+const {Html} = require("./html.js");
+const {Money, CurcySymbol, CurcyIso, CurcyName, MoneyReduce} = require("./money.js");
+const {DateF, TimeF, DateTime, HumanDate, HumanDateTime, ExpDate, HumanArrivalDateTime, HumanDepartureDateTime,
+  DepartureDateTime, ArrivalDateTime, DepartureDate, ArrivalDate, DepartureTime, ArrivalTime, HumanArrivalDate,
+  HumanDepartureDate
+} = require("./dateFormat.js");
+const {Text} = require("./text.js");
+const {QrString} = require("./qrstr.js");
+const {ToLetters} = require("./toletters.js");
+const {HttpImg} = require("./httpimg.js");
+const {Keys} = require("./object.js");
+const {
+  escInitQzTray,
+  lineSpacing,
+  lineSpacing2,
+  fontSelection,
+  escBold,
+  escCancelBold,
+  escCondensed,
+  escNewLine,
+  escCut,
+  escEject
+} = require("./escp.js");
+
+function getEngine() {
+  const engine = new Liquid({
+    layouts: ["/nowhere/"],
+    root: ["/nowhere/"],
+    partials: ["/nowhere/"],
+    extname: ".liquid",
+    dynamicPartials: false,
+    outputEscape: (val) => {
+      // if (typeof val === "string") {
+      //   return val.replace(/[\\]/g, '\\\\')
+      //   .replace(/[\"]/g, '\\"')
+      //   .replace(/[\/]/g, '\\/')
+      //   .replace(/[\b]/g, '\\b')
+      //   .replace(/[\f]/g, '\\f')
+      //   .replace(/[\n]/g, '\\n')
+      //   .replace(/[\r]/g, '\\r')
+      //   .replace(/[\t]/g, '\\t');
+      // }
+      return val;
+    }
+  });
+  engine.plugin(Localizer);
+  engine.plugin(Html);
+  engine.plugin(HorizontalLine);
+  engine.plugin(Barcode);
+  engine.plugin(Money);
+  engine.plugin(CurcySymbol);
+  engine.plugin(CurcyIso);
+  engine.plugin(CurcyName);
+  engine.plugin(MoneyReduce);
+  engine.plugin(DateF);
+  engine.plugin(TimeF);
+  engine.plugin(DateTime);
+  engine.plugin(HumanDate);
+  engine.plugin(HumanDateTime);
+  engine.plugin(HumanArrivalDateTime);
+  engine.plugin(HumanDepartureDateTime);
+  engine.plugin(DepartureDateTime);
+  engine.plugin(ArrivalDateTime);
+  engine.plugin(DepartureDate);
+  engine.plugin(ArrivalDate);
+  engine.plugin(DepartureTime);
+  engine.plugin(ArrivalTime);
+  engine.plugin(HumanArrivalDate);
+  engine.plugin(HumanDepartureDate);
+  engine.plugin(Text);
+  engine.plugin(ExpDate);
+  engine.plugin(QrString);
+  engine.plugin(ToLetters);
+  engine.plugin(HttpImg);
+  engine.plugin(Keys);
+  return engine;
+}
+
+module.exports = {
+  async processToObj(liquidTemplate, data) {
+    try {
+      const str = await this.processToString(liquidTemplate, data);
+      const obj = JSON.parse(str);
+      return obj;
+    } catch (err) {
+      err.data = liquidTemplate;
+      throw err;
+    }
+  },
+  async processToEscp(liquidTemplate, data) {
+    const engine = getEngine();
+    engine.plugin(escInitQzTray);
+    engine.plugin(lineSpacing);
+    engine.plugin(lineSpacing2);
+    engine.plugin(fontSelection);
+    engine.plugin(escBold);
+    engine.plugin(escCancelBold);
+    engine.plugin(escCondensed);
+    engine.plugin(escNewLine);
+    engine.plugin(escCut);
+    engine.plugin(escEject);
+    let str = await engine.parseAndRender(liquidTemplate, data);
+    str = str.split(/\n/).map((line) => {
+      return line.trim();
+    }).filter((line) => {
+      return line.length > 0;
+    })
+    .join(",");
+    // console.log(str);
+    return str;
+  },
+  async processToString(liquidTemplate, data) {
+    const engine = getEngine();
+    const str = await engine.parseAndRender(liquidTemplate, data);
+    return str;
+  }
+};

package/src/lines.js

@@ -0,0 +1,40 @@
+function hexToRgb(hex) {
+  var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ?  `${parseInt(result[1], 16)},${parseInt(result[2], 16)},${parseInt(result[3], 16)}` : null;
+}
+
+function HorizontalLine(engine) {
+  this.registerTag("hline", {
+    parse: function(tagToken, remainTokens) {
+      //width = 500, weight = 1, rgb = "0,0,0"
+      try {
+        const args = (tagToken.args || "").split(" ");
+        this.width = args[0] || 500;
+        this.weight = args[1] || 1;
+        this.rgb = args[2] || "0,0,0";
+      } catch (err) {
+        this.width = 500;
+        this.weight = 1;
+        this.rgb = "0,0,0";
+      }
+    },
+    render: async function(ctx) {
+      let rgb = this.rgb;
+      if (this.rgb.indexOf(".") > -1) {
+        rgb = await this.liquid.evalValue(this.rgb, ctx);
+      }
+      if (rgb.indexOf("#") === 0) {
+        rgb = hexToRgb(rgb);
+      }
+      return `{
+        "svg": "<svg height='2' width='100'><line x1='0' y1='0' x2='1000' y2='0' style='stroke:rgb(${rgb});stroke-width:${this.weight}' /></svg>",
+        "width": ${this.width}
+      }`;
+    }
+});
+}
+
+module.exports = {
+  HorizontalLine
+};
+

package/src/localizer.js

@@ -0,0 +1,25 @@
+function Localizer(engine) {
+  this.registerTag("t", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split("|");
+      this.str = (args[0] || "").trim();
+      if (args.length > 1) {
+        this.tags = args.slice(1);
+      }
+    },
+    render: async function(ctx) {
+      let str = await this.liquid.evalValue(this.str, ctx);
+      if (ctx && ctx.environments && ctx.environments.localizer && ctx.environments.localizer.get && str !== "") {
+        str = ctx.environments.localizer.get(str);
+      }
+      if (this.tags) {
+        return await this.liquid.evalValue(`"${str.replace(/"/g, '``')}"|${this.tags}`, ctx);
+      }
+      return str.replace(/[\"]/g, '``');
+    }
+});
+}
+
+module.exports = {
+  Localizer
+};

package/src/money.js

@@ -0,0 +1,195 @@
+const formatter = require("btrz-formatter");
+function getCurrencyValue(item, propName, providerPreferences, userOptions) {
+  const defaultOptions = {
+    prefix: "displayCurrency"
+  };
+  const options = Object.assign({}, defaultOptions, userOptions);
+  const prefix = options.prefix;
+
+  if (!propName || !prefix || typeof propName !== "string" || typeof prefix !== "string") {
+    throw new Error("getCurrencyValue: propName and prefix must be strings");
+  }
+
+  if (providerPreferences.preferences.multiCurrency) {
+    const prefixedPropName = propName.replace(/^./, "".concat(prefix).concat(propName[0].toUpperCase()));
+    return item[prefixedPropName] || item[propName];
+  }
+
+  return item[propName];
+}
+
+function getCurrency(item, providerPreferences) {
+  const baseCurrency = providerPreferences.preferences.supportedCurrencies[0];
+  if (providerPreferences.preferences.multiCurrency) {
+    return item && item.displayCurrency && item.displayCurrency.isocode ? item.displayCurrency : baseCurrency;
+  }
+  return baseCurrency;
+}
+
+function getCurrencySymbol(isocode) {
+  const currencies = [
+    {
+      isocode: "USD",
+      symbol: "$",
+      printSymbol: true
+    },
+    {
+      isocode: "AUD",
+      symbol: "$",
+      printSymbol: true
+    },
+    {
+      isocode: "CAD",
+      symbol: "$",
+      printSymbol: true
+    },
+    {
+      isocode: "EUR",
+      symbol: "€",
+      printSymbol: true
+    },
+    {
+      isocode: "GBP",
+      symbol: "£",
+      printSymbol: true
+    },
+    {
+      isocode: "NZD",
+      symbol: "$",
+      printSymbol: true
+    },
+    {
+      isocode: "MXN",
+      symbol: "$",
+      printSymbol: true
+    },
+    {
+      isocode: "HNL",
+      symbol: "L",
+      printSymbol: true
+    },
+    {
+      isocode: "NIO",
+      symbol: "C$",
+      printSymbol: true
+    },
+    {
+      isocode: "CRC",
+      symbol: "₡",
+      printSymbol: false
+    },
+    {
+      isocode: "GTQ",
+      symbol: "Q",
+      printSymbol: true
+    },
+    {
+      isocode: "PAB",
+      symbol: "B/.",
+      printSymbol: true
+    }
+  ]
+  const trimIsocode = isocode ? isocode.trim() : "";
+  const curcy = currencies.find((cur) => {
+    return cur.isocode === trimIsocode;
+  });
+  return curcy && curcy.printSymbol ? curcy.symbol : " ";
+}
+
+function MoneyReduce(engine) {
+  this.registerTag("moneyReduce", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket.taxes";
+      this.innerPropName = args[1] || "calculated";
+    },
+    render: async function(ctx) {
+      const coll = await this.liquid.evalValue(this.item, ctx);
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        Array.isArray(coll)) {
+        const sum = coll.reduce((acc, item) => {
+          return acc + getCurrencyValue(item, this.innerPropName, ctx.environments.providerPreferences, {prefix: "display"});
+        }, 0);
+        return formatter.money(sum);
+      }
+      return "PNA";
+    }
+  });
+}
+
+function Money(engine) {
+  this.registerTag("money", {
+    parse: function(tagToken, remainTokens) {
+      const args = tagToken.args.split(" ");
+      this.item = args[0] || "ticket.total";
+      this.propName = args[1] || "total";
+    },
+    render: async function(ctx) {
+      const item = await this.liquid.evalValue(this.item, ctx);
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences &&
+        item && item[this.propName] !== undefined) {
+        return formatter.money(getCurrencyValue(item, this.propName, ctx.environments.providerPreferences, {prefix: "display"}));
+      }
+      return "PNA";
+    }
+  });
+}
+
+function CurcySymbol(engine) {
+  this.registerTag("curcySymbol", {
+    parse: function(tagToken, remainTokens) {
+      this.item = tagToken.args || "ticket";
+    },
+    render: async function(ctx) {
+      const item = await this.liquid.evalValue(this.item, ctx);
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences && item) {
+        const itemCurrency = getCurrency(item, ctx.environments.providerPreferences);
+        return getCurrencySymbol((itemCurrency || {}).isocode || " ");
+      }
+      return "";
+    }
+  });
+}
+
+function CurcyIso(engine) {
+  this.registerTag("curcyIso", {
+    parse: function(tagToken, remainTokens) {
+      this.item = tagToken.args || "ticket";
+    },
+    render: async function(ctx) {
+      const item = await this.liquid.evalValue(this.item, ctx);
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences && item) {
+        const itemCurrency = getCurrency(item, ctx.environments.providerPreferences);
+        return (itemCurrency || {}).isocode || " ";
+      }
+      return "";
+    }
+  });
+}
+
+function CurcyName(engine) {
+  this.registerTag("curcyName", {
+    parse: function(tagToken, remainTokens) {
+      this.item = tagToken.args || "ticket";
+    },
+    render: async function(ctx) {
+      const item = await this.liquid.evalValue(this.item, ctx);
+      if (ctx && ctx.environments && ctx.environments.providerPreferences && ctx.environments.providerPreferences.preferences && item) {
+        if (item.isocode !== undefined && item.symbol !== undefined) { 
+          return ctx.environments.localizer.get((item || {}).isocode || " ");
+        }
+        const itemCurrency = getCurrency(item, ctx.environments.providerPreferences);
+        return ctx.environments.localizer.get((itemCurrency || {}).isocode || " ");
+      }
+      return "";
+    }
+  });
+}
+
+module.exports = {
+  CurcyIso,
+  CurcySymbol,
+  CurcyName,
+  Money,
+  MoneyReduce
+};

package/src/object.js

@@ -0,0 +1,11 @@
+function Keys(engine) {
+  this.registerFilter("keys", (value) => {
+    return Object.keys(value);
+  })
+}
+
+module.exports = {
+  Keys
+};
+
+

package/src/qrstr.js

@@ -0,0 +1,36 @@
+function QrString(engine) {
+  this.registerTag("qrstr", {
+    parse: function(tagToken, remainTokens) {
+      this.str = (tagToken.args || "ticket").toLowerCase();
+    },
+    render: async function(ctx) {
+      if (this.str === "reservation" || this.str === "ticket") {
+        return `https://${ctx.environments.providerPreferences.domain}/r/t/${ctx.environments[this.str].urlTicketCode}`;
+      }
+      if (this.str === "solditem") {
+        return `PI-${ctx.environments.soldItem._id.toString()}`;
+      }
+      if (this.str === "parcel") {
+        return `${ctx.environments.parcel.accountId}-PA-${ctx.environments.parcel._id.toString()}`;
+      }
+      if (this.str === "flexpass") {
+        return `${ctx.environments.flexPass.ticketNumber}`;
+      }
+      if (this.str === "ssr") {
+        return `${ctx.environments.ssr.ssrsInstanceId}`;
+      }
+      if (this.str === "redeemableitem") {
+        return `RI-${ctx.environments.redeemableItem._id.toString()}`;
+      }
+      if (this.str === "voucher") {
+        return `${ctx.environments.voucher.internalId}`;
+      }
+      return ""
+    }
+});
+}
+
+module.exports = {
+  QrString
+};
+