@frontmcp/uipack 0.6.1

package/handlebars/index.js

@@ -0,0 +1,666 @@
+"use strict";
+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);
+
+// libs/uipack/src/handlebars/index.ts
+var handlebars_exports = {};
+__export(handlebars_exports, {
+  HandlebarsRenderer: () => HandlebarsRenderer,
+  and: () => and,
+  builtinHelpers: () => builtinHelpers,
+  capitalize: () => capitalize,
+  classNames: () => classNames,
+  containsHandlebars: () => containsHandlebars,
+  createHandlebarsRenderer: () => createHandlebarsRenderer,
+  defaultValue: () => defaultValue,
+  eq: () => eq,
+  escapeHtml: () => escapeHtml,
+  extractAll: () => extractAll,
+  extractExpressions: () => extractExpressions,
+  extractInputPaths: () => extractInputPaths,
+  extractOutputPaths: () => extractOutputPaths,
+  extractStructuredContentPaths: () => extractStructuredContentPaths,
+  extractVariablePaths: () => extractVariablePaths,
+  first: () => first,
+  formatCurrency: () => formatCurrency,
+  formatDate: () => formatDate,
+  formatNumber: () => formatNumber,
+  getExpressionAt: () => getExpressionAt,
+  gt: () => gt,
+  gte: () => gte,
+  hasVariablePaths: () => hasVariablePaths,
+  includes: () => includes,
+  isHandlebarsAvailable: () => isHandlebarsAvailable,
+  join: () => join,
+  json: () => json,
+  jsonEmbed: () => jsonEmbed,
+  last: () => last,
+  length: () => length,
+  lowercase: () => lowercase,
+  lt: () => lt,
+  lte: () => lte,
+  ne: () => ne,
+  normalizePath: () => normalizePath,
+  not: () => not,
+  or: () => or,
+  renderTemplate: () => renderTemplate,
+  resetUniqueIdCounter: () => resetUniqueIdCounter,
+  truncate: () => truncate,
+  uniqueId: () => uniqueId,
+  uppercase: () => uppercase
+});
+module.exports = __toCommonJS(handlebars_exports);
+
+// libs/uipack/src/utils/escape-html.ts
+function escapeHtml(str) {
+  if (str === null || str === void 0) {
+    return "";
+  }
+  const s = String(str);
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+
+// libs/uipack/src/handlebars/helpers.ts
+function formatDate(date, format) {
+  if (date === null || date === void 0) {
+    return "";
+  }
+  let dateObj;
+  if (date instanceof Date) {
+    dateObj = date;
+  } else if (typeof date === "string" || typeof date === "number") {
+    dateObj = new Date(date);
+  } else {
+    return String(date);
+  }
+  if (isNaN(dateObj.getTime())) {
+    return String(date);
+  }
+  const options = {};
+  switch (format) {
+    case "short":
+      options.dateStyle = "short";
+      break;
+    case "medium":
+      options.dateStyle = "medium";
+      break;
+    case "long":
+      options.dateStyle = "long";
+      break;
+    case "full":
+      options.dateStyle = "full";
+      break;
+    case "time":
+      options.timeStyle = "short";
+      break;
+    case "datetime":
+      options.dateStyle = "medium";
+      options.timeStyle = "short";
+      break;
+    case "iso":
+      return dateObj.toISOString();
+    case "relative":
+      return formatRelativeDate(dateObj);
+    default:
+      options.dateStyle = "medium";
+  }
+  return new Intl.DateTimeFormat("en-US", options).format(dateObj);
+}
+function formatRelativeDate(date) {
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSecs = Math.floor(diffMs / 1e3);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffSecs < 60) {
+    return "just now";
+  } else if (diffMins < 60) {
+    return `${diffMins} minute${diffMins === 1 ? "" : "s"} ago`;
+  } else if (diffHours < 24) {
+    return `${diffHours} hour${diffHours === 1 ? "" : "s"} ago`;
+  } else if (diffDays < 7) {
+    return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
+  } else {
+    return formatDate(date, "medium");
+  }
+}
+function formatCurrency(amount, currency) {
+  if (amount === null || amount === void 0) {
+    return "";
+  }
+  const num = typeof amount === "number" ? amount : parseFloat(String(amount));
+  if (isNaN(num)) {
+    return String(amount);
+  }
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: typeof currency === "string" ? currency : "USD"
+  }).format(num);
+}
+function formatNumber(value, decimals) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const num = typeof value === "number" ? value : parseFloat(String(value));
+  if (isNaN(num)) {
+    return String(value);
+  }
+  const options = {};
+  if (typeof decimals === "number") {
+    options.minimumFractionDigits = decimals;
+    options.maximumFractionDigits = decimals;
+  }
+  return new Intl.NumberFormat("en-US", options).format(num);
+}
+function jsonEmbed(data) {
+  const json2 = JSON.stringify(data ?? null);
+  return json2.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function json(data, pretty) {
+  return JSON.stringify(data ?? null, null, pretty ? 2 : void 0);
+}
+function eq(a, b) {
+  return a === b;
+}
+function ne(a, b) {
+  return a !== b;
+}
+function gt(a, b) {
+  return Number(a) > Number(b);
+}
+function gte(a, b) {
+  return Number(a) >= Number(b);
+}
+function lt(a, b) {
+  return Number(a) < Number(b);
+}
+function lte(a, b) {
+  return Number(a) <= Number(b);
+}
+function and(a, b) {
+  return Boolean(a) && Boolean(b);
+}
+function or(a, b) {
+  return Boolean(a) || Boolean(b);
+}
+function not(value) {
+  return !value;
+}
+function first(arr) {
+  if (!Array.isArray(arr)) return void 0;
+  return arr[0];
+}
+function last(arr) {
+  if (!Array.isArray(arr)) return void 0;
+  return arr[arr.length - 1];
+}
+function length(value) {
+  if (Array.isArray(value)) return value.length;
+  if (typeof value === "string") return value.length;
+  return 0;
+}
+function includes(arr, value) {
+  if (!Array.isArray(arr)) return false;
+  return arr.includes(value);
+}
+function join(arr, separator) {
+  if (!Array.isArray(arr)) return "";
+  return arr.join(typeof separator === "string" ? separator : ", ");
+}
+function uppercase(str) {
+  return String(str ?? "").toUpperCase();
+}
+function lowercase(str) {
+  return String(str ?? "").toLowerCase();
+}
+function capitalize(str) {
+  const s = String(str ?? "");
+  return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+}
+function truncate(str, maxLength, suffix) {
+  const s = String(str ?? "");
+  const len = typeof maxLength === "number" ? maxLength : 50;
+  const suf = typeof suffix === "string" ? suffix : "...";
+  if (s.length <= len) return s;
+  return s.slice(0, len - suf.length) + suf;
+}
+function defaultValue(value, defaultValue2) {
+  return value || defaultValue2;
+}
+var idCounter = 0;
+function uniqueId(prefix) {
+  const id = ++idCounter;
+  return prefix ? `${prefix}-${id}` : `id-${id}`;
+}
+function resetUniqueIdCounter() {
+  idCounter = 0;
+}
+function classNames(...classes) {
+  return classes.filter(Boolean).map(String).join(" ");
+}
+var builtinHelpers = {
+  // Escaping
+  escapeHtml,
+  // Formatting
+  formatDate,
+  formatCurrency,
+  formatNumber,
+  json,
+  jsonEmbed,
+  // Comparison
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  // Logical
+  and,
+  or,
+  not,
+  // Array
+  first,
+  last,
+  length,
+  includes,
+  join,
+  // String
+  uppercase,
+  lowercase,
+  capitalize,
+  truncate,
+  // Utility
+  default: defaultValue,
+  uniqueId,
+  classNames
+};
+
+// libs/uipack/src/handlebars/expression-extractor.ts
+var EXPRESSION_REGEX = /\{\{\{?(?!!)(#|\/)?([^}]+?)\}?\}\}/g;
+var PATH_REGEX = /\b(output|input|structuredContent)(\.[a-zA-Z_$][a-zA-Z0-9_$]*|\.\[[^\]]+\])+/g;
+var KEYWORDS = /* @__PURE__ */ new Set(["this", "else", "@index", "@key", "@first", "@last", "@root"]);
+function extractExpressions(template) {
+  const expressions = [];
+  const lines = template.split("\n");
+  const positionMap = buildPositionMap(template);
+  let match;
+  EXPRESSION_REGEX.lastIndex = 0;
+  while ((match = EXPRESSION_REGEX.exec(template)) !== null) {
+    const fullExpression = match[0];
+    const prefix = match[1];
+    const content = match[2].trim();
+    const position = positionMap.get(match.index) ?? { line: 1, column: 1 };
+    let type = "variable";
+    let helperName;
+    if (prefix === "/") {
+      type = "block-close";
+      helperName = content;
+    } else if (prefix === "#") {
+      type = "block";
+      const parts = content.split(/\s+/);
+      helperName = parts[0];
+    } else {
+      const parts = content.split(/\s+/);
+      if (parts.length > 1 && !content.startsWith("(")) {
+        const firstToken = parts[0];
+        if (!firstToken.includes(".") && !KEYWORDS.has(firstToken)) {
+          type = "helper";
+          helperName = firstToken;
+        }
+      }
+    }
+    const paths = extractPathsFromContent(content);
+    for (const path of paths) {
+      expressions.push({
+        path,
+        fullExpression,
+        line: position.line,
+        column: position.column,
+        type,
+        helperName
+      });
+    }
+    if (paths.length === 0 && type === "variable") {
+      const cleanContent = content.trim();
+      if (!KEYWORDS.has(cleanContent) && !cleanContent.includes(" ") && !cleanContent.startsWith("(")) {
+      }
+    }
+  }
+  return expressions;
+}
+function extractPathsFromContent(content) {
+  const paths = [];
+  let match;
+  const regex = new RegExp(PATH_REGEX.source, "g");
+  while ((match = regex.exec(content)) !== null) {
+    paths.push(match[0]);
+  }
+  return paths;
+}
+function buildPositionMap(template) {
+  const map = /* @__PURE__ */ new Map();
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < template.length; i++) {
+    map.set(i, { line, column });
+    if (template[i] === "\n") {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return map;
+}
+function extractVariablePaths(template) {
+  const expressions = extractExpressions(template);
+  const paths = new Set(expressions.map((e) => e.path));
+  return Array.from(paths);
+}
+function extractOutputPaths(template) {
+  return extractVariablePaths(template).filter((p) => p.startsWith("output."));
+}
+function extractInputPaths(template) {
+  return extractVariablePaths(template).filter((p) => p.startsWith("input."));
+}
+function extractStructuredContentPaths(template) {
+  return extractVariablePaths(template).filter((p) => p.startsWith("structuredContent."));
+}
+function extractAll(template) {
+  const expressions = extractExpressions(template);
+  const paths = [...new Set(expressions.map((e) => e.path))];
+  return {
+    expressions,
+    paths,
+    outputPaths: paths.filter((p) => p.startsWith("output.")),
+    inputPaths: paths.filter((p) => p.startsWith("input.")),
+    structuredContentPaths: paths.filter((p) => p.startsWith("structuredContent."))
+  };
+}
+function hasVariablePaths(template) {
+  return extractVariablePaths(template).length > 0;
+}
+function getExpressionAt(template, line, column) {
+  const expressions = extractExpressions(template);
+  return expressions.find((expr) => {
+    if (expr.line !== line) return false;
+    const exprEnd = expr.column + expr.fullExpression.length;
+    return column >= expr.column && column <= exprEnd;
+  });
+}
+function normalizePath(path) {
+  return path.replace(/\.\d+\./g, ".[].").replace(/\.\d+$/g, ".[]").replace(/\[\d+\]/g, ".[]");
+}
+
+// libs/uipack/src/handlebars/index.ts
+var Handlebars = null;
+async function loadHandlebars() {
+  if (Handlebars !== null) {
+    return Handlebars;
+  }
+  try {
+    Handlebars = await import("handlebars");
+    return Handlebars;
+  } catch {
+    throw new Error("Handlebars is required for template rendering. Install it: npm install handlebars");
+  }
+}
+async function isHandlebarsAvailable() {
+  try {
+    await loadHandlebars();
+    return true;
+  } catch {
+    return false;
+  }
+}
+var HandlebarsRenderer = class {
+  options;
+  compiledTemplates = /* @__PURE__ */ new Map();
+  initialized = false;
+  hbs = null;
+  constructor(options = {}) {
+    this.options = {
+      strict: false,
+      autoEscape: true,
+      ...options
+    };
+  }
+  /**
+   * Initialize the renderer with Handlebars.
+   */
+  async init() {
+    if (this.initialized) return;
+    this.hbs = await loadHandlebars();
+    for (const [name, helper] of Object.entries(builtinHelpers)) {
+      this.hbs.registerHelper(name, helper);
+    }
+    if (this.options.helpers) {
+      for (const [name, helper] of Object.entries(this.options.helpers)) {
+        this.hbs.registerHelper(name, helper);
+      }
+    }
+    if (this.options.partials) {
+      for (const [name, template] of Object.entries(this.options.partials)) {
+        this.hbs.registerPartial(name, template);
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * Render a Handlebars template.
+   *
+   * @param template - Template string
+   * @param context - Render context with input/output
+   * @returns Rendered HTML string
+   */
+  async render(template, context) {
+    await this.init();
+    if (!this.hbs) {
+      throw new Error("Handlebars not initialized");
+    }
+    let compiled = this.compiledTemplates.get(template);
+    if (!compiled) {
+      compiled = this.hbs.compile(template, {
+        strict: this.options.strict,
+        noEscape: !this.options.autoEscape
+      });
+      this.compiledTemplates.set(template, compiled);
+    }
+    const data = {
+      input: context.input ?? {},
+      output: context.output ?? {},
+      structuredContent: context.structuredContent,
+      // Also expose at root level for convenience
+      ...context.input,
+      ...typeof context.output === "object" && context.output !== null ? context.output : {}
+    };
+    try {
+      return compiled(data);
+    } catch (error) {
+      throw new Error(`Template rendering failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Render a template synchronously.
+   *
+   * Note: Requires Handlebars to be pre-loaded. Use `render()` for async loading.
+   *
+   * @param template - Template string
+   * @param context - Render context
+   * @returns Rendered HTML string
+   */
+  renderSync(template, context) {
+    if (!this.initialized || !this.hbs) {
+      throw new Error("HandlebarsRenderer not initialized. Call render() first or use initSync().");
+    }
+    let compiled = this.compiledTemplates.get(template);
+    if (!compiled) {
+      compiled = this.hbs.compile(template, {
+        strict: this.options.strict,
+        noEscape: !this.options.autoEscape
+      });
+      this.compiledTemplates.set(template, compiled);
+    }
+    const data = {
+      input: context.input ?? {},
+      output: context.output ?? {},
+      structuredContent: context.structuredContent,
+      ...context.input,
+      ...typeof context.output === "object" && context.output !== null ? context.output : {}
+    };
+    return compiled(data);
+  }
+  /**
+   * Initialize synchronously (for environments where Handlebars is already loaded).
+   */
+  initSync(handlebars) {
+    this.hbs = handlebars;
+    for (const [name, helper] of Object.entries(builtinHelpers)) {
+      this.hbs.registerHelper(name, helper);
+    }
+    if (this.options.helpers) {
+      for (const [name, helper] of Object.entries(this.options.helpers)) {
+        this.hbs.registerHelper(name, helper);
+      }
+    }
+    if (this.options.partials) {
+      for (const [name, template] of Object.entries(this.options.partials)) {
+        this.hbs.registerPartial(name, template);
+      }
+    }
+    this.initialized = true;
+  }
+  /**
+   * Register a custom helper.
+   *
+   * @param name - Helper name
+   * @param fn - Helper function
+   */
+  registerHelper(name, fn) {
+    if (this.hbs) {
+      this.hbs.registerHelper(name, fn);
+    }
+    if (!this.options.helpers) {
+      this.options.helpers = {};
+    }
+    this.options.helpers[name] = fn;
+  }
+  /**
+   * Register a partial template.
+   *
+   * @param name - Partial name
+   * @param template - Partial template string
+   */
+  registerPartial(name, template) {
+    if (this.hbs) {
+      this.hbs.registerPartial(name, template);
+    }
+    if (!this.options.partials) {
+      this.options.partials = {};
+    }
+    this.options.partials[name] = template;
+  }
+  /**
+   * Clear compiled template cache.
+   */
+  clearCache() {
+    this.compiledTemplates.clear();
+  }
+  /**
+   * Check if a template string contains Handlebars syntax.
+   *
+   * @param template - Template string to check
+   * @returns true if contains {{...}} syntax
+   */
+  static containsHandlebars(template) {
+    return /\{\{(?!!)[\s\S]*?\}\}/.test(template);
+  }
+  /**
+   * Check if the renderer is initialized.
+   */
+  get isInitialized() {
+    return this.initialized;
+  }
+};
+function createHandlebarsRenderer(options) {
+  return new HandlebarsRenderer(options);
+}
+async function renderTemplate(template, context) {
+  const renderer = createHandlebarsRenderer();
+  return renderer.render(template, context);
+}
+function containsHandlebars(template) {
+  return HandlebarsRenderer.containsHandlebars(template);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HandlebarsRenderer,
+  and,
+  builtinHelpers,
+  capitalize,
+  classNames,
+  containsHandlebars,
+  createHandlebarsRenderer,
+  defaultValue,
+  eq,
+  escapeHtml,
+  extractAll,
+  extractExpressions,
+  extractInputPaths,
+  extractOutputPaths,
+  extractStructuredContentPaths,
+  extractVariablePaths,
+  first,
+  formatCurrency,
+  formatDate,
+  formatNumber,
+  getExpressionAt,
+  gt,
+  gte,
+  hasVariablePaths,
+  includes,
+  isHandlebarsAvailable,
+  join,
+  json,
+  jsonEmbed,
+  last,
+  length,
+  lowercase,
+  lt,
+  lte,
+  ne,
+  normalizePath,
+  not,
+  or,
+  renderTemplate,
+  resetUniqueIdCounter,
+  truncate,
+  uniqueId,
+  uppercase
+});