@k-msg/template 0.19.0 → 0.20.0

package/dist/personalization/variable.replacer.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Variable replacement and personalization system
+ */
+export type TemplateVariableMap = Record<string, unknown>;
+export interface TemplatePersonalizerOptions {
+    variablePattern: RegExp;
+    allowUndefined: boolean;
+    undefinedReplacement: string;
+    caseSensitive: boolean;
+    enableFormatting: boolean;
+    enableConditionals: boolean;
+    enableLoops: boolean;
+    maxRecursionDepth: number;
+}
+export interface TemplateVariableInfo {
+    name: string;
+    value: any;
+    formatted: string;
+    type: "string" | "number" | "date" | "boolean" | "array" | "object" | "undefined";
+    position: {
+        start: number;
+        end: number;
+    };
+}
+export interface ReplacementResult {
+    content: string;
+    variables: TemplateVariableInfo[];
+    missingVariables: string[];
+    errors: ReplacementError[];
+    metadata: {
+        originalLength: number;
+        finalLength: number;
+        variableCount: number;
+        replacementTime: number;
+    };
+}
+export interface ReplacementError {
+    type: "missing_variable" | "format_error" | "syntax_error" | "recursion_limit";
+    message: string;
+    variable?: string;
+    position?: {
+        start: number;
+        end: number;
+    };
+}
+export interface ConditionalBlock {
+    condition: string;
+    content: string;
+    elseContent?: string;
+}
+export interface LoopBlock {
+    variable: string;
+    array: string;
+    content: string;
+}
+export declare class TemplatePersonalizer {
+    private options;
+    private defaultOptions;
+    constructor(options?: Partial<TemplatePersonalizerOptions>);
+    /**
+     * Replace variables in content
+     */
+    replace(content: string, variables: TemplateVariableMap): ReplacementResult;
+    /**
+     * Extract variables from content without replacing
+     */
+    extractVariables(content: string): string[];
+    /**
+     * Validate that all required variables are provided
+     */
+    validate(content: string, variables: TemplateVariableMap): {
+        isValid: boolean;
+        missingVariables: string[];
+        errors: ReplacementError[];
+    };
+    /**
+     * Preview replacement result without actually replacing
+     */
+    preview(content: string, variables: TemplateVariableMap): {
+        originalContent: string;
+        previewContent: string;
+        variableHighlights: Array<{
+            variable: string;
+            value: string;
+            positions: Array<{
+                start: number;
+                end: number;
+            }>;
+        }>;
+    };
+    private replaceSimpleVariables;
+    private replaceRecursive;
+    private processConditionals;
+    private processLoops;
+    private parseVariableName;
+    private getVariableValue;
+    private formatValue;
+    private formatDate;
+    private getValueType;
+    private hasVariables;
+    private extractConditionals;
+    private extractLoops;
+    private extractVariablesFromExpression;
+    private evaluateCondition;
+    private buildConditionalPattern;
+    private buildLoopPattern;
+}
+/**
+ * Default instance with Korean-optimized settings
+ */
+export declare const defaultTemplatePersonalizer: TemplatePersonalizer;
+/**
+ * Utility functions
+ */
+export declare const TemplateVariableUtils: {
+    /**
+     * Extract all variables from content
+     */
+    extractVariables: (content: string) => string[];
+    /**
+     * Replace variables in content
+     */
+    replace: (content: string, variables: TemplateVariableMap) => string;
+    /**
+     * Validate content has all required variables
+     */
+    validate: (content: string, variables: TemplateVariableMap) => boolean;
+    /**
+     * Create personalized content for multiple recipients
+     */
+    personalize: (content: string, recipients: Array<{
+        phoneNumber: string;
+        variables: TemplateVariableMap;
+    }>) => Array<{
+        phoneNumber: string;
+        content: string;
+        errors?: string[];
+    }>;
+};

package/dist/runtime/template-input.d.ts

@@ -0,0 +1,19 @@
+import { KMsgError, type Result } from "@k-msg/core";
+import type { TemplateButton } from "../types/template.types";
+type TemplatePayload = {
+    name?: unknown;
+    content?: unknown;
+    buttons?: unknown;
+};
+export type ValidateTemplatePayloadOptions = {
+    requireName?: boolean;
+    requireContent?: boolean;
+};
+export type NormalizedTemplatePayload = {
+    name?: string;
+    content?: string;
+    buttons?: TemplateButton[];
+};
+export declare function parseTemplateButtons(value: unknown): Result<TemplateButton[] | undefined, KMsgError>;
+export declare function validateTemplatePayload(payload: TemplatePayload, options?: ValidateTemplatePayloadOptions): Result<NormalizedTemplatePayload, KMsgError>;
+export {};

package/dist/{service.d.ts → runtime/template-lifecycle.service.d.ts}

@@ -1,7 +1,8 @@
-import { KMsgError, type Result, type Template, type TemplateContext, type TemplateCreateInput, type TemplateProvider, type TemplateUpdateInput } from "@k-msg/core";
-export declare class TemplateService {
+import { KMsgError, type Result, type Template, type TemplateContext, type TemplateCreateInput, type TemplateInspectionProvider, type TemplateProvider, type TemplateUpdateInput } from "@k-msg/core";
+export declare class TemplateLifecycleService {
     private readonly provider;
-    constructor(provider: TemplateProvider);
+    private readonly inspectionProvider?;
+    constructor(provider: TemplateProvider, inspectionProvider?: TemplateInspectionProvider);
     create(input: TemplateCreateInput, ctx?: TemplateContext): Promise<Result<Template, KMsgError>>;
     update(code: string, patch: TemplateUpdateInput, ctx?: TemplateContext): Promise<Result<Template, KMsgError>>;
     delete(code: string, ctx?: TemplateContext): Promise<Result<void, KMsgError>>;
@@ -11,4 +12,5 @@ export declare class TemplateService {
         page?: number;
         limit?: number;
     }, ctx?: TemplateContext): Promise<Result<Template[], KMsgError>>;
+    requestInspection(code: string, ctx?: TemplateContext): Promise<Result<void, KMsgError>>;
 }

package/dist/{services/template.service.d.ts → toolkit/in-memory-template-store.d.ts}

@@ -1,10 +1,10 @@
 import type { AlimTalkTemplate } from "../types/template.types";
-export declare class TemplateService {
+export declare class InMemoryTemplateStore {
     private templates;
     createTemplate(template: Omit<AlimTalkTemplate, "id" | "metadata">): Promise<AlimTalkTemplate>;
     getTemplate(templateId: string): Promise<AlimTalkTemplate | null>;
     updateTemplate(templateId: string, updates: Partial<AlimTalkTemplate>): Promise<AlimTalkTemplate>;
     deleteTemplate(templateId: string): Promise<void>;
-    renderTemplate(templateId: string, variables: Record<string, any>): Promise<string>;
+    renderTemplate(templateId: string, variables: Record<string, string | number | Date>): Promise<string>;
     private generateTemplateId;
 }

package/dist/toolkit/index.d.ts

@@ -0,0 +1,3 @@
+export { TemplateBuilder, TemplateBuilders } from "../builder/template.builder";
+export { type TemplateHistory, TemplateRegistry, type TemplateRegistryOptions, type TemplateSearchFilters, type TemplateSearchOptions, type TemplateSearchResult, type TemplateUsageStats, type TemplateVersion, } from "../registry/template.registry";
+export { InMemoryTemplateStore } from "./in-memory-template-store";