Python 2, 39 bytes

lambda n,x:[v/n+v%n+1for v in range(x)]

Try it online!

Jelly, 4 bytes

Ḷd§‘

A dyadic Link accepting two positive integers, x on the left and n on the right, which yields a list of positive integers.

Try it online!

How?

Ḷd§‘ - Link: x, n e.g 13, 3
Ḷ - lowered range (x) [0,1,2,3,4,5,6,7,8,9,10,11,12]
 d - divmod (n) [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2],[3,0],[3,1],[3,2],[4,0]]
 § - sums [0,1,2,1,2,3,2,3,4,3,4,5,4]
 ‘ - increment (vectorises) [1,2,3,2,3,4,3,4,5,4,5,6,5]

R, 33 bytes

function(n,x,z=1:x-1)z%%n+z%/%n+1

Try it online!

Ports Jonathan Allan's Python solution.

R, 36 bytes

function(n,x)outer(1:n,0:x,"+")[1:x]

Try it online!

My original solution; generates an $ntimes x$ matrix with each column as the increments, i.e., $1 ldots n, 2ldots n+1,ldots$, then takes the first $x$ entries (going down the columns).

05AB1E, 6 bytes

L<s‰O>

Port of @JonathanAllan's Jelly answer, so make sure to upvote him!

First input is $x$, second input is $n$.

Try it online or verify all test cases.

Explanation:

L # Push a list in the range [1, (implicit) input]
 # i.e. 13 → [1,2,3,4,5,6,7,8,9,10,11,12,13]
 < # Decrease each by 1 to the range [0, input)
 # → [0,1,2,3,4,5,6,7,8,9,10,11,12]
 s‰ # Divmod each by the second input
 # i.e. 3 → [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2],[3,0],[3,1],[3,2],[4,0]]
 O # Sum each pair
 # → [0,1,2,1,2,3,2,3,4,3,4,5,4]
 > # And increase each by 1
 # → [1,2,3,2,3,4,3,4,5,4,5,6,5]
 # (after which the result is output implicitly)

My own initial approach was 8 bytes:

LI∍εN¹÷+

First input is $n$, second input is $x$.

Try it online or verify all test cases.

Explanation:

L # Push a list in the range [1, (implicit) input]
 # i.e. 3 → [1,2,3]
 I∍ # Extend it to the size of the second input
 # i.e. 13 → [1,2,3,1,2,3,1,2,3,1,2,3,1]
 ε # Map each value to:
 N¹÷ # The 0-based index integer-divided by the first input
 # → [0,0,0,1,1,1,2,2,2,3,3,3,4]
 + # Add that to the value
 # → [1,2,3,2,3,4,3,4,5,4,5,6,5]
 # (after which the result is output implicitly)

Brain-Flak, 100 bytes

(<>)<>([()]<(())(()[()](<>))<>(()<>)(<>)(<>)([()]<(<>[](())[()]<>)>)>)

With comments and formatting:

# Push a zero under the other stack
(<>)<>

# x times

 # x - 1
 ([()]<

 # Let 'a' be a counter that starts at n
 # Duplicate a and NOT
 (())(()[()](<>))

 # if a == 0
 
 # Pop truthy
 
 <>

 # Reset n to a
 (()<>)

 # Push 0 to each
 (<>)(<>)
 

 # Pop falsy
 

 # Decrement A, add one to the other stack, and duplicate that number under this stack
 ([()]<
 (<>[](())<>)
 >)
 >)

Try it online!

Jelly, 5 bytes

+þẎḣ’

Try it online!

Ruby, 32 bytes

->n,x(0...x).mapi

Try it online!

Japt -m, 12 7 bytes

Port of Jonathan's Python solution.

Takes x as the first input.

%VÄ+UzV

Try it

Perl 6, 18 bytes

(1..*X+ ^*)[^$_]

Try it online!

Curried function f(x)(n).

