@pdfme/common 5.1.6-dev.2 → 5.1.7-dev.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdfme/common",
-  "version": "5.1.6-dev.2",
+  "version": "5.1.7-dev.2",
   "sideEffects": false,
   "author": "hand-dot",
   "license": "MIT",
@@ -44,6 +44,7 @@
   },
   "dependencies": {
     "@pdfme/pdf-lib": "^1.18.3",
+    "acorn": "^8.14.0",
     "buffer": "^6.0.3",
     "zod": "^3.20.2"
   },
@@ -71,5 +72,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/estree": "^1.0.6"
   }
 }

package/src/constants.ts

@@ -4,6 +4,14 @@ export const PT_TO_PX_RATIO = 1.333;
 export const PT_TO_MM_RATIO = 0.3528;
 export const MM_TO_PT_RATIO = 2.8346; // https://www.ddc.co.jp/words/archives/20090701114500.html
 export const ZOOM = 3.7795275591;
+
+// TODO replace in the future
+// export const BLANK_PDF: BlankPdf = {
+//   width: 210,
+//   height: 297,
+//   padding: [10, 10, 10, 10],
+// };
+
 export const BLANK_PDF =
   'data:application/pdf;base64,JVBERi0xLjcKJeLjz9MKNSAwIG9iago8PAovRmlsdGVyIC9GbGF0ZURlY29kZQovTGVuZ3RoIDM4Cj4+CnN0cmVhbQp4nCvkMlAwUDC1NNUzMVGwMDHUszRSKErlCtfiyuMK5AIAXQ8GCgplbmRzdHJlYW0KZW5kb2JqCjQgMCBvYmoKPDwKL1R5cGUgL1BhZ2UKL01lZGlhQm94IFswIDAgNTk1LjQ0IDg0MS45Ml0KL1Jlc291cmNlcyA8PAo+PgovQ29udGVudHMgNSAwIFIKL1BhcmVudCAyIDAgUgo+PgplbmRvYmoKMiAwIG9iago8PAovVHlwZSAvUGFnZXMKL0tpZHMgWzQgMCBSXQovQ291bnQgMQo+PgplbmRvYmoKMSAwIG9iago8PAovVHlwZSAvQ2F0YWxvZwovUGFnZXMgMiAwIFIKPj4KZW5kb2JqCjMgMCBvYmoKPDwKL3RyYXBwZWQgKGZhbHNlKQovQ3JlYXRvciAoU2VyaWYgQWZmaW5pdHkgRGVzaWduZXIgMS4xMC40KQovVGl0bGUgKFVudGl0bGVkLnBkZikKL0NyZWF0aW9uRGF0ZSAoRDoyMDIyMDEwNjE0MDg1OCswOScwMCcpCi9Qcm9kdWNlciAoaUxvdmVQREYpCi9Nb2REYXRlIChEOjIwMjIwMTA2MDUwOTA5WikKPj4KZW5kb2JqCjYgMCBvYmoKPDwKL1NpemUgNwovUm9vdCAxIDAgUgovSW5mbyAzIDAgUgovSUQgWzwyODhCM0VENTAyOEU0MDcyNERBNzNCOUE0Nzk4OUEwQT4gPEY1RkJGNjg4NkVERDZBQUNBNDRCNEZDRjBBRDUxRDlDPl0KL1R5cGUgL1hSZWYKL1cgWzEgMiAyXQovRmlsdGVyIC9GbGF0ZURlY29kZQovSW5kZXggWzAgN10KL0xlbmd0aCAzNgo+PgpzdHJlYW0KeJxjYGD4/5+RUZmBgZHhFZBgDAGxakAEP5BgEmFgAABlRwQJCmVuZHN0cmVhbQplbmRvYmoKc3RhcnR4cmVmCjUzMgolJUVPRgo=';
 export const DEFAULT_FONT_NAME = 'Roboto';

package/src/dynamicTemplate.ts

