intor-translator 1.4.15 → 1.5.0

package/README.md

@@ -7,17 +7,11 @@ The <a href="https://github.com/yiming-liao/intor">Intor</a> translation engine
 <div align="center">
 
 [![NPM version](https://img.shields.io/npm/v/intor-translator?style=flat&colorA=000000&colorB=000000)](https://www.npmjs.com/package/intor-translator)
-[![Coverage Status](https://img.shields.io/coveralls/github/yiming-liao/intor-translator.svg?branch=main&style=flat&colorA=000000&colorB=000000)](https://coveralls.io/github/yiming-liao/intor-translator?branch=main)
 [![TypeScript](https://img.shields.io/badge/TypeScript-%E2%9C%94-blue?style=flat&colorA=000000&colorB=000000)](https://www.typescriptlang.org/)
 [![License](https://img.shields.io/npm/l/intor-translator?style=flat&colorA=000000&colorB=000000)](LICENSE)
 
 </div>
 
-> [!NOTE]  
-> intor-translator is the execution core of the Intor ecosystem.  
-> It provides deterministic translation resolution and rendering,  
-> without coupling to routing, configuration systems, or frameworks.
-
 ## Features
 
 - **Modular Pipeline** – A pluggable, hook-driven flow for any translation logic.
@@ -37,12 +31,6 @@ yarn add intor-translator
 pnpm add intor-translator
 ```
 
-Or load it directly from a CDN:
-
-```js
-import { Translator } from "https://cdn.jsdelivr.net/npm/intor-translator/+esm";
-```
-
 ## Quick Start
 
 ```typescript
@@ -67,42 +55,24 @@ translator.t("greeting", { name: "John doe" }); // -> Hello, John doe!
 
 ## Handlers & Hooks
 
-Intor Translator is powered by **a flexible pipeline** that lets you control how translations behave and how they are rendered.
-
-### Handlers — format the final output
-
-<sup>_changing how translations look_.</sup>
+Intor Translator runs on an explicit, hook-driven pipeline.
 
-Handlers operate on the resolved message, use them to:
+**Ordered pipeline:**  
+ resolveLocales → findMessage → **_loading_** → **_missing_** → **_format_** → interpolate
 
-- format ICU messages
-- apply custom plural logic
-- post-process output
-- style or transform the final string
+### Handlers
 
-### Hooks — shape the translation flow
-
-<sup>_changing how translations work_.</sup>
-
-Hooks run through the pipeline and can intercept any stage, use them to:
-
-- transform keys or messages
-- adjust fallback behavior
-- implement loading or missing logic
-- attach metadata or analytics
-
-> Together, they form a customizable translation pipeline — structured, predictable, beautifully simple.
-
----
+Handlers override specific pipeline stages:
 
-## Rich Message Processing
+- loading
+- missing
+- formatting
 
-This module provides a semantic message processing flow for **_translated rich-formatted strings_**.
+### Hooks
 
-- Tokenize → AST → renderer-driven output
-- Environment-agnostic by design
+Hooks participate in the ordered pipeline and control how the translation process executes.
 
-Read the documentation: [Message Processing ↗](https://github.com/yiming-liao/intor-translator/tree/main/src/message)
+They allow external logic to extend or adjust the pipeline behavior.
 
 ---
 

package/dist/chunk-B5RTLRCS.js

@@ -0,0 +1,173 @@
+// src/message/tokenize/utils/extract-attributes.ts
+var ATTR_REGEX = /\s+([a-zA-Z_][a-zA-Z0-9_]*)="([^"]*)"/g;
+var extractAttributes = (input) => {
+  const attributes = {};
+  let match;
+  let consumed = "";
+  while (match = ATTR_REGEX.exec(input)) {
+    const key = match[1];
+    const value = match[2];
+    attributes[key] = value;
+    consumed += match[0];
+  }
+  if (consumed.length !== input.length) {
+    return null;
+  }
+  return attributes;
+};
+
+// src/message/tokenize/tokenize.ts
+var OPEN_TAG_REGEX = /^<([a-zA-Z0-9_]+)([^>]*)>/;
+var CLOSE_TAG_REGEX = /^<\/([a-zA-Z0-9_]+)>/;
+var tokenize = (message) => {
+  const tokens = [];
+  let pos = 0;
+  let buffer = "";
+  const flushText = () => {
+    if (!buffer) return;
+    tokens.push({
+      type: "text",
+      value: buffer,
+      position: pos - buffer.length
+    });
+    buffer = "";
+  };
+  while (pos < message.length) {
+    const char = message[pos];
+    if (char === "<") {
+      const openMatch = message.slice(pos).match(OPEN_TAG_REGEX);
+      if (openMatch) {
+        const name = openMatch[1];
+        const rawAttributes = openMatch[2];
+        const attributes = extractAttributes(rawAttributes);
+        if (attributes) {
+          flushText();
+          tokens.push({
+            type: "tag-open",
+            name,
+            attributes,
+            position: pos
+          });
+          pos += openMatch[0].length;
+          continue;
+        }
+      }
+      const closeMatch = message.slice(pos).match(CLOSE_TAG_REGEX);
+      if (closeMatch) {
+        const name = closeMatch[1];
+        flushText();
+        tokens.push({
+          type: "tag-close",
+          name,
+          position: pos
+        });
+        pos += closeMatch[0].length;
+        continue;
+      }
+    }
+    buffer += char;
+    pos += 1;
+  }
+  flushText();
+  return tokens;
+};
+
+// src/message/ast/build-ast.ts
+function buildAST(tokens) {
+  const root = [];
+  const stack = [];
+  const pushNode = (node) => {
+    const parent = stack.at(-1);
+    if (parent) {
+      parent.children.push(node);
+    } else {
+      root.push(node);
+    }
+  };
+  for (const token of tokens) {
+    switch (token.type) {
+      case "text": {
+        pushNode({
+          type: "text",
+          value: token.value
+        });
+        break;
+      }
+      case "tag-open": {
+        const node = {
+          type: "tag",
+          name: token.name,
+          attributes: token.attributes,
+          children: []
+        };
+        pushNode(node);
+        stack.push(node);
+        break;
+      }
+      case "tag-close": {
+        const last = stack.pop();
+        if (!last || last.name !== token.name) {
+          throw new Error(
+            `Unmatched closing tag </${token.name}> at position ${token.position}`
+          );
+        }
+        break;
+      }
+    }
+  }
+  if (stack.length > 0) {
+    throw new Error(`Unclosed tag detected: <${stack.at(-1)?.name}>`);
+  }
+  return root;
+}
+
+// src/message/parse-rich-message.ts
+function parseRichMessage(message) {
+  if (message == null) return [];
+  if (typeof message === "string") {
+    const tokens = tokenize(message);
+    return buildAST(tokens);
+  }
+  if (typeof message === "number" || typeof message === "boolean") {
+    const tokens = tokenize(String(message));
+    return buildAST(tokens);
+  }
+  if (Array.isArray(message)) {
+    return message.flatMap((m) => parseRichMessage(m));
+  }
+  return [
+    {
+      type: "raw",
+      value: message
+    }
+  ];
+}
+
+// src/message/render/render.ts
+function render(nodes, renderer) {
+  return nodes.map((node) => {
+    switch (node.type) {
+      // Plain text node
+      case "text": {
+        return renderer.text(node.value);
+      }
+      // Semantic tag node
+      case "tag": {
+        const children = render(node.children, renderer);
+        return renderer.tag(node.name, node.attributes, children);
+      }
+      // Raw message value
+      case "raw": {
+        return renderer.raw(node.value);
+      }
+    }
+  });
+}
+
+// src/message/render-rich-message.ts
+function renderRichMessage(message, renderer) {
+  const nodes = parseRichMessage(message);
+  return render(nodes, renderer);
+}
+
+export { renderRichMessage, tokenize };