feat: application improvement

Author: drduhe

jest.config.js

@@ -0,0 +1,25 @@
+// Copyright 2023-2026 Amazon.com, Inc. or its affiliates.
+
+/** @type {import('jest').Config} */
+const config = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  roots: ["<rootDir>/src"],
+  testMatch: ["**/__tests__/**/*.test.ts", "**/__tests__/**/*.test.tsx"],
+  moduleNameMapper: {
+    "^@/(.*)$": "<rootDir>/src/$1"
+  },
+  transform: {
+    "^.+\\.tsx?$": [
+      "ts-jest",
+      {
+        tsconfig: "tsconfig.json",
+        diagnostics: false
+      }
+    ]
+  },
+  // Ignore CSS imports in tests
+  moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json"]
+};
+
+module.exports = config;

package-lock.json

@@ -15,6 +15,8 @@
     "dev": "vite",
     "build": "tsc && vite build && electron-builder",
     "preview": "vite preview",
+    "test": "jest --passWithNoTests",
+    "test:watch": "jest --watch",
     "clean": "rm -rf node_modules dist-electron",
     "postinstall": "patch-package"
   },
@@ -38,6 +40,7 @@
   },
   "devDependencies": {
     "@playwright/test": "^1.57.0",
+    "@types/jest": "^30.0.0",
     "@types/react": "^19.2.9",
     "@types/react-dom": "^19.2.3",
     "@types/uuid": "^11.0.0",

package.json

@@ -112,33 +112,25 @@ def get_extents(dataset_path: str) -> dict:
                         # Last resort: use coordinates as-is (assuming they're already WGS84)
                         geo_corners.append((x, y))
         else:
-            # Use geotransform to calculate corner coordinates
-            # Using the geotransform: [x_origin, pixel_width, rotation, y_origin, rotation, pixel_height]
-            x_origin = geotransform[0]
-            pixel_width = geotransform[1]
-            y_origin = geotransform[3]
-            pixel_height = geotransform[5]
-
-            # Calculate the four corners in source coordinates
-            x_min = x_origin
-            x_max = x_origin + x_size * pixel_width
-            y_min = y_origin + y_size * pixel_height  # Note: pixel_height is usually negative
-            y_max = y_origin
-
-            # Ensure we have the correct min/max values
-            if y_min > y_max:
-                y_min, y_max = y_max, y_min
-            if x_min > x_max:
-                x_min, x_max = x_max, x_min
-
-            # Transform the four corners to WGS84
-            corners = [
-                (x_min, y_max),  # Top-left
-                (x_max, y_max),  # Top-right
-                (x_max, y_min),  # Bottom-right
-                (x_min, y_min)   # Bottom-left
+            # Use the full geotransform to calculate corner coordinates.
+            # GeoTransform: [x_origin, pixel_width, x_rotation, y_origin, y_rotation, pixel_height]
+            # Full formula:
+            #   x_geo = gt[0] + col * gt[1] + row * gt[2]
+            #   y_geo = gt[3] + col * gt[4] + row * gt[5]
+            # This correctly handles images with rotation (non-zero gt[2] and gt[4]).
+            corners_pixel = [
+                (0, 0),                  # Top-left
+                (x_size, 0),             # Top-right
+                (x_size, y_size),        # Bottom-right
+                (0, y_size)              # Bottom-left
             ]
 
+            corners = []
+            for col, row in corners_pixel:
+                x = geotransform[0] + col * geotransform[1] + row * geotransform[2]
+                y = geotransform[3] + col * geotransform[4] + row * geotransform[5]
+                corners.append((x, y))
+
             # Transform all corners to WGS84
             geo_corners = []
             for i, (x, y) in enumerate(corners):

scripts/calculate_extents.py

@@ -12,6 +12,7 @@ import Logo from "@/components/Logo";
 import FeaturePopup, { type FeaturePopupData } from "@/components/FeaturePopup";
 import ConfigWarnings from "@/components/alert/ConfigWarnings";
 import { ResourceProvider } from "@/context/ResourceContext";
+import type { ImageRequestState } from "@/types";
 
 /** Natural Earth II fallback (offline, bundled with Cesium) */
 function naturalEarthLayer(): Cesium.ImageryLayer {
@@ -35,7 +36,7 @@ async function resolveBaseLayer(): Promise<Cesium.ImageryLayer> {
 }
 
 const App = () => {
-  const [imageRequestStatus, setImageRequestStatus] = useState({
+  const [imageRequestStatus, setImageRequestStatus] = useState<ImageRequestState>({
     state: "idle",
     data: {}
   });

src/App.tsx

@@ -0,0 +1,111 @@
+// Copyright 2023-2026 Amazon.com, Inc. or its affiliates.
+
+import { formatFeatureProperties, type PropertyGroup } from "@/utils/cesiumFormatters";
+
+describe("formatFeatureProperties", () => {
+  it("returns empty array for empty properties", () => {
+    const result = formatFeatureProperties({});
+    expect(result).toEqual([]);
+  });
+
+  it("classifies properties into correct groups", () => {
+    const result = formatFeatureProperties({
+      class: "building",
+      score: 0.95,
+      latitude: 38.0,
+      longitude: -77.0,
+      timestamp: "2025-01-01T00:00:00Z",
+      custom_field: "hello"
+    });
+
+    const groupNames = result.map((g: PropertyGroup) => g.group);
+    expect(groupNames).toContain("CLASSIFICATION");
+    expect(groupNames).toContain("LOCATION");
+    expect(groupNames).toContain("METADATA");
+    expect(groupNames).toContain("OTHER");
+  });
+
+  it("formats numeric values correctly", () => {
+    const result = formatFeatureProperties({
+      score: 0.8542,
+      count: 42
+    });
+
+    const classGroup = result.find((g) => g.group === "CLASSIFICATION");
+    const scoreEntry = classGroup?.entries.find((e) => e.key.toLowerCase().includes("score"));
+    // Score < 0.99, so should have 4 decimal places
+    expect(scoreEntry?.value).toBe("0.8542");
+
+    const otherGroup = result.find((g) => g.group === "OTHER");
+    const countEntry = otherGroup?.entries.find((e) => e.key.toLowerCase().includes("count"));
+    expect(countEntry?.value).toBe("42");
+  });
+
+  it("skips coordinate-like properties", () => {
+    const result = formatFeatureProperties({
+      coordinates: [1, 2, 3],
+      geometry: { type: "Point" },
+      type: "Feature",
+      class: "vehicle"
+    });
+
+    // Should only have classification group (from class)
+    const allEntries = result.flatMap((g) => g.entries);
+    expect(allEntries.some((e) => e.key.toLowerCase() === "coordinates")).toBe(false);
+    expect(allEntries.some((e) => e.key.toLowerCase() === "geometry")).toBe(false);
+    expect(allEntries.some((e) => e.key.toLowerCase() === "type")).toBe(false);
+  });
+
+  it("handles nested objects with children", () => {
+    const result = formatFeatureProperties({
+      metadata: {
+        version: "1.0",
+        author: "test"
+      }
+    });
+
+    // Should have an entry with children
+    const allEntries = result.flatMap((g) => g.entries);
+    const nested = allEntries.find((e) => e.children && e.children.length > 0);
+    expect(nested).toBeDefined();
+    expect(nested?.children?.length).toBeGreaterThan(0);
+  });
+
+  it("truncates long values", () => {
+    const longValue = "a".repeat(200);
+    const result = formatFeatureProperties({
+      long_field: longValue
+    });
+
+    const allEntries = result.flatMap((g) => g.entries);
+    const entry = allEntries.find((e) => e.key.toLowerCase().includes("long"));
+    expect(entry?.value.length).toBeLessThanOrEqual(104); // 100 + "..."
+    expect(entry?.value.endsWith("...")).toBe(true);
+  });
+
+  it("handles null and undefined values", () => {
+    const result = formatFeatureProperties({
+      empty_field: null,
+      undefined_field: undefined
+    });
+
+    const allEntries = result.flatMap((g) => g.entries);
+    const nullEntry = allEntries.find((e) => e.key.toLowerCase().includes("empty"));
+    expect(nullEntry?.value).toBe("N/A");
+  });
+
+  it("handles feature_classes special case with IRI and Score", () => {
+    const result = formatFeatureProperties({
+      feature_classes: [
+        { iri: "http://example.com/building", score: 0.92 }
+      ]
+    });
+
+    const classGroup = result.find((g) => g.group === "CLASSIFICATION");
+    expect(classGroup).toBeDefined();
+    const iriEntry = classGroup?.entries.find((e) => e.key === "IRI");
+    expect(iriEntry?.value).toBe("http://example.com/building");
+    const scoreEntry = classGroup?.entries.find((e) => e.key === "Score");
+    expect(scoreEntry?.value).toBe("0.9200");
+  });
+});

src/__tests__/cesiumFormatters.test.ts

@@ -0,0 +1,56 @@
+// Copyright 2023-2026 Amazon.com, Inc. or its affiliates.
+
+import { isCredentialError } from "@/config";
+
+describe("isCredentialError", () => {
+  it("returns true for known credential error names", () => {
+    const knownNames = [
+      "ExpiredToken",
+      "ExpiredTokenException",
+      "RequestExpired",
+      "InvalidClientTokenId",
+      "UnrecognizedClientException",
+      "InvalidIdentityToken",
+      "AccessDeniedException",
+      "AuthFailure",
+      "SignatureDoesNotMatch",
+      "IncompleteSignature"
+    ];
+
+    for (const name of knownNames) {
+      expect(isCredentialError({ name })).toBe(true);
+    }
+  });
+
+  it("returns true for HTTP 401 status codes", () => {
+    const err = { $metadata: { httpStatusCode: 401 } };
+    expect(isCredentialError(err)).toBe(true);
+  });
+
+  it("returns true for HTTP 403 status codes", () => {
+    const err = { $metadata: { httpStatusCode: 403 } };
+    expect(isCredentialError(err)).toBe(true);
+  });
+
+  it("returns true for HTTP 400 status codes", () => {
+    const err = { $metadata: { httpStatusCode: 400 } };
+    expect(isCredentialError(err)).toBe(true);
+  });
+
+  it("returns false for regular errors", () => {
+    expect(isCredentialError(new Error("Network timeout"))).toBe(false);
+    expect(isCredentialError({ name: "NotFoundError" })).toBe(false);
+    expect(isCredentialError(null)).toBe(false);
+    expect(isCredentialError(undefined)).toBe(false);
+  });
+
+  it("returns false for HTTP 500 status codes", () => {
+    const err = { $metadata: { httpStatusCode: 500 } };
+    expect(isCredentialError(err)).toBe(false);
+  });
+
+  it("returns false for HTTP 200 status codes", () => {
+    const err = { $metadata: { httpStatusCode: 200 } };
+    expect(isCredentialError(err)).toBe(false);
+  });
+});

src/__tests__/config.test.ts

@@ -0,0 +1,35 @@
+// Copyright 2023-2026 Amazon.com, Inc. or its affiliates.
+
+import { handleAwsError } from "@/hooks/useS3Browser";
+
+describe("handleAwsError", () => {
+  it("calls setShowCredsExpiredAlert(true) for credential errors", () => {
+    const setAlert = jest.fn();
+    handleAwsError({ name: "ExpiredToken" }, setAlert);
+    expect(setAlert).toHaveBeenCalledWith(true);
+  });
+
+  it("calls setShowCredsExpiredAlert(true) for HTTP 403", () => {
+    const setAlert = jest.fn();
+    handleAwsError({ $metadata: { httpStatusCode: 403 } }, setAlert);
+    expect(setAlert).toHaveBeenCalledWith(true);
+  });
+
+  it("does not call setShowCredsExpiredAlert for non-credential errors", () => {
+    const setAlert = jest.fn();
+    handleAwsError(new Error("Network timeout"), setAlert);
+    expect(setAlert).not.toHaveBeenCalled();
+  });
+
+  it("handles null error without throwing", () => {
+    const setAlert = jest.fn();
+    expect(() => handleAwsError(null, setAlert)).not.toThrow();
+    expect(setAlert).not.toHaveBeenCalled();
+  });
+
+  it("handles undefined error without throwing", () => {
+    const setAlert = jest.fn();
+    expect(() => handleAwsError(undefined, setAlert)).not.toThrow();
+    expect(setAlert).not.toHaveBeenCalled();
+  });
+});

src/__tests__/handleAwsError.test.ts

@@ -0,0 +1,50 @@
+// Copyright 2023-2026 Amazon.com, Inc. or its affiliates.
+
+import { logger } from "@/utils/logger";
+
+describe("logger", () => {
+  let consoleSpy: {
+    log: jest.SpyInstance;
+    warn: jest.SpyInstance;
+    error: jest.SpyInstance;
+  };
+
+  beforeEach(() => {
+    consoleSpy = {
+      log: jest.spyOn(console, "log").mockImplementation(),
+      warn: jest.spyOn(console, "warn").mockImplementation(),
+      error: jest.spyOn(console, "error").mockImplementation()
+    };
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("logger.info calls console.log with prefix", () => {
+    logger.info("test message");
+    expect(consoleSpy.log).toHaveBeenCalledWith("[INFO]", "test message");
+  });
+
+  it("logger.warn calls console.warn with prefix", () => {
+    logger.warn("warning message");
+    expect(consoleSpy.warn).toHaveBeenCalledWith("[WARN]", "warning message");
+  });
+
+  it("logger.error calls console.error with prefix", () => {
+    logger.error("error message");
+    expect(consoleSpy.error).toHaveBeenCalledWith("[ERROR]", "error message");
+  });
+
+  it("passes extra arguments through", () => {
+    const extra = { key: "value" };
+    logger.info("message", extra);
+    expect(consoleSpy.log).toHaveBeenCalledWith("[INFO]", "message", extra);
+  });
+
+  it("logger.error passes Error objects", () => {
+    const err = new Error("test error");
+    logger.error("something failed", err);
+    expect(consoleSpy.error).toHaveBeenCalledWith("[ERROR]", "something failed", err);
+  });
+});