@@ -0,0 +1,277 @@
+import { Schema, Template, BasePdf, BlankPdf, CommonOptions } from './types';
+import { cloneDeep, isBlankPdf } from './helper';
+
+interface ModifyTemplateForDynamicTableArg {
+  template: Template;
+  input: Record<string, string>;
+  _cache: Map<any, any>;
+  options: CommonOptions;
+  getDynamicHeights: (
+    value: string,
+    args: { schema: Schema; basePdf: BasePdf; options: CommonOptions; _cache: Map<any, any> }
+  ) => Promise<number[]>;
+}
+
+class LayoutNode {
+  index = 0;
+
+  schema?: Schema;
+
+  children: LayoutNode[] = [];
+
+  width = 0;
+  height = 0;
+  padding: [number, number, number, number] = [0, 0, 0, 0];
+  position: { x: number; y: number } = { x: 0, y: 0 };
+
+  constructor({ width = 0, height = 0 } = {}) {
+    this.width = width;
+    this.height = height;
+  }
+
+  setIndex(index: number): void {
+    this.index = index;
+  }
+
+  setSchema(schema: Schema): void {
+    this.schema = schema;
+  }
+
+  setWidth(width: number): void {
+    this.width = width;
+  }
+
+  setHeight(height: number): void {
+    this.height = height;
+  }
+
+  setPadding(padding: [number, number, number, number]): void {
+    this.padding = padding;
+  }
+
+  setPosition(position: { x: number; y: number }): void {
+    this.position = position;
+  }
+
+  insertChild(child: LayoutNode): void {
+    const index = this.getChildCount();
+    child.setIndex(index);
+    this.children.splice(index, 0, child);
+  }
+
+  getChildCount(): number {
+    return this.children.length;
+  }
+
+  getChild(index: number): LayoutNode {
+    return this.children[index];
+  }
+}
+
+function createPage(basePdf: BlankPdf) {
+  const page = new LayoutNode({ ...basePdf });
+  page.setPadding(basePdf.padding);
+  return page;
+}
+
+function createNode(arg: {
+  schema: Schema;
+  position: { x: number; y: number };
+  width: number;
+  height: number;
+}) {
+  const { position, width, height, schema } = arg;
+  const node = new LayoutNode({ width, height });
+  node.setPosition(position);
+  node.setSchema(schema);
+  return node;
+}
+
+function resortChildren(page: LayoutNode, orderMap: Map<string, number>): void {
+  page.children = page.children
+    .sort((a, b) => {
+      const orderA = orderMap.get(a.schema?.name!);
+      const orderB = orderMap.get(b.schema?.name!);
+      if (orderA === undefined || orderB === undefined) {
+        throw new Error('[@pdfme/common] order is not defined');
+      }
+      return orderA - orderB;
+    })
+    .map((child, index) => {
+      child.setIndex(index);
+      return child;
+    });
+}
+
+async function createOnePage(
+  arg: {
+    basePdf: BlankPdf;
+    schemaPage: Schema[];
+    orderMap: Map<string, number>;
+  } & Omit<ModifyTemplateForDynamicTableArg, 'template'>
+): Promise<LayoutNode> {
+  const { basePdf, schemaPage, orderMap, input, options, _cache, getDynamicHeights } = arg;
+  const page = createPage(basePdf);
+
+  const schemaPositions: number[] = [];
+  const sortedSchemaEntries = cloneDeep(schemaPage).sort((a, b) => a.position.y - b.position.y);
+  const diffMap = new Map();
+  for (const schema of sortedSchemaEntries) {
+    const { position, width } = schema;
+
+    const opt = { schema, basePdf, options, _cache };
+    const value = (schema.readOnly ? schema.content : input?.[schema.name]) || '';
+    const heights = await getDynamicHeights(value, opt);
+
+    const heightsSum = heights.reduce((acc, cur) => acc + cur, 0);
+    const originalHeight = schema.height;
+    if (heightsSum !== originalHeight) {
+      diffMap.set(position.y + originalHeight, heightsSum - originalHeight);
+    }
+    heights.forEach((height, index) => {
+      let y = schema.position.y + heights.reduce((acc, cur, i) => (i < index ? acc + cur : acc), 0);
+      for (const [diffY, diff] of diffMap.entries()) {
+        if (diffY <= schema.position.y) {
+          y += diff;
+        }
+      }
+      const node = createNode({ schema, position: { ...position, y }, width, height });
+
+      schemaPositions.push(y + height + basePdf.padding[2]);
+      page.insertChild(node);
+    });
+  }
+
+  const pageHeight = Math.max(...schemaPositions, basePdf.height - basePdf.padding[2]);
+  page.setHeight(pageHeight);
+
+  resortChildren(page, orderMap);
+
+  return page;
+}
+
+function breakIntoPages(arg: {
+  longPage: LayoutNode;
+  orderMap: Map<string, number>;
+  basePdf: BlankPdf;
+}): LayoutNode[] {
+  const { longPage, orderMap, basePdf } = arg;
+  const pages: LayoutNode[] = [createPage(basePdf)];
+  const [paddingTop, , paddingBottom] = basePdf.padding;
+  const yAdjustments: { page: number; value: number }[] = [];
+
+  const getPageHeight = (pageIndex: number) =>
+    basePdf.height - paddingBottom - (pageIndex > 0 ? paddingTop : 0);
+
+  const calculateNewY = (y: number, pageIndex: number) => {
+    const newY = y - pageIndex * (basePdf.height - paddingTop - paddingBottom);
+
+    while (pages.length <= pageIndex) {
+      if (!pages[pageIndex]) {
+        pages.push(createPage(basePdf));
+        yAdjustments.push({ page: pageIndex, value: (newY - paddingTop) * -1 });
+      }
+    }
+    return newY + (yAdjustments.find((adj) => adj.page === pageIndex)?.value || 0);
+  };
+
+  const children = longPage.children.sort((a, b) => a.position.y - b.position.y);
+  for (let i = 0; i < children.length; i++) {
+    const { schema, position, height, width } = children[i];
+    const { y, x } = position;
+
+    let targetPageIndex = Math.floor(y / getPageHeight(pages.length - 1));
+    let newY = calculateNewY(y, targetPageIndex);
+
+    if (newY + height > basePdf.height - paddingBottom) {
+      targetPageIndex++;
+      newY = calculateNewY(y, targetPageIndex);
+    }
+
+    if (!schema) throw new Error('[@pdfme/common] schema is undefined');
+
+    const clonedElement = createNode({ schema, position: { x, y: newY }, width, height });
+    pages[targetPageIndex].insertChild(clonedElement);
+  }
+
+  pages.forEach((page) => resortChildren(page, orderMap));
+
+  return pages;
+}
+
+function createNewTemplate(pages: LayoutNode[], basePdf: BlankPdf): Template {
+  const newTemplate: Template = {
+    schemas: Array.from({ length: pages.length }, () => [] as Schema[]),
+    basePdf: basePdf,
+  };
+
+  const nameToSchemas = new Map<string, LayoutNode[]>();
+
+  cloneDeep(pages).forEach((page, pageIndex) => {
+    page.children.forEach((child) => {
+      const { schema } = child;
+      if (!schema) throw new Error('[@pdfme/common] schema is undefined');
+
+      const name = schema.name;
+      if (!nameToSchemas.has(name)) {
+        nameToSchemas.set(name, []);
+      }
+      nameToSchemas.get(name)!.push(child);
+
+      const sameNameSchemas = page.children.filter((c) => c.schema?.name === name);
+      const start = nameToSchemas.get(name)!.length - sameNameSchemas.length;
+
+      if (sameNameSchemas.length > 0) {
+        if (!sameNameSchemas[0].schema) {
+          throw new Error('[@pdfme/common] schema is undefined');
+        }
+
+        // Use the first schema to get the schema and position
+        const schema = sameNameSchemas[0].schema;
+        const height = sameNameSchemas.reduce((acc, cur) => acc + cur.height, 0);
+        const position = sameNameSchemas[0].position;
+
+        // Currently, __bodyRange exists for table schemas, but if we make it more abstract,
+        // it could be used for other schemas as well to render schemas that have been split by page breaks, starting from the middle.
+        schema.__bodyRange = {
+          start: Math.max(start - 1, 0),
+          end: start + sameNameSchemas.length - 1,
+        };
+
+        // Currently, this is used to determine whether to display the header when a table is split.
+        schema.__isSplit = start > 0;
+
+        const newSchema = Object.assign({}, schema, { position, height });
+        const index = newTemplate.schemas[pageIndex].findIndex((s) => s.name === name);
+        if (index !== -1) {
+          newTemplate.schemas[pageIndex][index] = newSchema;
+        } else {
+          newTemplate.schemas[pageIndex].push(newSchema);
+        }
+      }
+    });
+  });
+
+  return newTemplate;
+}
+
+export const getDynamicTemplate = async (
+  arg: ModifyTemplateForDynamicTableArg
+): Promise<Template> => {
+  const { template } = arg;
+  if (!isBlankPdf(template.basePdf)) {
+    return template;
+  }
+
+  const basePdf = template.basePdf as BlankPdf;
+  const pages: LayoutNode[] = [];
+
+  for (const schemaPage of template.schemas) {
+    const orderMap = new Map(schemaPage.map((schema, index) => [schema.name, index]));
+    const longPage = await createOnePage({ basePdf, schemaPage, orderMap, ...arg });
+    const brokenPages = breakIntoPages({ longPage, basePdf, orderMap });
+    pages.push(...brokenPages);
+  }
+
+  return createNewTemplate(pages, template.basePdf);
+};