Explanation

 # Anonymous block
 X+ # Cartesian product with addition
 1..* # of range 1..Inf
 ^* # and range 0..n
 ( )[^$_] # First x elements

Perl 5 -na, 43 bytes

@r=map$_..$_+$F[1]-1,1..$_;say"@r[0..$_-1]"

Try it online!

Octave, 25 bytes

@(n,x)((1:n)'+(0:x))(1:x)

Anonymous function that inputs numbers n``andx`, and outputs a row vector.

Try it online!

MATL, 16 bytes

:i:"tQ]v!1e 2G:)

Try it online!

Explanation:

: % Push [1, 2... n]
 i:" ] % For i in [1, x]:
 t % Duplicate the first array
 Q % Increment each number
 v % Concatenate everything into 1 matrix
 ! % Transpose
 1e % Reshape into 1 row
 2G % Push x again
 :) % And take the first x elements

J, ¹³ 12 bytes

[$[:,1++/&i.

Try it online!

how

We take x as the left arg, n as the right. Let's take x = 8 and n = 3 for this example:

• 
  

  +/&i.: Transform both args by creating integer ranges i., that is, the left arg becomes 0 1 2 3 4 5 6 7 and the right arg becomes 0 1 2. Now we create an "addition table +/ from those two:

  
  
  

   0 1 2
   1 2 3
   2 3 4
   3 4 5
   4 5 6
   5 6 7
   6 7 8
   7 8 9
  

  
  


• 
  

  1 +: Add 1 to every element of this table:

  
  
  

   1 2 3
   2 3 4
   3 4 5
   4 5 6
   5 6 7
   6 7 8
   7 8 9
   8 9 10
  

  
  


• 
  

  [: ,: Flatten it ,:

  
  
  

   1 2 3 2 3 4 3 4 5 4 5 6 5 6 7 6 7 8 7 8 9 8 9 10
  

  
  


• 
  

  [ $: Shape it $ so it has the same number of elements as the original, untransformed left arg [, ie, x:

  
  
  

   1 2 3 2 3 4 3 4 
  

  
  

Alchemist, 77 bytes

_->In_n+In_x
x+n+0y+0z->a+Out_a+Out_" "+m+y
y+n->n
y+0n->z
z+m+a->z+n
z+0m->a

Try it online!

Increments and outputs a counter n times, then subtracts n-1 before repeating.

Charcoal, 18 bytes

ＮθＦＮ⊞υ⊕⎇‹ιθι§υ±θＩυ

Try it online! Link is to verbose version of code. I had dreams of seeding the list with a zero-indexed range and then slicing it off again but that was actually 2 bytes longer. Explanation:

Ｎθ Input `n` into variable
 Ｎ Input `x`
 Ｆ Loop over implicit range
 ι Current index
 ‹ Less than
 θ Variable `n`
 ⎇ ι Then current index else
 θ Variable `n`
 ± Negated
 §υ Cyclically indexed into list
 ⊕ Incremented
 ⊞υ Pushed to list
 Ｉυ Cast list to string for implicit output

APL+WIN, 29 23 bytes

x↑,(0,⍳⌊(x←⎕)÷n)∘.+⍳n←⎕

Prompts for n and x

Try it online! Courtesy of Dyalog Classic

JS, 54 bytes

f=(n,x)=>Array.from(Array(x),(_,i)=>i+1-(i/n|0)*(n-1))

Try it online!

Haskell, 34 33 bytes

n#x=take x$do j<-[1..];[j..j+n-1]

Try it online!

JavaScript, 36 bytes

n=>g=x=>x?[...g(--x),1+x%n+x/n|0]:[]

Try It Online!

Perl 5, 39 bytes

say 1+int($_/$F[1])+$_%$F[1]for 0..$_-1

Try it online!

C (gcc), 49 44 bytes

Using recursion to save some bytes.

f(n,x)x&&printf("%d ",x%n+x/n+1,f(n,--x));

Try it online!