fix geometric utils bug with polygon deletion

Author: TrevorBurgoyne

.github/tasks.md

@@ -1,38 +1,3 @@
-## Tasks: Fix Type Declarations for npm Consumers
+## Tasks
 
-### Phase 1: Enable Declaration Generation
-- [x] Add `declaration: true` and `declarationMap: true` to `tsconfig.json`
-- [x] Add `"files"` field to `package.json` to include `dist/`, `build/`, `src/`, `index.d.ts`
-
-### Phase 2: Fix Incorrect Types in `index.d.ts`
-- [x] Fix `get_allowed_toolbox_item_enum()` return type → `typeof AllowedToolboxItem`
-- [x] Fix `get_resize_toolbox_item()` return type → `typeof AnnotationResizeItem`
-- [x] Fix `get_annotations` / `set_annotations` parameter type → `string` (subtask key)
-- [x] Update constructor to accept kwargs object with deprecated overload
-
-### Phase 3: Add Missing Declarations
-- [x] Add `static version(): string` and instance `version(): string`
-- [x] Re-export `AllowedToolboxItem`, `ULabelAnnotation`, `ULabelSubtask` from `index.d.ts`
-
-### Phase 4: Verify
-- [x] Run `npm run build` successfully
-- [x] Run `npm run lint` successfully
-
-### Phase 5: Fix Behavioral Changes from Strict TypeScript Migration
-- [x] Revert null→undefined changes in `suggest_edits`, `fly_to_annotation_id`, `show_global_edit_suggestion`
-- [x] Preserve `task_meta` null value in submit payload
-- [x] Preserve `class_def.keybind` null value in `original_class_keybinds`
-- [x] Widen `index.d.ts` types to accept null where runtime uses null
-- [x] Unit tests for keybind storage and configuration defaults
-- [x] E2E tests for API behavior contracts (api-behavior.spec.js)
-- [x] Assess `annotation_operators.ts` default value changes (id=0, distance=Infinity, distances={distance:0})
-- [x] Add annotation classification unit test
-- [x] Add distance_from property e2e test
-- [x] Revert `show_annotation_mode(undefined)` → `null` in html_builder.ts
-- [x] Revert `redraw_all_annotations(key, undefined, false)` → `null` in toolbox.ts (2 sites)
-- [x] Widen `index.d.ts` types for `redraw_all_annotations` offset and `show_annotation_mode` el
-- [x] Unit tests for `replaceLowerConcat` (split/join behavior)
-- [x] E2E tests for `show_annotation_mode(null)`, `redraw_all_annotations` with null offset/subtask
-- [x] Run full lint + build + test validation
-- [ ] Run full lint + build + test validation
 

src/geometric_utils.ts

@@ -204,8 +204,10 @@ export class GeometricUtils {
             return turf.length(b) - turf.length(a);
         });
 
-        // Return the longest remaining split
-        // TODO: split into multiple polylines?
+        // Return the longest remaining split, or empty if all parts were inside the polygon
+        if (remaining_splits.features.length === 0) {
+            return [];
+        }
         return <ULabelSpatialPayload2D>remaining_splits.features[0].geometry.coordinates;
     }
 

src/utilities.ts

@@ -6,6 +6,7 @@
 import { ULabel } from "../src/index";
 import { ULabelSubtask } from "./subtask";
 import { DELETE_CLASS_ID, DELETE_MODES } from "./annotation";
+import { log_message, LogLevel } from "./error_logging";
 
 /**
  * Checks if something is an object, not an array, and not null
@@ -61,12 +62,14 @@ export function get_active_class_id(ulabel: ULabel): number | undefined {
 
         // If the payload is an object then return its id if its confidence is > 0
         if (payload.confidence > 0) {
-            console.log(`payload: ${payload}`);
             return payload.class_id;
         }
     }
-    console.error(`get_active_class_id was unable to determine an active class id.
-    current_subtask: ${JSON.stringify(current_subtask)}`);
+    log_message(
+        `get_active_class_id was unable to determine an active class id. current_subtask: ${JSON.stringify(current_subtask)}`,
+        LogLevel.WARNING,
+    );
+    return undefined;
 }
 
 /**

tests/geometric_utils.test.js

@@ -0,0 +1,47 @@
+// Tests for geometric utility functions
+const { GeometricUtils } = require("../build/geometric_utils");
+
+describe("GeometricUtils", () => {
+    describe("subtract_simple_polygon_from_polyline", () => {
+        test("should return empty array when polyline is entirely inside polygon", () => {
+            // A polyline completely inside a large polygon
+            const polyline = [[2, 2], [3, 3], [4, 4]];
+            const polygon = [[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]];
+
+            const result = GeometricUtils.subtract_simple_polygon_from_polyline(polyline, polygon);
+            expect(result).toEqual([]);
+        });
+
+        test("should return the polyline unchanged when entirely outside polygon", () => {
+            // A polyline completely outside the polygon
+            const polyline = [[20, 20], [30, 30], [40, 40]];
+            const polygon = [[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]];
+
+            const result = GeometricUtils.subtract_simple_polygon_from_polyline(polyline, polygon);
+            expect(result).toEqual(polyline);
+        });
+
+        test("should return partial polyline when it crosses through the polygon", () => {
+            // A polyline that crosses through the polygon
+            const polyline = [[-5, 5], [5, 5], [15, 5]];
+            const polygon = [[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]];
+
+            const result = GeometricUtils.subtract_simple_polygon_from_polyline(polyline, polygon);
+            // Should return a portion of the line (the longest part outside the polygon)
+            expect(result.length).toBeGreaterThan(0);
+        });
+
+        test("should not throw when all split segments are inside the polygon", () => {
+            // A polyline that enters and exits but the remaining parts after split
+            // are all inside — edge case that previously caused a crash
+            const polyline = [[1, 5], [5, 5], [9, 5]];
+            const polygon = [[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]];
+
+            // Should not throw, should return empty array
+            expect(() => {
+                const result = GeometricUtils.subtract_simple_polygon_from_polyline(polyline, polygon);
+                expect(result).toEqual([]);
+            }).not.toThrow();
+        });
+    });
+});