package/src/expression.ts

@@ -0,0 +1,392 @@
+import * as acorn from 'acorn';
+import type { Node as AcornNode, Identifier, Property } from 'estree';
+import type { SchemaPageArray } from './types';
+
+const expressionCache = new Map<string, (context: Record<string, unknown>) => unknown>();
+const parseDataCache = new Map<string, Record<string, unknown>>();
+
+const parseData = (data: Record<string, unknown>): Record<string, unknown> => {
+  const key = JSON.stringify(data);
+  if (parseDataCache.has(key)) {
+    return parseDataCache.get(key)!;
+  }
+
+  const parsed = Object.fromEntries(
+    Object.entries(data).map(([key, value]) => {
+      if (typeof value === 'string') {
+        try {
+          const parsedValue = JSON.parse(value) as unknown;
+          return [key, parsedValue];
+        } catch {
+          return [key, value];
+        }
+      }
+      return [key, value];
+    })
+  );
+
+  parseDataCache.set(key, parsed);
+  return parsed;
+};
+
+const padZero = (num: number): string => String(num).padStart(2, '0');
+
+const formatDate = (date: Date): string =>
+  `${date.getFullYear()}/${padZero(date.getMonth() + 1)}/${padZero(date.getDate())}`;
+
+const formatDateTime = (date: Date): string =>
+  `${formatDate(date)} ${padZero(date.getHours())}:${padZero(date.getMinutes())}`;
+
+const allowedGlobals: Record<string, unknown> = {
+  Math,
+  String,
+  Number,
+  Boolean,
+  Array,
+  Object,
+  Date,
+  JSON,
+  isNaN,
+  parseFloat,
+  parseInt,
+  decodeURI,
+  decodeURIComponent,
+  encodeURI,
+  encodeURIComponent,
+};
+
+const validateAST = (node: AcornNode): void => {
+  switch (node.type) {
+    case 'Literal':
+    case 'Identifier':
+      break;
+    case 'BinaryExpression':
+    case 'LogicalExpression': {
+      const binaryNode = node;
+      validateAST(binaryNode.left);
+      validateAST(binaryNode.right);
+      break;
+    }
+    case 'UnaryExpression': {
+      const unaryNode = node;
+      validateAST(unaryNode.argument);
+      break;
+    }
+    case 'ConditionalExpression': {
+      const condNode = node;
+      validateAST(condNode.test);
+      validateAST(condNode.consequent);
+      validateAST(condNode.alternate);
+      break;
+    }
+    case 'MemberExpression': {
+      const memberNode = node;
+      validateAST(memberNode.object);
+      if (memberNode.computed) {
+        validateAST(memberNode.property);
+      } else {
+        const propName = (memberNode.property as Identifier).name;
+        if (['constructor', '__proto__', 'prototype'].includes(propName)) {
+          throw new Error('Access to prohibited property');
+        }
+        const prohibitedMethods = ['toLocaleString', 'valueOf'];
+        if (typeof propName === 'string' && prohibitedMethods.includes(propName)) {
+          throw new Error(`Access to prohibited method: ${propName}`);
+        }
+      }
+      break;
+    }
+    case 'CallExpression': {
+      const callNode = node;
+      validateAST(callNode.callee);
+      callNode.arguments.forEach(validateAST);
+      break;
+    }
+    case 'ArrayExpression': {
+      const arrayNode = node;
+      arrayNode.elements.forEach((elem) => {
+        if (elem) validateAST(elem);
+      });
+      break;
+    }
+    case 'ObjectExpression': {
+      const objectNode = node;
+      objectNode.properties.forEach((prop) => {
+        const propNode = prop as Property;
+        validateAST(propNode.key);
+        validateAST(propNode.value);
+      });
+      break;
+    }
+    case 'ArrowFunctionExpression': {
+      const arrowFuncNode = node;
+      arrowFuncNode.params.forEach((param) => {
+        if (param.type !== 'Identifier') {
+          throw new Error('Only identifier parameters are supported in arrow functions');
+        }
+        validateAST(param);
+      });
+      validateAST(arrowFuncNode.body);
+      break;
+    }
+    default:
+      throw new Error(`Unsupported syntax in placeholder: ${node.type}`);
+  }
+};
+
+const evaluateAST = (node: AcornNode, context: Record<string, unknown>): unknown => {
+  switch (node.type) {
+    case 'Literal': {
+      const literalNode = node;
+      return literalNode.value;
+    }
+    case 'Identifier': {
+      const idNode = node;
+      if (Object.prototype.hasOwnProperty.call(context, idNode.name)) {
+        return context[idNode.name];
+      } else if (Object.prototype.hasOwnProperty.call(allowedGlobals, idNode.name)) {
+        return allowedGlobals[idNode.name];
+      } else {
+        throw new Error(`Undefined variable: ${idNode.name}`);
+      }
+    }
+    case 'BinaryExpression': {
+      const binaryNode = node;
+      const left = evaluateAST(binaryNode.left, context) as number;
+      const right = evaluateAST(binaryNode.right, context) as number;
+      switch (binaryNode.operator) {
+        case '+':
+          return left + right;
+        case '-':
+          return left - right;
+        case '*':
+          return left * right;
+        case '/':
+          return left / right;
+        case '%':
+          return left % right;
+        case '**':
+          return left ** right;
+        default:
+          throw new Error(`Unsupported operator: ${binaryNode.operator}`);
+      }
+    }
+    case 'LogicalExpression': {
+      const logicalNode = node;
+      const leftLogical = evaluateAST(logicalNode.left, context);
+      const rightLogical = evaluateAST(logicalNode.right, context);
+      switch (logicalNode.operator) {
+        case '&&':
+          return leftLogical && rightLogical;
+        case '||':
+          return leftLogical || rightLogical;
+        default:
+          throw new Error(`Unsupported operator: ${logicalNode.operator}`);
+      }
+    }
+    case 'UnaryExpression': {
+      const unaryNode = node;
+      const arg = evaluateAST(unaryNode.argument, context) as number;
+      switch (unaryNode.operator) {
+        case '+':
+          return +arg;
+        case '-':
+          return -arg;
+        case '!':
+          return !arg;
+        default:
+          throw new Error(`Unsupported operator: ${unaryNode.operator}`);
+      }
+    }
+    case 'ConditionalExpression': {
+      const condNode = node;
+      const test = evaluateAST(condNode.test, context);
+      return test
+        ? evaluateAST(condNode.consequent, context)
+        : evaluateAST(condNode.alternate, context);
+    }
+    case 'MemberExpression': {
+      const memberNode = node;
+      const obj = evaluateAST(memberNode.object, context) as Record<string, unknown>;
+      let prop: string | number;
+      if (memberNode.computed) {
+        prop = evaluateAST(memberNode.property, context) as string | number;
+      } else {
+        prop = (memberNode.property as Identifier).name;
+      }
+      if (typeof prop === 'string' || typeof prop === 'number') {
+        if (typeof prop === 'string' && ['constructor', '__proto__', 'prototype'].includes(prop)) {
+          throw new Error('Access to prohibited property');
+        }
+        return obj[prop];
+      } else {
+        throw new Error('Invalid property access');
+      }
+    }
+    case 'CallExpression': {
+      const callNode = node;
+      const callee = evaluateAST(callNode.callee, context);
+      const args = callNode.arguments.map((argNode) => evaluateAST(argNode, context));
+      if (typeof callee === 'function') {
+        if (callNode.callee.type === 'MemberExpression') {
+          const memberExpr = callNode.callee;
+          const obj = evaluateAST(memberExpr.object, context);
+          if (
+            obj !== null &&
+            (typeof obj === 'object' ||
+              typeof obj === 'number' ||
+              typeof obj === 'string' ||
+              typeof obj === 'boolean')
+          ) {
+            return callee.call(obj, ...args);
+          } else {
+            throw new Error('Invalid object in member function call');
+          }
+        } else {
+          return callee(...args);
+        }
+      } else {
+        throw new Error('Attempted to call a non-function');
+      }
+    }
+    case 'ArrowFunctionExpression': {
+      const arrowFuncNode = node;
+      const params = arrowFuncNode.params.map((param) => (param as Identifier).name);
+      const body = arrowFuncNode.body;
+
+      return (...args: unknown[]) => {
+        const newContext = { ...context };
+        params.forEach((param, index) => {
+          newContext[param] = args[index];
+        });
+        return evaluateAST(body, newContext);
+      };
+    }
+    case 'ArrayExpression': {
+      const arrayNode = node;
+      return arrayNode.elements.map((elem) => (elem ? evaluateAST(elem, context) : null));
+    }
+    case 'ObjectExpression': {
+      const objectNode = node;
+      const objResult: Record<string, unknown> = {};
+      objectNode.properties.forEach((prop) => {
+        const propNode = prop as Property;
+        let key: string;
+        if (propNode.key.type === 'Identifier') {
+          key = propNode.key.name;
+        } else {
+          const evaluatedKey = evaluateAST(propNode.key, context);
+          if (typeof evaluatedKey !== 'string' && typeof evaluatedKey !== 'number') {
+            throw new Error('Object property keys must be strings or numbers');
+          }
+          key = String(evaluatedKey);
+        }
+        const value = evaluateAST(propNode.value, context);
+        objResult[key] = value;
+      });
+      return objResult;
+    }
+    default:
+      throw new Error(`Unsupported syntax in placeholder: ${node.type}`);
+  }
+};
+
+const evaluatePlaceholders = (arg: {
+  content: string;
+  context: Record<string, unknown>;
+}): string => {
+  const { content, context } = arg;
+
+  let resultContent = '';
+  let index = 0;
+
+  while (index < content.length) {
+    const startIndex = content.indexOf('{', index);
+    if (startIndex === -1) {
+      resultContent += content.slice(index);
+      break;
+    }
+
+    resultContent += content.slice(index, startIndex);
+    let braceCount = 1;
+    let endIndex = startIndex + 1;
+
+    while (endIndex < content.length && braceCount > 0) {
+      if (content[endIndex] === '{') {
+        braceCount++;
+      } else if (content[endIndex] === '}') {
+        braceCount--;
+      }
+      endIndex++;
+    }
+
+    if (braceCount === 0) {
+      const code = content.slice(startIndex + 1, endIndex - 1).trim();
+      
+      if (expressionCache.has(code)) {
+        const evalFunc = expressionCache.get(code)!;
+        try {
+          const value = evalFunc(context);
+          resultContent += String(value);
+        } catch {
+          resultContent += content.slice(startIndex, endIndex);
+        }
+      } else {
+        try {
+          const ast = acorn.parseExpressionAt(code, 0, { ecmaVersion: 'latest' }) as AcornNode;
+          validateAST(ast);
+          const evalFunc = (ctx: Record<string, unknown>) => evaluateAST(ast, ctx);
+          expressionCache.set(code, evalFunc);
+          const value = evalFunc(context);
+          resultContent += String(value);
+        } catch {
+          resultContent += content.slice(startIndex, endIndex);
+        }
+      }
+
+      index = endIndex;
+    } else {
+      throw new Error('Invalid placeholder');
+    }
+  }
+
+  return resultContent;
+};
+
+
+export const replacePlaceholders = (arg: {
+  content: string;
+  variables: Record<string, any>;
+  schemas: SchemaPageArray;
+}): string => {
+  const { content, variables, schemas } = arg;
+  if (!content || typeof content !== 'string' || !content.includes('{') || !content.includes('}')) {
+    return content;
+  }
+
+  const date = new Date();
+  const formattedDate = formatDate(date);
+  const formattedDateTime = formatDateTime(date);
+
+  const data = {
+    ...Object.fromEntries(
+      schemas.flat().map((schema) => [schema.name, schema.readOnly ? schema.content || '' : ''])
+    ),
+    ...variables,
+  };
+  const parsedInput = parseData(data);
+
+  const context: Record<string, unknown> = {
+    date: formattedDate,
+    dateTime: formattedDateTime,
+    ...parsedInput,
+  };
+
+  Object.entries(context).forEach(([key, value]) => {
+    if (typeof value === 'string' && value.includes('{') && value.includes('}')) {
+      context[key] = evaluatePlaceholders({ content: value, context });
+    }
+  });
+
+  return evaluatePlaceholders({ content, context });
+};