[GSoC2024] add return types to fix typescript warnings

cvat-canvas/src/typescript/canvasView.ts

@@ -97,7 +97,7 @@ export class CanvasViewImpl implements CanvasView, Listener {
         return this.controller.mode;
     }
 
-    private onMessage = (messages: CanvasHint[] | null, topic: string) => {
+    private onMessage = (messages: CanvasHint[] | null, topic: string): void => {
         this.canvas.dispatchEvent(
             new CustomEvent('canvas.message', {
                 bubbles: false,

cvat-canvas/src/typescript/objectSelector.ts

@@ -91,15 +91,15 @@ export class ObjectSelectorImpl implements ObjectSelector {
         return filtered;
     }
 
-    private onMouseDown = (event: MouseEvent) => {
+    private onMouseDown = (event: MouseEvent): void => {
         const point = translateToSVG((this.canvas.node as any) as SVGSVGElement, [event.clientX, event.clientY]);
         this.mouseDownPosition = { x: point[0], y: point[1] };
         this.selectionRect = this.canvas.rect().addClass('cvat_canvas_selection_box');
         this.selectionRect.attr({ 'stroke-width': consts.BASE_STROKE_WIDTH / this.geometry.scale });
         this.selectionRect.attr({ ...this.mouseDownPosition });
     };
 
-    private onMouseUp = (event: MouseEvent) => {
+    private onMouseUp = (event: MouseEvent): void => {
         if (this.selectionRect) {
             this.selectionRect.remove();
             this.selectionRect = null;
@@ -138,7 +138,7 @@ export class ObjectSelectorImpl implements ObjectSelector {
         }
     };
 
-    private onMouseMove = (event: MouseEvent) => {
+    private onMouseMove = (event: MouseEvent): void => {
         if (this.selectionRect) {
             const box = this.getSelectionBox(event);
             this.selectionRect.attr({

cvat-core/src/annotations-objects.ts

@@ -2075,7 +2075,7 @@ export class SkeletonShape extends Shape {
             return new ObjectState(this.get(frame));
         }
 
-        const updateElements = (affectedElements, action, property: 'points' | 'occluded' | 'hidden' | 'lock') => {
+        const updateElements = (affectedElements, action, property: 'points' | 'occluded' | 'hidden' | 'lock'): void => {
             const undoSkeletonProperties = this.elements.map((element) => element[property]);
             const undoSource = this.source;
             const redoSource = this.readOnlyFields.includes('source') ? this.source : computeNewSource(this.source);
@@ -2540,7 +2540,7 @@ class PolyTrack extends Track {
             return updatedMatching;
         }
 
-        function reduceInterpolation(interpolatedPoints, matching, leftPoints, rightPoints) {
+        function reduceInterpolation(interpolatedPoints, matching, leftPoints, rightPoints): void {
             function averagePoint(points: Point2D[]): Point2D {
                 let sumX = 0;
                 let sumY = 0;
@@ -2559,7 +2559,7 @@ class PolyTrack extends Track {
                 return Math.sqrt((point1.x - point2.x) ** 2 + (point1.y - point2.y) ** 2);
             }
 
-            function minimizeSegment(baseLength: number, N: number, startInterpolated, stopInterpolated) {
+            function minimizeSegment(baseLength: number, N: number, startInterpolated, stopInterpolated): void {
                 const threshold = baseLength / (2 * N);
                 const minimized = [interpolatedPoints[startInterpolated]];
                 let latestPushed = startInterpolated;
@@ -2596,7 +2596,7 @@ class PolyTrack extends Track {
                 interpolatedIndexes[i] = matching[i].map(() => accumulated++);
             }
 
-            function leftSegment(start, stop) {
+            function leftSegment(start, stop): void {
                 const startInterpolated = interpolatedIndexes[start][0];
                 const stopInterpolated = interpolatedIndexes[stop][0];
 
@@ -2611,7 +2611,7 @@ class PolyTrack extends Track {
                 reduced.push(...minimizeSegment(baseLength, N, startInterpolated, stopInterpolated));
             }
 
-            function rightSegment(leftPoint) {
+            function rightSegment(leftPoint): void {
                 const start = matching[leftPoint][0];
                 const [stop] = matching[leftPoint].slice(-1);
                 const startInterpolated = interpolatedIndexes[leftPoint][0];

cvat-core/src/lambda-manager.ts

@@ -6,14 +6,36 @@
 import serverProxy from './server-proxy';
 import { ArgumentError } from './exceptions';
 import MLModel from './ml-model';
-import { RQStatus } from './enums';
+import { RQStatus, ShapeType } from './enums';
 
 export interface ModelProvider {
     name: string;
     icon: string;
     attributes: Record<string, string>;
 }
 
+export interface InteractorResults {
+    mask: number[][];
+    points?: [number, number][];
+    bounds?: [number, number, number, number]
+}
+
+export interface DetectedShape {
+    type: ShapeType;
+    rotation?: number;
+    attributes: { name: string; value: string }[];
+    label: string;
+    outside?: boolean;
+    points?: number[];
+    mask?: number[];
+    elements: DetectedShape[];
+}
+
+export interface TrackerResults {
+    states: any[];
+    shapes: number[][];
+}
+
 class LambdaManager {
     private cachedList: MLModel[];
     private listening: Record<number, {
@@ -43,7 +65,7 @@ class LambdaManager {
         return { models, count: lambdaFunctions.length };
     }
 
-    async run(taskID: number, model: MLModel, args: any) {
+    async run(taskID: number, model: MLModel, args: any): Promise<string> {
         if (!Number.isInteger(taskID) || taskID < 0) {
             throw new ArgumentError(`Argument taskID must be a positive integer. Got "${taskID}"`);
         }
@@ -68,7 +90,7 @@ class LambdaManager {
         return result.id;
     }
 
-    async call(taskID, model, args) {
+    async call(taskID, model, args): Promise<TrackerResults | InteractorResults | DetectedShape[]> {
         if (!Number.isInteger(taskID) || taskID < 0) {
             throw new ArgumentError(`Argument taskID must be a positive integer. Got "${taskID}"`);
         }
@@ -81,7 +103,7 @@ class LambdaManager {
         return result;
     }
 
-    async requests() {
+    async requests(): Promise<any[]> {
         const lambdaRequests = await serverProxy.lambda.requests();
         return lambdaRequests
             .filter((request) => [RQStatus.QUEUED, RQStatus.STARTED].includes(request.status));