better typing for FE. remove a lot of explicit type casts, fix ts errors

Author: sawka

emain/emain-menu.ts

@@ -1,7 +1,7 @@
 // Copyright 2025, Command Line Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import { waveEventSubscribe } from "@/app/store/wps";
+import { waveEventSubscribeSingle } from "@/app/store/wps";
 import { RpcApi } from "@/app/store/wshclientapi";
 import * as electron from "electron";
 import { fireAndForget } from "../frontend/util/util";
@@ -385,7 +385,7 @@ export function makeAndSetAppMenu() {
 }
 
 function initMenuEventSubscriptions() {
-    waveEventSubscribe({
+    waveEventSubscribeSingle({
         eventType: "workspace:update",
         handler: makeAndSetAppMenu,
     });

frontend/app/store/global.ts

@@ -31,7 +31,7 @@ import { globalStore } from "./jotaiStore";
 import { modalsModel } from "./modalmodel";
 import { ClientService, ObjectService } from "./services";
 import * as WOS from "./wos";
-import { getFileSubject, waveEventSubscribe } from "./wps";
+import { getFileSubject, waveEventSubscribeSingle } from "./wps";
 
 let atoms: GlobalAtomsType;
 let globalEnvironment: "electron" | "renderer";
@@ -198,65 +198,56 @@ function initGlobalAtoms(initOpts: GlobalInitOptions) {
 }
 
 function initGlobalWaveEventSubs(initOpts: WaveInitOpts) {
-    waveEventSubscribe(
-        {
-            eventType: "waveobj:update",
-            handler: (event) => {
-                // console.log("waveobj:update wave event handler", event);
-                const update: WaveObjUpdate = event.data;
-                WOS.updateWaveObject(update);
-            },
+    waveEventSubscribeSingle({
+        eventType: "waveobj:update",
+        handler: (event) => {
+            // console.log("waveobj:update wave event handler", event);
+            WOS.updateWaveObject(event.data);
         },
-        {
-            eventType: "config",
-            handler: (event) => {
-                // console.log("config wave event handler", event);
-                const fullConfig = (event.data as WatcherUpdate).fullconfig;
-                globalStore.set(atoms.fullConfigAtom, fullConfig);
-            },
+    });
+    waveEventSubscribeSingle({
+        eventType: "config",
+        handler: (event) => {
+            // console.log("config wave event handler", event);
+            globalStore.set(atoms.fullConfigAtom, event.data.fullconfig);
         },
-        {
-            eventType: "waveai:modeconfig",
-            handler: (event) => {
-                const modeConfigs = (event.data as AIModeConfigUpdate).configs;
-                globalStore.set(atoms.waveaiModeConfigAtom, modeConfigs);
-            },
+    });
+    waveEventSubscribeSingle({
+        eventType: "waveai:modeconfig",
+        handler: (event) => {
+            globalStore.set(atoms.waveaiModeConfigAtom, event.data.configs);
         },
-        {
-            eventType: "userinput",
-            handler: (event) => {
-                // console.log("userinput event handler", event);
-                const data: UserInputRequest = event.data;
-                modalsModel.pushModal("UserInputModal", { ...data });
-            },
-            scope: initOpts.windowId,
+    });
+    waveEventSubscribeSingle({
+        eventType: "userinput",
+        handler: (event) => {
+            // console.log("userinput event handler", event);
+            modalsModel.pushModal("UserInputModal", { ...event.data });
         },
-        {
-            eventType: "blockfile",
-            handler: (event) => {
-                // console.log("blockfile event update", event);
-                const fileData: WSFileEventData = event.data;
-                const fileSubject = getFileSubject(fileData.zoneid, fileData.filename);
-                if (fileSubject != null) {
-                    fileSubject.next(fileData);
-                }
-            },
+        scope: initOpts.windowId,
+    });
+    waveEventSubscribeSingle({
+        eventType: "blockfile",
+        handler: (event) => {
+            // console.log("blockfile event update", event);
+            const fileSubject = getFileSubject(event.data.zoneid, event.data.filename);
+            if (fileSubject != null) {
+                fileSubject.next(event.data);
+            }
         },
-        {
-            eventType: "waveai:ratelimit",
-            handler: (event) => {
-                const rateLimitInfo: RateLimitInfo = event.data;
-                globalStore.set(atoms.waveAIRateLimitInfoAtom, rateLimitInfo);
-            },
+    });
+    waveEventSubscribeSingle({
+        eventType: "waveai:ratelimit",
+        handler: (event) => {
+            globalStore.set(atoms.waveAIRateLimitInfoAtom, event.data);
         },
-        {
-            eventType: "tab:indicator",
-            handler: (event) => {
-                const data: TabIndicatorEventData = event.data;
-                setTabIndicatorInternal(data.tabid, data.indicator);
-            },
-        }
-    );
+    });
+    waveEventSubscribeSingle({
+        eventType: "tab:indicator",
+        handler: (event) => {
+            setTabIndicatorInternal(event.data.tabid, event.data.indicator);
+        },
+    });
 }
 
 const blockCache = new Map<string, Map<string, any>>();
@@ -762,11 +753,11 @@ async function loadTabIndicators() {
 }
 
 function subscribeToConnEvents() {
-    waveEventSubscribe({
+    waveEventSubscribeSingle({
         eventType: "connchange",
-        handler: (event: WaveEvent) => {
+        handler: (event) => {
             try {
-                const connStatus = event.data as ConnStatus;
+                const connStatus = event.data;
                 if (connStatus == null || isBlank(connStatus.connection)) {
                     return;
                 }
@@ -852,7 +843,7 @@ function setTabIndicator(tabId: string, indicator: TabIndicator) {
         data: {
             tabid: tabId,
             indicator: indicator,
-        } as TabIndicatorEventData,
+        },
     };
     fireAndForget(() => RpcApi.EventPublishCommand(TabRpcClient, eventData));
 }

frontend/app/store/wos.ts

@@ -3,7 +3,7 @@
 
 // WaveObjectStore
 
-import { waveEventSubscribe } from "@/app/store/wps";
+import { waveEventSubscribeSingle } from "@/app/store/wps";
 import { getWebServerEndpoint } from "@/util/endpoints";
 import { fetch } from "@/util/fetchutil";
 import { fireAndForget } from "@/util/util";
@@ -79,7 +79,7 @@ function debugLogBackendCall(methodName: string, durationStr: string, args: any[
 }
 
 function wpsSubscribeToObject(oref: string): () => void {
-    return waveEventSubscribe({
+    return waveEventSubscribeSingle({
         eventType: "waveobj:update",
         scope: oref,
         handler: (event) => {

frontend/app/store/wps.ts

@@ -12,17 +12,19 @@ function setWpsRpcClient(client: WshClient) {
     WpsRpcClient = client;
 }
 
-type WaveEventSubject = {
-    handler: (event: WaveEvent) => void;
+type WaveEventSubject<T extends WaveEventName = WaveEventName> = {
+    handler: (event: Extract<WaveEvent, { event: T }>) => void;
     scope?: string;
 };
 
-type WaveEventSubjectContainer = WaveEventSubject & {
+type WaveEventSubjectContainer = {
+    handler: (event: WaveEvent) => void;
+    scope?: string;
     id: string;
 };
 
-type WaveEventSubscription = WaveEventSubject & {
-    eventType: string;
+type WaveEventSubscription<T extends WaveEventName = WaveEventName> = WaveEventSubject<T> & {
+    eventType: T;
 };
 
 type WaveEventUnsubscribe = {
@@ -58,29 +60,25 @@ function updateWaveEventSub(eventType: string) {
     RpcApi.EventSubCommand(WpsRpcClient, subreq, { noresponse: true });
 }
 
-function waveEventSubscribe(...subscriptions: WaveEventSubscription[]): () => void {
-    const unsubs: WaveEventUnsubscribe[] = [];
-    const eventTypeSet = new Set<string>();
-    for (const subscription of subscriptions) {
-        // console.log("waveEventSubscribe", subscription);
-        if (subscription.handler == null) {
-            return;
-        }
-        const id: string = crypto.randomUUID();
-        let subjects = waveEventSubjects.get(subscription.eventType);
-        if (subjects == null) {
-            subjects = [];
-            waveEventSubjects.set(subscription.eventType, subjects);
-        }
-        const subcont: WaveEventSubjectContainer = { id, handler: subscription.handler, scope: subscription.scope };
-        subjects.push(subcont);
-        unsubs.push({ id, eventType: subscription.eventType });
-        eventTypeSet.add(subscription.eventType);
+function waveEventSubscribeSingle<T extends WaveEventName>(subscription: WaveEventSubscription<T>): () => void {
+    // console.log("waveEventSubscribeSingle", subscription);
+    if (subscription.handler == null) {
+        return () => {};
     }
-    for (const eventType of eventTypeSet) {
-        updateWaveEventSub(eventType);
+    const id: string = crypto.randomUUID();
+    let subjects = waveEventSubjects.get(subscription.eventType);
+    if (subjects == null) {
+        subjects = [];
+        waveEventSubjects.set(subscription.eventType, subjects);
     }
-    return () => waveEventUnsubscribe(...unsubs);
+    const subcont: WaveEventSubjectContainer = {
+        id,
+        handler: subscription.handler as (event: WaveEvent) => void,
+        scope: subscription.scope,
+    };
+    subjects.push(subcont);
+    updateWaveEventSub(subscription.eventType);
+    return () => waveEventUnsubscribe({ id, eventType: subscription.eventType });
 }
 
 function waveEventUnsubscribe(...unsubscribes: WaveEventUnsubscribe[]) {
@@ -149,7 +147,7 @@ export {
     getFileSubject,
     handleWaveEvent,
     setWpsRpcClient,
-    waveEventSubscribe,
+    waveEventSubscribeSingle,
     waveEventUnsubscribe,
     wpsReconnectHandler,
 };

frontend/app/tab/workspaceswitcher.tsx

@@ -21,7 +21,7 @@ import { IconButton } from "../element/iconbutton";
 import { atoms, getApi } from "../store/global";
 import { WorkspaceService } from "../store/services";
 import { getObjectValue, makeORef } from "../store/wos";
-import { waveEventSubscribe } from "../store/wps";
+import { waveEventSubscribeSingle } from "../store/wps";
 import { WorkspaceEditor } from "./workspaceeditor";
 import "./workspaceswitcher.scss";
 
@@ -59,7 +59,7 @@ const WorkspaceSwitcher = forwardRef<HTMLDivElement>((_, ref) => {
 
     useEffect(
         () =>
-            waveEventSubscribe({
+            waveEventSubscribeSingle({
                 eventType: "workspace:update",
                 handler: () => fireAndForget(updateWorkspaceList),
             }),

frontend/app/view/sysinfo/sysinfo.tsx

@@ -13,7 +13,7 @@ import * as jotai from "jotai";
 import * as React from "react";
 
 import { useDimensionsWithExistingRef } from "@/app/hook/useDimensions";
-import { waveEventSubscribe } from "@/app/store/wps";
+import { waveEventSubscribeSingle } from "@/app/store/wps";
 import { RpcApi } from "@/app/store/wshclientapi";
 import { TabRpcClient } from "@/app/store/wshrpcutil";
 import { atoms } from "@/store/global";
@@ -80,8 +80,8 @@ for (let i = 0; i < 32; i++) {
     DefaultPlotMeta[`cpu:${i}`] = defaultCpuMeta(`Core ${i}`);
 }
 
-function convertWaveEventToDataItem(event: WaveEvent): DataItem {
-    const eventData: TimeSeriesData = event.data;
+function convertWaveEventToDataItem(event: Extract<WaveEvent, { event: "sysinfo" }>): DataItem {
+    const eventData = event.data;
     if (eventData == null || eventData.ts == null || eventData.values == null) {
         return null;
     }
@@ -360,7 +360,7 @@ function SysinfoView({ model, blockId }: SysinfoViewProps) {
         }
     }, [connStatus.status, connName]);
     React.useEffect(() => {
-        const unsubFn = waveEventSubscribe({
+        const unsubFn = waveEventSubscribeSingle({
             eventType: "sysinfo",
             scope: connName,
             handler: (event) => {

frontend/app/view/term/term-model.ts

@@ -6,7 +6,7 @@ import { BlockNodeModel } from "@/app/block/blocktypes";
 import { appHandleKeyDown } from "@/app/store/keymodel";
 import { modalsModel } from "@/app/store/modalmodel";
 import type { TabModel } from "@/app/store/tab-model";
-import { waveEventSubscribe } from "@/app/store/wps";
+import { waveEventSubscribeSingle } from "@/app/store/wps";
 import { RpcApi } from "@/app/store/wshclientapi";
 import { makeFeBlockRouteId } from "@/app/store/wshrouter";
 import { DefaultRouter, TabRpcClient } from "@/app/store/wshrpcutil";
@@ -330,12 +330,11 @@ export class TermViewModel implements ViewModel {
         initialShellProcStatus.then((rts) => {
             this.updateShellProcStatus(rts);
         });
-        this.shellProcStatusUnsubFn = waveEventSubscribe({
+        this.shellProcStatusUnsubFn = waveEventSubscribeSingle({
             eventType: "controllerstatus",
             scope: WOS.makeORef("block", blockId),
             handler: (event) => {
-                let bcRTS: BlockControllerRuntimeStatus = event.data;
-                this.updateShellProcStatus(bcRTS);
+                this.updateShellProcStatus(event.data);
             },
         });
         this.shellProcStatus = jotai.atom((get) => {
@@ -364,7 +363,7 @@ export class TermViewModel implements ViewModel {
             .catch((error) => {
                 console.log("error getting initial block job status", error);
             });
-        this.blockJobStatusUnsubFn = waveEventSubscribe({
+        this.blockJobStatusUnsubFn = waveEventSubscribeSingle({
             eventType: "block:jobstatus",
             scope: `block:${blockId}`,
             handler: (event) => {

frontend/app/view/term/term.tsx

@@ -6,7 +6,7 @@ import type { BlockNodeModel } from "@/app/block/blocktypes";
 import { Search, useSearch } from "@/app/element/search";
 import { ContextMenuModel } from "@/app/store/contextmenu";
 import { useTabModel } from "@/app/store/tab-model";
-import { waveEventSubscribe } from "@/app/store/wps";
+import { waveEventSubscribeSingle } from "@/app/store/wps";
 import { RpcApi } from "@/app/store/wshclientapi";
 import { TabRpcClient } from "@/app/store/wshrpcutil";
 import type { TermViewModel } from "@/app/view/term/term-model";
@@ -55,7 +55,7 @@ const TermResyncHandler = React.memo(({ blockId, model }: TerminalViewProps) =>
 
 const TermVDomToolbarNode = ({ vdomBlockId, blockId, model }: TerminalViewProps & { vdomBlockId: string }) => {
     React.useEffect(() => {
-        const unsub = waveEventSubscribe({
+        const unsub = waveEventSubscribeSingle({
             eventType: "blockclose",
             scope: WOS.makeORef("block", vdomBlockId),
             handler: (event) => {
@@ -98,7 +98,7 @@ const TermVDomToolbarNode = ({ vdomBlockId, blockId, model }: TerminalViewProps
 
 const TermVDomNodeSingleId = ({ vdomBlockId, blockId, model }: TerminalViewProps & { vdomBlockId: string }) => {
     React.useEffect(() => {
-        const unsub = waveEventSubscribe({
+        const unsub = waveEventSubscribeSingle({
             eventType: "blockclose",
             scope: WOS.makeORef("block", vdomBlockId),
             handler: (event) => {