@buenojs/bueno 0.8.4 → 0.8.6

package/dist/template/index.js

@@ -0,0 +1,640 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+// src/templates/loader.ts
+import { readFileSync, watch } from "fs";
+import { existsSync } from "fs";
+import { extname, resolve } from "path";
+function parseFrontMatter(content) {
+  const lines = content.split(`
+`);
+  if (lines[0]?.trim() !== "---") {
+    return { metadata: {}, body: content };
+  }
+  let endIdx = -1;
+  for (let i = 1;i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      endIdx = i;
+      break;
+    }
+  }
+  if (endIdx === -1) {
+    return { metadata: {}, body: content };
+  }
+  const frontMatterLines = lines.slice(1, endIdx);
+  const metadata = {};
+  for (const line of frontMatterLines) {
+    if (!line.trim())
+      continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1)
+      continue;
+    const key = line.substring(0, colonIdx).trim();
+    let value = line.substring(colonIdx + 1).trim();
+    if (value === "true")
+      value = true;
+    else if (value === "false")
+      value = false;
+    else if (value === "null")
+      value = null;
+    else if (!isNaN(Number(value)) && value !== "")
+      value = Number(value);
+    else if (value.startsWith("[") && value.endsWith("]")) {
+      const arrayContent = value.slice(1, -1).trim();
+      value = arrayContent.split(",").map((v) => {
+        let item = v.trim();
+        if (item.startsWith('"') && item.endsWith('"') || item.startsWith("'") && item.endsWith("'")) {
+          item = item.slice(1, -1);
+        }
+        return item;
+      });
+    }
+    metadata[key] = value;
+  }
+  const body = lines.slice(endIdx + 1).join(`
+`);
+  return { metadata, body };
+}
+function parseVariants(content) {
+  const sections = content.split(/^## /m);
+  const variants = {};
+  for (const section of sections) {
+    if (!section.trim())
+      continue;
+    const lines = section.split(`
+`);
+    const headerLine = lines[0];
+    if (!headerLine)
+      continue;
+    const variantNames = headerLine.split(/[,/]\s*/).map((s) => s.trim().toLowerCase()).filter((s) => s);
+    const contentLines = lines.slice(1);
+    let contentStart = 0;
+    while (contentStart < contentLines.length && !contentLines[contentStart]?.trim()) {
+      contentStart++;
+    }
+    const sectionContent = contentLines.slice(contentStart).join(`
+`).trim();
+    const separatorIdx = sectionContent.indexOf(`
+---`);
+    const finalContent = separatorIdx !== -1 ? sectionContent.substring(0, separatorIdx) : sectionContent;
+    for (const variantName of variantNames) {
+      variants[variantName] = finalContent;
+    }
+  }
+  return variants;
+}
+function detectFormat(filePath, metadata) {
+  if (metadata.format) {
+    const fmt = String(metadata.format).toLowerCase();
+    if (["markdown", "text", "html"].includes(fmt)) {
+      return fmt;
+    }
+  }
+  const ext = extname(filePath).toLowerCase();
+  if (ext === ".md" || ext === ".markdown")
+    return "markdown";
+  if (ext === ".txt" || ext === ".text")
+    return "text";
+  if (ext === ".html" || ext === ".htm")
+    return "html";
+  return "markdown";
+}
+
+class TemplateLoader {
+  options;
+  cache = new Map;
+  watchers = new Map;
+  metrics = {
+    loads: 0,
+    cacheHits: 0,
+    cacheMisses: 0
+  };
+  constructor(options) {
+    this.options = options;
+    this.options.cacheEnabled = options.cacheEnabled ?? true;
+    this.options.cacheTtl = options.cacheTtl ?? 3600;
+    this.options.maxCacheSize = options.maxCacheSize ?? 100;
+    this.options.extension = options.extension ?? ".md";
+  }
+  load(templateId) {
+    const now = Date.now();
+    if (this.options.cacheEnabled) {
+      const cached = this.cache.get(templateId);
+      if (cached) {
+        const age = (now - cached.timestamp) / 1000;
+        if (age < (this.options.cacheTtl ?? 3600)) {
+          this.metrics.cacheHits++;
+          return cached.template;
+        }
+      }
+    }
+    this.metrics.cacheMisses++;
+    const template = this._loadFromDisk(templateId);
+    if (this.options.cacheEnabled) {
+      if (this.cache.size >= (this.options.maxCacheSize ?? 100) && !this.cache.has(templateId)) {
+        const oldest = Array.from(this.cache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp)[0];
+        if (oldest) {
+          this.cache.delete(oldest[0]);
+        }
+      }
+      this.cache.set(templateId, { template, timestamp: now });
+      if (this.options.watch) {
+        this._watchTemplate(templateId, template.id);
+      }
+    }
+    this.metrics.loads++;
+    return template;
+  }
+  _loadFromDisk(templateId) {
+    let filePath = resolve(this.options.basePath, templateId + this.options.extension);
+    if (!existsSync(filePath)) {
+      filePath = resolve(this.options.basePath, templateId + ".md");
+    }
+    if (!existsSync(filePath)) {
+      filePath = resolve(this.options.basePath, templateId + ".txt");
+    }
+    if (!existsSync(filePath)) {
+      throw new Error(`Template not found: ${templateId}`);
+    }
+    const content = readFileSync(filePath, "utf-8");
+    const { metadata, body } = parseFrontMatter(content);
+    const variants = parseVariants(body);
+    if (Object.keys(variants).length === 0) {
+      const defaultVariant = metadata.default || "default";
+      variants[defaultVariant] = body;
+    }
+    const format = detectFormat(filePath, metadata);
+    return {
+      id: templateId,
+      format,
+      content: body,
+      variants,
+      metadata,
+      loadedAt: Date.now()
+    };
+  }
+  _watchTemplate(templateId, filePath) {
+    if (this.watchers.has(templateId)) {
+      return;
+    }
+    try {
+      const fullPath = resolve(this.options.basePath, filePath);
+      const watcher = watch(fullPath, () => {
+        this.cache.delete(templateId);
+        this.watchers.delete(templateId);
+      });
+      this.watchers.set(templateId, watcher);
+    } catch {}
+  }
+  clear() {
+    this.cache.clear();
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+}
+
+// src/templates/renderers/markdown.ts
+class MarkdownRenderer {
+  static toHtml(markdown) {
+    let html = markdown;
+    html = html.replace(/`([^`]+)`/g, "<code>$1</code>");
+    html = html.replace(/\*\*([^\*]+)\*\*/g, "<strong>$1</strong>");
+    html = html.replace(/__([^_]+)__/g, "<strong>$1</strong>");
+    html = html.replace(/(?<!\*)\*([^\*]+)\*(?!\*)/g, "<em>$1</em>");
+    html = html.replace(/(?<!_)_([^_]+)_(?!_)/g, "<em>$1</em>");
+    html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+    html = html.replace(/ {2}\n/g, `<br>
+`);
+    html = html.replace(/^> (.+)$/gm, "<blockquote>$1</blockquote>");
+    html = html.replace(/^### ([^\n]+)$/gm, "<h3>$1</h3>");
+    html = html.replace(/^## ([^\n]+)$/gm, "<h2>$1</h2>");
+    html = html.replace(/^# ([^\n]+)$/gm, "<h1>$1</h1>");
+    html = this._processOrderedLists(html);
+    html = this._processUnorderedLists(html);
+    html = this._processParagraphs(html);
+    html = html.replace(/^---$/gm, "<hr>");
+    return html.trim();
+  }
+  static toText(markdown) {
+    let text = markdown;
+    text = text.replace(/`([^`]+)`/g, "$1");
+    text = text.replace(/\*\*([^\*]+)\*\*/g, "$1");
+    text = text.replace(/__([^_]+)__/g, "$1");
+    text = text.replace(/\*([^\*]+)\*/g, "$1");
+    text = text.replace(/_([^_]+)_/g, "$1");
+    text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1: $2");
+    text = text.replace(/^> (.+)$/gm, "$1");
+    text = text.replace(/^#+\s+(.+)$/gm, "$1");
+    text = text.replace(/^\d+\.\s+/gm, "");
+    text = text.replace(/^[-*+]\s+/gm, "");
+    text = text.replace(/\n\n\n+/g, `
+
+`);
+    return text.trim();
+  }
+  static _processOrderedLists(html) {
+    const lines = html.split(`
+`);
+    let inList = false;
+    let listHtml = "";
+    const result = [];
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      const match = line.match(/^(\d+)\.\s+(.+)$/);
+      if (match) {
+        if (!inList) {
+          inList = true;
+          listHtml = `<ol>
+<li>${match[2]}</li>`;
+        } else {
+          listHtml += `
+<li>${match[2]}</li>`;
+        }
+      } else {
+        if (inList) {
+          result.push(listHtml + `
+</ol>`);
+          inList = false;
+          listHtml = "";
+        }
+        result.push(line);
+      }
+    }
+    if (inList) {
+      result.push(listHtml + `
+</ol>`);
+    }
+    return result.join(`
+`);
+  }
+  static _processUnorderedLists(html) {
+    const lines = html.split(`
+`);
+    let inList = false;
+    let listHtml = "";
+    const result = [];
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      const match = line.match(/^[-*+]\s+(.+)$/);
+      if (match) {
+        if (!inList) {
+          inList = true;
+          listHtml = `<ul>
+<li>${match[1]}</li>`;
+        } else {
+          listHtml += `
+<li>${match[1]}</li>`;
+        }
+      } else {
+        if (inList) {
+          result.push(listHtml + `
+</ul>`);
+          inList = false;
+          listHtml = "";
+        }
+        result.push(line);
+      }
+    }
+    if (inList) {
+      result.push(listHtml + `
+</ul>`);
+    }
+    return result.join(`
+`);
+  }
+  static _processParagraphs(html) {
+    const blocks = html.split(/\n\n+/);
+    const result = [];
+    for (const block of blocks) {
+      if (!block.trim())
+        continue;
+      if (block.match(/^<[a-z]/) || block.match(/^<\/[a-z]/)) {
+        result.push(block);
+      } else if (block.match(/^<(h[1-6]|ul|ol|blockquote|hr|code)/)) {
+        result.push(block);
+      } else {
+        result.push(`<p>${block}</p>`);
+      }
+    }
+    return result.join(`
+`);
+  }
+}
+
+// src/templates/renderers/simple.ts
+var builtinFilters = {
+  uppercase: (value) => String(value).toUpperCase(),
+  lowercase: (value) => String(value).toLowerCase(),
+  capitalize: (value) => {
+    const str = String(value);
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+  },
+  trim: (value) => String(value).trim(),
+  reverse: (value) => String(value).split("").reverse().join(""),
+  length: (value) => {
+    if (Array.isArray(value))
+      return value.length;
+    if (typeof value === "string")
+      return value.length;
+    return 0;
+  },
+  join: (value, separator = ",") => {
+    if (Array.isArray(value))
+      return value.join(String(separator));
+    return String(value);
+  },
+  slice: (value, start = 0, end = undefined) => {
+    const str = String(value);
+    return str.slice(Number(start), end ? Number(end) : undefined);
+  },
+  default: (value, defaultVal) => {
+    if (value === null || value === undefined || value === "") {
+      return defaultVal;
+    }
+    return value;
+  },
+  isEmpty: (value) => {
+    if (Array.isArray(value))
+      return value.length === 0;
+    if (value === null || value === undefined || value === "")
+      return true;
+    return false;
+  },
+  date: (value, format = "YYYY-MM-DD") => {
+    if (!(value instanceof Date)) {
+      value = new Date(value);
+    }
+    if (isNaN(value.getTime()))
+      return String(value);
+    const year = value.getFullYear();
+    const month = String(value.getMonth() + 1).padStart(2, "0");
+    const date = String(value.getDate()).padStart(2, "0");
+    const hours = String(value.getHours()).padStart(2, "0");
+    const minutes = String(value.getMinutes()).padStart(2, "0");
+    const seconds = String(value.getSeconds()).padStart(2, "0");
+    return format.replace("YYYY", String(year)).replace("MM", month).replace("DD", date).replace("HH", hours).replace("mm", minutes).replace("ss", seconds);
+  }
+};
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === undefined) {
+      return;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function evaluateCondition(condition, data) {
+  condition = condition.trim();
+  if (condition.includes("||")) {
+    return condition.split("||").map((c) => evaluateCondition(c.trim(), data)).some((result) => result);
+  }
+  if (condition.includes("&&")) {
+    return condition.split("&&").map((c) => evaluateCondition(c.trim(), data)).every((result) => result);
+  }
+  if (condition.startsWith("!")) {
+    return !evaluateCondition(condition.slice(1).trim(), data);
+  }
+  const value = getNestedValue(data, condition);
+  return Boolean(value);
+}
+
+class SimpleRenderer {
+  filters;
+  constructor(customFilters) {
+    this.filters = { ...builtinFilters, ...customFilters || {} };
+  }
+  render(template, data) {
+    let result = template;
+    result = this._processConditionals(result, data);
+    result = this._processVariables(result, data);
+    return result;
+  }
+  _processConditionals(template, data) {
+    let result = template;
+    const ifRegex = /\{\{\s*if\s+([^}]+)\s*\}\}([\s\S]*?)\{\{\s*endif\s*\}\}/;
+    while (ifRegex.test(result)) {
+      result = result.replace(ifRegex, (match, condition, content) => {
+        const elseRegex = /\{\{\s*else\s*\}\}([\s\S]*)$/;
+        let thenBlock = content;
+        let elseBlock = "";
+        const elseMatch = content.match(elseRegex);
+        if (elseMatch) {
+          thenBlock = content.substring(0, elseMatch.index);
+          elseBlock = elseMatch[1];
+        }
+        if (evaluateCondition(condition, data)) {
+          return thenBlock;
+        } else {
+          return elseBlock;
+        }
+      });
+    }
+    return result;
+  }
+  _processVariables(template, data) {
+    const varRegex = /\{\{\s*([^|}\s][^}]*?)\s*(?:\|([^}]*?))?\s*\}\}/g;
+    return template.replace(varRegex, (match, varPath, filterChain) => {
+      let value = getNestedValue(data, varPath.trim());
+      if (value === undefined || value === null) {
+        return "";
+      }
+      if (filterChain) {
+        const filters = filterChain.split("|").map((f) => f.trim());
+        for (const filterStr of filters) {
+          const filterMatch = filterStr.match(/^(\w+)(?:\(([^)]*)\))?$/);
+          if (!filterMatch)
+            continue;
+          const filterName = filterMatch[1];
+          const argsStr = filterMatch[2];
+          const filterFn = this.filters[filterName];
+          if (!filterFn) {
+            console.warn(`Unknown filter: ${filterName}`);
+            continue;
+          }
+          const args = [];
+          if (argsStr) {
+            let current = "";
+            let inQuotes = false;
+            let quoteChar = "";
+            for (const char of argsStr) {
+              if ((char === '"' || char === "'") && !inQuotes) {
+                inQuotes = true;
+                quoteChar = char;
+              } else if (char === quoteChar && inQuotes) {
+                inQuotes = false;
+                quoteChar = "";
+              } else if (char === "," && !inQuotes) {
+                const trimmed = current.trim();
+                const unquoted = trimmed.replace(/^["']|["']$/g, "");
+                args.push(unquoted);
+                current = "";
+              } else {
+                current += char;
+              }
+            }
+            if (current) {
+              const trimmed = current.trim();
+              const unquoted = trimmed.replace(/^["']|["']$/g, "");
+              args.push(unquoted);
+            }
+          }
+          value = filterFn(value, ...args);
+        }
+      }
+      return String(value);
+    });
+  }
+  registerFilter(name, fn) {
+    this.filters[name] = fn;
+  }
+}
+
+// src/templates/engine.ts
+var DEFAULT_CHANNEL_VARIANT_MAP = {
+  email: "email",
+  sms: "sms",
+  push: "push",
+  whatsapp: "whatsapp",
+  web: "web"
+};
+
+class TemplateEngine {
+  config;
+  loader;
+  simpleRenderer;
+  metrics = {
+    loaded: 0,
+    cacheHits: 0,
+    cacheMisses: 0,
+    avgRenderTime: 0,
+    totalRenders: 0
+  };
+  renderTimes = [];
+  channelVariantMap;
+  constructor(config) {
+    this.config = config;
+    this.loader = new TemplateLoader({
+      basePath: config.basePath,
+      cacheEnabled: config.cache?.enabled ?? true,
+      cacheTtl: config.cache?.ttl ?? 3600,
+      maxCacheSize: config.cache?.maxSize ?? 100,
+      watch: config.watch ?? false
+    });
+    this.simpleRenderer = new SimpleRenderer;
+    this.channelVariantMap = config.channelVariantMap || DEFAULT_CHANNEL_VARIANT_MAP;
+  }
+  async render(templateId, data, options) {
+    const startTime = Date.now();
+    try {
+      const template = this.loader.load(templateId);
+      const variant = this._getVariant(template, options?.variant);
+      let content = template.variants[variant];
+      if (!content) {
+        content = Object.values(template.variants)[0] || "";
+      }
+      const interpolated = this.simpleRenderer.render(content, data);
+      const outputFormat = options?.outputFormat || "html";
+      let result;
+      if (template.format === "markdown") {
+        if (outputFormat === "text") {
+          result = MarkdownRenderer.toText(interpolated);
+        } else {
+          result = MarkdownRenderer.toHtml(interpolated);
+        }
+      } else {
+        result = interpolated;
+      }
+      const duration = Date.now() - startTime;
+      this._updateMetrics(duration);
+      return result;
+    } catch (error) {
+      throw new Error(`Failed to render template "${templateId}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async renderToHtml(templateId, data, variant) {
+    return this.render(templateId, data, {
+      variant,
+      outputFormat: "html"
+    });
+  }
+  async renderToText(templateId, data, variant) {
+    return this.render(templateId, data, {
+      variant,
+      outputFormat: "text"
+    });
+  }
+  _getVariant(template, explicitVariant) {
+    if (explicitVariant && template.variants[explicitVariant]) {
+      return explicitVariant;
+    }
+    if (template.metadata.default) {
+      const defaultVariant = String(template.metadata.default);
+      if (template.variants[defaultVariant]) {
+        return defaultVariant;
+      }
+    }
+    return Object.keys(template.variants)[0] || "default";
+  }
+  getVariantForChannel(channel) {
+    return this.channelVariantMap[channel.toLowerCase()] || channel;
+  }
+  registerFilter(name, fn) {
+    this.simpleRenderer.registerFilter(name, fn);
+  }
+  _updateMetrics(duration) {
+    this.metrics.totalRenders++;
+    this.renderTimes.push(duration);
+    if (this.renderTimes.length > 100) {
+      this.renderTimes.shift();
+    }
+    this.metrics.avgRenderTime = this.renderTimes.reduce((a, b) => a + b, 0) / this.renderTimes.length;
+    const loaderMetrics = this.loader.getMetrics();
+    this.metrics.loaded = loaderMetrics.loads;
+    this.metrics.cacheHits = loaderMetrics.cacheHits;
+    this.metrics.cacheMisses = loaderMetrics.cacheMisses;
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  clear() {
+    this.loader.clear();
+  }
+}
+export {
+  TemplateLoader,
+  TemplateEngine,
+  SimpleRenderer,
+  MarkdownRenderer
+};