@typia/utils 12.0.0-dev.20260307-2 → 12.0.0-dev.20260309

package/src/utils/internal/parseLenientJson.ts

@@ -1,5 +1,122 @@
 import { DeepPartial, IJsonParseResult } from "@typia/interface";
 
+/**
+ * Parse lenient JSON that may be incomplete or malformed.
+ *
+ * Handles:
+ *
+ * - Unclosed brackets `{`, `[` - parses as much as possible
+ * - Trailing commas `[1, 2, ]` - ignores them
+ * - Unclosed strings `"hello` - returns partial string
+ * - Junk text before JSON (LLM often adds explanatory text)
+ * - Markdown code blocks (extracts content from `json ... `)
+ * - Incomplete keywords like `tru`, `fal`, `nul`
+ * - Unicode escape sequences including surrogate pairs (emoji)
+ * - JavaScript-style comments (single-line and multi-line)
+ * - Unquoted object keys (JavaScript identifier style)
+ *
+ * @param input Raw JSON string (potentially incomplete)
+ * @returns Parse result with data, original input, and any errors
+ * @internal
+ */
+export function parseLenientJson<T>(input: string): IJsonParseResult<T> {
+  // Try native JSON.parse first (faster for valid JSON)
+  try {
+    return {
+      success: true,
+      data: JSON.parse(input) as T,
+    };
+  } catch {
+    // Fall back to lenient parser
+  }
+
+  // Extract markdown code block if present
+  const codeBlockContent: string | null = extractMarkdownCodeBlock(input);
+  const jsonSource: string =
+    codeBlockContent !== null ? codeBlockContent : input;
+
+  // Check if input is empty or whitespace-only
+  const trimmed: string = jsonSource.trim();
+  if (trimmed.length === 0) {
+    return {
+      success: false,
+      data: undefined as DeepPartial<T>,
+      input,
+      errors: [
+        {
+          path: "$input",
+          expected: "JSON value",
+          value: "empty input",
+        },
+      ],
+    };
+  }
+
+  // Check if input starts with a primitive value (no junk prefix skipping needed)
+  if (startsWithPrimitive(trimmed)) {
+    const errors: IJsonParseResult.IError[] = [];
+    const parser: LenientJsonParser = new LenientJsonParser(jsonSource, errors);
+    const data: unknown = parser.parse();
+    if (errors.length > 0) {
+      return { success: false, data: data as DeepPartial<T>, input, errors };
+    }
+    return { success: true, data: data as T };
+  }
+
+  // Find JSON start position (skip junk prefix from LLM)
+  const jsonStart: number = findJsonStart(jsonSource);
+  if (jsonStart === -1) {
+    // No object/array found - check if there's a primitive after skipping comments
+    const skipped: string = skipCommentsAndWhitespace(jsonSource);
+    if (skipped.length > 0 && startsWithPrimitive(skipped)) {
+      const errors: IJsonParseResult.IError[] = [];
+      const parser: LenientJsonParser = new LenientJsonParser(
+        jsonSource,
+        errors,
+      );
+      const data: unknown = parser.parse();
+      if (errors.length > 0) {
+        return { success: false, data: data as DeepPartial<T>, input, errors };
+      }
+      return { success: true, data: data as T };
+    }
+    // No valid JSON found - return failure
+    return {
+      success: false,
+      data: undefined as DeepPartial<T>,
+      input,
+      errors: [
+        {
+          path: "$input",
+          expected: "JSON value",
+          value: jsonSource,
+        },
+      ],
+    };
+  }
+
+  // Extract JSON portion (skip junk prefix)
+  const jsonInput: string =
+    jsonStart > 0 ? jsonSource.slice(jsonStart) : jsonSource;
+
+  const errors: IJsonParseResult.IError[] = [];
+  const parser: LenientJsonParser = new LenientJsonParser(jsonInput, errors);
+  const data: unknown = parser.parse();
+
+  if (errors.length > 0) {
+    return {
+      success: false,
+      data: data as DeepPartial<T>,
+      input,
+      errors,
+    };
+  }
+  return {
+    success: true,
+    data: data as T,
+  };
+}
+
 /**
  * Maximum nesting depth to prevent stack overflow attacks.
  *
@@ -88,21 +205,126 @@ function extractMarkdownCodeBlock(input: string): string | null {
  * - "Here is your JSON: {"name": "test"}"
  * - "Sure! [1, 2, 3]"
  *
- * This function only looks for `{` or `[` to skip junk prefix. Primitive values
- * (strings, numbers, booleans) are handled directly by the parser.
+ * This function skips over comments and strings to find the real JSON start.
+ * Primitive values (strings, numbers, booleans) are handled directly by the
+ * parser.
  *
  * @param input Text that may contain JSON with junk prefix
- * @returns Index of first `{` or `[`, or -1 if not found
+ * @returns Index of first `{` or `[` outside comments/strings, or -1 if not
+ *   found
  * @internal
  */
 function findJsonStart(input: string): number {
-  const objStart: number = input.indexOf("{");
-  const arrStart: number = input.indexOf("[");
+  let pos: number = 0;
+  const len: number = input.length;
+
+  while (pos < len) {
+    const ch: string = input[pos]!;
+
+    // Found JSON start
+    if (ch === "{" || ch === "[") {
+      return pos;
+    }
+
+    // Skip single-line comment
+    if (ch === "/" && pos + 1 < len && input[pos + 1] === "/") {
+      pos += 2;
+      while (pos < len && input[pos] !== "\n" && input[pos] !== "\r") {
+        pos++;
+      }
+      continue;
+    }
+
+    // Skip multi-line comment
+    if (ch === "/" && pos + 1 < len && input[pos + 1] === "*") {
+      pos += 2;
+      while (pos + 1 < len) {
+        if (input[pos] === "*" && input[pos + 1] === "/") {
+          pos += 2;
+          break;
+        }
+        pos++;
+      }
+      // If unclosed comment, move to end
+      if (pos + 1 >= len) {
+        pos = len;
+      }
+      continue;
+    }
+
+    // Skip string literal (to avoid matching { or [ inside strings)
+    if (ch === '"') {
+      pos++;
+      while (pos < len) {
+        if (input[pos] === "\\") {
+          pos += 2; // skip escape sequence
+          continue;
+        }
+        if (input[pos] === '"') {
+          pos++;
+          break;
+        }
+        pos++;
+      }
+      continue;
+    }
+
+    pos++;
+  }
+
+  return -1;
+}
+
+/**
+ * Skip leading comments and whitespace from input.
+ *
+ * @param input Text that may start with comments or whitespace
+ * @returns Input with leading comments and whitespace removed
+ * @internal
+ */
+function skipCommentsAndWhitespace(input: string): string {
+  let pos: number = 0;
+  const len: number = input.length;
 
-  if (objStart === -1 && arrStart === -1) return -1;
-  if (objStart === -1) return arrStart;
-  if (arrStart === -1) return objStart;
-  return Math.min(objStart, arrStart);
+  while (pos < len) {
+    const ch: string = input[pos]!;
+
+    // Skip whitespace
+    if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") {
+      pos++;
+      continue;
+    }
+
+    // Skip single-line comment
+    if (ch === "/" && pos + 1 < len && input[pos + 1] === "/") {
+      pos += 2;
+      while (pos < len && input[pos] !== "\n" && input[pos] !== "\r") {
+        pos++;
+      }
+      continue;
+    }
+
+    // Skip multi-line comment
+    if (ch === "/" && pos + 1 < len && input[pos + 1] === "*") {
+      pos += 2;
+      while (pos + 1 < len) {
+        if (input[pos] === "*" && input[pos + 1] === "/") {
+          pos += 2;
+          break;
+        }
+        pos++;
+      }
+      if (pos + 1 >= len) {
+        pos = len;
+      }
+      continue;
+    }
+
+    // Not whitespace or comment
+    break;
+  }
+
+  return input.slice(pos);
 }
 
 /**
@@ -126,106 +348,26 @@ function startsWithPrimitive(input: string): boolean {
     input.startsWith("null")
   )
     return true;
-  // Partial keywords
+  // Partial keywords (note: "null" requires at least 2 chars to match parseKeywordOrIdentifier logic)
   if (
     "true".startsWith(input) ||
     "false".startsWith(input) ||
-    "null".startsWith(input)
+    ("null".startsWith(input) && input.length >= 2)
+  )
+    return true;
+  // Boolean string variants (note: "n" is intentionally excluded)
+  const lower: string = input.toLowerCase();
+  if (
+    lower === "yes" ||
+    lower === "y" ||
+    lower === "on" ||
+    lower === "no" ||
+    lower === "off"
   )
     return true;
   return false;
 }
 
-/**
- * Parse lenient JSON that may be incomplete or malformed.
- *
- * Handles:
- *
- * - Unclosed brackets `{`, `[` - parses as much as possible
- * - Trailing commas `[1, 2, ]` - ignores them
- * - Unclosed strings `"hello` - returns partial string
- * - Junk text before JSON (LLM often adds explanatory text)
- * - Markdown code blocks (extracts content from `json ... `)
- * - Incomplete keywords like `tru`, `fal`, `nul`
- * - Unicode escape sequences including surrogate pairs (emoji)
- * - JavaScript-style comments (single-line and multi-line)
- * - Unquoted object keys (JavaScript identifier style)
- *
- * @param input Raw JSON string (potentially incomplete)
- * @returns Parse result with data, original input, and any errors
- * @internal
- */
-export function parseLenientJson<T>(input: string): IJsonParseResult<T> {
-  // Try native JSON.parse first (faster for valid JSON)
-  try {
-    return {
-      success: true,
-      data: JSON.parse(input) as T,
-    };
-  } catch {
-    // Fall back to lenient parser
-  }
-
-  // Extract markdown code block if present
-  const codeBlockContent: string | null = extractMarkdownCodeBlock(input);
-  const jsonSource: string =
-    codeBlockContent !== null ? codeBlockContent : input;
-
-  // Check if input is empty or whitespace-only
-  const trimmed: string = jsonSource.trim();
-  if (trimmed.length === 0) {
-    const errors: IJsonParseResult.IError[] = [];
-    const parser: LenientJsonParser = new LenientJsonParser(jsonSource, errors);
-    const data: unknown = parser.parse();
-    if (errors.length > 0) {
-      return { success: false, data: data as DeepPartial<T>, input, errors };
-    }
-    return { success: true, data: data as T };
-  }
-
-  // Check if input starts with a primitive value (no junk prefix skipping needed)
-  if (startsWithPrimitive(trimmed)) {
-    const errors: IJsonParseResult.IError[] = [];
-    const parser: LenientJsonParser = new LenientJsonParser(jsonSource, errors);
-    const data: unknown = parser.parse();
-    if (errors.length > 0) {
-      return { success: false, data: data as DeepPartial<T>, input, errors };
-    }
-    return { success: true, data: data as T };
-  }
-
-  // Find JSON start position (skip junk prefix from LLM)
-  const jsonStart: number = findJsonStart(jsonSource);
-  if (jsonStart === -1) {
-    // No JSON found - return empty object for lenient behavior
-    return {
-      success: true,
-      data: {} as T,
-    };
-  }
-
-  // Extract JSON portion (skip junk prefix)
-  const jsonInput: string =
-    jsonStart > 0 ? jsonSource.slice(jsonStart) : jsonSource;
-
-  const errors: IJsonParseResult.IError[] = [];
-  const parser: LenientJsonParser = new LenientJsonParser(jsonInput, errors);
-  const data: unknown = parser.parse();
-
-  if (errors.length > 0) {
-    return {
-      success: false,
-      data: data as DeepPartial<T>,
-      input,
-      errors,
-    };
-  }
-  return {
-    success: true,
-    data: data as T,
-  };
-}
-
 /**
  * Lenient JSON parser that handles incomplete JSON.
  *
@@ -279,6 +421,13 @@ class LenientJsonParser {
       return this.parseKeywordOrIdentifier(path);
     }
 
+    // Don't skip structural characters - let the caller handle them
+    const ch: string = this.input[this.pos]!;
+    if (ch === "}" || ch === "]" || ch === ",") {
+      // Not an error - just no value here (e.g., {"a":} or [,])
+      return undefined;
+    }
+
     this.errors.push({
       path,
       expected: "JSON value",
@@ -320,10 +469,16 @@ class LenientJsonParser {
     if (token === "false") return false;
     if (token === "null") return null;
 
+    // Boolean string coercion: "yes", "y", "on" -> true, "no", "off" -> false
+    // Note: "n" is intentionally NOT handled (neither null nor false)
+    const lower: string = token.toLowerCase();
+    if (lower === "yes" || lower === "y" || lower === "on") return true;
+    if (lower === "no" || lower === "off") return false;
+
     // Partial match for lenient parsing (e.g., "tru" -> true, "fal" -> false)
     if ("true".startsWith(token) && token.length > 0) return true;
     if ("false".startsWith(token) && token.length > 0) return false;
-    if ("null".startsWith(token) && token.length > 0) return null;
+    if ("null".startsWith(token) && token.length >= 2) return null;
 
     // Check if this looks like a string with missing opening quote (e.g., abcdefg")
     if (this.pos < this.input.length && this.input[this.pos] === '"') {
@@ -469,7 +624,15 @@ class LenientJsonParser {
       }
 
       // Parse value
+      const prevPos: number = this.pos;
       const value: unknown = this.parseValue(path + "[" + index + "]");
+
+      // Guard: if parseValue didn't advance, skip unexpected char to prevent infinite loop
+      if (this.pos === prevPos && this.pos < this.input.length) {
+        this.pos++;
+        continue;
+      }
+
       result.push(value);
       index++;