Bdtyk

const tests = [

  '{"just":"json }}{}{}{{}}}}","x":[1,2,3]}',

  'Just a string',

  'This string has a tricky case: {"like":"this one } right here"}',

  'This string {} has a tiny JSON object in it.',

  '.{}.',

  'This is a string {"with":"json","in":"it"} followed by more text {"and":{"some":["more","json"]}} and more text',

];



tests.forEach( test => console.log( parse_json_interleaved_string( test ) ) );



function parse_json_interleaved_string ( str ) {

  const chunks = [ ];

  let last_json_end_index = -1;

  let json_index = str.indexOf( '{', last_json_end_index + 1 );

  for ( ; json_index !== -1; json_index = str.indexOf( '{', last_json_end_index + 1 ) ) {



    // Push the plain string before the JSON

    if ( json_index !== last_json_end_index + 1 )

        chunks.push( str.substring( last_json_end_index, json_index ) );



    let json_end_index = str.indexOf( '}', json_index + 1 );



    // Find the end of the JSON

    while ( true ) {

       try { 

         JSON.parse( str.substring( json_index, json_end_index + 1 ) );

         break;

       } catch ( e ) {

         json_end_index = str.indexOf( '}', json_end_index + 1 );

         if ( json_end_index === -1 )

           throw new Error( 'Unterminated JSON object in string' );

       }

    }



    // Push JSON

    chunks.push( str.substring( json_index, json_end_index + 1 ) );

    last_json_end_index = json_end_index + 1;

  }



  // Push final plain string if any

  if ( last_json_end_index === - 1 )

    chunks.push( str );

  else if ( str.length !== last_json_end_index )

    chunks.push( str.substr( last_json_end_index ) );



  return chunks;

}

const tryJSON = input => {

  try {

    return JSON.parse(input);

  } catch (e) {

    return false;

  }

}



const parse = input => {

  let output = ;

  let chunks = input.split(/([{}])/);



  for (let i = 0; i < chunks.length; i++) {

    if (chunks[i] === '{') {

      // found some possible JSON; start at the last } and backtrack until it works.

      for (let j = chunks.lastIndexOf('}'); j > i; j--) {

        if (chunks[j] === '}') {

          // Does it blend?

          let parsed = tryJSON(chunks.slice(i, j + 1).join(""))

          if (parsed) {

            // it does! Grab the whole thing and skip ahead

            output.push(parsed);

            i = j;

          }

        }

      }

    } else if (chunks[i]) {

      // neither JSON nor empty

      output.push(chunks[i])

    }

  }



  console.log(output)

  return output

}



parse(`{"foo": "bar"}`)

parse(`test{"foo": "b}ar{{[[[{}}}}{}{}}"}`)

parse(`this {"is": "a st}ri{ng"} with {"json": ["in", "i{t"]}`)

parse(`{}`)

parse(`this {"i{s": invalid}`)

parse(`So is {this: "one"}`)

const str = `This is a string {"with":"json","in":"it"} followed by more text {"and":{"some":["more","json"]}} and more text {"like":"this one } right here"}`;



const formatStringContainingJSON = s => {

  const r = /(s(?=[{]))|s(?=[ws]+[{])/ig;

  const matches = s.split(r).filter(Boolean);

  const res = ;

  while (matches.length) {

    const index = matches.findIndex(s => /^s+$/.test(s));

    const match =  matches.splice(0, index + 1);

    res.push(

      `${!res.length ? '' : ' '}${match.join(' ').replace(/s$/, '')}`

    , `${matches.shift()}`

    );

  };

  return res;

}



let result = formatStringContainingJSON(str);



console.log(result);

function construct(str) {

  const len = str.length

  let lastSavedIndex = -1

  let bracketLevel = 0

  let inJsonString = false

  let lastCharWasEscapeChar = false

  

  let result = 

  

  for(let i = 0; i < len; ++i) {

    if(bracketLevel !== 0 && !lastCharWasEscapeChar && str[i] === '"') {

      inJsonString = !inJsonString

    }

    else if (!inJsonString && str[i] === '{') {

      if (bracketLevel === 0) {

        result.push(str.substring(lastSavedIndex + 1, i))

        lastSavedIndex = i - 1

      }

      

      ++bracketLevel

    }

    else if (!inJsonString && str[i] === '}') {

      --bracketLevel

      

      if (bracketLevel === 0) {

        result.push(JSON.parse(str.substring(lastSavedIndex + 1, i + 1)))

        lastSavedIndex = i

      }

    }

    else if (inJsonString && str[i] === '\') {

      lastCharWasEscapeChar = !lastCharWasEscapeChar

    }

    else {

      lastCharWasEscapeChar = false

    }

  }

  if(lastSavedIndex !== len -1) {

    result.push(str.substring(lastSavedIndex + 1, len))

  }

  return result

}





const standardText = 'This is a string {"with":"json","in":"it"} followed by more text {"and":{"some":["more","json"]}} and more text. {"foo": "bar}"}'



const inputTA = document.getElementById('input')

const outputDiv = document.getElementById('output')



function updateOutput() {

  outputDiv.innerText =

    JSON.stringify(

      construct(inputTA.value),

      null,

      2

    )

}



inputTA.oninput = updateOutput

inputTA.value = standardText

updateOutput()

<textarea id="input" rows="5" cols="50"></textarea>



<pre id="output"><pre>

const input = 'This is a string {"with":"json", "in":"it"} followed by more text {"and":{"some":["more","json","data"]}} and more text';



let obj = Array.from(input).reduce(({res, isJson, chunk}, curr) =>

{

    if (curr === "{")

    {

        if (!isJson) res.push(chunk);

        chunk = isJson ? chunk + curr : curr;

        isJson = true;

    }

    else if (isJson)

    {

        try

        {

            chunk += curr;

            JSON.parse(chunk);



            // If no error, we found a JSON.

            res.push(chunk);

            chunk = "";

            isJson = false;

        }

        catch(e) {/* Ignore error */}

    }

    else

    {

        chunk += curr;

    }



    return {res, isJson, chunk};



}, {res:, isJson:false, chunk:""})



// First stage done, lets debug obtained data.



obj.res.push(obj.chunk);

console.log(obj.res);



// Finally, we map the pieces.



let res = obj.res.map(x => x.match("{") ? JSON.parse(x) : x);

console.log(res);