kunkun/packages/api/src/events.ts
Huakun Shen ed87fc6c12
App Setup (#2)
* chore: add vendor submodules

* feat: add packages for db,ci,schema,api,jarvis cmds

* feat: add tauri-jarvis-plugin

* feat: implement extension commands list

* fix(desktop): import path errors after packages refactor

* chore: add self signed cert

* fix: prevent prerender for desktop

* fix(desktop): desktop sveltekit static build, use csr for dynamic route

* feat: add error handling page and components

* refactor: component lib

* refactor: move more types, functions and components out of desktop

* refactor(ui): more refactor

* refactor(ui): move store components to @kksh/ui

* ci: add CI for build & test

* refactor: rename @kksh/extensions to @kksh/extension

* ci: add 2 more ci

* ci: fix

* fix: CI env var

* chore: add changeset

* feat: implement extension store item detail view

* feat: implement extension store install, uninstall, upgrade

* format

* revert: upgradable logic, the new one doesn't work yet

* refactor: make @kksh/ui dependent only on @kksh/api

Reason: @kksh/ui may be published later for building website, all its dependency packages must be also published. To avoid trouble it should be standalone, depend only on packages already published

* refactor: cleanup

* fixed: some typescript error

* chore: got typedoc working on @kksh/api

* ci: disable manifest schema upload CI on push
2024-11-03 13:54:44 -05:00

32 lines
1.2 KiB
TypeScript

import { emitTo, listen, type EventCallback, type UnlistenFn } from "@tauri-apps/api/event"
/* ------------------------------- Event Names ------------------------------ */
export const RECORD_EXTENSION_PROCESS_EVENT = "record-extension-process"
export interface IRecordExtensionProcessEvent {
windowLabel: string
pid: number
}
/**
* listen to RECORD_EXTENSION_PROCESS_EVENT
* This event is emitted when an extension spawns a process. Processes won't be cleaned up automatically
* Extensions should clean up the processes when extension quits, but there is no way to guarantee this.
* So we need to record the processes spawned from extensions and clean up the processes when extension quits.
* @param callback
* @returns
*/
export function listenToRecordExtensionProcessEvent(
callback: EventCallback<IRecordExtensionProcessEvent>
): Promise<UnlistenFn> {
return listen<IRecordExtensionProcessEvent>(RECORD_EXTENSION_PROCESS_EVENT, callback)
}
export const KILL_PROCESS_EVENT = "kunkun://kill-process"
export function emitKillProcessEvent(pid: number) {
return emitTo("main", KILL_PROCESS_EVENT, { pid })
}
export function listenToKillProcessEvent(cb: EventCallback<{ pid: number }>) {
return listen<{ pid: number }>(KILL_PROCESS_EVENT, cb)
}