This question is inspired by Kevin Cruijssen's question.

Now that the carpet is laid out, we want to roll it. Your task is to write a program that takes a string and returns a spiral made from this string (representing a rolled carpet viewed from the side).

The procedure for one step of rolling the carpet is the following. There is an example to illustrate what I mean. Notice that the example starts with a partially rolled carpet for better understanding:

ac
rpet

• separate the "head" from the "tail" of the carpet: the head is what has been rolled so far, the tail is what remains to be rolled.

Head: ac Tail:
 rp et

• Rotate the head 90°, clockwise.

Rotated head: ra Tail (unchanged):
 pc et

• if the width of the new head (here 2) is less or equal than the length of the tail (here 2)
  
  
  • then, put it on top of the tail
  
  
  • else, the carpet (as it was at the begining of the step) was rolled
  
  

New carpet: ra
 pc
 et

Repeat the procedure as many times as needed.

Two examples showing all steps of the carpet rolling:

carpet

 c
 arpet

 ac
 rpet

 ra
 pc
 et

0123456789

 0
 123456789

 10
 23456789

 21
 30
 456789

 432
 501
 6789

Some precisions:

• You don't need to show all intermediate steps, only the rolled carpet (e.g. if you find a non-iterative way to compute the result, it's perfect). Also, you don't need to print any leading whitespace, in the examples above, I only show them to align stuff.


• Input is a String, a list/array of char


• Output is printed to stdout or to a file.


• Input is nice: the length is at least 1 char, and at most a constant sufficiently small so that it doesn't cause problems, but you can't use that constant in your program; the content of the string is only nice characters ([a-zA-Z0-9]), encoding at your preference.


• This is code-golf, so shortest answer in bytes wins. Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.


• 
  Default Loopholes are forbidden.


• If possible, please add a link with a test for your code.


• Also, add an explanation for your answer if you think it is needed.

J, 73 bytes

[:(:@[,{:@[,])&>/[:((|:@|.@[,#@[.]);#@[.])&>/^:(<:&#&>/)^:_,:@,:@.;.

Try it online!

I plan to golf this further after work tonight.

R, 146 132 bytes

function(s)m=F[F]
while(m=rbind(t(m)[,F:0],s[1:F])
s=s[-1:-F]
length(s)>sum(F<-dim(m)))0
write(m[F:1,],1,F[1],,"")
cat(s,sep="")

Try it online!

Implements the carpet-rolling procedure. Takes input as a list of characters and prints to stdout.

Saved 14 bytes by finding a way to use a do-while loop and initializing using F.

function(s)
m=F[F]					# logical(0); create an empty array (this gets automatically promoted to character(0) later
while(					# do-while loop
 m=rbind(t(m)[,F:0],s[1:F])	# rotate m counterclockwise and add the first F characters of s to the bottom
 s=s[-1:-F]			# remove those characters
 length(s)>sum(F<-dim(m)))0	# while the number of characters remaining is greater than the sum of m's dimensions
write(m[F:1,],1,F[1],,"")		# write the rolled portion write writes down the columns, we reverse each column
cat(s,sep="")				# and write the remaining characters

Jelly, 30 bytes

_{Seems overly long...}

ḢW,ðZU;Ls@¥©ḢWɗ,®Ẏ¤ð/ẈṢƑ$¿ḢY;Ɗ

Try it online!

How?

ḢW,ðZU;Ls@¥©ḢWɗ,®Ẏ¤ð/ẈṢƑ$¿ḢY;Ɗ - Main Link: list of characters
Ḣ - pop and yield head
 W - wrap in a list
 , - pair with (the remaining list after Ḣ)
 ¿ - while...
 $ - ...condition: last two links as a monad:
 Ẉ - length of each
 Ƒ - is invariant under:
 Ṣ - sort
 / - ...do: reduce by:
 ð ð - the enclosed dyadic chain -- i.e. f(head, tail):
 Z - transpose
 U - reverse each (giving a rotated head)
 ɗ - last three links as a dyad:
 ¥ - last two links as a dyad:
 L - length (i.e. number of rows in current roll)
 @ - with swapped arguments:
 s - split (the tail) into chunks of that length
 © - (copy to register for later)
 Ḣ - pop and yield head (Note register "copy" is altered too)
 W - wrap in a list
 ; - concatenate (the rotated head with the first chunk of the tail)
 ¤ - nilad followed by link(s) as a nilad:
 ® - recall from register (other chunks of tail, or an empty list)
 Ẏ - tighten (the chunks to a flat list)
 , - pair (the concatenate result with the tightened chunks)
 Ɗ - last three links as a monad:
 Ḣ - pop and yield head
 Y - join with newline characters
 ; - concatenate (the remaining tail)
 - when running as a full program implicitly prints