add nonumber to code snippets

Author: kettanaito

exercises/02.functions/01.solution.mock-functions/README.mdx

@@ -4,7 +4,7 @@
 
 In the `emitter.test.ts`, I will start from creating the `listener` function but it won't be a regular JavaScript function. Instead, I will use the `vi.fn()` API from Vitest, which creates a _special_ kind of function.
 
-```ts filename=emitter.test.ts
+```ts filename=emitter.test.ts nonumber
 const listener = vi.fn()
 ```
 
@@ -16,13 +16,13 @@ Calling `vi.fn()` returns a function imbued with superpowers, one of which is th
 
 Now that the mock function is ready, I will use it as a listener argument for the `hello` event:
 
-```ts filename=emitter.test.ts
+```ts filename=emitter.test.ts nonumber
 emitter.on('hello', listener)
 ```
 
 Everything up to this point was the setup for this test. The action here would be calling the `.emit()` method to emit the `hello` event because the listeners are only called when the respective event gets emitted.
 
-```ts filename=emitter.test.ts
+```ts filename=emitter.test.ts nonumber
 emitter.emit('hello', 'John')
 ```
 
@@ -35,14 +35,14 @@ The `expect()` function from Vitest comes with handy assertions to describe both
 
 First, I will use the `.toHaveBeenCalledOnce()` assertion:
 
-```ts filename=emitter.test.ts
+```ts filename=emitter.test.ts nonumber
 expect(listener).toHaveBeenCalledOnce()
 ```
 
 This will only pass if the `listener` function has been called exactly once. If it gets called any other number of times, it's a bug, and the test will fail.
 
 In the same fashion, I will apply the [`.toHaveBeenCalledWith()`](https://vitest.dev/api/expect.html#tohavebeencalledwith) assertion to check that the `listener` function gets called with the right data:
 
-```ts filename=emitter.test.ts
+```ts filename=emitter.test.ts nonumber
 expect(listener).toHaveBeenCalledWith('John')
 ```

exercises/02.functions/02.problem.spies/README.mdx

@@ -28,7 +28,7 @@ To make things more complicated, logging out the event is not the responsibility
 
 Luckily, the class accepts a `logger` instance as an argument:
 
-```ts filename=user-service.ts nocopy
+```ts filename=user-service.ts nocopy nonumber
 constructor(private logger: Logger) {}
 ```
 

exercises/02.functions/02.solution.spies/README.mdx

@@ -4,29 +4,29 @@
 
 Let's start by creating a _spy_ for the `logger.log()` method using the [`vi.spyOn()`](https://vitest.dev/api/vi.html#vi-spyon) function from Vitest:
 
-```ts filename=user-service.test.ts lines=2
+```ts filename=user-service.test.ts nonumber lines=2
 const logger = new Logger()
 vi.spyOn(logger, 'log')
 const service = new UserService(logger)
 ```
 
 The `spyOn()` function has a bit of unusual call signature since it _will not_ accept the `logger.log` method reference directly. Instead, it expects the object that owns the method first, and then the method name as a string:
 
-```ts
+```ts nonumber
 vi.spyOn(target, method)
 ```
 
 > :owl: The reason behind this call signature is how `.spyOn()` works under the hood. It redefines the `method` on the `target` object with a spied version of that method! You can think of it as `target[method] = methodSpy`.
 
 Now that I have the spy ready and recording, I can write an assertion on that method being called with the correct arguments using the [`.toHaveBeenCalledWith()`](https://vitest.dev/api/expect.html#tohavebeencalledwith) assertion:
 
-```ts filename=user-service.test.ts
+```ts filename=user-service.test.ts nonumber
 expect(logger.log).toHaveBeenCalledWith('createUser', { id: 'abc-123' })
 ```
 
 Finally, I will make sure that `logger.log()` has been called exactly once:
 
-```ts filename=user-service.test.ts
+```ts filename=user-service.test.ts nonumber
 expect(logger.log).toHaveBeenCalledOnce()
 ```
 

exercises/02.functions/03.problem.mock-implementation/README.mdx

@@ -9,7 +9,7 @@ In this one, we have an `OrderController` class responsible for handling orders
 
 The `.createOrder()` method relies on another `.isItemInStock()` method of the same class to check any given cart item's availability.
 
-```ts filename=order-controller.ts nocopy lines=2-4
+```ts filename=order-controller.ts nocopy nonumber lines=2-4
   public createOrder(args: { cart: Cart }): Order {
     const itemsOutOfStock = args.cart.filter(
       (item) => !this.isItemInStock(item),
@@ -32,7 +32,7 @@ The `.createOrder()` method relies on another `.isItemInStock()` method of the s
 
 The data for the item availability itself comes from the `stock.json` file that 👨‍💼 Peter the Project Manager does a faithful job of updating on a daily basis (think of this JSON file as any source of data—e.g. a database).
 
-```ts filename=order-controller.ts nocopy lines=7
+```ts filename=order-controller.ts nocopy nonumber lines=7
 import stockJson from './stock.json'
 
 export class OrderController {

exercises/02.functions/03.solution.mock-implementation/README.mdx

@@ -4,7 +4,7 @@
 
 Let's start by going to the first test case for our `OrderController` and spying on the `isItemInStock` method of the created `controller` instance:
 
-```ts filename=order-controller.test.ts lines=4
+```ts filename=order-controller.test.ts nonumber lines=4
 test('creates an order when all items are in stock', () => {
   const controller = new OrderController()
 
@@ -15,7 +15,7 @@ test('creates an order when all items are in stock', () => {
 
 By using [`.mockReturnValue()`](https://vitest.dev/api/mock.html#mockreturnvalue), I am forcing the `.isItemInStock()` method to always return true when run in this test. With that behavior fixed, I can write the assertions around how the new order should be created:
 
-```ts filename=order-controller.test.ts lines=15-23
+```ts filename=order-controller.test.ts nonumber lines=15-23
 test('creates an order when all items are in stock', () => {
   const controller = new OrderController()
 
@@ -46,7 +46,7 @@ test('creates an order when all items are in stock', () => {
 
 In the next test case, I'd like to do things a little differently. I will still spy on the `.isItemInStock()` method, but instead of mocking its return value, I will _mock that method's implementation_.
 
-```ts filename=order-controller.test.ts lines=4-6
+```ts filename=order-controller.test.ts nonumber lines=4-6
 test('throws an error when one of the items is out of stock', () => {
   const controller = new OrderController()
 
@@ -57,7 +57,7 @@ test('throws an error when one of the items is out of stock', () => {
 
 By mocking the implementation, I am creating a mock with conditional behavior. It will behave differently based on the cart `item` that's being checked. Only the item with `id` that equals `4` will be considered in stock. This way, I am able to reproduce the error throwing logic as well as assert on the `controller` class including the right item IDs in the error message.
 
-```ts filename=order-controller.test.ts lines=26-28
+```ts filename=order-controller.test.ts nonumber lines=26-28
 test('throws an error when one of the items is out of stock', () => {
   const controller = new OrderController()
 

exercises/03.date-and-time/02.solution.timers/README.mdx

@@ -47,7 +47,7 @@ vi.advanceTimersByTime(250)
 
 This will immediately fastforward the test universe ahead by 250ms, allowing me to write my expectations toward the tested debounced function:
 
-```ts filename=debounce.test.ts nonumber lines=2-4
+```ts filename=debounce.test.ts nonumber lines=3-4
 vi.advanceTimersByTime(250)
 
 expect(fn).toHaveBeenCalledOnce()

exercises/03.date-and-time/03.problem.ticks-and-tasks/README.mdx

@@ -25,7 +25,7 @@ export class Connection extends EventTarget {
 
 You'd expect the consumers of this class to be able to listen to the `connection` event but that's not going to happen:
 
-```ts
+```ts nonumber
 const connection = new Connection()
 connection.addEventListener('connection', () => {
   console.log('This is never called!')