lingo.dev 0.99.8 → 0.100.0

package/build/cli.cjs

@@ -4134,6 +4134,127 @@ function createIgnoredKeysLoader(ignoredKeys) {
   });
 }
 
+// src/cli/loaders/ejs.ts
+function parseEjsForTranslation(input2) {
+  const translatable = {};
+  let counter = 0;
+  const ejsTagRegex = /<%[\s\S]*?%>/g;
+  const parts = [];
+  let lastIndex = 0;
+  let match2;
+  while ((match2 = ejsTagRegex.exec(input2)) !== null) {
+    if (match2.index > lastIndex) {
+      parts.push({
+        type: "text",
+        content: input2.slice(lastIndex, match2.index)
+      });
+    }
+    parts.push({
+      type: "ejs",
+      content: match2[0]
+    });
+    lastIndex = match2.index + match2[0].length;
+  }
+  if (lastIndex < input2.length) {
+    parts.push({
+      type: "text",
+      content: input2.slice(lastIndex)
+    });
+  }
+  let template = "";
+  for (const part of parts) {
+    if (part.type === "ejs") {
+      template += part.content;
+    } else {
+      const textContent = part.content;
+      const htmlTagRegex = /<[^>]+>/g;
+      const textParts = [];
+      let lastTextIndex = 0;
+      let htmlMatch;
+      while ((htmlMatch = htmlTagRegex.exec(textContent)) !== null) {
+        if (htmlMatch.index > lastTextIndex) {
+          const textBefore = textContent.slice(lastTextIndex, htmlMatch.index);
+          if (textBefore.trim()) {
+            textParts.push({ type: "text", content: textBefore });
+          } else {
+            textParts.push({ type: "html", content: textBefore });
+          }
+        }
+        textParts.push({ type: "html", content: htmlMatch[0] });
+        lastTextIndex = htmlMatch.index + htmlMatch[0].length;
+      }
+      if (lastTextIndex < textContent.length) {
+        const remainingText = textContent.slice(lastTextIndex);
+        if (remainingText.trim()) {
+          textParts.push({ type: "text", content: remainingText });
+        } else {
+          textParts.push({ type: "html", content: remainingText });
+        }
+      }
+      if (textParts.length === 0) {
+        const trimmedContent = textContent.trim();
+        if (trimmedContent) {
+          textParts.push({ type: "text", content: textContent });
+        } else {
+          textParts.push({ type: "html", content: textContent });
+        }
+      }
+      for (const textPart of textParts) {
+        if (textPart.type === "text") {
+          const trimmedContent = textPart.content.trim();
+          if (trimmedContent) {
+            const key = `text_${counter++}`;
+            translatable[key] = trimmedContent;
+            template += textPart.content.replace(trimmedContent, `__LINGO_PLACEHOLDER_${key}__`);
+          } else {
+            template += textPart.content;
+          }
+        } else {
+          template += textPart.content;
+        }
+      }
+    }
+  }
+  return { content: template, translatable };
+}
+function reconstructEjsWithTranslation(template, translatable) {
+  let result = template;
+  for (const [key, value] of Object.entries(translatable)) {
+    const placeholder = `__LINGO_PLACEHOLDER_${key}__`;
+    result = result.replace(new RegExp(placeholder, "g"), value);
+  }
+  return result;
+}
+function createEjsLoader() {
+  return createLoader({
+    async pull(locale, input2) {
+      if (!input2 || input2.trim() === "") {
+        return {};
+      }
+      try {
+        const parseResult = parseEjsForTranslation(input2);
+        return parseResult.translatable;
+      } catch (error) {
+        console.warn("Warning: Could not parse EJS template, treating as plain text");
+        return { content: input2.trim() };
+      }
+    },
+    async push(locale, data, originalInput) {
+      if (!originalInput) {
+        return Object.values(data).join("\n");
+      }
+      try {
+        const parseResult = parseEjsForTranslation(originalInput);
+        const mergedTranslatable = { ...parseResult.translatable, ...data };
+        return reconstructEjsWithTranslation(parseResult.content, mergedTranslatable);
+      } catch (error) {
+        console.warn("Warning: Could not reconstruct EJS template, returning translated data");
+        return Object.values(data).join("\n");
+      }
+    }
+  });
+}
+
 // src/cli/loaders/index.ts
 function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys, lockedPatterns, ignoredKeys) {
   switch (bucketType) {
@@ -4172,6 +4293,16 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
           options.returnUnlocalizedKeys
         )
       );
+    case "ejs":
+      return composeLoaders(
+        createTextFileLoader(bucketPathPattern),
+        createEjsLoader(),
+        createSyncLoader(),
+        createUnlocalizableLoader(
+          options.isCacheRestore,
+          options.returnUnlocalizedKeys
+        )
+      );
     case "json":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
@@ -9127,7 +9258,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.99.8",
+  version: "0.100.0",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {
@@ -9257,6 +9388,7 @@ var package_default = {
     "@modelcontextprotocol/sdk": "^1.5.0",
     "@openrouter/ai-sdk-provider": "^0.7.1",
     "@paralleldrive/cuid2": "^2.2.2",
+    "@types/ejs": "^3.1.5",
     ai: "^4.3.15",
     bitbucket: "^2.12.0",
     chalk: "^5.4.1",
@@ -9269,6 +9401,7 @@ var package_default = {
     dedent: "^1.5.3",
     diff: "^7.0.0",
     dotenv: "^16.4.7",
+    ejs: "^3.1.10",
     express: "^5.1.0",
     "external-editor": "^3.1.0",
     figlet: "^1.8.0",