@geode/opengeodeweb-front 10.37.0 → 10.38.0-rc.1

package/app/components/Viewer/Options/AttributeSelector.vue

@@ -1,16 +1,24 @@
 <script setup lang="ts">
+import {
+  type AttributeRange,
+  type RangesPerData,
+  useBatchGroup,
+} from "@ogw_front/composables/batch_style";
+import { getAttributeRange, intersectAttributes } from "@ogw_front/utils/attributes";
 import { DEFAULT_NO_DATA_COLOR } from "@ogw_front/utils/default_styles/constants";
 import type { JsonRpcSchema } from "@ogw_shared/utils/types.js";
 import ViewerOptionsAttributeColorBar from "@ogw_front/components/Viewer/Options/AttributeColorBar.vue";
 import ViewerOptionsColorPicker from "@ogw_front/components/Viewer/Options/ColorPicker.vue";
-import { getAttributeRange } from "@ogw_front/utils/attributes";
+import { requestForTargets } from "@ogw_front/utils/request_for_targets";
 import { useBackStore } from "@ogw_front/stores/back";
 
 const backStore = useBackStore();
 
 const attributeName = defineModel<string>("attributeName");
 const attributeItem = defineModel<number>("attributeItem");
-const attributeRange = defineModel<(number | undefined)[]>("attributeRange");
+const attributeRange = defineModel<(number | undefined)[]>("attributeRange", {
+  default: () => [],
+});
 const attributeColorMap = defineModel<string>("attributeColorMap");
 const attributeNoDataColor = defineModel<typeof DEFAULT_NO_DATA_COLOR>("attributeNoDataColor");
 
