Create an ASCII art unjumble! Given a string of ASCII art like such (This isn't ASCII art but it will do for the example):

abc
d e
fgh


Jumble it as if it was being displayed on a screen with one character per line, like so:

a
b
c
d

e
f
g
h


Print the result, wait one second, ±0.5 seconds before clearing the terminal and the print the same thing, but with 2 characters displayed per line instead of 1. Basically, the width of the display turns from 1 to 2.

ab
c
d 
e
fg
h


Note the space after the d. Repeat waiting, then printing with an additional character per line until the inputted text is outputted.

If you hit the end of a line when trying to print characters, then you insert a newline and print the rest of them following this rule. For example the input:

abcdefg
ab


Would print the following when the display length is 4.

abcd
efg
ab


You can find the effect of the terminal resize here: https://repl.it/GoeU/1. Run the program, then drag the thing separating the terminal from the text editor back and forth.

Clarification:

Once a line appears exactly how it was inputted, you can leave that line alone for future larger character counts per line.

abc
ab


should print

ab
c
ab


when the sentence length = 2.



This is code-golf, so least amount of bytes wins!

Rules:


Must print to STDOUT as the only output.
Must clear the terminal, or create the illusion of clearing the terminal by adding 150 or so empty lines.
Can take input through the standard methods.
Default loopholes apply.
Trailing stuff with the text is NOT OKAY.


This idea came to me when I was resizing a terminal with ASCII art on it. It looked interesting, so I decided to make a challenge out of it.



Test cases:

Since it would be too much work to show each step for each test case individually, I will review each answer to make sure it is valid. Make sure the answer can handle the test cases.

 ______   ______     __     __   __     ______      __    __     ______    
/\  == \ /\  == \   /\ \   /\ "-.\ \   /\__  _\    /\ "-./  \   /\  ___\   
\ \  _-/ \ \  __&lt;   \ \ \  \ \ \-.  \  \/_/\ \/    \ \ \-./\ \  \ \  __\   
 \ \_\    \ \_\ \_\  \ \_\  \ \_\\"\_\    \ \_\     \ \_\ \ \_\  \ \_____\ 
  \/_/     \/_/ /_/   \/_/   \/_/ \/_/     \/_/      \/_/  \/_/   \/_____/ 


This pastebin.

                        __/\__
                        \    /
                  __/\__/    \__/\__
                  \                /
                  /_              _\
                    \            /
      __/\__      __/            \__      __/\__
      \    /      \                /      \    /
__/\__/    \__/\__/                \__/\__/    \__/\__
Python 3.6, 124 bytes

Loops over length of input string like officialaimm's solution

import re,time
def d(s):
 for i in range(len(s)):print(*'\n'*75,*re.split(f'(.{{1,{i+1}}})',s)[1::2],sep='\n');time.sleep(1)


143 bytes to only go to width of longest line a al Frxstrem's Bash answer

import re,time
def d(s):
 for i in range(max(map(len,s.split()))):print(*'\n'*75,*re.split(f'(.{{1,{i+1}}})', s)[1::2],sep='\n');time.sleep(.5)


Uses "re.split((.{1,i+1}))" to break the string into groups of characters.  Because '.' doesn't match '\n', the groups don't wrap around from one line to the next. If the regex uses a capturing group, then re.split() returns a list with the matched groups at the odd indexes.  These are retrieved with [1::2].

Uses python 3.6 f-string to make the re pattern depend on group width i.  

The * in front of re.split() uses python 3.6 unpacking to turn the list into arguments to the print statement.  Similarly, *'\n'*75, turns into 75 '\n' arguments to the print statement.  With the print keyword argument sep='\n', the result is printing about 150 blank lines to clear the screen, followed by each group of characters on a separate line.