vbss-translator 1.1.1 → 2.0.0

package/dist/generator.js

@@ -1,360 +1,477 @@
-import { glob as y } from "glob";
-import { mkdir as v, writeFile as $, readFile as j } from "fs/promises";
-import { dirname as p, resolve as F, normalize as d, relative as P } from "path";
-async function T(n) {
+import { readdir as S, stat as x, mkdir as E, writeFile as O, readFile as D } from "fs/promises";
+import { isAbsolute as L, parse as C, resolve as w, join as d, dirname as b, normalize as j, relative as N } from "path";
+const R = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR", "EACCES", "EPERM"]), A = /* @__PURE__ */ new Set(["win32", "darwin"]), P = (t) => typeof t == "object" && t !== null && "code" in t && typeof t.code == "string" && R.has(t.code), v = async (t) => {
   try {
-    const r = await y(n, { cwd: process.cwd(), absolute: !1 }), t = process.cwd();
-    return r.map((e) => ({
-      path: F(t, e),
-      relativePath: d(e).replace(/\\/g, "/"),
+    return await S(t, { withFileTypes: !0 });
+  } catch (n) {
+    if (P(n)) return [];
+    throw n;
+  }
+}, F = async (t) => {
+  try {
+    return await x(t);
+  } catch (n) {
+    if (P(n)) return null;
+    throw n;
+  }
+}, I = (t) => t.replace(/[.*+?^${}()|[\]\\/-]/g, "\\$&"), G = (t) => t.replace(/[\\\][^]/g, "\\$&"), _ = (t, n) => {
+  const e = [];
+  let s = 0, a = n + 1;
+  for (let r = n; r < t.length; r++) {
+    const o = t[r];
+    if (o === "{")
+      s++;
+    else if (o === "}") {
+      if (s--, s === 0)
+        return e.push(t.slice(a, r)), { alternatives: e, end: r };
+    } else o === "," && s === 1 && (e.push(t.slice(a, r)), a = r + 1);
+  }
+  return { alternatives: e, end: -1 };
+}, $ = (t) => {
+  const n = t.indexOf("{");
+  if (n === -1) return [t];
+  const { alternatives: e, end: s } = _(t, n);
+  if (s === -1) return [t];
+  const a = t.slice(0, n), r = t.slice(s + 1);
+  if (e.length < 2) {
+    const o = t.slice(n, s + 1);
+    return $(r).map((u) => a + o + u);
+  }
+  return e.flatMap(
+    (o) => $(a + o + r)
+  );
+}, J = (t, n) => {
+  let e = "";
+  for (let s = 0; s < t.length; s++) {
+    const a = t[s];
+    if (a === "*")
+      e += "[^/]*";
+    else if (a === "?")
+      e += "[^/]";
+    else if (a === "[") {
+      const r = t.indexOf("]", s + 2);
+      if (r === -1)
+        e += "\\[";
+      else {
+        const o = t.slice(s + 1, r), u = o.startsWith("!") || o.startsWith("^");
+        e += `[${u ? "^" : ""}${G(
+          u ? o.slice(1) : o
+        )}]`, s = r;
+      }
+    } else
+      e += I(a);
+  }
+  return new RegExp(`^${e}$`, n ? "i" : "");
+}, M = (t, n) => {
+  var s;
+  const e = [];
+  for (const a of t)
+    a === "**" ? ((s = e[e.length - 1]) == null ? void 0 : s.kind) !== "globstar" && e.push({ kind: "globstar" }) : /[*?[]/.test(a) ? e.push({
+      kind: "pattern",
+      regexp: J(a, n),
+      matchesDotfiles: a.startsWith(".")
+    }) : e.push({ kind: "literal", text: a });
+  return e;
+}, T = async (t, n) => {
+  var e;
+  return n.isFile() ? !0 : n.isSymbolicLink() ? ((e = await F(d(t, n.name))) == null ? void 0 : e.isFile()) ?? !1 : !1;
+}, W = async (t, n) => {
+  var e;
+  return n.isDirectory() ? !0 : n.isSymbolicLink() ? ((e = await F(d(t, n.name))) == null ? void 0 : e.isDirectory()) ?? !1 : !1;
+};
+async function q(t, n) {
+  const e = A.has(process.platform), s = /* @__PURE__ */ new Set();
+  for (const a of $(t.replace(/\\/g, "/"))) {
+    const r = L(a) ? C(a).root : "", o = a.slice(r.length).split("/").filter((i) => i !== "" && i !== ".");
+    if (o.length === 0) continue;
+    const u = M(o, e), f = (i, h, c) => {
+      s.add(
+        r || n.absolute ? w(i, c) : [...h, c].join("/")
+      );
+    }, l = async (i, h, c) => {
+      const p = u[c], m = c === u.length - 1;
+      if (p.kind === "globstar") {
+        m || await l(i, h, c + 1);
+        for (const g of await v(i))
+          g.name.startsWith(".") || (g.isDirectory() ? await l(
+            d(i, g.name),
+            [...h, g.name],
+            c
+          ) : m && await T(i, g) && f(i, h, g.name));
+        return;
+      }
+      if (p.kind === "literal") {
+        const g = d(i, p.text), y = await F(g);
+        if (!y) return;
+        m ? y.isFile() && f(i, h, p.text) : y.isDirectory() && await l(g, [...h, p.text], c + 1);
+        return;
+      }
+      for (const g of await v(i))
+        p.regexp.test(g.name) && (g.name.startsWith(".") && !p.matchesDotfiles || (m ? await T(i, g) && f(i, h, g.name) : await W(i, g) && await l(
+          d(i, g.name),
+          [...h, g.name],
+          c + 1
+        )));
+    };
+    await l(r || w(n.cwd), [], 0);
+  }
+  return [...s].sort();
+}
+async function U(t) {
+  try {
+    const n = await q(t, {
+      cwd: process.cwd(),
+      absolute: !1
+    }), e = process.cwd();
+    return n.map((s) => ({
+      path: w(e, s),
+      relativePath: j(s).replace(/\\/g, "/"),
       translations: []
     }));
-  } catch (r) {
-    const t = r instanceof Error ? r.message : "Unknown error";
+  } catch (n) {
+    const e = n instanceof Error ? n.message : "Unknown error";
     return [
       {
         path: "",
         relativePath: "",
         translations: [],
         error: {
-          file: n,
-          message: `Failed to discover files: ${t}`,
+          file: t,
+          message: `Failed to discover files: ${e}`,
           type: "file_system"
         }
       }
     ];
   }
 }
-async function b(n) {
-  const r = n.map(async (t) => {
-    if (t.error)
-      return t;
+async function B(t) {
+  const n = t.map(async (e) => {
+    if (e.error)
+      return e;
     try {
-      const e = await j(t.path, "utf-8"), a = JSON.parse(e), o = [];
+      const s = await D(e.path, "utf-8"), a = JSON.parse(s), r = [];
       if (Array.isArray(a))
-        for (const s of a) {
-          if (typeof s != "object" || s === null)
+        for (const o of a) {
+          if (typeof o != "object" || o === null)
             return {
-              ...t,
+              ...e,
               translations: [],
               error: {
-                file: t.path,
+                file: e.path,
                 message: "Translation array must contain objects only",
                 type: "validation"
               }
             };
-          const c = {};
-          for (const [u, i] of Object.entries(s)) {
-            if (typeof i != "string")
+          const u = {};
+          for (const [f, l] of Object.entries(o)) {
+            if (typeof l != "string")
               return {
-                ...t,
+                ...e,
                 translations: [],
                 error: {
-                  file: t.path,
-                  message: `Translation value for key "${u}" must be a string, got ${typeof i}`,
+                  file: e.path,
+                  message: `Translation value for key "${f}" must be a string, got ${typeof l}`,
                   type: "validation"
                 }
               };
-            c[u] = i;
+            u[f] = l;
           }
-          o.push(c);
+          r.push(u);
         }
       else if (typeof a == "object" && a !== null) {
-        const s = {};
-        for (const [c, u] of Object.entries(a)) {
-          if (typeof u != "string")
+        const o = {};
+        for (const [u, f] of Object.entries(a)) {
+          if (typeof f != "string")
             return {
-              ...t,
+              ...e,
               translations: [],
               error: {
-                file: t.path,
-                message: `Translation value for key "${c}" must be a string, got ${typeof u}`,
+                file: e.path,
+                message: `Translation value for key "${u}" must be a string, got ${typeof f}`,
                 type: "validation"
               }
             };
-          s[c] = u;
+          o[u] = f;
         }
-        return o.push(s), {
-          ...t,
-          translations: o,
+        return r.push(o), {
+          ...e,
+          translations: r,
           wasSingleObject: !0
         };
       } else
         return {
-          ...t,
+          ...e,
           translations: [],
           error: {
-            file: t.path,
+            file: e.path,
             message: "Translation file must contain a JSON object or array of objects",
             type: "validation"
           }
         };
       return {
-        ...t,
-        translations: o
+        ...e,
+        translations: r
       };
-    } catch (e) {
-      if (e instanceof SyntaxError)
+    } catch (s) {
+      if (s instanceof SyntaxError)
         return {
-          ...t,
+          ...e,
           translations: [],
           error: {
-            file: t.path,
-            message: `Invalid JSON: ${e.message}`,
+            file: e.path,
+            message: `Invalid JSON: ${s.message}`,
             type: "invalid_json"
           }
         };
-      const a = e instanceof Error ? e.message : "Unknown error";
+      const a = s instanceof Error ? s.message : "Unknown error";
       return {
-        ...t,
+        ...e,
         translations: [],
         error: {
-          file: t.path,
+          file: e.path,
           message: `Failed to read file: ${a}`,
           type: "file_system"
         }
       };
     }
   });
-  return Promise.all(r);
+  return Promise.all(n);
 }
-function w(n) {
-  for (const r of n)
-    if (!r.error && r.translations.length > 0)
-      return Object.keys(r.translations[0]);
+function V(t) {
+  for (const n of t)
+    if (!n.error && n.translations.length > 0)
+      return Object.keys(n.translations[0]);
   return null;
 }
-function k(n, r) {
-  const t = [];
-  for (const e of n) {
-    if (e.error)
+function z(t, n) {
+  const e = [];
+  for (const s of t) {
+    if (s.error)
       continue;
-    if (e.translations.length === 0) {
-      t.push({
-        file: e.path,
+    if (s.translations.length === 0) {
+      e.push({
+        file: s.path,
         message: "File has no translations",
         type: "validation"
       });
       continue;
     }
-    const a = Object.keys(e.translations[0]);
-    for (let i = 1; i < e.translations.length; i++) {
-      const f = Object.keys(e.translations[i]);
-      if (JSON.stringify([...f].sort()) !== JSON.stringify([...a].sort())) {
-        t.push({
-          file: e.path,
-          message: `Translation ${i + 1} in file has different language keys`,
+    const a = Object.keys(s.translations[0]);
+    for (let l = 1; l < s.translations.length; l++) {
+      const i = Object.keys(s.translations[l]);
+      if (JSON.stringify([...i].sort()) !== JSON.stringify([...a].sort())) {
+        e.push({
+          file: s.path,
+          message: `Translation ${l + 1} in file has different language keys`,
           type: "validation"
         });
         continue;
       }
     }
-    const o = [...a].sort(), s = [...r].sort(), c = s.filter(
-      (i) => !o.includes(i)
-    ), u = o.filter(
-      (i) => !s.includes(i)
+    const r = [...a].sort(), o = [...n].sort(), u = o.filter(
+      (l) => !r.includes(l)
+    ), f = r.filter(
+      (l) => !o.includes(l)
     );
-    if (c.length > 0 || u.length > 0) {
-      const i = [];
-      c.length > 0 && i.push(`missing languages: ${c.join(", ")}`), u.length > 0 && i.push(`extra languages: ${u.join(", ")}`), t.push({
-        file: e.path,
-        message: `Language mismatch: ${i.join(
+    if (u.length > 0 || f.length > 0) {
+      const l = [];
+      u.length > 0 && l.push(`missing languages: ${u.join(", ")}`), f.length > 0 && l.push(`extra languages: ${f.join(", ")}`), e.push({
+        file: s.path,
+        message: `Language mismatch: ${l.join(
           ", "
-        )}. Expected: ${r.join(", ")}`,
+        )}. Expected: ${n.join(", ")}`,
         type: "missing_languages"
       });
     }
   }
-  return t;
+  return e;
 }
-function O(n, r) {
-  const t = /* @__PURE__ */ new Set(), e = [];
-  for (const a of n) {
-    const o = a[r];
-    if (o === void 0) {
-      e.push(a);
+function X(t, n) {
+  const e = /* @__PURE__ */ new Set(), s = [];
+  for (const a of t) {
+    const r = a[n];
+    if (r === void 0) {
+      s.push(a);
       continue;
     }
-    const s = o;
-    t.has(s) || (t.add(s), e.push(a));
+    const o = r;
+    e.has(o) || (e.add(o), s.push(a));
   }
-  return e;
+  return s;
 }
-function S(n, r) {
-  const t = p(n);
-  let a = P(t, r);
-  return a = d(a).replace(/\\/g, "/"), a.startsWith(".") || (a = "./" + a), a;
+function H(t, n) {
+  const e = b(t);
+  let a = N(e, n);
+  return a = j(a).replace(/\\/g, "/"), a.startsWith(".") || (a = "./" + a), a;
 }
-function m(n, r, t) {
-  const e = n.filter((f) => !f.error && f.translations.length > 0).sort((f, g) => f.path.localeCompare(g.path));
-  if (e.length === 0)
+function k(t, n, e) {
+  const s = t.filter((i) => !i.error && i.translations.length > 0).sort((i, h) => i.path.localeCompare(h.path));
+  if (s.length === 0)
     return `export default []
 `;
-  const a = e.map((f, g) => {
-    const l = S(r, f.path);
-    return `import translations${g} from '${l}' assert { type: 'json' };`;
+  const a = s.map((i, h) => {
+    const c = H(n, i.path);
+    return `import translations${h} from '${c}' assert { type: 'json' };`;
   }).join(`
-`), o = e.map((f, g) => f.wasSingleObject ? `  ...(Array.isArray(translations${g}) ? translations${g} : [translations${g}])` : `  ...translations${g}`).join(`,
-`), c = `export interface Translation {
-${t.map((f) => `  ${f}: string;`).join(`
+`), r = s.map((i, h) => i.wasSingleObject ? `  ...(Array.isArray(translations${h}) ? translations${h} : [translations${h}])` : `  ...translations${h}`).join(`,
+`), u = `export interface Translation {
+${e.map((i) => `  ${i}: string;`).join(`
 `)}
   [key: string]: string;
-}`, u = t[0] || "en", i = e.length > 0 ? `
+}`, f = e[0] || "en", l = s.length > 0 ? `
 const uniqueTranslations = allTranslations.filter(
-  (translation, index, self) => index === self.findIndex((t) => t.${u} === translation.${u})
+  (translation, index, self) => index === self.findIndex((t) => t.${f} === translation.${f})
 );` : "";
   return `${a}
 
-${c}
+${u}
 
 const allTranslations: Translation[] = [
-${o}
-];${i}
+${r}
+];${l}
 
 export default uniqueTranslations;
 `;
 }
-function x(n) {
-  const r = n.filter((s) => !s.error && s.translations.length > 0).sort((s, c) => s.path.localeCompare(c.path));
-  if (r.length === 0)
+function K(t) {
+  const n = t.filter((o) => !o.error && o.translations.length > 0).sort((o, u) => o.path.localeCompare(u.path));
+  if (n.length === 0)
     return `export default []
 `;
-  const t = [];
-  for (const s of r)
-    s.wasSingleObject && s.translations.length === 1 ? t.push(s.translations[0]) : t.push(...s.translations);
-  const e = t.length > 0 ? Object.keys(t[0])[0] : "en", a = t.map((s) => JSON.stringify(s, null, 2).split(`
-`).map((i) => `  ${i}`).join(`
+  const e = [];
+  for (const o of n)
+    o.wasSingleObject && o.translations.length === 1 ? e.push(o.translations[0]) : e.push(...o.translations);
+  const s = e.length > 0 ? Object.keys(e[0])[0] : "en", a = e.map((o) => JSON.stringify(o, null, 2).split(`
+`).map((l) => `  ${l}`).join(`
 `)).join(`,
-`), o = `
+`), r = `
 const uniqueTranslations = allTranslations.filter(
-  (translation, index, self) => index === self.findIndex((t) => t.${e} === translation.${e})
+  (translation, index, self) => index === self.findIndex((t) => t.${s} === translation.${s})
 );`;
   return `const allTranslations = [
 ${a}
-];${o}
+];${r}
 
 export default uniqueTranslations;
 `;
 }
-function L(n, r, t) {
-  return m(n, r, t);
+function Q(t, n, e) {
+  return k(t, n, e);
 }
-async function N(n) {
-  const r = [], t = Date.now(), e = await T(n.pattern);
-  if (e.length === 0)
+async function tt(t) {
+  const n = [], e = Date.now(), s = await U(t.pattern);
+  if (s.length === 0)
     return {
       success: !0,
       filesFound: 0,
       translationsGenerated: 0,
       errors: [],
-      outputPath: n.outputPath
+      outputPath: t.outputPath
     };
-  for (const l of e)
-    l.error && r.push(l.error);
-  const a = await b(e);
-  for (const l of a)
-    l.error && r.push(l.error);
-  const o = w(a);
-  if ((!o || o.length === 0) && a.filter(
-    (h) => !h.error && h.translations.length > 0
+  const a = await B(s);
+  for (const c of a)
+    c.error && n.push(c.error);
+  const r = V(a);
+  if ((!r || r.length === 0) && a.filter(
+    (p) => !p.error && p.translations.length > 0
   ).length === 0)
     return {
       success: !1,
-      filesFound: e.length,
+      filesFound: s.length,
       translationsGenerated: 0,
-      errors: r.length > 0 ? r : [
+      errors: n.length > 0 ? n : [
         {
-          file: n.pattern,
+          file: t.pattern,
           message: "No valid translation files found",
           type: "validation"
         }
       ],
-      outputPath: n.outputPath
+      outputPath: t.outputPath
     };
-  if (o && o.length > 0) {
-    const l = k(a, o);
-    if (r.push(...l), l.length > 0)
+  if (r && r.length > 0) {
+    const c = z(a, r);
+    if (n.push(...c), c.length > 0)
       return {
         success: !1,
-        filesFound: e.length,
+        filesFound: s.length,
         translationsGenerated: 0,
-        errors: r,
-        outputPath: n.outputPath
+        errors: n,
+        outputPath: t.outputPath
       };
   }
-  const s = [];
-  for (const l of a)
-    !l.error && l.translations.length > 0 && s.push(...l.translations);
-  const c = n.referenceLanguage || (o == null ? void 0 : o[0]) || "en", u = O(
-    s,
-    c
+  const o = [];
+  for (const c of a)
+    !c.error && c.translations.length > 0 && o.push(...c.translations);
+  const u = t.referenceLanguage || (r == null ? void 0 : r[0]) || "en", f = X(
+    o,
+    u
   );
-  let i;
-  const f = a.filter(
-    (l) => !l.error && l.translations.length > 0
+  let l;
+  const i = a.filter(
+    (c) => !c.error && c.translations.length > 0
   );
-  switch (n.outputFormat) {
+  switch (t.outputFormat) {
     case "ts":
-      i = m(
-        f,
-        n.outputPath,
-        o || []
+      l = k(
+        i,
+        t.outputPath,
+        r || []
       );
       break;
     case "tsx":
-      i = L(
-        f,
-        n.outputPath,
-        o || []
+      l = Q(
+        i,
+        t.outputPath,
+        r || []
       );
       break;
     case "js":
-      i = x(f);
+      l = K(i);
       break;
     default:
       return {
         success: !1,
-        filesFound: e.length,
+        filesFound: s.length,
         translationsGenerated: 0,
         errors: [
-          ...r,
+          ...n,
           {
-            file: n.outputPath,
-            message: `Unsupported output format: ${n.outputFormat}`,
+            file: t.outputPath,
+            message: `Unsupported output format: ${t.outputFormat}`,
             type: "validation"
           }
         ],
-        outputPath: n.outputPath
+        outputPath: t.outputPath
       };
   }
   try {
-    const l = p(n.outputPath);
-    await v(l, { recursive: !0 }), await $(n.outputPath, i, "utf-8");
-  } catch (l) {
-    const h = l instanceof Error ? l.message : "Unknown error";
-    return r.push({
-      file: n.outputPath,
-      message: `Failed to write output file: ${h}`,
+    const c = b(t.outputPath);
+    await E(c, { recursive: !0 }), await O(t.outputPath, l, "utf-8");
+  } catch (c) {
+    const p = c instanceof Error ? c.message : "Unknown error";
+    return n.push({
+      file: t.outputPath,
+      message: `Failed to write output file: ${p}`,
       type: "file_system"
     }), {
       success: !1,
-      filesFound: e.length,
-      translationsGenerated: u.length,
-      errors: r,
-      outputPath: n.outputPath
+      filesFound: s.length,
+      translationsGenerated: f.length,
+      errors: n,
+      outputPath: t.outputPath
     };
   }
-  const g = Date.now() - t;
-  return g > 1e3 && e.length < 100 && console.warn(
-    `⚠️  Generation took ${g}ms for ${e.length} files`
+  const h = Date.now() - e;
+  return h > 1e3 && s.length < 100 && console.warn(
+    `⚠️  Generation took ${h}ms for ${s.length} files`
   ), {
-    success: r.length === 0,
-    filesFound: e.length,
-    translationsGenerated: u.length,
-    errors: r,
-    outputPath: n.outputPath
+    success: n.length === 0,
+    filesFound: s.length,
+    translationsGenerated: f.length,
+    errors: n,
+    outputPath: t.outputPath
   };
 }
 export {
-  N as generate
+  tt as generate
 };