@@ -22,6 +30,13 @@ interface Props {
 
 const { id, componentIds = undefined, schema } = defineProps<Props>();
 
+interface Emits {
+  "update:attributeColorMap": [colorMap: string];
+  ranges_per_data: [ranges: RangesPerData];
+}
+
+const emit = defineEmits<Emits>();
+
 interface AttributeInfo {
   attribute_name: string;
   nb_items: number;
@@ -30,6 +45,9 @@ interface AttributeInfo {
 }
 
 const attributes = ref<AttributeInfo[]>([]);
+let attributesPerTarget = new Map<string, AttributeInfo[]>();
+
+const groupTargetIds = useBatchGroup(() => id);
 
 const currentAttribute = computed<AttributeInfo | undefined>(() =>
   attributes.value.find((attr) => attr.attribute_name === attributeName.value),
@@ -39,16 +57,12 @@ const cssNoDataColor = computed<string>(() => {
   return `rgba(${red}, ${green}, ${blue}, ${alpha})`;
 });
 const rangeMin = computed<number | undefined>({
-  get: () => {
-    const range = attributeRange.value as number[] | undefined;
-    return range ? range[0] : undefined;
-  },
+  get: () => attributeRange.value[0],
   set: (val: number | undefined) => {
     if (val === undefined) {
       return;
     }
-    const range = attributeRange.value as number[] | undefined;
-    const currentMax = range ? range[1] : undefined;
+    const [, currentMax] = attributeRange.value;
     let newMin = val;
     if (typeof currentMax === "number" && val > currentMax) {
       newMin = currentMax;
@@ -57,16 +71,12 @@ const rangeMin = computed<number | undefined>({
   },
 });
 const rangeMax = computed<number | undefined>({
-  get: () => {
-    const range = attributeRange.value as number[] | undefined;
-    return range ? range[1] : undefined;
-  },
+  get: () => attributeRange.value[1],
   set: (val: number | undefined) => {
     if (val === undefined) {
       return;
     }
-    const range = attributeRange.value as number[] | undefined;
-    const currentMin = range ? range[0] : undefined;
+    const [currentMin] = attributeRange.value;
     let newMax = val;
     if (typeof currentMin === "number" && val < currentMin) {
       newMax = currentMin;
@@ -103,7 +113,37 @@ function hasSelectedComponent(components: unknown): boolean {
   return Array.isArray(components) && components.length > 0;
 }
 
-function getAttributes(): void {
+async function getGroupAttributes(targetIds: string[]): Promise<void> {
+  const responses = await requestForTargets<{ attributes: AttributeInfo[] }>(schema, targetIds, {
+    attributes: [],
+  });
+  attributesPerTarget = new Map(
+    responses.map(([targetId, response]) => [targetId, response.attributes]),
+  );
+  attributes.value = intersectAttributes([...attributesPerTarget.values()]);
+}
+
+function initGroupAttribute(name: string, item: number): void {
+  const ranges = new Map<string, AttributeRange>();
+  for (const [targetId, targetAttributes] of attributesPerTarget) {
+    const attribute = targetAttributes.find((candidate) => candidate.attribute_name === name);
+    if (attribute) {
+      const { min, max } = getAttributeRange(
+        attribute as unknown as Parameters<typeof getAttributeRange>[0],
+        item,
+      );
+      ranges.set(targetId, [min, max]);
+    }
+  }
+  emit("update:attributeColorMap", attributeColorMap.value ?? "batlow");
+  emit("ranges_per_data", ranges);
+}
+
+async function getAttributes(): Promise<void> {
+  if (groupTargetIds.value) {
+    await getGroupAttributes(groupTargetIds.value);
+    return;
+  }
   const schemaProperties = schema.properties as Record<string, unknown> | undefined;
   const requiresComponent = schemaProperties?.component_ids !== undefined;
   if (requiresComponent && !hasSelectedComponent(componentIds)) {
@@ -115,7 +155,7 @@ function getAttributes(): void {
     params.component_ids = componentIds;
   }
 
-  backStore.request(
+  await backStore.request(
     { schema, params },
     {
       response_function: (response: unknown) => {
@@ -125,25 +165,34 @@ function getAttributes(): void {
   );
 }
 
-onMounted(() => {
-  getAttributes();
+onMounted(async () => {
+  await getAttributes();
 });
 
 watch(
   () => [id, componentIds, schema],
-  () => {
-    getAttributes();
+  async () => {
+    await getAttributes();
   },
 );
 
+watch([attributeName, attributeItem], ([name, item]) => {
+  if (groupTargetIds.value && name !== undefined) {
+    initGroupAttribute(name, item ?? 0);
+  }
+});
+
 watch([attributeName, attributeItem, currentAttribute], () => {
+  if (groupTargetIds.value) {
+    return;
+  }
   if (attributeColorMap.value === undefined) {
     attributeColorMap.value = "batlow";
   }
   if (attributeNoDataColor.value === undefined) {
     attributeNoDataColor.value = DEFAULT_NO_DATA_COLOR;
   }
-  if (!attributeRange.value || attributeRange.value[0] === undefined) {
+  if (attributeRange.value[0] === undefined) {
     resetRange();
   }
 });
@@ -200,6 +249,7 @@ watch([attributeName, attributeItem, currentAttribute], () => {
     v-model:minimum="rangeMin"
     v-model:maximum="rangeMax"
     v-model:colorMap="attributeColorMap"
+    :hide-range="groupTargetIds !== undefined"
     @reset="resetRange"
   />
 </template>

package/app/components/Viewer/Options/ColoringTypeSelector.vue

@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import type { JsonRpcSchema } from "@ogw_shared/utils/types.js";
 import type { RGBAColor } from "@ogw_front/utils/default_styles/constants";
+import type { RangesPerData } from "@ogw_front/composables/batch_style";
 import ViewerOptionsAttributeSelector from "@ogw_front/components/Viewer/Options/AttributeSelector.vue";
 import ViewerOptionsColorPicker from "@ogw_front/components/Viewer/Options/ColorPicker.vue";
 import ViewerOptionsTexturesSelector from "@ogw_front/components/Viewer/Options/TexturesSelector.vue";
@@ -26,6 +27,16 @@ interface Schemas {
 
 const coloring_style_key = defineModel<string>("coloring_style_key");
 
+interface Emits {
+  vertex_attribute_ranges_per_data: [ranges: RangesPerData];
+  edge_attribute_ranges_per_data: [ranges: RangesPerData];
+  cell_attribute_ranges_per_data: [ranges: RangesPerData];
+  polygon_attribute_ranges_per_data: [ranges: RangesPerData];
+  polyhedron_attribute_ranges_per_data: [ranges: RangesPerData];
+}
+
+const emit = defineEmits<Emits>();
+
 const color = defineModel<RGBAColor>("color");
 const textures = defineModel<Texture[]>("textures");
 
@@ -246,6 +257,7 @@ watch(
           v-model:attributeRange="vertex_attribute_range"
           v-model:attributeColorMap="vertex_attribute_color_map"
           v-model:attributeNoDataColor="vertex_attribute_no_data_color"
+          @ranges_per_data="emit('vertex_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
           :schema="vertexSchema"
@@ -258,6 +270,7 @@ watch(
           v-model:attributeRange="edge_attribute_range"
           v-model:attributeColorMap="edge_attribute_color_map"
           v-model:attributeNoDataColor="edge_attribute_no_data_color"
+          @ranges_per_data="emit('edge_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
           :schema="edgeSchema"
@@ -270,6 +283,7 @@ watch(
           v-model:attributeRange="cell_attribute_range"
           v-model:attributeColorMap="cell_attribute_color_map"
           v-model:attributeNoDataColor="cell_attribute_no_data_color"
+          @ranges_per_data="emit('cell_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
           :schema="cellSchema"
@@ -282,6 +296,7 @@ watch(
           v-model:attributeRange="polygon_attribute_range"
           v-model:attributeColorMap="polygon_attribute_color_map"
           v-model:attributeNoDataColor="polygon_attribute_no_data_color"
+          @ranges_per_data="emit('polygon_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
           :schema="polygonSchema"
@@ -294,6 +309,7 @@ watch(
           v-model:attributeRange="polyhedron_attribute_range"
           v-model:attributeColorMap="polyhedron_attribute_color_map"
           v-model:attributeNoDataColor="polyhedron_attribute_no_data_color"
+          @ranges_per_data="emit('polyhedron_attribute_ranges_per_data', $event)"
           :id="id"
           :componentIds="componentIds"
           :schema="polyhedronSchema"

package/app/components/Viewer/Options/TextureItem.vue

@@ -1,7 +1,10 @@
 <script setup lang="ts">
 import FileUploader from "@ogw_front/components/FileUploader.vue";
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+import { intersectBy } from "@ogw_front/utils/attributes";
+import { requestForTargets } from "@ogw_front/utils/request_for_targets";
 import { useBackStore } from "@ogw_front/stores/back";
+import { useBatchGroup } from "@ogw_front/composables/batch_style";
 
 // Mirrors FileUploader's own (unexported) UploadFile type.
 type UploadFile = File & { isConfigured?: boolean; displayName?: string };
@@ -40,21 +43,22 @@ watch(
 const textureCoordinates = ref<string[]>([]);
 const backStore = useBackStore();
 
-function getTextureCoordinates(): void {
+const groupTargetIds = useBatchGroup(() => id);
+
+async function getTextureCoordinates(): Promise<void> {
   const schema = back_schemas.opengeodeweb_back.texture_coordinates;
-  const params = { id };
-  backStore.request(
-    { schema, params },
-    {
-      response_function: (response) => {
-        textureCoordinates.value = response.texture_coordinates;
-      },
-    },
+  const targetIds = groupTargetIds.value ?? [id];
+  const responses = await requestForTargets<{ texture_coordinates: string[] }>(schema, targetIds, {
+    texture_coordinates: [],
+  });
+  textureCoordinates.value = intersectBy(
+    responses.map(([, response]) => response.texture_coordinates),
+    (coordinate) => coordinate,
   );
 }
 
-onMounted(() => {
-  getTextureCoordinates();
+onMounted(async () => {
+  await getTextureCoordinates();
 });
 
 async function files_uploaded_event(value: UploadFile[]): Promise<void> {

package/app/components/Viewer/PointSet/SpecificPointsOptions.vue

@@ -1,4 +1,9 @@
 <script setup lang="ts">
+import {
+  type RangesPerData,
+  applyRangesPerData,
+  useBatchStyle,
+} from "@ogw_front/composables/batch_style";
 import ViewerContextMenuItem, {
   type ItemProps,
 } from "@ogw_front/components/Viewer/ContextMenu/ContextMenuItem.vue";
@@ -7,7 +12,6 @@ import type { RGBAColor } from "@ogw_front/utils/default_styles/constants";
 import ViewerOptionsColoringTypeSelector from "@ogw_front/components/Viewer/Options/ColoringTypeSelector.vue";
 import ViewerOptionsSizeSlider from "@ogw_front/components/Viewer/Options/Sliders/Size.vue";
 import ViewerOptionsVisibilitySwitch from "@ogw_front/components/Viewer/Options/VisibilitySwitch.vue";
-import { useBatchStyle } from "@ogw_front/composables/batch_style";
 import { useDataStyleStore } from "@ogw_front/stores/data_style";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 
@@ -120,6 +124,13 @@ const vertex_attribute_no_data_color = computed<RGBAColor>({
     hybridViewerStore.remoteRender();
   },
 });
+
+async function setVertexAttributeRangesPerData(ranges: RangesPerData): Promise<void> {
+  await applyRangesPerData(ranges, (targetId, minimum, maximum) =>
+    dataStyleStore.setMeshPointsVertexAttributeRange(targetId, minimum, maximum),
+  );
+  hybridViewerStore.remoteRender();
+}
 </script>
 <template>
   <ViewerContextMenuItem
@@ -144,6 +155,7 @@ const vertex_attribute_no_data_color = computed<RGBAColor>({
           v-model:vertex_attribute_name="vertex_attribute_name"
           v-model:vertex_attribute_item="vertex_attribute_item"
           v-model:vertex_attribute_range="vertex_attribute_range"
+          @vertex_attribute_ranges_per_data="setVertexAttributeRangesPerData"
           v-model:vertex_attribute_color_map="vertex_attribute_color_map"
           v-model:vertex_attribute_no_data_color="vertex_attribute_no_data_color"
           :vertex_has_colormap="true"

package/app/components/Viewer/Solid/SpecificPolyhedraOptions.vue

@@ -1,4 +1,9 @@
 <script setup lang="ts">
+import {
+  type RangesPerData,
+  applyRangesPerData,
+  useBatchStyle,
+} from "@ogw_front/composables/batch_style";
 import ViewerContextMenuItem, {
   type ItemProps,
 } from "@ogw_front/components/Viewer/ContextMenu/ContextMenuItem.vue";
@@ -6,7 +11,6 @@ import type { RGBAColor } from "@ogw_front/utils/default_styles/constants";
 import SolidPolyhedra from "@ogw_front/assets/viewer_svgs/solid_polyhedra.svg";
 import ViewerOptionsColoringTypeSelector from "@ogw_front/components/Viewer/Options/ColoringTypeSelector.vue";
 import ViewerOptionsVisibilitySwitch from "@ogw_front/components/Viewer/Options/VisibilitySwitch.vue";
-import { useBatchStyle } from "@ogw_front/composables/batch_style";
 import { useDataStyleStore } from "@ogw_front/stores/data_style";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 
@@ -163,6 +167,20 @@ const polyhedron_attribute_no_data_color = computed<RGBAColor>({
     hybridViewerStore.remoteRender();
   },
 });
+
+async function setVertexAttributeRangesPerData(ranges: RangesPerData): Promise<void> {
+  await applyRangesPerData(ranges, (targetId, minimum, maximum) =>
+    dataStyleStore.setMeshPolyhedraVertexAttributeRange(targetId, minimum, maximum),
+  );
+  hybridViewerStore.remoteRender();
+}
+
+async function setPolyhedronAttributeRangesPerData(ranges: RangesPerData): Promise<void> {
+  await applyRangesPerData(ranges, (targetId, minimum, maximum) =>
+    dataStyleStore.setMeshPolyhedraPolyhedronAttributeRange(targetId, minimum, maximum),
+  );
+  hybridViewerStore.remoteRender();
+}
 </script>
 <template>
   <ViewerContextMenuItem
@@ -185,11 +203,13 @@ const polyhedron_attribute_no_data_color = computed<RGBAColor>({
           v-model:vertex_attribute_name="vertex_attribute_name"
           v-model:vertex_attribute_item="vertex_attribute_item"
           v-model:vertex_attribute_range="vertex_attribute_range"
+          @vertex_attribute_ranges_per_data="setVertexAttributeRangesPerData"
           v-model:vertex_attribute_color_map="vertex_attribute_color_map"
           v-model:vertex_attribute_no_data_color="vertex_attribute_no_data_color"
           v-model:polyhedron_attribute_name="polyhedron_attribute_name"
           v-model:polyhedron_attribute_item="polyhedron_attribute_item"
           v-model:polyhedron_attribute_range="polyhedron_attribute_range"
+          @polyhedron_attribute_ranges_per_data="setPolyhedronAttributeRangesPerData"
           v-model:polyhedron_attribute_color_map="polyhedron_attribute_color_map"
           v-model:polyhedron_attribute_no_data_color="polyhedron_attribute_no_data_color"
         />

package/app/components/Viewer/Surface/PolygonsOptions.vue

@@ -1,4 +1,9 @@
 <script setup lang="ts">
+import {
+  type RangesPerData,
+  applyRangesPerData,
+  useBatchStyle,
+} from "@ogw_front/composables/batch_style";
 import ViewerContextMenuItem, {
   type ItemProps,
 } from "@ogw_front/components/Viewer/ContextMenu/ContextMenuItem.vue";
@@ -6,7 +11,6 @@ import PolygonalSurfacePolygons from "@ogw_front/assets/viewer_svgs/surface_tria
 import type { RGBAColor } from "@ogw_front/utils/default_styles/constants";
 import ViewerOptionsColoringTypeSelector from "@ogw_front/components/Viewer/Options/ColoringTypeSelector.vue";
 import ViewerOptionsVisibilitySwitch from "@ogw_front/components/Viewer/Options/VisibilitySwitch.vue";
-import { useBatchStyle } from "@ogw_front/composables/batch_style";
 import { useDataStyleStore } from "@ogw_front/stores/data_style";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 
@@ -178,6 +182,20 @@ const polygon_attribute_no_data_color = computed<RGBAColor>({
     hybridViewerStore.remoteRender();
   },
 });
+
+async function setVertexAttributeRangesPerData(ranges: RangesPerData): Promise<void> {
+  await applyRangesPerData(ranges, (targetId, minimum, maximum) =>
+    dataStyleStore.setMeshPolygonsVertexAttributeRange(targetId, minimum, maximum),
+  );
+  hybridViewerStore.remoteRender();
+}
+
+async function setPolygonAttributeRangesPerData(ranges: RangesPerData): Promise<void> {
+  await applyRangesPerData(ranges, (targetId, minimum, maximum) =>
+    dataStyleStore.setMeshPolygonsPolygonAttributeRange(targetId, minimum, maximum),
+  );
+  hybridViewerStore.remoteRender();
+}
 </script>
 
 <template>
@@ -202,11 +220,13 @@ const polygon_attribute_no_data_color = computed<RGBAColor>({
           v-model:vertex_attribute_name="vertex_attribute_name"
           v-model:vertex_attribute_item="vertex_attribute_item"
           v-model:vertex_attribute_range="vertex_attribute_range"
+          @vertex_attribute_ranges_per_data="setVertexAttributeRangesPerData"
           v-model:vertex_attribute_color_map="vertex_attribute_color_map"
           v-model:vertex_attribute_no_data_color="vertex_attribute_no_data_color"
           v-model:polygon_attribute_name="polygon_attribute_name"
           v-model:polygon_attribute_item="polygon_attribute_item"
           v-model:polygon_attribute_range="polygon_attribute_range"
+          @polygon_attribute_ranges_per_data="setPolygonAttributeRangesPerData"
           v-model:polygon_attribute_color_map="polygon_attribute_color_map"
           v-model:polygon_attribute_no_data_color="polygon_attribute_no_data_color"
         />

package/app/components/Viewer/Ui.vue

@@ -1,12 +1,16 @@
 <script setup lang="ts">
+import {
+  type ViewerIdResult,
+  useOverlappingPicker,
+} from "@ogw_front/composables/use_overlapping_picker";
 import OverlappingObjectsPicker from "@ogw_front/components/Viewer/OverlappingObjectsPicker.vue";
 import ToolActiveChip from "@ogw_front/components/Viewer/ToolActiveChip.vue";
+import type { TreeMenuPayload } from "@ogw_front/utils/treeview";
 import ViewerContextMenu from "@ogw_front/components/Viewer/ContextMenu/ContextMenu.vue";
 import ViewerObjectTreeLayout from "@ogw_front/components/Viewer/ObjectTree/Layout.vue";
 import { getCurrentInstance } from "vue";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { useMenuStore } from "@ogw_front/stores/menu";
-import { useOverlappingPicker } from "@ogw_front/composables/use_overlapping_picker";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 
 interface Props {
@@ -18,7 +22,7 @@ interface Props {
 const { displayMenu, containerWidth, containerHeight } = defineProps<Props>();
 
 const emit = defineEmits<{
-  "show-menu": [args: unknown];
+  "show-menu": [payload: TreeMenuPayload];
 }>();
 const menuStore = useMenuStore();
 const viewerStore = useViewerStore();
@@ -66,7 +70,7 @@ const {
   get_viewer_id: trigger_picker,
 } = useOverlappingPicker();
 
-function get_viewer_id(x: number, y: number): string {
+function get_viewer_id(x: number, y: number): Promise<ViewerIdResult> {
   const instance = getCurrentInstance();
   const containerRect = instance?.proxy?.$el
     ?.closest?.('[data-testid="hybridViewer"]')

package/app/composables/batch_style.ts

@@ -1,14 +1,74 @@
+import {
+  type ComputedRef,
+  type InjectionKey,
+  type MaybeRefOrGetter,
+  computed,
+  inject,
+  provide,
+  toValue,
+} from "vue";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useTreeviewStore } from "@ogw_front/stores/treeview";
 
-export function useBatchStyle(): { applyBatchStyle: typeof applyBatchStyle } {
+type AttributeRange = [number, number];
+type RangesPerData = ReadonlyMap<string, AttributeRange>;
+
+const BATCH_GROUP_KEY: InjectionKey<ComputedRef<string[]>> = Symbol("batch_group");
+
+function provideBatchGroup(targetIds: () => string[]): void {
+  provide(BATCH_GROUP_KEY, computed(targetIds));
+}
+
+function injectBatchGroup(): ComputedRef<string[]> {
+  return inject(BATCH_GROUP_KEY, () => computed(() => []), true);
+}
+
+function groupTargetsOf(targetIds: string[], id: string): string[] | undefined {
+  return targetIds.includes(id) ? targetIds : undefined;
+}
+
+function useBatchGroup(id: MaybeRefOrGetter<string>): ComputedRef<string[] | undefined> {
+  const group = injectBatchGroup();
+  return computed(() => groupTargetsOf(group.value, toValue(id)));
+}
+
+async function applyRangesPerData(
+  ranges: RangesPerData,
+  setRange: (id: string, minimum: number, maximum: number) => unknown,
+): Promise<void> {
+  await Promise.all(
+    [...ranges].map(async ([targetId, [minimum, maximum]]) => {
+      await setRange(targetId, minimum, maximum);
+    }),
+  );
+}
+
+async function applyActionOn(
+  targets: readonly string[],
+  action: (id: string) => Promise<unknown>,
+): Promise<void> {
+  await Promise.all(
+    targets.map(async (targetId) => {
+      await action(targetId);
+    }),
+  );
+}
+
+function useBatchStyle(): { applyBatchStyle: typeof applyBatchStyle } {
   const treeviewStore = useTreeviewStore();
   const dataStore = useDataStore();
+  const group = injectBatchGroup();
 
   async function applyBatchStyle(
     id: string,
     action: (id: string) => Promise<unknown>,
   ): Promise<void> {
+    const groupTargets = groupTargetsOf(group.value, id);
+    if (groupTargets) {
+      await applyActionOn(groupTargets, action);
+      return;
+    }
+
     const isActive = treeviewStore.activeItems.includes(id);
     if (!isActive || treeviewStore.activeItems.length <= 1) {
       await action(id);
@@ -38,3 +98,6 @@ export function useBatchStyle(): { applyBatchStyle: typeof applyBatchStyle } {
 
   return { applyBatchStyle };
 }
+
+export { BATCH_GROUP_KEY, applyRangesPerData, provideBatchGroup, useBatchGroup, useBatchStyle };
+export type { AttributeRange, RangesPerData };

package/app/composables/tree_filter.ts

@@ -30,10 +30,10 @@ interface UseTreeFilterReturn {
   availableFilterOptions: ComputedRef<string[]>;
   toggleSort: () => void;
   customFilter: typeof customFilter;
-  applySearchFilter: (
-    newSelection: readonly unknown[],
-    previousSelection?: readonly unknown[],
-  ) => unknown[];
+  applySearchFilter: <TId>(
+    newSelection: readonly TId[],
+    previousSelection?: readonly TId[],
+  ) => TId[];
 }
 
 function customFilter(
@@ -163,10 +163,10 @@ function useTreeFilter(
     return map;
   });
 
-  function applySearchFilter(
-    newSelection: readonly unknown[],
-    previousSelection: readonly unknown[] = [],
-  ): unknown[] {
+  function applySearchFilter<TId>(
+    newSelection: readonly TId[],
+    previousSelection: readonly TId[] = [],
+  ): TId[] {
     if (!search.value) {
       return [...newSelection];
     }

package/app/composables/use_overlapping_picker.ts

@@ -192,3 +192,5 @@ export function useOverlappingPicker(): UseOverlappingPickerReturn {
     get_viewer_id,
   };
 }
+
+export type { ViewerIdResult };