Tauri Listener Accumulation

[BatuhanAksoyy]

Hello, I'm coding a desktop application with Vue and Tauri. Today I was trying implement progression system with the library that i have created.

#[derive(Clone)]
struct InstanceReporter<'a> {
    window: &'a Window,
}

#[derive(Serialize, Clone)]
struct ProgressPayload<T> {
    event: String,
    data: T,
}

impl<'a> Reporter for InstanceReporter<'a> {
    fn send(&self, case: lyceris::reporter::Case) {
        match case {
            Case::SetMessage(m) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "send_message".to_string(),
                            data: m,
                        },
                    )
                    .ok();
            }
            Case::SetSubMessage(m) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "send_sub_message".to_string(),
                            data: m,
                        },
                    )
                    .ok();
            }
            Case::SetProgress(p) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "set_progress".to_string(),
                            data: p,
                        },
                    )
                    .ok();
            }
            Case::SetMaxProgress(p) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "set_max_progress".to_string(),
                            data: p,
                        },
                    )
                    .ok();
            }
            Case::SetSubProgress(p) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "set_sub_progress".to_string(),
                            data: p,
                        },
                    )
                    .ok();
            }
            Case::SetLoadingProgress => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "set_loading_progress".to_string(),
                            data: 0,
                        },
                    )
                    .ok();
            }
            Case::SetMaxSubProgress(p) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "set_max_sub_progress".to_string(),
                            data: p,
                        },
                    )
                    .ok();
            }
            Case::AddProgress(p) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "add_progress".to_string(),
                            data: p,
                        },
                    )
                    .ok();
            }
            Case::AddMaxProgress(p) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "add_max_progress".to_string(),
                            data: p,
                        },
                    )
                    .ok();
            }
            Case::AddSubProgress(p) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "add_sub_progress".to_string(),
                            data: p,
                        },
                    )
                    .ok();
            }
            Case::AddMaxSubProgress(p) => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "add_max_sub_progress".to_string(),
                            data: p,
                        },
                    )
                    .ok();
            }
            Case::HideProgress => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "hide_progress".to_string(),
                            data: 0,
                        },
                    )
                    .ok();
            }
            Case::RemoveProgress => {
                self.window
                    .emit(
                        "progress",
                        ProgressPayload {
                            event: "remove_progress".to_string(),
                            data: 0,
                        },
                    )
                    .ok();
            }
        }
    }
}

The library that I use want me to provide a struct that implements Reporter. It uses send method for progression and I use emit to send this information to the frontend.
At the frontend I use listen to listen progressions.

const progress = {
    current: Number(),
    max: Number(),
    text: String()
}

export const startListen = async () => {
    await listen("progress", (m: any) => {
        const wait = useWait();
        switch (m.payload.event) {
            case "set_message":
                progress.text = m.payload.data as string;
                wait.set({ text: progress.text, status:true,percent: progress.current / progress.max * 100 });
                break;
            case "set_sub_message":
                progress.text = m.payload.data as string;
                wait.set({ percent: progress.current / progress.max * 100, text: progress.text, status:true });
                break;
            case "set_progress":
                progress.current = m.payload.data as number;
                wait.set({ percent: progress.current / progress.max * 100, text: progress.text, status:true });
                break;
            case "set_max_progress":
                progress.max = m.payload.data as number;
                wait.set({ percent: progress.current / progress.max * 100, text: progress.text, status:true });
                break;
            case "add_progress":
                progress.current += m.payload.data as number;
                wait.set({ percent: progress.current / progress.max * 100, text: progress.text, status:true });
                break;
            case "add_max_progress":
                progress.max += m.payload.data as number;
                wait.set({ percent: progress.current / progress.max * 100, text: progress.text, status:true });
                break;
            case "hide_progress":
                wait.clear();
                break;
            case "remove_progress":
                wait.clear();
                break;
            default:
                return;
        }
    });
}

I should hide the window when process is started and show the window when process exits.
I press a start button, it downloads things and shows me the progression, hids the window.
Then I stop the process, it shows the window.
When I stop the process and try to navigate through vue-router it shows me the loading screen.
For some reason the listen function triggers and shows the loading screen cause I use store function wait.set for every event.

The funny part is when I add println!() under the back-end InstanceReport send function it doesn't happen.
I wasn't facing with this issue on old tauri versions.
I'm using tauri-2.0.0rc and it uses a new trait Emitter.

Maybe the problem is me, Vue or this new Emitter trait but I need some help because I couldn't fix the problem.