feat: tagged template

Author: wan2land

deno.json

@@ -12,6 +12,7 @@
   },
   "imports": {
     "@deno/dnt": "jsr:@deno/dnt@^0.41.1",
+    "@kokr/text": "npm:@kokr/text@^0.4.1",
     "@std/assert": "jsr:@std/assert@^0.222.1",
     "@std/fmt": "jsr:@std/fmt@^0.222.1",
     "@std/testing": "jsr:@std/testing@^0.222.1"

formatter.test.ts

@@ -1,4 +1,5 @@
 import { assertEquals } from "@std/assert/assert-equals";
+import { text } from "@kokr/text";
 import { Formatter } from "./formatter.ts";
 
 Deno.test("formatter, plural", () => {
@@ -36,6 +37,7 @@ Deno.test("formatter, plural", () => {
     const formatter = new Formatter({
       locale: "ko",
       messages: messages.ko,
+      taggedTemplate: text,
     });
 
     assertEquals(

formatter.ts

@@ -1,20 +1,29 @@
 import { Interpreter } from "./interpreter.ts";
 import { defaultHooks } from "./plugins/default.ts";
-import type { FormatParameters, Hook, Runtime } from "./types.ts";
+import type {
+  FormatParameters,
+  Hook,
+  Runtime,
+  TaggedTemplateHandler,
+} from "./types.ts";
 
 export interface FormatterOptions<Messages extends Record<string, string>> {
   locale?: string;
   messages?: Messages;
   hooks?: Record<string, Hook>;
+  taggedTemplate?: TaggedTemplateHandler;
 }
 
 export class Formatter<Messages extends Record<string, string>> {
   readonly runtime: Runtime;
   readonly messages: Messages;
   constructor({ messages, ...options }: FormatterOptions<Messages>) {
     this.runtime = new Interpreter(
-      options.hooks ?? defaultHooks,
-      options.locale,
+      {
+        locale: options.locale,
+        hooks: options.hooks ?? defaultHooks,
+        taggedTemplate: options.taggedTemplate,
+      },
     );
     this.messages = messages ?? {} as Messages;
   }

interpreter.test.ts

@@ -32,8 +32,10 @@ Deno.test("interpreter, basic template value", () => {
 
 Deno.test("interpreter, template value with method", () => {
   const runtime = new Interpreter({
-    upper: (source, _, ctx) => `${ctx.out ?? source}`.toUpperCase(),
-    trim: (source, _, ctx) => `${ctx.out ?? source}`.trim(),
+    hooks: {
+      upper: (source, _, ctx) => `${ctx.out ?? source}`.toUpperCase(),
+      trim: (source, _, ctx) => `${ctx.out ?? source}`.trim(),
+    },
   });
 
   assertEquals(
@@ -85,7 +87,7 @@ Deno.test("interpreter, template value with method", () => {
 });
 
 Deno.test("interpreter, template with method that returns template", () => {
-  const runtime = new Interpreter(defaultHooks);
+  const runtime = new Interpreter({ hooks: defaultHooks });
 
   assertEquals(
     runtime.executeAst([

interpreter.ts

@@ -8,16 +8,38 @@ import type {
   HookInfo,
   PrimitiveType,
   Runtime,
+  TaggedTemplateHandler,
 } from "./types.ts";
 
+export interface InterpreterOptions {
+  locale?: string | null;
+  hooks?: Record<string, Hook>;
+  taggedTemplate?: TaggedTemplateHandler;
+}
+
+function defaultTaggedTemplateHandler(
+  strings: TemplateStringsArray,
+  ...args: unknown[]
+): string {
+  return strings.reduce((carry, string, index) => {
+    if (index > 0) {
+      carry += args[index - 1];
+    }
+    return carry + string;
+  });
+}
+
 export class Interpreter implements Runtime {
   _cache: Map<string, AstTemplate> = new Map();
   _decorator: (source: PrimitiveType) => unknown;
+  _taggedTemplate: TaggedTemplateHandler;
 
-  constructor(hooks: Record<string, Hook>, locale?: string | null) {
-    this._decorator = createDecorator(hooks, {
-      locale: locale ?? null,
+  constructor(options: InterpreterOptions = {}) {
+    this._decorator = createDecorator(options.hooks ?? {}, {
+      locale: options.locale ?? null,
     });
+    this._taggedTemplate = options.taggedTemplate ??
+      defaultTaggedTemplateHandler;
   }
 
   execute(text: string, parameters: FormatParameters): string {
@@ -31,38 +53,38 @@ export class Interpreter implements Runtime {
 
   executeAst(ast: AstTemplate, parameters: FormatParameters): string {
     const [strings, values] = ast;
-    let result = strings[0] ?? "";
-    values.forEach(([valueName, methods], valueIndex) => {
-      const self = parameters[valueName];
+    return this._taggedTemplate(
+      Object.assign(strings, { raw: strings }),
+      ...values.map(([valueName, methods]) => {
+        const self = parameters[valueName];
 
-      let value = this._decorator(self);
-      for (const [methodName, methodArgs] of methods) {
-        const method = getSafeMethod(value, methodName);
-        if (method) {
-          value = method(
-            ...methodArgs.map((methodArg) => {
-              switch (methodArg[0]) {
-                case 2:
-                  return methodArg[1];
-                case 3:
-                  return methodArg[1];
-                case 4:
-                  return () =>
-                    this.executeAst(methodArg[1], { _: self, ...parameters });
-                default:
-                  throw new Error(
-                    `Unknown method argument type: ${methodArg[0]}`,
-                  );
-              }
-            }),
-          );
+        let value = this._decorator(self);
+        for (const [methodName, methodArgs] of methods) {
+          const method = getSafeMethod(value, methodName);
+          if (method) {
+            value = method(
+              ...methodArgs.map((methodArg) => {
+                switch (methodArg[0]) {
+                  case 2:
+                    return methodArg[1];
+                  case 3:
+                    return methodArg[1];
+                  case 4:
+                    return () =>
+                      this.executeAst(methodArg[1], { _: self, ...parameters });
+                  default:
+                    throw new Error(
+                      `Unknown method argument type: ${methodArg[0]}`,
+                    );
+                }
+              }),
+            );
+          }
         }
-      }
 
-      result += value && value.toString ? value.toString() : (value ?? "");
-      result += strings[valueIndex + 1] ?? "";
-    });
-    return result;
+        return value && value.toString ? value.toString() : (value ?? "");
+      }),
+    );
   }
 }
 

types.ts

@@ -25,3 +25,8 @@ export type Hook = (
   ctx: HookContext,
   info: HookInfo,
 ) => string | null;
+
+export type TaggedTemplateHandler = (
+  strings: TemplateStringsArray,
+  ...args: unknown[]
+) => string;