diff --git a/README.md b/README.md
index 06be680f8..580afc0e0 100644
--- a/README.md
+++ b/README.md
@@ -121,6 +121,4 @@ If you need to support every single locale on the planet, we recommend to polyfi
 
 [floating-vue](https://floating-vue.starpad.dev/)
 
-[mitt](https://www.npmjs.com/package/mitt)
-
 [svg-country-flags](https://www.npmjs.com/package/svg-country-flags)
diff --git a/package-lock.json b/package-lock.json
index c4b97842e..d68b341c8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@ebury/chameleon-components",
-  "version": "2.6.0",
+  "version": "2.6.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@ebury/chameleon-components",
-      "version": "2.6.0",
+      "version": "2.6.1",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {
@@ -17,7 +17,6 @@
         "floating-vue": "2.0.0-beta.16",
         "focus-trap": "6.9.4",
         "lodash": "4.17.21",
-        "mitt": "3.0.1",
         "svg-country-flags": "1.2.10",
         "tailwindcss": "3.3.5",
         "vue": "3.3.4"
@@ -19643,11 +19642,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/mitt": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
-      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw=="
-    },
     "node_modules/mixin-deep": {
       "version": "1.3.2",
       "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz",
@@ -42471,11 +42465,6 @@
         }
       }
     },
-    "mitt": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
-      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw=="
-    },
     "mixin-deep": {
       "version": "1.3.2",
       "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz",
diff --git a/package.json b/package.json
index b6a23bdbf..81b1ac9f8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@ebury/chameleon-components",
-  "version": "2.6.0",
+  "version": "2.6.1",
   "main": "src/main.js",
   "sideEffects": false,
   "author": "Ebury Team (http://labs.ebury.rocks/)",
@@ -45,7 +45,6 @@
     "floating-vue": "2.0.0-beta.16",
     "focus-trap": "6.9.4",
     "lodash": "4.17.21",
-    "mitt": "3.0.1",
     "svg-country-flags": "1.2.10",
     "tailwindcss": "3.3.5",
     "vue": "3.3.4"
diff --git a/src/components/ec-timer/__snapshots__/ec-timer.spec.js.snap b/src/components/ec-timer/__snapshots__/ec-timer.spec.js.snap
index 05f1305f7..f384536d6 100644
--- a/src/components/ec-timer/__snapshots__/ec-timer.spec.js.snap
+++ b/src/components/ec-timer/__snapshots__/ec-timer.spec.js.snap
@@ -46,6 +46,98 @@ exports[`EcTimer > :props > should render as expected 1`] = `
 </div>
 `;
 
+exports[`EcTimer > :props > should restart when seconds prop is updated > after restart 1`] = `
+<div
+  class="ec-timer"
+  data-test="ec-timer"
+>
+  <svg
+    class="ec-timer__svg"
+    height="52"
+    viewBox="0 0 52 52"
+    width="52"
+  >
+    <circle
+      class="ec-timer__elapsed"
+      cx="50%"
+      cy="50%"
+      fill="transparent"
+      r="24"
+      stroke-width="4"
+    />
+    <circle
+      class="ec-timer__remaining"
+      cx="50%"
+      cy="50%"
+      fill="transparent"
+      r="24"
+      stroke-dasharray="150.79644737231007"
+      stroke-dashoffset="301.59289474462014"
+      stroke-width="4"
+    />
+    <text
+      class="ec-timer__text"
+      data-test="ec-timer__text-only-seconds"
+      dominant-baseline="central"
+      text-anchor="middle"
+      x="50%"
+      y="50%"
+    >
+      30
+      
+      s
+      
+    </text>
+  </svg>
+</div>
+`;
+
+exports[`EcTimer > :props > should restart when seconds prop is updated > before restart 1`] = `
+<div
+  class="ec-timer"
+  data-test="ec-timer"
+>
+  <svg
+    class="ec-timer__svg"
+    height="52"
+    viewBox="0 0 52 52"
+    width="52"
+  >
+    <circle
+      class="ec-timer__elapsed"
+      cx="50%"
+      cy="50%"
+      fill="transparent"
+      r="24"
+      stroke-width="4"
+    />
+    <circle
+      class="ec-timer__remaining"
+      cx="50%"
+      cy="50%"
+      fill="transparent"
+      r="24"
+      stroke-dasharray="150.79644737231007"
+      stroke-dashoffset="226.1946710584651"
+      stroke-width="4"
+    />
+    <text
+      class="ec-timer__text"
+      data-test="ec-timer__text-only-seconds"
+      dominant-baseline="central"
+      text-anchor="middle"
+      x="50%"
+      y="50%"
+    >
+      10
+      
+      s
+      
+    </text>
+  </svg>
+</div>
+`;
+
 exports[`EcTimer > :props > when "showMinutes" is true > when "isRunning" is false > should render as expected 1`] = `
 <div
   class="ec-timer"
diff --git a/src/components/ec-timer/ec-timer.spec.js b/src/components/ec-timer/ec-timer.spec.js
index a4e048313..67903f557 100644
--- a/src/components/ec-timer/ec-timer.spec.js
+++ b/src/components/ec-timer/ec-timer.spec.js
@@ -1,11 +1,22 @@
 import fakeTimers from '@sinonjs/fake-timers';
 import { mount } from '@vue/test-utils';
-import { vi } from 'vitest';
 
 import { withMockedConsole } from '../../../tests/utils/console';
 import EcTimer from './ec-timer.vue';
 
 describe('EcTimer', () => {
+  let clock;
+
+  beforeEach(() => {
+    clock = fakeTimers.install();
+  });
+
+  afterEach(() => {
+    if (clock) {
+      clock.uninstall();
+    }
+  });
+
   function mountTimer(props, mountOpts) {
     return mount(EcTimer, {
       props,
@@ -60,13 +71,11 @@ describe('EcTimer', () => {
     });
 
     it('should clear the interval if we set "isRunning" to false', async () => {
-      const clearTimeoutSpy = vi.spyOn(window, 'clearInterval');
       const wrapper = mountTimer({ seconds: 20, isRunning: true });
-
-      expect(clearTimeoutSpy).toHaveBeenCalledTimes(0);
+      expect(clock.countTimers()).toBe(1);
 
       await wrapper.setProps({ isRunning: false });
-      expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);
+      expect(clock.countTimers()).toBe(0);
     });
 
     it('should render as expected', () => {
@@ -75,6 +84,17 @@ describe('EcTimer', () => {
       expect(wrapper.element).toMatchSnapshot();
     });
 
+    it('should restart when seconds prop is updated', async () => {
+      const wrapper = mountTimer({ seconds: 20, isRunning: true });
+      clock.tick(10000);
+      await wrapper.vm.$nextTick();
+      expect(wrapper.element).toMatchSnapshot('before restart');
+
+      await wrapper.setProps({ seconds: 30 });
+
+      expect(wrapper.element).toMatchSnapshot('after restart');
+    });
+
     describe('when "showMinutes" is true', () => {
       describe('when "isRunning" is false', () => {
         it('should render as expected', () => {
@@ -92,11 +112,17 @@ describe('EcTimer', () => {
         });
       });
 
-      it('should render a timer with minutes', () => {
+      it('should render a timer with leading zero in minutes', () => {
         const wrapper = mountTimer({ seconds: 20, isRunning: true, showMinutes: true });
 
         expect(wrapper.findByDataTest('ec-timer__text-with-minutes').text()).toBe('0:20');
       });
+
+      it('should render a timer with minutes', () => {
+        const wrapper = mountTimer({ seconds: 80, isRunning: true, showMinutes: true });
+
+        expect(wrapper.findByDataTest('ec-timer__text-with-minutes').text()).toBe('1:20');
+      });
     });
   });
 
@@ -119,18 +145,6 @@ describe('EcTimer', () => {
   });
 
   describe('@events', () => {
-    let clock;
-
-    beforeEach(() => {
-      clock = fakeTimers.install();
-    });
-
-    afterEach(() => {
-      if (clock) {
-        clock.uninstall();
-      }
-    });
-
     it('should emit an event called "time-expired" after the countdown completes', async () => {
       const wrapper = mountTimer({ seconds: 20, isRunning: true });
 
@@ -165,12 +179,11 @@ describe('EcTimer', () => {
     });
   });
 
-  it('should clear the interval before we destroy the components', () => {
-    const clearTimeoutSpy = vi.spyOn(window, 'clearInterval');
+  it('should clear the interval before destroying the component', () => {
     const wrapper = mountTimer({ seconds: 20, isRunning: true });
+    expect(clock.countTimers()).toBe(1);
 
-    expect(clearTimeoutSpy).toHaveBeenCalledTimes(0);
     wrapper.unmount();
-    expect(clearTimeoutSpy).toHaveBeenCalledTimes(1);
+    expect(clock.countTimers()).toBe(0);
   });
 });
diff --git a/src/components/ec-timer/ec-timer.vue b/src/components/ec-timer/ec-timer.vue
index 681e28fb6..6b0452065 100644
--- a/src/components/ec-timer/ec-timer.vue
+++ b/src/components/ec-timer/ec-timer.vue
@@ -58,11 +58,9 @@
 </template>
 
 <script setup>
-import {
-  computed, onBeforeUnmount, ref, watchEffect,
-} from 'vue';
+import { computed, onBeforeUnmount, watchEffect } from 'vue';
 
-import Countdown from '../../utils/countdown';
+import useEcCountdown from '../../composables/use-ec-countdown/use-ec-countdown';
 
 const props = defineProps({
   /**
@@ -94,46 +92,32 @@ const strokeWidth = 4;
 const diameter = radius * 2 + strokeWidth;
 const viewbox = `0 0 ${diameter} ${diameter}`;
 const circumference = 2 * Math.PI * radius;
-const steps = circumference / props.seconds;
+const steps = computed(() => circumference / props.seconds);
 
 const offset = computed(() => {
   if (totalSecondsLeft.value === 0) {
     return circumference;
   }
 
-  return circumference + steps * totalSecondsLeft.value;
+  return circumference + steps.value * totalSecondsLeft.value;
 });
 
 const minutesLeft = computed(() => Math.floor(totalSecondsLeft.value / 60));
 
 const minuteSecondsLeft = computed(() => totalSecondsLeft.value % 60);
 
-const totalSecondsLeft = ref(props.seconds);
-
-let countdown = null;
-
-function startCountdown() {
-  countdown = new Countdown();
-  countdown.start(props.seconds);
-  countdown.on('time-updated', (newValue) => {
-    totalSecondsLeft.value = newValue;
-  });
-  countdown.on('time-expired', () => {
-    /**
-     * Emitted after the countdown is finish
-     * @event time-expired
-     * @type {void}
-     */
-    emit('time-expired');
-  });
-}
+const seconds = computed(() => props.seconds);
 
-function stopCountdown() {
-  if (countdown) {
-    countdown.stop();
-    countdown = null;
-  }
-}
+const {
+  start: startCountdown,
+  stop: stopCountdown,
+  secondsLeft: totalSecondsLeft,
+  onTimeExpired,
+} = useEcCountdown(seconds);
+
+onTimeExpired(() => {
+  emit('time-expired');
+});
 
 watchEffect(() => {
   if (props.isRunning) {
diff --git a/src/composables/use-ec-countdown/index.ts b/src/composables/use-ec-countdown/index.ts
new file mode 100644
index 000000000..3da9b6047
--- /dev/null
+++ b/src/composables/use-ec-countdown/index.ts
@@ -0,0 +1 @@
+export { default } from './use-ec-countdown';
diff --git a/src/composables/use-ec-countdown/use-ec-countdown.spec.ts b/src/composables/use-ec-countdown/use-ec-countdown.spec.ts
new file mode 100644
index 000000000..b0d84eeeb
--- /dev/null
+++ b/src/composables/use-ec-countdown/use-ec-countdown.spec.ts
@@ -0,0 +1,167 @@
+import fakeTimers, { type InstalledClock } from '@sinonjs/fake-timers';
+import { flushPromises } from '@vue/test-utils';
+import { vi } from 'vitest';
+import { ref } from 'vue';
+
+import useEcCountdown from './use-ec-countdown';
+
+describe('useEcCountdown', () => {
+  let clock: InstalledClock;
+
+  beforeEach(() => {
+    clock = fakeTimers.install();
+  });
+
+  afterEach(() => {
+    if (clock) {
+      clock.uninstall();
+    }
+  });
+
+  it('should not running until started', () => {
+    const { secondsLeft, start, isRunning } = useEcCountdown(20);
+    clock.tick(10000);
+    expect(isRunning.value).toBe(false);
+    expect(secondsLeft.value).toBe(20);
+    expect(clock.countTimers()).toBe(0);
+
+    start();
+    clock.tick(1000);
+    expect(isRunning.value).toBe(true);
+    expect(secondsLeft.value).toBe(19);
+    expect(clock.countTimers()).toBe(1);
+  });
+
+  it('should count down to 0', () => {
+    const { secondsLeft, start } = useEcCountdown(20);
+    start();
+    clock.tick(20000);
+
+    expect(secondsLeft.value).toBe(0);
+    expect(clock.countTimers()).toBe(0);
+  });
+
+  it('should stop counting down', () => {
+    const { secondsLeft, start, stop } = useEcCountdown(20);
+    start();
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(19);
+    expect(clock.countTimers()).toBe(1);
+    stop();
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(19);
+    expect(clock.countTimers()).toBe(0);
+  });
+
+  it('should be able to restart', () => {
+    const { secondsLeft, start, restart } = useEcCountdown(20);
+    start();
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(19);
+    expect(clock.countTimers()).toBe(1);
+    restart();
+    expect(secondsLeft.value).toBe(20);
+    expect(clock.countTimers()).toBe(1);
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(19);
+    expect(clock.countTimers()).toBe(1);
+  });
+
+  it('should be able to restart with different amount of seconds', () => {
+    const { secondsLeft, start, restart } = useEcCountdown(20);
+    start();
+    clock.tick(10000);
+    expect(secondsLeft.value).toBe(10);
+    expect(clock.countTimers()).toBe(1);
+
+    restart(60);
+    expect(secondsLeft.value).toBe(60);
+    expect(clock.countTimers()).toBe(1);
+  });
+
+  it('should be able to restart using stop/start', () => {
+    const { secondsLeft, start, stop } = useEcCountdown(20);
+    start();
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(19);
+    expect(clock.countTimers()).toBe(1);
+    stop();
+    expect(clock.countTimers()).toBe(0);
+    start();
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(19);
+    expect(clock.countTimers()).toBe(1);
+  });
+
+  it('should be able to restart using stop/start with different amount of seconds', async () => {
+    const seconds = ref(20);
+    const { secondsLeft, start } = useEcCountdown(seconds);
+    start();
+    clock.tick(10000);
+    expect(secondsLeft.value).toBe(10);
+    expect(clock.countTimers()).toBe(1);
+
+    seconds.value = 60;
+    await flushPromises();
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(59);
+    expect(clock.countTimers()).toBe(1);
+  });
+
+  it('should be able to start different amount of seconds', async () => {
+    const seconds = ref(20);
+    const { secondsLeft, start } = useEcCountdown(seconds);
+    clock.tick(10000);
+    expect(secondsLeft.value).toBe(20);
+    expect(clock.countTimers()).toBe(0);
+
+    seconds.value = 60;
+    await flushPromises();
+    start();
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(59);
+    expect(clock.countTimers()).toBe(1);
+  });
+
+  it('should trigger events when ticking', () => {
+    const timeUpdatedSpy = vi.fn();
+    const timeExpiredSpy = vi.fn();
+
+    const {
+      secondsLeft, start, onTimeExpired, onTimeUpdated,
+    } = useEcCountdown(3);
+    onTimeExpired(timeExpiredSpy);
+    onTimeUpdated(timeUpdatedSpy);
+    start();
+
+    // 3 -> 2
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(2);
+    expect(timeUpdatedSpy).toHaveBeenCalledTimes(1);
+    expect(timeUpdatedSpy).toHaveBeenLastCalledWith(2);
+    expect(timeExpiredSpy).toHaveBeenCalledTimes(0);
+
+    // 2 -> 1
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(1);
+    expect(timeUpdatedSpy).toHaveBeenCalledTimes(2);
+    expect(timeUpdatedSpy).toHaveBeenLastCalledWith(1);
+    expect(timeExpiredSpy).toHaveBeenCalledTimes(0);
+
+    // 1 -> 0
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(0);
+    expect(timeUpdatedSpy).toHaveBeenCalledTimes(3);
+    expect(timeUpdatedSpy).toHaveBeenLastCalledWith(0);
+    expect(timeExpiredSpy).toHaveBeenCalledTimes(1);
+    expect(timeExpiredSpy).toHaveBeenLastCalledWith(undefined);
+
+    // should stop firing events after
+    clock.tick(1000);
+    expect(secondsLeft.value).toBe(0);
+    expect(timeUpdatedSpy).toHaveBeenCalledTimes(3);
+    expect(timeUpdatedSpy).toHaveBeenLastCalledWith(0);
+    expect(timeExpiredSpy).toHaveBeenCalledTimes(1);
+    expect(timeExpiredSpy).toHaveBeenLastCalledWith(undefined);
+  });
+});
diff --git a/src/composables/use-ec-countdown/use-ec-countdown.ts b/src/composables/use-ec-countdown/use-ec-countdown.ts
new file mode 100644
index 000000000..2f6f6ba03
--- /dev/null
+++ b/src/composables/use-ec-countdown/use-ec-countdown.ts
@@ -0,0 +1,71 @@
+import { createEventHook } from '@vueuse/core';
+import {
+  type MaybeRef, ref, unref, watch,
+} from 'vue';
+
+export default function useEcCountdown(secondsToGo: MaybeRef<number>) {
+  const secondsLeft = ref(unref(secondsToGo));
+
+  watch(() => unref(secondsToGo), () => {
+    restart(unref(secondsToGo));
+  });
+
+  const isRunning = ref(false);
+  let startTime: number;
+  let intervalId: NodeJS.Timeout;
+
+  const timeUpdatedEvent = createEventHook<number>();
+  const timeExpiredEvent = createEventHook<void>();
+
+  function reduceSecondsLeft() {
+    const currentTime = getCurrentTime();
+    const timeDifference = currentTime - startTime;
+
+    updateSecondsLeft(unref(secondsToGo) - timeDifference);
+    if (secondsLeft.value <= 0) {
+      stop();
+      timeExpiredEvent.trigger();
+    }
+  }
+
+  function updateSecondsLeft(seconds: number) {
+    secondsLeft.value = Math.max(seconds, 0);
+    timeUpdatedEvent.trigger(secondsLeft.value);
+  }
+
+  function getCurrentTime() {
+    return Math.ceil(Date.now() / 1000);
+  }
+
+  function start() {
+    startTime = getCurrentTime();
+    intervalId = setInterval(reduceSecondsLeft, 1000);
+    isRunning.value = true;
+  }
+
+  function stop() {
+    if (isRunning.value) {
+      clearInterval(intervalId);
+    }
+    isRunning.value = false;
+  }
+
+  function restart(seconds: number = unref(secondsToGo)) {
+    const wasRunning = isRunning.value;
+    stop();
+    updateSecondsLeft(seconds);
+    if (wasRunning) {
+      start();
+    }
+  }
+
+  return {
+    secondsLeft,
+    start,
+    restart,
+    stop,
+    isRunning,
+    onTimeUpdated: timeUpdatedEvent.on,
+    onTimeExpired: timeExpiredEvent.on,
+  };
+}
diff --git a/src/main.js b/src/main.js
index 8c668ac4b..aa05f874c 100644
--- a/src/main.js
+++ b/src/main.js
@@ -62,6 +62,7 @@ export { default as EcTimer } from './components/ec-timer';
 export { default as EcToaster } from './components/ec-toaster';
 export { default as EcUserInfo } from './components/ec-user-info';
 export { CHAMELEON_CONFIG_KEY, default as useEcConfig } from './composables/use-ec-config';
+export { default as useEcCountdown } from './composables/use-ec-countdown';
 export { default as useEcPagination } from './composables/use-ec-pagination';
 export { default as useEcSorting } from './composables/use-ec-sorting';
 export { default as config } from './config';
@@ -72,5 +73,4 @@ export { DEFAULT_PAGE_SIZE, PAGE_SIZES } from './enums/pagination';
 export { default as ecWithAbortableFetch } from './hocs/ec-with-abortable-fetch';
 export { createHOC, createHOCc } from './hocs/hoc';
 export { availableCurrencyFlagsSet, types as AvailableCurrencyFlagsTypes, flags } from './icons/currency-flags';
-export { default as Countdown } from './utils/countdown';
 export { default as flatpickr } from 'flatpickr';
diff --git a/src/utils/countdown.js b/src/utils/countdown.js
deleted file mode 100644
index 965ece2af..000000000
--- a/src/utils/countdown.js
+++ /dev/null
@@ -1,34 +0,0 @@
-import mitt from 'mitt';
-
-export default class Countdown {
-  constructor() {
-    const m = mitt();
-    Object.assign(this, m);
-  }
-
-  start(secondsToGo) {
-    this.seconds = secondsToGo;
-    this.secondsLeft = secondsToGo;
-    this.currentTime = Math.ceil(Date.now() / 1000);
-    this.startTime = Math.ceil(Date.now() / 1000);
-    this.interval = setInterval(() => this.reduceSecondsLeft(), 1000);
-  }
-
-  get timeDifference() {
-    return this.currentTime - this.startTime;
-  }
-
-  reduceSecondsLeft() {
-    this.currentTime = Math.ceil(Date.now() / 1000);
-    this.secondsLeft = this.seconds - this.timeDifference;
-    this.emit('time-updated', this.secondsLeft);
-    if (this.secondsLeft <= 0) {
-      this.stop();
-      this.emit('time-expired');
-    }
-  }
-
-  stop() {
-    clearInterval(this.interval);
-  }
-}
diff --git a/src/utils/countdown.spec.js b/src/utils/countdown.spec.js
deleted file mode 100644
index ce9cc412a..000000000
--- a/src/utils/countdown.spec.js
+++ /dev/null
@@ -1,51 +0,0 @@
-import fakeTimers from '@sinonjs/fake-timers';
-import { vi } from 'vitest';
-
-import Countdown from './countdown';
-
-describe('Countdown', () => {
-  let clock;
-
-  beforeEach(() => {
-    clock = fakeTimers.install();
-  });
-
-  afterEach(() => {
-    if (clock) {
-      clock.uninstall();
-    }
-  });
-
-  it('should finish the countdown', () => {
-    const countdown = new Countdown();
-    countdown.start(20);
-    clock.tick(20000);
-
-    expect(countdown.secondsLeft).toBe(0);
-    expect(clock.countTimers()).toBe(0);
-  });
-
-  it('should update the "secondsLeft" when the time is running', () => {
-    const countdown = new Countdown();
-    countdown.start(20);
-    clock.tick(10000);
-    expect(countdown.secondsLeft).toBe(10);
-    clock.tick(10000);
-    expect(countdown.secondsLeft).toBe(0);
-    expect(clock.countTimers()).toBe(0);
-  });
-
-  it('should emit the events', () => {
-    const timeExpiredMock = vi.fn();
-    const timeUpdatedMock = vi.fn();
-    const countdown = new Countdown();
-    countdown.on('time-expired', timeExpiredMock);
-    countdown.on('time-updated', timeUpdatedMock);
-    countdown.start(20);
-    clock.tick(20000);
-
-    expect(timeExpiredMock).toHaveBeenCalledTimes(1);
-    expect(timeUpdatedMock).toHaveBeenCalledTimes(20);
-    expect(clock.countTimers()).toBe(0);
-  });
-});