@k-msg/template 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -1,1315 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ButtonParser: () => ButtonParser,
-  TemplateBuilder: () => TemplateBuilder,
-  TemplateBuilders: () => TemplateBuilders,
-  TemplateCategory: () => TemplateCategory,
-  TemplateRegistry: () => TemplateRegistry,
-  TemplateService: () => TemplateService,
-  TemplateStatus: () => TemplateStatus,
-  TemplateType: () => TemplateType,
-  TemplateValidator: () => TemplateValidator,
-  VariableParser: () => VariableParser
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/parser/variable.parser.ts
-var VariableParser = class {
-  static VARIABLE_PATTERN = /#{([^}]+)}/g;
-  /**
-   * 템플릿 내용에서 변수를 추출합니다
-   */
-  static extractVariables(content) {
-    const variables = [];
-    const matches = content.matchAll(this.VARIABLE_PATTERN);
-    for (const match of matches) {
-      const variableName = match[1].trim();
-      if (variableName && !variables.includes(variableName)) {
-        variables.push(variableName);
-      }
-    }
-    return variables;
-  }
-  /**
-   * 템플릿 내용의 변수를 실제 값으로 치환합니다
-   */
-  static replaceVariables(content, variables) {
-    return content.replace(this.VARIABLE_PATTERN, (match, variableName) => {
-      const value = variables[variableName.trim()];
-      if (value === void 0 || value === null) {
-        return match;
-      }
-      if (value instanceof Date) {
-        return value.toISOString();
-      }
-      return String(value);
-    });
-  }
-  /**
-   * 변수 정의와 실제 제공된 값을 검증합니다
-   */
-  static validateVariables(variableDefinitions, providedVariables) {
-    const errors = [];
-    for (const definition of variableDefinitions) {
-      const value = providedVariables[definition.name];
-      if (definition.required && (value === void 0 || value === null)) {
-        errors.push(`Required variable '${definition.name}' is missing`);
-        continue;
-      }
-      if (value === void 0 || value === null) {
-        continue;
-      }
-      if (!this.validateVariableType(value, definition.type)) {
-        errors.push(`Variable '${definition.name}' has invalid type. Expected: ${definition.type}`);
-      }
-      if (definition.maxLength && String(value).length > definition.maxLength) {
-        errors.push(`Variable '${definition.name}' exceeds maximum length of ${definition.maxLength}`);
-      }
-      if (definition.format && !new RegExp(definition.format).test(String(value))) {
-        errors.push(`Variable '${definition.name}' does not match required format: ${definition.format}`);
-      }
-    }
-    return {
-      isValid: errors.length === 0,
-      errors
-    };
-  }
-  static validateVariableType(value, expectedType) {
-    switch (expectedType) {
-      case "string":
-        return typeof value === "string";
-      case "number":
-        return typeof value === "number" && !isNaN(value);
-      case "date":
-        return value instanceof Date || !isNaN(Date.parse(value));
-      case "custom":
-        return true;
-      // 커스텀 타입은 별도 검증 로직 필요
-      default:
-        return false;
-    }
-  }
-  /**
-   * 템플릿에서 사용된 변수와 정의된 변수의 일치성을 검사합니다
-   */
-  static validateTemplateVariables(content, variableDefinitions) {
-    const usedVariables = this.extractVariables(content);
-    const definedVariables = variableDefinitions.map((v) => v.name);
-    const errors = [];
-    for (const usedVar of usedVariables) {
-      if (!definedVariables.includes(usedVar)) {
-        errors.push(`Variable '${usedVar}' is used in template but not defined`);
-      }
-    }
-    for (const definition of variableDefinitions) {
-      if (definition.required && !usedVariables.includes(definition.name)) {
-        errors.push(`Required variable '${definition.name}' is defined but not used in template`);
-      }
-    }
-    return {
-      isValid: errors.length === 0,
-      errors
-    };
-  }
-};
-
-// src/types/template.types.ts
-var import_zod = require("zod");
-var TemplateType = /* @__PURE__ */ ((TemplateType2) => {
-  TemplateType2["ALIMTALK"] = "ALIMTALK";
-  TemplateType2["SMS"] = "SMS";
-  TemplateType2["LMS"] = "LMS";
-  TemplateType2["MMS"] = "MMS";
-  TemplateType2["RCS"] = "RCS";
-  return TemplateType2;
-})(TemplateType || {});
-var TemplateCategory = /* @__PURE__ */ ((TemplateCategory2) => {
-  TemplateCategory2["AUTHENTICATION"] = "AUTHENTICATION";
-  TemplateCategory2["NOTIFICATION"] = "NOTIFICATION";
-  TemplateCategory2["PROMOTION"] = "PROMOTION";
-  TemplateCategory2["INFORMATION"] = "INFORMATION";
-  TemplateCategory2["RESERVATION"] = "RESERVATION";
-  TemplateCategory2["SHIPPING"] = "SHIPPING";
-  TemplateCategory2["PAYMENT"] = "PAYMENT";
-  return TemplateCategory2;
-})(TemplateCategory || {});
-var TemplateStatus = /* @__PURE__ */ ((TemplateStatus2) => {
-  TemplateStatus2["DRAFT"] = "DRAFT";
-  TemplateStatus2["PENDING"] = "PENDING";
-  TemplateStatus2["APPROVED"] = "APPROVED";
-  TemplateStatus2["REJECTED"] = "REJECTED";
-  TemplateStatus2["DISABLED"] = "DISABLED";
-  return TemplateStatus2;
-})(TemplateStatus || {});
-var TemplateVariableSchema = import_zod.z.object({
-  name: import_zod.z.string().min(1),
-  type: import_zod.z.enum(["string", "number", "date", "custom"]),
-  required: import_zod.z.boolean(),
-  maxLength: import_zod.z.number().optional(),
-  format: import_zod.z.string().optional(),
-  description: import_zod.z.string().optional(),
-  example: import_zod.z.string().optional()
-});
-var TemplateButtonSchema = import_zod.z.object({
-  type: import_zod.z.enum(["WL", "AL", "DS", "BK", "MD"]),
-  name: import_zod.z.string().min(1),
-  linkMobile: import_zod.z.string().url().optional(),
-  linkPc: import_zod.z.string().url().optional(),
-  linkIos: import_zod.z.string().url().optional(),
-  linkAndroid: import_zod.z.string().url().optional(),
-  schemeIos: import_zod.z.string().optional(),
-  schemeAndroid: import_zod.z.string().optional()
-});
-var AlimTalkTemplateSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  code: import_zod.z.string(),
-  name: import_zod.z.string().min(1),
-  content: import_zod.z.string().min(1),
-  variables: import_zod.z.array(TemplateVariableSchema),
-  buttons: import_zod.z.array(TemplateButtonSchema).optional(),
-  category: import_zod.z.nativeEnum(TemplateCategory),
-  status: import_zod.z.nativeEnum(TemplateStatus),
-  provider: import_zod.z.string(),
-  metadata: import_zod.z.object({
-    createdAt: import_zod.z.date(),
-    updatedAt: import_zod.z.date(),
-    approvedAt: import_zod.z.date().optional(),
-    rejectedAt: import_zod.z.date().optional(),
-    rejectionReason: import_zod.z.string().optional(),
-    usage: import_zod.z.object({
-      sent: import_zod.z.number().min(0),
-      delivered: import_zod.z.number().min(0),
-      failed: import_zod.z.number().min(0)
-    })
-  })
-});
-
-// src/parser/button.parser.ts
-var ButtonParser = class {
-  /**
-   * 버튼 설정의 유효성을 검증합니다
-   */
-  static validateButtons(buttons) {
-    const errors = [];
-    if (buttons.length > 5) {
-      errors.push("Maximum 5 buttons are allowed");
-    }
-    for (let i = 0; i < buttons.length; i++) {
-      const button = buttons[i];
-      const buttonIndex = i + 1;
-      if (!button.name || button.name.trim().length === 0) {
-        errors.push(`Button ${buttonIndex}: name is required`);
-      } else if (button.name.length > 14) {
-        errors.push(`Button ${buttonIndex}: name cannot exceed 14 characters`);
-      }
-      this.validateButtonByType(button, buttonIndex, errors);
-    }
-    return {
-      isValid: errors.length === 0,
-      errors
-    };
-  }
-  static validateButtonByType(button, buttonIndex, errors) {
-    switch (button.type) {
-      case "WL":
-        this.validateWebLinkButton(button, buttonIndex, errors);
-        break;
-      case "AL":
-        this.validateAppLinkButton(button, buttonIndex, errors);
-        break;
-      case "DS":
-        this.validateDeliveryButton(button, buttonIndex, errors);
-        break;
-      case "BK":
-        this.validateBotKeywordButton(button, buttonIndex, errors);
-        break;
-      case "MD":
-        this.validateMessageDeliveryButton(button, buttonIndex, errors);
-        break;
-      default:
-        errors.push(`Button ${buttonIndex}: invalid button type '${button.type}'`);
-    }
-  }
-  static validateWebLinkButton(button, buttonIndex, errors) {
-    if (!button.linkMobile && !button.linkPc) {
-      errors.push(`Button ${buttonIndex}: web link button must have at least mobile or PC link`);
-    }
-    if (button.linkMobile && !this.isValidUrl(button.linkMobile)) {
-      errors.push(`Button ${buttonIndex}: invalid mobile link URL`);
-    }
-    if (button.linkPc && !this.isValidUrl(button.linkPc)) {
-      errors.push(`Button ${buttonIndex}: invalid PC link URL`);
-    }
-  }
-  static validateAppLinkButton(button, buttonIndex, errors) {
-    const hasAnyLink = button.linkIos || button.linkAndroid || button.schemeIos || button.schemeAndroid;
-    if (!hasAnyLink) {
-      errors.push(`Button ${buttonIndex}: app link button must have at least one app link or scheme`);
-    }
-    if (button.linkIos && !this.isValidUrl(button.linkIos)) {
-      errors.push(`Button ${buttonIndex}: invalid iOS link URL`);
-    }
-    if (button.linkAndroid && !this.isValidUrl(button.linkAndroid)) {
-      errors.push(`Button ${buttonIndex}: invalid Android link URL`);
-    }
-  }
-  static validateDeliveryButton(button, buttonIndex, errors) {
-  }
-  static validateBotKeywordButton(button, buttonIndex, errors) {
-  }
-  static validateMessageDeliveryButton(button, buttonIndex, errors) {
-  }
-  static isValidUrl(url) {
-    try {
-      new URL(url);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * 버튼을 JSON 문자열로 직렬화합니다 (카카오 API 형식)
-   */
-  static serializeButtons(buttons) {
-    const serializedButtons = buttons.map((button) => ({
-      name: button.name,
-      type: button.type,
-      url_mobile: button.linkMobile,
-      url_pc: button.linkPc,
-      scheme_ios: button.schemeIos,
-      scheme_android: button.schemeAndroid
-    }));
-    return JSON.stringify(serializedButtons);
-  }
-  /**
-   * JSON 문자열에서 버튼 배열로 역직렬화합니다
-   */
-  static deserializeButtons(buttonsJson) {
-    try {
-      const parsed = JSON.parse(buttonsJson);
-      return parsed.map((button) => ({
-        name: button.name,
-        type: button.type,
-        linkMobile: button.url_mobile,
-        linkPc: button.url_pc,
-        linkIos: button.url_ios,
-        linkAndroid: button.url_android,
-        schemeIos: button.scheme_ios,
-        schemeAndroid: button.scheme_android
-      }));
-    } catch (error) {
-      throw new Error(`Failed to parse buttons JSON: ${error}`);
-    }
-  }
-};
-
-// src/parser/validator.ts
-var TemplateValidator = class {
-  /**
-   * 알림톡 템플릿의 전체적인 유효성을 검증합니다
-   */
-  static validate(template) {
-    const errors = [];
-    const warnings = [];
-    this.validateBasicFields(template, errors);
-    this.validateContent(template, errors, warnings);
-    const variableValidation = VariableParser.validateTemplateVariables(
-      template.content,
-      template.variables
-    );
-    errors.push(...variableValidation.errors);
-    if (template.buttons && template.buttons.length > 0) {
-      const buttonValidation = ButtonParser.validateButtons(template.buttons);
-      errors.push(...buttonValidation.errors);
-    }
-    this.validateByCategory(template, errors, warnings);
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings
-    };
-  }
-  static validateBasicFields(template, errors) {
-    if (!template.name || template.name.trim().length === 0) {
-      errors.push("Template name is required");
-    }
-    if (!template.code || template.code.trim().length === 0) {
-      errors.push("Template code is required");
-    }
-    if (!template.provider || template.provider.trim().length === 0) {
-      errors.push("Provider is required");
-    }
-  }
-  static validateContent(template, errors, warnings) {
-    if (!template.content || template.content.trim().length === 0) {
-      errors.push("Template content is required");
-      return;
-    }
-    const content = template.content;
-    if (content.length > 1e3) {
-      errors.push("Template content cannot exceed 1000 characters");
-    }
-    if (this.containsProhibitedCharacters(content)) {
-      errors.push("Template content contains prohibited characters");
-    }
-    const lineBreaks = (content.match(/\n/g) || []).length;
-    if (lineBreaks > 20) {
-      warnings.push("Template content has many line breaks, which may affect readability");
-    }
-    this.validateUrlsInContent(content, warnings);
-  }
-  static containsProhibitedCharacters(content) {
-    const prohibitedChars = /[<>]/;
-    return prohibitedChars.test(content);
-  }
-  static validateUrlsInContent(content, warnings) {
-    const urlPattern = /https?:\/\/[^\s]+/g;
-    const urls = content.match(urlPattern) || [];
-    for (const url of urls) {
-      try {
-        new URL(url);
-      } catch {
-        warnings.push(`Invalid URL found in content: ${url}`);
-      }
-    }
-  }
-  static validateByCategory(template, errors, warnings) {
-    switch (template.category) {
-      case "AUTHENTICATION" /* AUTHENTICATION */:
-        this.validateAuthenticationTemplate(template, errors, warnings);
-        break;
-      case "PROMOTION" /* PROMOTION */:
-        this.validatePromotionTemplate(template, errors, warnings);
-        break;
-      case "PAYMENT" /* PAYMENT */:
-        this.validatePaymentTemplate(template, errors, warnings);
-        break;
-    }
-  }
-  static validateAuthenticationTemplate(template, errors, warnings) {
-    const hasAuthCode = template.variables.some(
-      (v) => v.name.includes("\uC778\uC99D") || v.name.includes("\uCF54\uB4DC") || v.name.includes("\uBC88\uD638")
-    );
-    if (!hasAuthCode) {
-      warnings.push("Authentication template should include an authentication code variable");
-    }
-    if (template.buttons && template.buttons.length > 0) {
-      warnings.push("Authentication templates typically should not have buttons");
-    }
-  }
-  static validatePromotionTemplate(template, errors, warnings) {
-    if (!template.buttons || template.buttons.length === 0) {
-      warnings.push("Promotion templates typically should have action buttons");
-    }
-  }
-  static validatePaymentTemplate(template, errors, warnings) {
-    const hasAmountVariable = template.variables.some(
-      (v) => v.name.includes("\uAE08\uC561") || v.name.includes("\uAC00\uACA9") || v.name.includes("\uC6D0")
-    );
-    if (!hasAmountVariable) {
-      warnings.push("Payment template should include an amount variable");
-    }
-  }
-  /**
-   * 빠른 검증 - 기본적인 필수 필드만 검사
-   */
-  static quickValidate(template) {
-    const errors = [];
-    if (!template.name) errors.push("Name is required");
-    if (!template.content) errors.push("Content is required");
-    if (!template.category) errors.push("Category is required");
-    if (!template.provider) errors.push("Provider is required");
-    return {
-      isValid: errors.length === 0,
-      errors,
-      warnings: []
-    };
-  }
-};
-
-// src/services/template.service.ts
-var TemplateService = class {
-  templates = /* @__PURE__ */ new Map();
-  async createTemplate(template) {
-    const variables = VariableParser.extractVariables(template.content);
-    const newTemplate = {
-      ...template,
-      id: this.generateTemplateId(),
-      variables: variables.map((name) => ({
-        name,
-        type: "string",
-        required: true
-      })),
-      metadata: {
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date(),
-        usage: { sent: 0, delivered: 0, failed: 0 }
-      }
-    };
-    const validation = TemplateValidator.validate(newTemplate);
-    if (!validation.isValid) {
-      throw new Error(`Template validation failed: ${validation.errors.join(", ")}`);
-    }
-    this.templates.set(newTemplate.id, newTemplate);
-    return newTemplate;
-  }
-  async getTemplate(templateId) {
-    return this.templates.get(templateId) || null;
-  }
-  async updateTemplate(templateId, updates) {
-    const template = this.templates.get(templateId);
-    if (!template) {
-      throw new Error(`Template ${templateId} not found`);
-    }
-    const updatedTemplate = {
-      ...template,
-      ...updates,
-      metadata: {
-        ...template.metadata,
-        updatedAt: /* @__PURE__ */ new Date()
-      }
-    };
-    this.templates.set(templateId, updatedTemplate);
-    return updatedTemplate;
-  }
-  async deleteTemplate(templateId) {
-    this.templates.delete(templateId);
-  }
-  async renderTemplate(templateId, variables) {
-    const template = this.templates.get(templateId);
-    if (!template) {
-      throw new Error(`Template ${templateId} not found`);
-    }
-    const validation = VariableParser.validateVariables(template.variables, variables);
-    if (!validation.isValid) {
-      throw new Error(`Variable validation failed: ${validation.errors.join(", ")}`);
-    }
-    return VariableParser.replaceVariables(template.content, variables);
-  }
-  generateTemplateId() {
-    return `tpl_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-};
-
-// src/builder/template.builder.ts
-var TemplateBuilder = class _TemplateBuilder {
-  template = {
-    variables: [],
-    buttons: [],
-    status: "DRAFT" /* DRAFT */,
-    metadata: {
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      usage: { sent: 0, delivered: 0, failed: 0 }
-    }
-  };
-  /**
-   * Set template name
-   */
-  name(name) {
-    this.template.name = name;
-    return this;
-  }
-  /**
-   * Set template code (provider specific)
-   */
-  code(code) {
-    this.template.code = code;
-    return this;
-  }
-  /**
-   * Set template content with variables
-   */
-  content(content) {
-    this.template.content = content;
-    const extractedVariables = VariableParser.extractVariables(content);
-    const existingVariableNames = (this.template.variables || []).map((v) => v.name);
-    for (const varName of extractedVariables) {
-      if (!existingVariableNames.includes(varName)) {
-        this.variable(varName, "string", true);
-      }
-    }
-    return this;
-  }
-  /**
-   * Set template category
-   */
-  category(category) {
-    this.template.category = category;
-    return this;
-  }
-  /**
-   * Set template provider
-   */
-  provider(provider) {
-    this.template.provider = provider;
-    return this;
-  }
-  /**
-   * Set template status
-   */
-  status(status) {
-    this.template.status = status;
-    return this;
-  }
-  /**
-   * Add a variable definition
-   */
-  variable(name, type = "string", required = true, options = {}) {
-    if (!this.template.variables) {
-      this.template.variables = [];
-    }
-    this.template.variables = this.template.variables.filter((v) => v.name !== name);
-    const variable = {
-      name,
-      type,
-      required,
-      ...options
-    };
-    this.template.variables.push(variable);
-    return this;
-  }
-  /**
-   * Add multiple variables at once
-   */
-  variables(variables) {
-    for (const variable of variables) {
-      this.variable(
-        variable.name,
-        variable.type || "string",
-        variable.required ?? true,
-        {
-          maxLength: variable.maxLength,
-          format: variable.format,
-          description: variable.description,
-          example: variable.example
-        }
-      );
-    }
-    return this;
-  }
-  /**
-   * Add a web link button
-   */
-  webLinkButton(name, mobileUrl, pcUrl) {
-    return this.button({
-      type: "WL",
-      name,
-      linkMobile: mobileUrl,
-      linkPc: pcUrl
-    });
-  }
-  /**
-   * Add an app link button
-   */
-  appLinkButton(name, options) {
-    return this.button({
-      type: "AL",
-      name,
-      linkIos: options.iosUrl,
-      linkAndroid: options.androidUrl,
-      schemeIos: options.iosScheme,
-      schemeAndroid: options.androidScheme
-    });
-  }
-  /**
-   * Add a delivery tracking button
-   */
-  deliveryButton(name) {
-    return this.button({
-      type: "DS",
-      name
-    });
-  }
-  /**
-   * Add a bot keyword button
-   */
-  botKeywordButton(name) {
-    return this.button({
-      type: "BK",
-      name
-    });
-  }
-  /**
-   * Add a message delivery button
-   */
-  messageDeliveryButton(name) {
-    return this.button({
-      type: "MD",
-      name
-    });
-  }
-  /**
-   * Add a custom button
-   */
-  button(button) {
-    if (!this.template.buttons) {
-      this.template.buttons = [];
-    }
-    if (this.template.buttons.length >= 5) {
-      throw new Error("Maximum 5 buttons are allowed per template");
-    }
-    this.template.buttons.push(button);
-    return this;
-  }
-  /**
-   * Clear all buttons
-   */
-  clearButtons() {
-    this.template.buttons = [];
-    return this;
-  }
-  /**
-   * Set template metadata
-   */
-  metadata(metadata) {
-    this.template.metadata = {
-      ...this.template.metadata,
-      ...metadata,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    return this;
-  }
-  /**
-   * Validate the current template
-   */
-  validate() {
-    const quickValidation = TemplateValidator.quickValidate(this.template);
-    if (!quickValidation.isValid) {
-      return quickValidation;
-    }
-    try {
-      const fullTemplate = this.build();
-      return TemplateValidator.validate(fullTemplate);
-    } catch (error) {
-      return {
-        isValid: false,
-        errors: [error instanceof Error ? error.message : "Unknown validation error"],
-        warnings: []
-      };
-    }
-  }
-  /**
-   * Preview the template with sample variables
-   */
-  preview(sampleVariables = {}) {
-    if (!this.template.content) {
-      throw new Error("Template content is required for preview");
-    }
-    const variables = { ...this.generateSampleVariables(), ...sampleVariables };
-    return VariableParser.replaceVariables(this.template.content, variables);
-  }
-  /**
-   * Generate sample variables based on variable definitions
-   */
-  generateSampleVariables() {
-    const samples = {};
-    for (const variable of this.template.variables || []) {
-      if (variable.example) {
-        samples[variable.name] = variable.example;
-      } else {
-        switch (variable.type) {
-          case "string":
-            samples[variable.name] = variable.name.includes("name") || variable.name.includes("\uC774\uB984") ? "\uD64D\uAE38\uB3D9" : variable.name.includes("code") || variable.name.includes("\uCF54\uB4DC") ? "123456" : `\uC0D8\uD50C${variable.name}`;
-            break;
-          case "number":
-            samples[variable.name] = variable.name.includes("amount") || variable.name.includes("\uAE08\uC561") ? 1e4 : variable.name.includes("count") || variable.name.includes("\uAC1C\uC218") ? 1 : 123;
-            break;
-          case "date":
-            samples[variable.name] = /* @__PURE__ */ new Date();
-            break;
-          default:
-            samples[variable.name] = `\uC0D8\uD50C\uAC12`;
-        }
-      }
-    }
-    return samples;
-  }
-  /**
-   * Clone the current builder
-   */
-  clone() {
-    const cloned = new _TemplateBuilder();
-    cloned.template = JSON.parse(JSON.stringify(this.template));
-    return cloned;
-  }
-  /**
-   * Reset the builder to start fresh
-   */
-  reset() {
-    this.template = {
-      variables: [],
-      buttons: [],
-      status: "DRAFT" /* DRAFT */,
-      metadata: {
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date(),
-        usage: { sent: 0, delivered: 0, failed: 0 }
-      }
-    };
-    return this;
-  }
-  /**
-   * Build the final template
-   */
-  build() {
-    if (!this.template.name) throw new Error("Template name is required");
-    if (!this.template.code) throw new Error("Template code is required");
-    if (!this.template.content) throw new Error("Template content is required");
-    if (!this.template.category) throw new Error("Template category is required");
-    if (!this.template.provider) throw new Error("Template provider is required");
-    const template = {
-      id: this.template.id || this.generateTemplateId(),
-      name: this.template.name,
-      code: this.template.code,
-      content: this.template.content,
-      variables: this.template.variables || [],
-      buttons: this.template.buttons,
-      category: this.template.category,
-      status: this.template.status || "DRAFT" /* DRAFT */,
-      provider: this.template.provider,
-      metadata: {
-        ...this.template.metadata,
-        updatedAt: /* @__PURE__ */ new Date()
-      }
-    };
-    const validation = TemplateValidator.validate(template);
-    if (!validation.isValid) {
-      throw new Error(`Template validation failed: ${validation.errors.join(", ")}`);
-    }
-    return template;
-  }
-  generateTemplateId() {
-    return `tpl_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-};
-var TemplateBuilders = {
-  /**
-   * Create an authentication template builder
-   */
-  authentication(name, provider) {
-    return new TemplateBuilder().name(name).category("AUTHENTICATION" /* AUTHENTICATION */).provider(provider).variable("code", "string", true, {
-      maxLength: 10,
-      description: "Authentication code",
-      example: "123456"
-    });
-  },
-  /**
-   * Create a notification template builder
-   */
-  notification(name, provider) {
-    return new TemplateBuilder().name(name).category("NOTIFICATION" /* NOTIFICATION */).provider(provider).variable("name", "string", true, {
-      description: "Recipient name",
-      example: "\uD64D\uAE38\uB3D9"
-    });
-  },
-  /**
-   * Create a promotion template builder
-   */
-  promotion(name, provider) {
-    return new TemplateBuilder().name(name).category("PROMOTION" /* PROMOTION */).provider(provider).variable("name", "string", true, {
-      description: "Customer name",
-      example: "\uD64D\uAE38\uB3D9"
-    }).variable("discount", "number", false, {
-      description: "Discount percentage",
-      example: "20"
-    });
-  },
-  /**
-   * Create a payment template builder
-   */
-  payment(name, provider) {
-    return new TemplateBuilder().name(name).category("PAYMENT" /* PAYMENT */).provider(provider).variable("name", "string", true, {
-      description: "Customer name",
-      example: "\uD64D\uAE38\uB3D9"
-    }).variable("amount", "number", true, {
-      description: "Payment amount",
-      example: "10000"
-    });
-  }
-};
-
-// src/registry/template.registry.ts
-var import_events = require("events");
-var TemplateRegistry = class extends import_events.EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.options = options;
-    this.options = { ...this.defaultOptions, ...options };
-    if (this.options.enableAutoBackup) {
-      this.startAutoBackup();
-    }
-  }
-  templates = /* @__PURE__ */ new Map();
-  templatesByCode = /* @__PURE__ */ new Map();
-  templatesByProvider = /* @__PURE__ */ new Map();
-  templatesByCategory = /* @__PURE__ */ new Map();
-  templateHistories = /* @__PURE__ */ new Map();
-  usageStats = /* @__PURE__ */ new Map();
-  backupTimer;
-  defaultOptions = {
-    enableVersioning: true,
-    maxVersionsPerTemplate: 10,
-    enableUsageTracking: true,
-    enableAutoBackup: false,
-    backupInterval: 36e5,
-    // 1 hour
-    enableValidationOnRegister: true
-  };
-  /**
-   * Register a new template
-   */
-  async register(template) {
-    if (this.options.enableValidationOnRegister) {
-      const validation = TemplateValidator.validate(template);
-      if (!validation.isValid) {
-        throw new Error(`Template validation failed: ${validation.errors.join(", ")}`);
-      }
-    }
-    const existingTemplate = this.getByCode(template.code, template.provider);
-    if (existingTemplate && existingTemplate.id !== template.id) {
-      throw new Error(`Template with code '${template.code}' already exists for provider '${template.provider}'`);
-    }
-    this.templates.set(template.id, template);
-    this.templatesByCode.set(`${template.provider}:${template.code}`, template);
-    this.updateIndexes(template);
-    if (this.options.enableVersioning) {
-      this.initializeVersionHistory(template);
-    }
-    if (this.options.enableUsageTracking) {
-      this.initializeUsageStats(template);
-    }
-    this.emit("template:registered", { template });
-  }
-  /**
-   * Update an existing template
-   */
-  async update(templateId, updates) {
-    const existing = this.templates.get(templateId);
-    if (!existing) {
-      throw new Error(`Template ${templateId} not found`);
-    }
-    const updatedTemplate = {
-      ...existing,
-      ...updates,
-      id: templateId,
-      // Ensure ID doesn't change
-      metadata: {
-        ...existing.metadata,
-        ...updates.metadata,
-        updatedAt: /* @__PURE__ */ new Date()
-      }
-    };
-    if (this.options.enableValidationOnRegister) {
-      const validation = TemplateValidator.validate(updatedTemplate);
-      if (!validation.isValid) {
-        throw new Error(`Template validation failed: ${validation.errors.join(", ")}`);
-      }
-    }
-    if (this.options.enableVersioning) {
-      this.addVersionToHistory(existing, updatedTemplate);
-    }
-    this.templates.set(templateId, updatedTemplate);
-    this.templatesByCode.set(`${updatedTemplate.provider}:${updatedTemplate.code}`, updatedTemplate);
-    this.updateIndexes(updatedTemplate);
-    this.emit("template:updated", {
-      oldTemplate: existing,
-      newTemplate: updatedTemplate
-    });
-    return updatedTemplate;
-  }
-  /**
-   * Get template by ID
-   */
-  get(templateId) {
-    return this.templates.get(templateId) || null;
-  }
-  /**
-   * Get template by code and provider
-   */
-  getByCode(code, provider) {
-    return this.templatesByCode.get(`${provider}:${code}`) || null;
-  }
-  /**
-   * Search templates with filters and pagination
-   */
-  search(filters = {}, options = {}) {
-    let templates = Array.from(this.templates.values());
-    if (filters.provider) {
-      templates = templates.filter((t) => t.provider === filters.provider);
-    }
-    if (filters.category) {
-      templates = templates.filter((t) => t.category === filters.category);
-    }
-    if (filters.status) {
-      templates = templates.filter((t) => t.status === filters.status);
-    }
-    if (filters.nameContains) {
-      const searchTerm = filters.nameContains.toLowerCase();
-      templates = templates.filter((t) => t.name.toLowerCase().includes(searchTerm));
-    }
-    if (filters.codeContains) {
-      const searchTerm = filters.codeContains.toLowerCase();
-      templates = templates.filter((t) => t.code.toLowerCase().includes(searchTerm));
-    }
-    if (filters.createdAfter) {
-      templates = templates.filter((t) => t.metadata.createdAt >= filters.createdAfter);
-    }
-    if (filters.createdBefore) {
-      templates = templates.filter((t) => t.metadata.createdAt <= filters.createdBefore);
-    }
-    if (filters.usageMin !== void 0) {
-      templates = templates.filter((t) => t.metadata.usage.sent >= filters.usageMin);
-    }
-    if (filters.usageMax !== void 0) {
-      templates = templates.filter((t) => t.metadata.usage.sent <= filters.usageMax);
-    }
-    const sortBy = options.sortBy || "createdAt";
-    const sortOrder = options.sortOrder || "desc";
-    templates.sort((a, b) => {
-      let aValue, bValue;
-      switch (sortBy) {
-        case "name":
-          aValue = a.name;
-          bValue = b.name;
-          break;
-        case "code":
-          aValue = a.code;
-          bValue = b.code;
-          break;
-        case "createdAt":
-          aValue = a.metadata.createdAt.getTime();
-          bValue = b.metadata.createdAt.getTime();
-          break;
-        case "updatedAt":
-          aValue = a.metadata.updatedAt.getTime();
-          bValue = b.metadata.updatedAt.getTime();
-          break;
-        case "usage":
-          aValue = a.metadata.usage.sent;
-          bValue = b.metadata.usage.sent;
-          break;
-        default:
-          aValue = a.metadata.createdAt.getTime();
-          bValue = b.metadata.createdAt.getTime();
-      }
-      if (sortOrder === "asc") {
-        return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
-      } else {
-        return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
-      }
-    });
-    const page = options.page || 1;
-    const limit = options.limit || 20;
-    const start = (page - 1) * limit;
-    const end = start + limit;
-    const paginatedTemplates = templates.slice(start, end);
-    return {
-      templates: paginatedTemplates,
-      total: templates.length,
-      page,
-      limit,
-      hasMore: end < templates.length
-    };
-  }
-  /**
-   * Get templates by provider
-   */
-  getByProvider(provider) {
-    const templateIds = this.templatesByProvider.get(provider) || /* @__PURE__ */ new Set();
-    return Array.from(templateIds).map((id) => this.templates.get(id)).filter((template) => template !== void 0);
-  }
-  /**
-   * Get templates by category
-   */
-  getByCategory(category) {
-    const templateIds = this.templatesByCategory.get(category) || /* @__PURE__ */ new Set();
-    return Array.from(templateIds).map((id) => this.templates.get(id)).filter((template) => template !== void 0);
-  }
-  /**
-   * Delete template
-   */
-  async delete(templateId) {
-    const template = this.templates.get(templateId);
-    if (!template) {
-      return false;
-    }
-    this.templates.delete(templateId);
-    this.templatesByCode.delete(`${template.provider}:${template.code}`);
-    const providerSet = this.templatesByProvider.get(template.provider);
-    if (providerSet) {
-      providerSet.delete(templateId);
-      if (providerSet.size === 0) {
-        this.templatesByProvider.delete(template.provider);
-      }
-    }
-    const categorySet = this.templatesByCategory.get(template.category);
-    if (categorySet) {
-      categorySet.delete(templateId);
-      if (categorySet.size === 0) {
-        this.templatesByCategory.delete(template.category);
-      }
-    }
-    this.templateHistories.delete(templateId);
-    this.usageStats.delete(templateId);
-    this.emit("template:deleted", { template });
-    return true;
-  }
-  /**
-   * Get template version history
-   */
-  getHistory(templateId) {
-    return this.templateHistories.get(templateId) || null;
-  }
-  /**
-   * Get specific template version
-   */
-  getVersion(templateId, version) {
-    const history = this.templateHistories.get(templateId);
-    if (!history) return null;
-    const versionEntry = history.versions.find((v) => v.version === version);
-    return versionEntry ? versionEntry.template : null;
-  }
-  /**
-   * Restore template to a specific version
-   */
-  async restoreVersion(templateId, version) {
-    const versionTemplate = this.getVersion(templateId, version);
-    if (!versionTemplate) {
-      throw new Error(`Version ${version} not found for template ${templateId}`);
-    }
-    return this.update(templateId, {
-      ...versionTemplate,
-      metadata: {
-        ...versionTemplate.metadata,
-        updatedAt: /* @__PURE__ */ new Date()
-      }
-    });
-  }
-  /**
-   * Get template usage statistics
-   */
-  getUsageStats(templateId) {
-    return this.usageStats.get(templateId) || null;
-  }
-  /**
-   * Update template usage statistics
-   */
-  updateUsageStats(templateId, stats) {
-    const template = this.templates.get(templateId);
-    if (!template) return;
-    if (stats.sent) template.metadata.usage.sent += stats.sent;
-    if (stats.delivered) template.metadata.usage.delivered += stats.delivered;
-    if (stats.failed) template.metadata.usage.failed += stats.failed;
-    if (this.options.enableUsageTracking) {
-      const usageStats = this.usageStats.get(templateId);
-      if (usageStats) {
-        if (stats.sent) usageStats.totalSent += stats.sent;
-        if (stats.delivered) usageStats.totalDelivered += stats.delivered;
-        if (stats.failed) usageStats.totalFailed += stats.failed;
-        usageStats.deliveryRate = usageStats.totalSent > 0 ? usageStats.totalDelivered / usageStats.totalSent * 100 : 0;
-        usageStats.failureRate = usageStats.totalSent > 0 ? usageStats.totalFailed / usageStats.totalSent * 100 : 0;
-        usageStats.lastUsed = /* @__PURE__ */ new Date();
-        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-        let todayStats = usageStats.usageByDay.find((d) => d.date === today);
-        if (!todayStats) {
-          todayStats = { date: today, sent: 0, delivered: 0, failed: 0 };
-          usageStats.usageByDay.push(todayStats);
-          usageStats.usageByDay = usageStats.usageByDay.sort((a, b) => b.date.localeCompare(a.date)).slice(0, 30);
-        }
-        if (stats.sent) todayStats.sent += stats.sent;
-        if (stats.delivered) todayStats.delivered += stats.delivered;
-        if (stats.failed) todayStats.failed += stats.failed;
-      }
-    }
-    this.emit("usage:updated", { templateId, stats });
-  }
-  /**
-   * Get registry statistics
-   */
-  getStats() {
-    const templates = Array.from(this.templates.values());
-    const byProvider = {};
-    const byCategory = {};
-    const byStatus = {};
-    for (const template of templates) {
-      byProvider[template.provider] = (byProvider[template.provider] || 0) + 1;
-      byCategory[template.category] = (byCategory[template.category] || 0) + 1;
-      byStatus[template.status] = (byStatus[template.status] || 0) + 1;
-    }
-    return {
-      totalTemplates: templates.length,
-      byProvider,
-      byCategory,
-      byStatus
-    };
-  }
-  /**
-   * Export templates to JSON
-   */
-  export(filters) {
-    const result = this.search(filters, { limit: 1e4 });
-    return JSON.stringify({
-      templates: result.templates,
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      total: result.total
-    }, null, 2);
-  }
-  /**
-   * Import templates from JSON
-   */
-  async import(jsonData, options = {}) {
-    const result = { imported: 0, skipped: 0, errors: [] };
-    try {
-      const data = JSON.parse(jsonData);
-      const templates = data.templates || [];
-      for (const templateData of templates) {
-        try {
-          const existingTemplate = this.get(templateData.id);
-          if (existingTemplate && !options.overwrite) {
-            result.skipped++;
-            continue;
-          }
-          await this.register(templateData);
-          result.imported++;
-        } catch (error) {
-          result.errors.push(`Template ${templateData.id}: ${error instanceof Error ? error.message : "Unknown error"}`);
-        }
-      }
-    } catch (error) {
-      result.errors.push(`Invalid JSON format: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    return result;
-  }
-  /**
-   * Clear all templates (use with caution!)
-   */
-  clear() {
-    this.templates.clear();
-    this.templatesByCode.clear();
-    this.templatesByProvider.clear();
-    this.templatesByCategory.clear();
-    this.templateHistories.clear();
-    this.usageStats.clear();
-    this.emit("registry:cleared");
-  }
-  /**
-   * Stop the registry and cleanup
-   */
-  destroy() {
-    if (this.backupTimer) {
-      clearInterval(this.backupTimer);
-      this.backupTimer = void 0;
-    }
-    this.removeAllListeners();
-    this.emit("registry:destroyed");
-  }
-  updateIndexes(template) {
-    if (!this.templatesByProvider.has(template.provider)) {
-      this.templatesByProvider.set(template.provider, /* @__PURE__ */ new Set());
-    }
-    this.templatesByProvider.get(template.provider).add(template.id);
-    if (!this.templatesByCategory.has(template.category)) {
-      this.templatesByCategory.set(template.category, /* @__PURE__ */ new Set());
-    }
-    this.templatesByCategory.get(template.category).add(template.id);
-  }
-  initializeVersionHistory(template) {
-    const history = {
-      templateId: template.id,
-      versions: [{
-        version: 1,
-        template: JSON.parse(JSON.stringify(template)),
-        changes: ["Initial version"],
-        createdAt: /* @__PURE__ */ new Date()
-      }],
-      currentVersion: 1
-    };
-    this.templateHistories.set(template.id, history);
-  }
-  addVersionToHistory(oldTemplate, newTemplate) {
-    const history = this.templateHistories.get(newTemplate.id);
-    if (!history) return;
-    const changes = [];
-    if (oldTemplate.name !== newTemplate.name) changes.push("Name changed");
-    if (oldTemplate.content !== newTemplate.content) changes.push("Content changed");
-    if (oldTemplate.category !== newTemplate.category) changes.push("Category changed");
-    if (oldTemplate.status !== newTemplate.status) changes.push("Status changed");
-    if (JSON.stringify(oldTemplate.variables) !== JSON.stringify(newTemplate.variables)) {
-      changes.push("Variables changed");
-    }
-    if (JSON.stringify(oldTemplate.buttons) !== JSON.stringify(newTemplate.buttons)) {
-      changes.push("Buttons changed");
-    }
-    if (changes.length === 0) return;
-    const newVersion = {
-      version: history.currentVersion + 1,
-      template: JSON.parse(JSON.stringify(newTemplate)),
-      changes,
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    history.versions.push(newVersion);
-    history.currentVersion = newVersion.version;
-    if (history.versions.length > this.options.maxVersionsPerTemplate) {
-      history.versions = history.versions.slice(-this.options.maxVersionsPerTemplate);
-    }
-  }
-  initializeUsageStats(template) {
-    const stats = {
-      templateId: template.id,
-      totalSent: template.metadata.usage.sent,
-      totalDelivered: template.metadata.usage.delivered,
-      totalFailed: template.metadata.usage.failed,
-      deliveryRate: 0,
-      failureRate: 0,
-      usageByDay: []
-    };
-    if (stats.totalSent > 0) {
-      stats.deliveryRate = stats.totalDelivered / stats.totalSent * 100;
-      stats.failureRate = stats.totalFailed / stats.totalSent * 100;
-    }
-    this.usageStats.set(template.id, stats);
-  }
-  startAutoBackup() {
-    this.backupTimer = setInterval(() => {
-      this.emit("backup:requested", {
-        data: this.export(),
-        timestamp: /* @__PURE__ */ new Date()
-      });
-    }, this.options.backupInterval);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ButtonParser,
-  TemplateBuilder,
-  TemplateBuilders,
-  TemplateCategory,
-  TemplateRegistry,
-  TemplateService,
-  TemplateStatus,
-  TemplateType,
-  TemplateValidator,
-  VariableParser
-});
-//# sourceMappingURL=index.cjs.map