lingo.dev 0.113.6 → 0.113.8

package/build/cli.mjs

@@ -3637,39 +3637,320 @@ function parsePropertyLine(line) {
   };
 }
 
+// src/cli/loaders/xcode-strings/tokenizer.ts
+var Tokenizer = class {
+  input;
+  pos;
+  line;
+  column;
+  constructor(input2) {
+    this.input = input2;
+    this.pos = 0;
+    this.line = 1;
+    this.column = 1;
+  }
+  tokenize() {
+    const tokens = [];
+    while (this.pos < this.input.length) {
+      const char = this.current();
+      if (this.isWhitespace(char)) {
+        this.advance();
+        continue;
+      }
+      if (char === "/" && this.peek() === "/") {
+        tokens.push(this.scanSingleLineComment());
+        continue;
+      }
+      if (char === "/" && this.peek() === "*") {
+        tokens.push(this.scanMultiLineComment());
+        continue;
+      }
+      if (char === '"') {
+        tokens.push(this.scanString());
+        continue;
+      }
+      if (char === "=") {
+        tokens.push(this.makeToken("EQUALS" /* EQUALS */, "="));
+        this.advance();
+        continue;
+      }
+      if (char === ";") {
+        tokens.push(this.makeToken("SEMICOLON" /* SEMICOLON */, ";"));
+        this.advance();
+        continue;
+      }
+      this.advance();
+    }
+    tokens.push(this.makeToken("EOF" /* EOF */, ""));
+    return tokens;
+  }
+  scanString() {
+    const start = this.getPosition();
+    let value = "";
+    this.advance();
+    while (this.pos < this.input.length) {
+      const char = this.current();
+      if (char === "\\") {
+        this.advance();
+        if (this.pos < this.input.length) {
+          const nextChar = this.current();
+          value += "\\" + nextChar;
+          this.advance();
+        }
+        continue;
+      }
+      if (char === '"') {
+        this.advance();
+        return {
+          type: "STRING" /* STRING */,
+          value,
+          ...start
+        };
+      }
+      value += char;
+      this.advance();
+    }
+    return {
+      type: "STRING" /* STRING */,
+      value,
+      ...start
+    };
+  }
+  scanSingleLineComment() {
+    const start = this.getPosition();
+    let value = "";
+    this.advance();
+    this.advance();
+    while (this.pos < this.input.length && this.current() !== "\n") {
+      value += this.current();
+      this.advance();
+    }
+    return {
+      type: "COMMENT_SINGLE" /* COMMENT_SINGLE */,
+      value,
+      ...start
+    };
+  }
+  scanMultiLineComment() {
+    const start = this.getPosition();
+    let value = "";
+    this.advance();
+    this.advance();
+    while (this.pos < this.input.length) {
+      if (this.current() === "*" && this.peek() === "/") {
+        this.advance();
+        this.advance();
+        return {
+          type: "COMMENT_MULTI" /* COMMENT_MULTI */,
+          value,
+          ...start
+        };
+      }
+      value += this.current();
+      this.advance();
+    }
+    return {
+      type: "COMMENT_MULTI" /* COMMENT_MULTI */,
+      value,
+      ...start
+    };
+  }
+  current() {
+    return this.input[this.pos];
+  }
+  peek() {
+    if (this.pos + 1 < this.input.length) {
+      return this.input[this.pos + 1];
+    }
+    return null;
+  }
+  advance() {
+    if (this.pos < this.input.length) {
+      if (this.current() === "\n") {
+        this.line++;
+        this.column = 1;
+      } else {
+        this.column++;
+      }
+      this.pos++;
+    }
+  }
+  isWhitespace(char) {
+    return char === " " || char === "	" || char === "\n" || char === "\r";
+  }
+  getPosition() {
+    return {
+      line: this.line,
+      column: this.column
+    };
+  }
+  makeToken(type, value) {
+    return {
+      type,
+      value,
+      ...this.getPosition()
+    };
+  }
+};
+
+// src/cli/loaders/xcode-strings/escape.ts
+function unescapeString(raw) {
+  let result = "";
+  let i = 0;
+  while (i < raw.length) {
+    if (raw[i] === "\\" && i + 1 < raw.length) {
+      const nextChar = raw[i + 1];
+      switch (nextChar) {
+        case '"':
+          result += '"';
+          i += 2;
+          break;
+        case "\\":
+          result += "\\";
+          i += 2;
+          break;
+        case "n":
+          result += "\n";
+          i += 2;
+          break;
+        case "t":
+          result += "	";
+          i += 2;
+          break;
+        case "r":
+          result += "\r";
+          i += 2;
+          break;
+        default:
+          result += raw[i];
+          i++;
+          break;
+      }
+    } else {
+      result += raw[i];
+      i++;
+    }
+  }
+  return result;
+}
+function escapeString(str) {
+  if (str == null) {
+    return "";
+  }
+  let result = "";
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    switch (char) {
+      case "\\":
+        result += "\\\\";
+        break;
+      case '"':
+        result += '\\"';
+        break;
+      case "\n":
+        result += "\\n";
+        break;
+      case "\r":
+        result += "\\r";
+        break;
+      case "	":
+        result += "\\t";
+        break;
+      default:
+        result += char;
+        break;
+    }
+  }
+  return result;
+}
+
+// src/cli/loaders/xcode-strings/parser.ts
+var Parser = class {
+  tokens;
+  pos;
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.pos = 0;
+  }
+  parse() {
+    const result = {};
+    while (this.pos < this.tokens.length) {
+      const token = this.current();
+      if (token.type === "COMMENT_SINGLE" /* COMMENT_SINGLE */ || token.type === "COMMENT_MULTI" /* COMMENT_MULTI */) {
+        this.advance();
+        continue;
+      }
+      if (token.type === "EOF" /* EOF */) {
+        break;
+      }
+      if (token.type === "STRING" /* STRING */) {
+        const entry = this.parseEntry();
+        if (entry) {
+          result[entry.key] = entry.value;
+        }
+        continue;
+      }
+      this.advance();
+    }
+    return result;
+  }
+  parseEntry() {
+    const keyToken = this.current();
+    if (keyToken.type !== "STRING" /* STRING */) {
+      return null;
+    }
+    const key = keyToken.value;
+    this.advance();
+    if (!this.expect("EQUALS" /* EQUALS */)) {
+      return null;
+    }
+    const valueToken = this.current();
+    if (valueToken.type !== "STRING" /* STRING */) {
+      return null;
+    }
+    const rawValue = valueToken.value;
+    this.advance();
+    if (!this.expect("SEMICOLON" /* SEMICOLON */)) {
+    }
+    const value = unescapeString(rawValue);
+    return { key, value };
+  }
+  current() {
+    return this.tokens[this.pos];
+  }
+  advance() {
+    if (this.pos < this.tokens.length) {
+      this.pos++;
+    }
+  }
+  expect(type) {
+    if (this.current()?.type === type) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+};
+
 // src/cli/loaders/xcode-strings.ts
 function createXcodeStringsLoader() {
   return createLoader({
     async pull(locale, input2) {
-      const lines = input2.split("\n");
-      const result = {};
-      for (const line of lines) {
-        const trimmedLine = line.trim();
-        if (trimmedLine && !trimmedLine.startsWith("//")) {
-          const match2 = trimmedLine.match(/^"(.+)"\s*=\s*"(.+)";$/);
-          if (match2) {
-            const [, key, value] = match2;
-            result[key] = unescapeXcodeString(value);
-          }
-        }
-      }
+      const tokenizer = new Tokenizer(input2);
+      const tokens = tokenizer.tokenize();
+      const parser = new Parser(tokens);
+      const result = parser.parse();
       return result;
     },
     async push(locale, payload) {
-      const lines = Object.entries(payload).map(([key, value]) => {
-        const escapedValue = escapeXcodeString(value);
+      const lines = Object.entries(payload).filter(([_36, value]) => value != null).map(([key, value]) => {
+        const escapedValue = escapeString(value);
         return `"${key}" = "${escapedValue}";`;
       });
       return lines.join("\n");
     }
   });
 }
-function unescapeXcodeString(str) {
-  return str.replace(/\\"/g, '"').replace(/\\n/g, "\n").replace(/\\\\/g, "\\");
-}
-function escapeXcodeString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-}
 
 // src/cli/loaders/xcode-stringsdict.ts
 import plist from "plist";
@@ -13098,7 +13379,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.113.6",
+  version: "0.113.8",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {