@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/.build/shared/utils/parse_boolean.js

@@ -0,0 +1,23 @@
+//#region shared/utils/parse_boolean.ts
+const TRUTHY_VALUES = /* @__PURE__ */ new Set([
+	true,
+	1,
+	"1",
+	"true",
+	"yes"
+]);
+const FALSY_VALUES = /* @__PURE__ */ new Set([
+	false,
+	0,
+	"0",
+	"false",
+	"no"
+]);
+function parseBoolean(value) {
+	const normalized = typeof value === "string" ? value.trim().toLowerCase() : value;
+	if (TRUTHY_VALUES.has(normalized)) return true;
+	if (FALSY_VALUES.has(normalized)) return false;
+	throw new Error(`Cannot parse boolean from: ${value}`);
+}
+//#endregion
+export { parseBoolean };

package/.build/shared/utils/response_handlers/load.js

@@ -0,0 +1,50 @@
+//#region shared/utils/response_handlers/load.ts
+function getFileExtension(filename) {
+	return filename.slice(filename.lastIndexOf(".") + 1);
+}
+function getObject(objectMap, key) {
+	const object = objectMap[key];
+	if (!object) throw new Error(`Unknown geode object key: ${key}`);
+	return object;
+}
+function selectGeodeObject(objectMap) {
+	const objectKeys = Object.keys(objectMap);
+	if (objectKeys.length === 0) return;
+	const [firstKey] = objectKeys;
+	if (objectKeys.length === 1 && firstKey !== void 0 && getObject(objectMap, firstKey).is_loadable > 0) return firstKey;
+	const highestLoadScore = Math.max(...objectKeys.map((key) => getObject(objectMap, key).is_loadable));
+	if (highestLoadScore <= 0) return;
+	const bestScoreObjects = objectKeys.filter((key) => getObject(objectMap, key).is_loadable === highestLoadScore);
+	if (bestScoreObjects.length === 1) return bestScoreObjects[0];
+	const highestPriority = Math.max(...bestScoreObjects.map((key) => getObject(objectMap, key).object_priority ?? -Infinity));
+	const bestPriorityObjects = bestScoreObjects.filter((key) => getObject(objectMap, key).object_priority === highestPriority);
+	if (highestPriority !== -Infinity && bestPriorityObjects.length === 1) return bestPriorityObjects[0];
+}
+function intersectAllowedObjects(allowedObjectsList) {
+	const allKeys = [...new Set(allowedObjectsList.flatMap((object) => Object.keys(object)))];
+	const commonKeys = allKeys.filter((key) => allowedObjectsList.every((object) => key in object));
+	const mergedEntries = commonKeys.map((key) => {
+		const loadScores = allowedObjectsList.map((object) => getObject(object, key).is_loadable);
+		const priorities = allowedObjectsList.map((object) => getObject(object, key).object_priority).filter((priority) => priority !== void 0);
+		if (priorities.length > 0) return [key, {
+			is_loadable: Math.min(...loadScores),
+			object_priority: Math.max(...priorities)
+		}];
+		return [key, { is_loadable: Math.min(...loadScores) }];
+	});
+	return {
+		commonKeys,
+		allKeys,
+		mergedAllowedObjects: Object.fromEntries(mergedEntries)
+	};
+}
+function resolveAllowedObjects(filenames, allowedObjectsList) {
+	const { commonKeys, allKeys, mergedAllowedObjects } = intersectAllowedObjects(allowedObjectsList);
+	return {
+		mergedAllowedObjects,
+		multipleFilesNoCommon: filenames.length > 1 && allKeys.length > 0 && commonKeys.length === 0,
+		selectedGeodeObject: selectGeodeObject(mergedAllowedObjects)
+	};
+}
+//#endregion
+export { getFileExtension, resolveAllowedObjects };

package/.build/shared/utils/types.js

@@ -0,0 +1 @@
+export {};

package/.build/shared/utils/validate_schema.js

@@ -0,0 +1,17 @@
+import Ajv from "ajv";
+//#region shared/utils/validate_schema.ts
+function validateSchema(schema, body) {
+	const ajv = new Ajv();
+	for (const keyword of [
+		"methods",
+		"route",
+		"max_retry",
+		"rpc"
+	]) ajv.addKeyword(keyword);
+	return {
+		valid: ajv.validate(schema, body),
+		error: ajv.errorsText()
+	};
+}
+//#endregion
+export { validateSchema };

package/README.md

@@ -1,3 +1,11 @@
 # OpenGeodeWeb-Front
 
 OpenSource Vue/Vuetify framework for web applications.
+
+## Development
+
+This codebase is written in TypeScript (`strict` mode, `noUncheckedIndexedAccess`).
+
+- `npm run typecheck` — type-checks the app/server/shared code (via `nuxt typecheck`) and the tests/scripts code (via `tsc -p tsconfig.tests.json`), which live under separate `tsconfig.json` projects since Nuxt's own generated config only covers the former.
+- `npm run lint` — runs [oxlint](https://oxc.rs/docs/guide/usage/linter.html) with autofix. The project's `.oxlintrc.json` must stay in sync with the shared [`Geode-solutions/actions`](https://github.com/Geode-solutions/actions) config, which CI re-downloads and enforces on every run.
+- `npm run test:unit` / `npm run test:integration` — run the Vitest suites under `tests/`.

package/app/assets/{geode_objects.js → geode_objects.ts}

@@ -24,7 +24,12 @@ import TriangulatedSurface2D from "@ogw_front/assets/img/geode_objects/Triangula
 import TriangulatedSurface3D from "@ogw_front/assets/img/geode_objects/TriangulatedSurface3D.svg";
 import VertexSet from "@ogw_front/assets/img/geode_objects/VertexSet.svg";
 
-export const geode_objects = {
+interface GeodeObject {
+  tooltip: string;
+  image: string;
+}
+
+const geode_objects: Record<string, GeodeObject> = {
   BRep: {
     tooltip: "BRep",
     image: BRep,
@@ -126,3 +131,5 @@ export const geode_objects = {
     image: VertexSet,
   },
 };
+
+export { geode_objects };

package/app/components/ActionButton.vue

@@ -1,17 +1,33 @@
-<script setup>
+<script setup lang="ts">
 const DEFAULT_ICON_SIZE = 28;
-const { icon, tooltip, color, size, variant, density, tooltipLocation, iconSize } = defineProps({
-  icon: { type: String, required: true },
-  tooltip: { type: String, required: true },
-  color: { type: String, default: undefined },
-  size: { type: [String, Number], default: undefined },
-  variant: { type: String, default: undefined },
-  density: { type: String, default: "comfortable" },
-  tooltipLocation: { type: String, default: "left" },
-  iconSize: { type: [String, Number], default: DEFAULT_ICON_SIZE },
-});
 
-const emit = defineEmits(["click"]);
+interface Props {
+  icon: string;
+  tooltip: string;
+  color?: string;
+  size?: string | number;
+  variant?: unknown;
+  density?: unknown;
+  tooltipLocation?: string;
+  iconSize?: string | number;
+}
+
+const {
+  icon,
+  tooltip,
+  color = undefined,
+  size = undefined,
+  variant = undefined,
+  density = "comfortable",
+  tooltipLocation = "left",
+  iconSize = DEFAULT_ICON_SIZE,
+} = defineProps<Props>();
+
+interface Emits {
+  click: [event: MouseEvent];
+}
+
+const emit = defineEmits<Emits>();
 </script>
 
 <template>

package/app/components/Basic/Slider.vue

@@ -1,5 +1,5 @@
-<script setup>
-const model = defineModel({ type: Number });
+<script setup lang="ts">
+const model = defineModel<number>();
 </script>
 
 <template>

package/app/components/Basic/Switch.vue

@@ -1,5 +1,5 @@
-<script setup>
-const model = defineModel({ type: Boolean });
+<script setup lang="ts">
+const model = defineModel<boolean>();
 </script>
 
 <template>

package/app/components/CameraManager/List.vue

@@ -1,4 +1,4 @@
-<script setup>
+<script setup lang="ts">
 import { useCameraManagerStore } from "@ogw_front/stores/camera_manager";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 
@@ -7,10 +7,10 @@ const hybridViewerStore = useHybridViewerStore();
 
 const savedPositions = cameraManagerStore.refAllCameraPositions();
 
-const editingId = ref(undefined);
-const editingName = ref("");
+const editingId = ref<number | undefined>(undefined);
+const editingName = ref<string>("");
 
-async function restorePosition(positionId) {
+async function restorePosition(positionId: number): void {
   const position = await cameraManagerStore.getCameraPosition(positionId);
   if (position) {
     if (hybridViewerStore.genericRenderWindow) {
@@ -21,17 +21,17 @@ async function restorePosition(positionId) {
   }
 }
 
-async function deletePosition(positionId) {
+async function deletePosition(positionId: number): void {
   await cameraManagerStore.deleteCameraPosition(positionId);
 }
 
-function startEditing(position) {
+function startEditing(position: { id?: number; name?: string }): void {
   editingId.value = position.id;
-  editingName.value = position.name;
+  editingName.value = position.name ?? "";
 }
 
-async function saveRename() {
-  if (editingName.value) {
+async function saveRename(): void {
+  if (editingName.value && editingId.value !== undefined) {
     await cameraManagerStore.renameCameraPosition(editingId.value, editingName.value);
   }
   editingId.value = undefined;
@@ -55,7 +55,7 @@ async function saveRename() {
           size="x-small"
           class="mr-1"
           :data-testid="`restoreCameraPosition${position.name}Button`"
-          @click="restorePosition(position.id)"
+          @click="restorePosition(position.id!)"
         >
           <v-icon size="14">mdi-play</v-icon>
           <v-tooltip activator="parent" location="top">Restore</v-tooltip>
@@ -94,7 +94,7 @@ async function saveRename() {
             variant="text"
             size="x-small"
             color="error"
-            @click="deletePosition(position.id)"
+            @click="deletePosition(position.id!)"
           >
             <v-icon size="14">mdi-delete</v-icon>
             <v-tooltip activator="parent" location="top">Delete</v-tooltip>

package/app/components/CameraManager/Saver.vue

@@ -1,19 +1,23 @@
-<script setup>
+<script setup lang="ts">
+import type { CameraOptions } from "@ogw_internal/stores/hybrid_viewer/vtk_types.js";
 import { useCameraManagerStore } from "@ogw_front/stores/camera_manager";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 
 const cameraManagerStore = useCameraManagerStore();
 const hybridViewerStore = useHybridViewerStore();
 
-const newPositionName = ref("");
+const newPositionName = ref<string>("");
 
-async function saveCurrentPosition() {
+async function saveCurrentPosition(): void {
   if (!newPositionName.value) {
     return;
   }
   await cameraManagerStore.saveCameraPosition(
     newPositionName.value,
-    toRaw(hybridViewerStore.camera_options),
+    // HybridViewerStore.camera_options is a loosely-typed reactive object (it's
+    // Populated dynamically from the viewer's camera state), but is always a
+    // CameraOptions shape at runtime once the viewer has synced a camera.
+    toRaw(hybridViewerStore.camera_options) as unknown as CameraOptions,
   );
   newPositionName.value = "";
 }

package/app/components/CameraManager.vue

@@ -1,17 +1,29 @@
-<script setup>
-import List from "@ogw_front/components/CameraManager/List";
-import Saver from "@ogw_front/components/CameraManager/Saver";
-import ToolPanel from "@ogw_front/components/ToolPanel";
+<script setup lang="ts">
+import List from "@ogw_front/components/CameraManager/List.vue";
+import Saver from "@ogw_front/components/CameraManager/Saver.vue";
+import ToolPanel from "@ogw_front/components/ToolPanel.vue";
 
-const emit = defineEmits(["close"]);
+const DEFAULT_PANEL_WIDTH = 260;
 
-const { showDialog, width, escapeFunction } = defineProps({
-  showDialog: { type: Boolean, required: true },
-  width: { type: Number, required: false, default: 260 },
-  escapeFunction: { type: Function, default: undefined },
-});
+interface Emits {
+  close: [];
+}
+
+const emit = defineEmits<Emits>();
+
+interface Props {
+  showDialog: boolean;
+  width?: number;
+  escapeFunction?: () => void;
+}
+
+const {
+  showDialog,
+  width = DEFAULT_PANEL_WIDTH,
+  escapeFunction = undefined,
+} = defineProps<Props>();
 
-function handleClose() {
+function handleClose(): void {
   if (escapeFunction) {
     escapeFunction();
   } else {
@@ -19,7 +31,7 @@ function handleClose() {
   }
 }
 
-const show = computed({
+const show = computed<boolean>({
   get: () => showDialog,
   set: (val) => {
     if (!val) {

package/app/components/CameraOrientation.vue

@@ -1,18 +1,32 @@
-<script setup>
-import ToolPanel from "@ogw_front/components/ToolPanel";
+<script setup lang="ts">
+import type { CameraOptions } from "@ogw_internal/stores/hybrid_viewer/vtk_types.js";
+import ToolPanel from "@ogw_front/components/ToolPanel.vue";
 import { applyCameraOptions } from "@ogw_internal/stores/hybrid_viewer/camera";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { newInstance as vtkAnnotatedCubeActor } from "@kitware/vtk.js/Rendering/Core/AnnotatedCubeActor";
 import { newInstance as vtkGenericRenderWindow } from "@kitware/vtk.js/Rendering/Misc/GenericRenderWindow";
 
-const { panel, width, escapeFunction } = defineProps({
-  panel: { type: Boolean, default: false },
-  width: { type: Number, default: 260 },
-  escapeFunction: { type: Function, default: undefined },
-});
+const DEFAULT_PANEL_WIDTH = 260;
+
+interface Props {
+  panel?: boolean;
+  width?: number;
+  escapeFunction?: () => void;
+}
+
+const {
+  panel = false,
+  width = DEFAULT_PANEL_WIDTH,
+  escapeFunction = undefined,
+} = defineProps<Props>();
+
+interface Emits {
+  select: [value: string];
+}
+
+const emit = defineEmits<Emits>();
 
-const show = defineModel("show", { type: Boolean, default: false });
-const emit = defineEmits(["select"]);
+const show = defineModel<boolean>("show", { default: false });
 
 const orientations = [
   {
@@ -65,15 +79,15 @@ const orientations = [
   },
 ];
 
-const hoveredFace = ref(undefined);
+const hoveredFace = ref<string | undefined>(undefined);
 const hybridViewerStore = useHybridViewerStore();
 const cubeContainer = useTemplateRef("cubeContainer");
 
-let genericRenderWindow = undefined;
-let cubeActor = undefined;
+let genericRenderWindow: unknown = undefined;
+let cubeActor: unknown = undefined;
 let isInteracting = false;
 
-function initVTK() {
+function initVTK(): void {
   if (genericRenderWindow) {
     return;
   }
@@ -100,7 +114,7 @@ function initVTK() {
     edgeColor: "rgba(255, 255, 255, 0.4)",
     edgeThickness: 0.1,
     resolution: 400,
-    fontSizeScale: (resolution) => resolution / 4,
+    fontSizeScale: (resolution: number) => resolution / 4,
   });
 
   for (const orientation of orientations) {
@@ -118,13 +132,13 @@ function initVTK() {
   renderer.resetCamera();
 }
 
-function syncCubeCamera() {
+function syncCubeCamera(): void {
   const options = hybridViewerStore.camera_options;
   if (!genericRenderWindow || isInteracting || !options.position) {
     return;
   }
   const camera = genericRenderWindow.getRenderer().getActiveCamera();
-  applyCameraOptions(camera, options);
+  applyCameraOptions(camera, options as unknown as CameraOptions);
   genericRenderWindow.getRenderer().resetCamera();
   genericRenderWindow.getRenderWindow().render();
 }
@@ -151,7 +165,7 @@ watch(hoveredFace, (newFace, oldFace) => {
   if (!cubeActor) {
     return;
   }
-  function updateFace(face, active) {
+  function updateFace(face: string | undefined, active: boolean): void {
     const config = orientations.find((orientation) => orientation.face === face);
     if (config) {
       cubeActor[`set${config.vtkKey}FaceProperty`]({

package/app/components/ClippingPlaneCard.vue

@@ -1,18 +1,19 @@
-<script setup>
+<script setup lang="ts">
 import { getPlaneCssColor } from "@ogw_front/utils/clipping_planes";
 
-const { plane, index } = defineProps({
-  plane: {
-    type: Object,
-    required: true,
-  },
-  index: {
-    type: Number,
-    required: true,
-  },
-});
+interface Props {
+  plane: { origin?: number[]; normal: number[] };
+  index: number;
+}
 
-const emit = defineEmits(["remove", "flipNormal"]);
+const { plane, index } = defineProps<Props>();
+
+interface Emits {
+  remove: [];
+  flipNormal: [];
+}
+
+const emit = defineEmits<Emits>();
 </script>
 
 <template>

package/app/components/ClippingPlanes.vue

@@ -1,28 +1,35 @@
-<script setup>
+<script setup lang="ts">
 import { DEBOUNCE_DELAY, DEFAULT_NORMALS } from "@ogw_front/utils/clipping_planes";
-import ClippingPlaneCard from "@ogw_front/components/ClippingPlaneCard";
-import ToolPanel from "@ogw_front/components/ToolPanel";
+import ClippingPlaneCard from "@ogw_front/components/ClippingPlaneCard.vue";
+import ToolPanel from "@ogw_front/components/ToolPanel.vue";
 import { useClippingPlanesWidget } from "@ogw_front/composables/clipping_planes_widget";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useDebounceFn } from "@vueuse/core";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 
-const { escapeFunction } = defineProps({
-  escapeFunction: { type: Function, default: undefined },
-});
+interface Props {
+  escapeFunction?: () => void;
+}
+
+const { escapeFunction = undefined } = defineProps<Props>();
 
-const show = defineModel("show", { type: Boolean, default: false });
+const show = defineModel<boolean>("show", { default: false });
 const dataStore = useDataStore();
 const hybridViewerStore = useHybridViewerStore();
-const targetAllVisible = ref(true);
-const selectedDatasetIds = ref([]);
-const planes = ref([{ origin: undefined, normal: [1, 0, 0] }]);
+const targetAllVisible = ref<boolean>(true);
+const selectedDatasetIds = ref<string[]>([]);
+const planes = ref<{ origin?: number[]; normal: number[] }[]>([
+  { origin: undefined, normal: [1, 0, 0] },
+]);
 const allItems = dataStore.refAllItems();
-const availableDatasets = computed(() =>
-  allItems.value.map((item) => ({ title: item.name || item.id, value: item.id })),
+const availableDatasets = computed<{ title: string; value: string }[]>(() =>
+  allItems.value.map((item) => ({
+    title: item.name || item.id,
+    value: item.id,
+  })),
 );
 const widgetContainer = useTemplateRef("widgetContainer");
-let debouncedApply = undefined;
+let debouncedApply: ((...args: unknown[]) => void) | undefined = undefined;
 
 const {
   getSceneCenter,
@@ -39,10 +46,10 @@ const {
   selectedDatasetIds,
   allItems,
   hybridViewerStore,
-  debouncedApply: (...args) => debouncedApply?.(...args),
+  debouncedApply: (...args: unknown[]) => debouncedApply?.(...args),
 });
 
-async function applyClippingPlanes() {
+async function applyClippingPlanes(): Promise<void> {
   const allIds = allItems.value.map((item) => item.id);
   if (allIds.length === 0) {
     return;
@@ -65,22 +72,25 @@ async function applyClippingPlanes() {
 
 debouncedApply = useDebounceFn(() => applyClippingPlanes(), DEBOUNCE_DELAY);
 
-function addPlane() {
-  const normal = DEFAULT_NORMALS[planes.value.length % DEFAULT_NORMALS.length];
+function addPlane(): void {
+  // Index is always in-bounds (modulo the fixed-size list); the fallbacks only
+  // Satisfy noUncheckedIndexedAccess and are never hit at runtime.
+  const normal = DEFAULT_NORMALS[planes.value.length % DEFAULT_NORMALS.length] ??
+    DEFAULT_NORMALS[0] ?? [1, 0, 0];
   planes.value.push({ origin: getSceneCenter(), normal });
 }
 
-function removePlane(index) {
+function removePlane(index: number): void {
   planes.value.splice(index, 1);
 }
 
-function flipNormal(plane) {
+function flipNormal(plane: { normal: number[] }): void {
   plane.normal = plane.normal.map((component) => -component);
   syncWidgets();
   applyClippingPlanes();
 }
 
-async function resetClippingPlanes() {
+async function resetClippingPlanes(): Promise<void> {
   setFromWidget(true);
   planes.value = [{ origin: undefined, normal: [1, 0, 0] }];
   updateWidgetPlacement({ isReset: true });
@@ -88,7 +98,7 @@ async function resetClippingPlanes() {
   await applyClippingPlanes();
 }
 
-async function removeClippingPlanes() {
+async function removeClippingPlanes(): Promise<void> {
   const allIds = allItems.value.map((item) => item.id);
   await hybridViewerStore.setClippingPlanes(allIds, []);
 }

package/app/components/CrsSelector.vue

@@ -1,27 +1,35 @@
-<script setup>
+<script setup lang="ts">
 import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
 import { useBackStore } from "@ogw_front/stores/back";
 
 const schema = schemas.opengeodeweb_back.geographic_coordinate_systems;
 
-const emit = defineEmits(["update_values", "increment_step", "decrement_step"]);
+interface Emits {
+  update_values: [values: Record<string, unknown>];
+  increment_step: [];
+  decrement_step: [];
+}
 
-const { geodeObjectType, keyToUpdate } = defineProps({
-  geodeObjectType: { type: String, required: true },
-  keyToUpdate: { type: String, required: true },
-});
+const emit = defineEmits<Emits>();
+
+interface Props {
+  geodeObjectType: string;
+  keyToUpdate: string;
+}
+
+const { geodeObjectType, keyToUpdate } = defineProps<Props>();
 
-const search = ref("");
-const data_table_loading = ref(false);
-const crs_list = ref([]);
-const selected_crs = ref([]);
+const search = ref<string>("");
+const data_table_loading = ref<boolean>(false);
+const crs_list = ref<Record<string, unknown>[]>([]);
+const selected_crs = ref<unknown[]>([]);
 const toggle_loading = useToggle(data_table_loading);
 const backStore = useBackStore();
 
-function get_selected_crs(crs_code) {
-  for (let i = 0; i <= crs_list.value.length; i += 1) {
-    if (crs_list.value[i]["code"] === crs_code) {
-      return crs_list.value[i];
+function get_selected_crs(crs_code: unknown): unknown {
+  for (const crs of crs_list.value) {
+    if (crs && crs["code"] === crs_code) {
+      return crs;
     }
   }
 }
@@ -35,14 +43,14 @@ watch(selected_crs, (new_value) => {
   emit("increment_step");
 });
 
-async function get_crs_table() {
+async function get_crs_table(): void {
   const params = { geode_object_type: geodeObjectType };
   toggle_loading();
   await backStore.request(
     { schema, params },
     {
-      response_function: (response) => {
-        crs_list.value = response.crs_list;
+      response_function: (response: unknown) => {
+        crs_list.value = (response as { crs_list: Record<string, unknown>[] }).crs_list;
       },
     },
   );
@@ -58,7 +66,7 @@ const headers = [
   },
   { title: "Code", align: "end", key: "code" },
   { title: "Name", align: "end", key: "name" },
-];
+] as const;
 
 // oxlint-disable-next-line no-top-level-await
 await get_crs_table();