feat: import ArcGIS Pro projects from CIM JSON (#1637)

* feat: import ArcGIS Pro projects from CIM JSON

Reads .aprx and .mapx files directly, so ArcGIS Pro and ArcPy are not
needed to bring an existing map into GeoLibre. The importer restores the
first 2D map's extent, local vector layers, nested groups, visibility,
simple symbols, and field labels, and reports per-layer why anything was
skipped instead of failing the whole import.

* feat: import ArcGIS Pro rasters and vector tile services

Extends the importer beyond vector layers: local GeoTIFF raster layers and
portal-hosted vector tile layers now come across, and the Tauri asset guard
accepts .aprx/.mapx alongside .qgs/.qgz so an imported raster path can be read.

Also fixes a pre-existing defect the raster loop inherited from the QGIS
importer. The raster control creates its store layer before it awaits the
GeoTIFF header, so a rejection left the layer on the map while the importer
reported it as an unsupported format -- the layer list and the warning dialog
disagreed. Failed rasters are now rolled back, and the striped "not tiled"
rejection is no longer treated as a failure at all, since that layer stays on
purpose while the non-tiled handler offers to convert it to a COG.

* Address Copilot, Claude, and CodeRabbit review feedback

- Store each layer's and group's own visibility instead of the cascaded
  value. applyGroupEffects folds ancestor visibility in at render time, so
  pre-cascading discarded a nested item's real state and left it stuck hidden
  after its parent group was re-enabled.
- Measure the MAPX size in bytes rather than String.length, which counts
  UTF-16 code units, and check binary input before decoding it to a string.
- Cap an APRX's combined decompressed size, not just each member's, so many
  members just under the per-entry limit cannot add up past it.
- Read CIM colors according to their subclass. CMYK, gray, and HSV colors
  store different channels on different scales, so interpreting every values
  array as RGB produced the wrong color; unknown subclasses keep the default.
- Warn when a saved extent is dropped because its coordinate system cannot be
  converted, instead of silently opening at the generic world view.
- Join a folder workspace with its dataset generically so file formats other
  than shapefile and delimited text can resolve.
- Omit `reason` from resolveDataSource on success rather than returning
  "format" for a supported layer, and rename the shadowed `bytes` binding.

* Address Claude review feedback

- Keep a layer group whose only members are a raster or a service. Both are
  attached after the project loads, so pruning the group made the later
  moveLayerToGroup a silent no-op and stranded them at the top level.
- Report a raster on a UNC workspace as "network-path" rather than "format",
  matching what the vector path already reports for the same root cause.
- Stop unbounded group recursion. A corrupt or crafted project can reference
  a group that already contains it, and children resolved from the archive
  share object identity, so the import recursed until the stack overflowed.
  Group nesting now carries an ancestor set plus a depth cap, and a project
  that trips either gets a warning instead of crashing the import.

* Address Claude and CodeRabbit review feedback

- Read layer opacity from CIM `transparency` (0-100, inverted) rather than a
  non-existent `opacity` field, so partially transparent ArcGIS layers no
  longer import as fully opaque. Applied to rasters, services, groups, and
  feature layers, and rounded so float noise does not reach the project file.
- Give addArcGISLayer a `zoomTo` opt-out and use it when importing services.
  It fit the map to every layer's bounds unconditionally, throwing away the
  extent loadProject had just restored from the project file.
- Place a raster in its imported group on the recoverable "not tiled" path.
  That layer stays on the map pending COG conversion, so returning early left
  it outside the group the project put it in.
- Re-prune layer groups in the browser build after local-file layers are
  dropped, counting services (which still load) and not rasters (which never
  do), and keeping ancestors of surviving groups.
- Rename the `allow_raster_asset` parameter and its caller option to
  `import_project_path`/`importProjectPath` now that it accepts ArcGIS Pro
  projects too, and update the Rust doc comment to match.
- Assert an asymmetric gray level so the color test pins the scale direction.

Author: giswqs

apps/geolibre-desktop/src-tauri/src/lib.rs

@@ -460,29 +460,33 @@ fn read_local_file(path: String) -> Result<tauri::ipc::Response, String> {
 /// Add one GeoTIFF to the asset-protocol scope. The filesystem and asset scopes
 /// are separate in Tauri; dialogs and native drops grant the former, but
 /// maplibre-gl-raster fetches through the latter for range reads. A GeoTIFF
-/// referenced by an imported QGIS project is also accepted when that project
-/// file itself was explicitly selected by the user.
+/// referenced by an imported project -- QGIS (`.qgs`/`.qgz`) or ArcGIS Pro
+/// (`.aprx`/`.mapx`) -- is also accepted when that project file itself was
+/// explicitly selected by the user.
 #[tauri::command]
 fn allow_raster_asset(
     app: tauri::AppHandle,
     path: String,
-    qgis_project_path: Option<String>,
+    import_project_path: Option<String>,
 ) -> Result<(), String> {
     let lower = path.to_ascii_lowercase();
     if !is_safe_absolute_path(&path) || !(lower.ends_with(".tif") || lower.ends_with(".tiff")) {
         return Err(format!(
             "Refusing to expose \"{path}\": not an absolute GeoTIFF path"
         ));
     }
-    let selected_qgis_project = qgis_project_path.is_some_and(|project_path| {
+    let selected_import_project = import_project_path.is_some_and(|project_path| {
         let lower = project_path.to_ascii_lowercase();
         is_safe_absolute_path(&project_path)
-            && (lower.ends_with(".qgs") || lower.ends_with(".qgz"))
+            && (lower.ends_with(".qgs")
+                || lower.ends_with(".qgz")
+                || lower.ends_with(".aprx")
+                || lower.ends_with(".mapx"))
             && app.fs_scope().is_allowed(&project_path)
     });
-    if !app.fs_scope().is_allowed(&path) && !selected_qgis_project {
+    if !app.fs_scope().is_allowed(&path) && !selected_import_project {
         return Err(format!(
-            "Refusing to expose \"{path}\": neither the file nor its QGIS project was selected by the user"
+            "Refusing to expose \"{path}\": neither the file nor its imported project was selected by the user"
         ));
     }
     app.asset_protocol_scope()

apps/geolibre-desktop/src/components/layout/TopToolbar.tsx

@@ -1551,6 +1551,7 @@ export function TopToolbar({
           onOpenFromUrl={() => projectFiles.setProjectUrlDialogOpen(true)}
           onOpenGallery={() => setGalleryDialogOpen(true)}
           onImportQgisProject={() => void projectFiles.handleImportQgisProject()}
+          onImportArcgisProject={() => void projectFiles.handleImportArcgisProject()}
           onOpenRecent={(path) => {
             void projectFiles.handleOpenRecent(path).then((error) => {
               if (error) projectFiles.setActionError(error);

apps/geolibre-desktop/src/components/layout/toolbar/ProjectFileDialogs.tsx

@@ -76,6 +76,38 @@ export function ProjectFileDialogs({ projectFiles }: ProjectFileDialogsProps) {
           </form>
         </DialogContent>
       </Dialog>
+      <Dialog
+        open={projectFiles.arcgisImportWarnings !== null}
+        onOpenChange={(open: boolean) => {
+          if (!open) projectFiles.setArcgisImportWarnings(null);
+        }}
+      >
+        <DialogContent className="max-w-lg">
+          <DialogHeader>
+            <DialogTitle>{t("toolbar.item.arcgisImportComplete")}</DialogTitle>
+            <DialogDescription>
+              {t("toolbar.item.arcgisImportWarnings", {
+                count: projectFiles.arcgisImportWarnings?.length ?? 0,
+              })}
+            </DialogDescription>
+          </DialogHeader>
+          <ul className="max-h-64 space-y-2 overflow-y-auto text-sm">
+            {projectFiles.arcgisImportWarnings?.map((warning, index) => (
+              <li key={`${warning.layerName}-${index}`}>
+                <strong>{warning.layerName}:</strong>{" "}
+                {t(`toolbar.item.arcgisImportReason.${warning.reason}`, {
+                  layerType: warning.layerType || t("toolbar.item.arcgisUnknownLayerType"),
+                })}
+              </li>
+            ))}
+          </ul>
+          <div className="flex justify-end">
+            <Button onClick={() => projectFiles.setArcgisImportWarnings(null)}>
+              {t("common.ok")}
+            </Button>
+          </div>
+        </DialogContent>
+      </Dialog>
       <Dialog
         open={projectFiles.actionError !== null}
         onOpenChange={(open: boolean) => {

apps/geolibre-desktop/src/components/layout/toolbar/ProjectMenu.tsx

@@ -46,6 +46,7 @@ interface ProjectMenuProps {
   onOpenFromUrl: () => void;
   onOpenGallery: () => void;
   onImportQgisProject: () => void;
+  onImportArcgisProject: () => void;
   onOpenRecent: (path: string) => void;
   onOpenHistory: () => void;
   onSave: () => void;
@@ -68,6 +69,7 @@ export function ProjectMenu({
   onOpenFromUrl,
   onOpenGallery,
   onImportQgisProject,
+  onImportArcgisProject,
   onOpenRecent,
   onOpenHistory,
   onSave,
@@ -222,6 +224,10 @@ export function ProjectMenu({
                 <FileInput className="me-2 h-3.5 w-3.5" />
                 {t("toolbar.item.importQgisProjectEllipsis")}
               </DropdownMenuItem>
+              <DropdownMenuItem onSelect={onImportArcgisProject}>
+                <FileInput className="me-2 h-3.5 w-3.5" />
+                {t("toolbar.item.importArcgisProjectEllipsis")}
+              </DropdownMenuItem>
             </DropdownMenuSubContent>
           </DropdownMenuSub>
         )}

apps/geolibre-desktop/src/hooks/useProjectFileActions.ts

@@ -6,7 +6,12 @@ import {
   useAppStore,
   type GeoLibreLayer,
 } from "@geolibre/core";
-import { addRasterToMap, materializeEmbeddableVectorLayers } from "@geolibre/plugins";
+import {
+  addArcGISLayer,
+  addRasterToMap,
+  isRecoverableNonTiledRasterError,
+  materializeEmbeddableVectorLayers,
+} from "@geolibre/plugins";
 import type { FeatureCollection } from "geojson";
 import { type FormEvent, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
@@ -18,6 +23,7 @@ import {
   isHttpUrl,
   isTauri,
   loadDroppedRasterPaths,
+  openArcgisProjectFile,
   openProjectFile,
   openQgisProjectFile,
   openRecentProjectFile,
@@ -41,6 +47,7 @@ import {
   materializeQgisRemoteLayers,
   type QgisProjectImportWarning,
 } from "../lib/qgis-project-import";
+import { importArcgisProject, type ArcgisProjectImportWarning } from "../lib/arcgis-project-import";
 import type { MapControllerRef } from "../components/layout/toolbar/constants";
 
 /** A pending "strip env vars before saving?" prompt. */
@@ -134,6 +141,58 @@ function importedProjectMapReady(
   })();
 }
 
+/**
+ * Adds one raster from an imported QGIS/ArcGIS Pro project, cleaning up after
+ * itself when the raster cannot be loaded.
+ *
+ * `addRasterToMap` resolves only once the GeoTIFF header has been read, but the
+ * control creates the store layer earlier (its `rasteradd` fires before that
+ * await). A rejection therefore leaves the layer behind, so importers that
+ * simply caught the error listed a raster as unsupported while it was still
+ * sitting in the layer list -- see the NLCD case in GeoLibre#1637. Rolling the
+ * layer back keeps the warning dialog and the layer list telling the same story.
+ *
+ * The striped "not tiled" rejection is deliberately not a failure: that layer
+ * stays on the map while the registered non-tiled handler offers to convert it
+ * to a COG, so it is neither rolled back nor reported.
+ *
+ * @param app - The app API for the live map.
+ * @param source - Raster source resolved from the project's layer path.
+ * @param options - Passed through to {@link addRasterToMap}.
+ * @param groupId - Imported layer group to move the raster into, if any.
+ * @throws The original load error, after the partial layer has been removed.
+ */
+async function addImportedProjectRaster(
+  app: ReturnType<typeof createAppAPI>,
+  source: Parameters<typeof addRasterToMap>[1],
+  options: Parameters<typeof addRasterToMap>[2],
+  groupId: string | undefined,
+): Promise<void> {
+  const before = new Set(useAppStore.getState().layers.map((layer) => layer.id));
+  try {
+    const layerId = await addRasterToMap(app, source, options);
+    if (groupId) useAppStore.getState().moveLayerToGroup(layerId, groupId);
+  } catch (error) {
+    if (isRecoverableNonTiledRasterError(error)) {
+      // The rejection carried no layer id, but the control already created the
+      // store layer and is keeping it while the COG conversion is offered, so
+      // it still has to be placed in its imported group -- otherwise a raster
+      // that converts successfully ends up at the top level.
+      if (groupId) {
+        const { layers, moveLayerToGroup } = useAppStore.getState();
+        const created = layers.find((layer) => !before.has(layer.id));
+        if (created) moveLayerToGroup(created.id, groupId);
+      }
+      return;
+    }
+    const { layers, removeLayer } = useAppStore.getState();
+    for (const layer of layers) {
+      if (!before.has(layer.id)) removeLayer(layer.id);
+    }
+    throw error;
+  }
+}
+
 /**
  * Bundles every project file action (open from file/URL/recent, save, save as)
  * along with the related dialog state (Open-from-URL, env-var strip prompt, and
@@ -154,6 +213,9 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   const [qgisImportWarnings, setQgisImportWarnings] = useState<QgisProjectImportWarning[] | null>(
     null,
   );
+  const [arcgisImportWarnings, setArcgisImportWarnings] = useState<
+    ArcgisProjectImportWarning[] | null
+  >(null);
   const [projectUrlDialogOpen, setProjectUrlDialogOpen] = useState(false);
   const [projectUrl, setProjectUrl] = useState("");
   const [projectUrlError, setProjectUrlError] = useState<string | null>(null);
@@ -235,28 +297,30 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
         for (const raster of imported.rasters) {
           try {
             const [loaded] = await loadDroppedRasterPaths([raster.sourcePath], {
-              qgisProjectPath: result.path,
+              importProjectPath: result.path,
             });
             if (!loaded) throw new Error("Unsupported raster path");
-            const rasterLayerId = await addRasterToMap(app, loaded.source, {
-              name: raster.name,
-              localPath: raster.sourcePath,
-              // The Tauri/WebKitGTK WASM backend can stall when its first
-              // source is created immediately after a project style load.
-              // GPU renders this local COG directly and preserves the imported
-              // QGIS ramp, so use the verified backend for project imports.
-              defaults: { engine: "maplibre-gl-raster" },
-              state: {
-                ...raster.state,
-                visible: raster.visible,
-                opacity: raster.opacity,
+            await addImportedProjectRaster(
+              app,
+              loaded.source,
+              {
+                name: raster.name,
+                localPath: raster.sourcePath,
+                // The Tauri/WebKitGTK WASM backend can stall when its first
+                // source is created immediately after a project style load.
+                // GPU renders this local COG directly and preserves the imported
+                // QGIS ramp, so use the verified backend for project imports.
+                defaults: { engine: "maplibre-gl-raster" },
+                state: {
+                  ...raster.state,
+                  visible: raster.visible,
+                  opacity: raster.opacity,
+                },
+                beforeId: raster.beforeId,
+                zoomTo: false,
               },
-              beforeId: raster.beforeId,
-              zoomTo: false,
-            });
-            if (raster.groupId) {
-              useAppStore.getState().moveLayerToGroup(rasterLayerId, raster.groupId);
-            }
+              raster.groupId,
+            );
           } catch (error) {
             console.error(`Failed to import QGIS raster "${raster.name}"`, error);
             imported.warnings.push({
@@ -276,6 +340,117 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     }
   };
 
+  const handleImportArcgisProject = async () => {
+    const result = await openArcgisProjectFile();
+    if (!result) return;
+    try {
+      const imported = importArcgisProject(result.data, result.path);
+      if (!isTauri()) {
+        const unavailableLayerIds = new Set<string>();
+        for (const layer of imported.project.layers) {
+          if (layer.sourcePath && !isHttpUrl(layer.sourcePath)) {
+            unavailableLayerIds.add(layer.id);
+            imported.warnings.push({ layerName: layer.name, reason: "browser-local-file" });
+          }
+        }
+        imported.project.layers = imported.project.layers.filter(
+          (layer) => !unavailableLayerIds.has(layer.id),
+        );
+        for (const raster of imported.rasters) {
+          imported.warnings.push({ layerName: raster.name, reason: "browser-local-file" });
+        }
+        // Rasters never load in the browser build, so drop them before the
+        // group prune below rather than letting them keep a group alive that
+        // will stay empty. Services still load, so they still count.
+        imported.rasters = [];
+        // Re-prune the groups: dropping the local-file layers can empty a group
+        // that the importer kept, and an empty group left behind shows up as a
+        // dangling entry in the layer panel.
+        const usedGroupIds = new Set<string>([
+          ...imported.project.layers.flatMap((layer) => (layer.groupId ? [layer.groupId] : [])),
+          ...imported.services.flatMap((service) => (service.groupId ? [service.groupId] : [])),
+        ]);
+        // A parent group stays as long as a surviving group still names it, so
+        // walk up the chain before filtering.
+        const groupById = new Map(
+          (imported.project.layerGroups ?? []).map((group) => [group.id, group]),
+        );
+        for (const id of [...usedGroupIds]) {
+          let parentId = groupById.get(id)?.parentId;
+          while (parentId && !usedGroupIds.has(parentId)) {
+            usedGroupIds.add(parentId);
+            parentId = groupById.get(parentId)?.parentId;
+          }
+        }
+        imported.project.layerGroups = imported.project.layerGroups?.filter((group) =>
+          usedGroupIds.has(group.id),
+        );
+      }
+      const mapReady = importedProjectMapReady(
+        mapControllerRef,
+        useAppStore.getState().basemapStyleUrl !== imported.project.basemapStyleUrl,
+      );
+      loadProject(imported.project, null);
+      await mapReady;
+      const app = createAppAPI(mapControllerRef);
+      if (isTauri()) {
+        for (const raster of imported.rasters) {
+          try {
+            const [loaded] = await loadDroppedRasterPaths([raster.sourcePath], {
+              importProjectPath: result.path,
+            });
+            if (!loaded) throw new Error("Unsupported raster path");
+            await addImportedProjectRaster(
+              app,
+              loaded.source,
+              {
+                name: raster.name,
+                localPath: raster.sourcePath,
+                defaults: { engine: "maplibre-gl-raster" },
+                state: { visible: raster.visible, opacity: raster.opacity },
+                zoomTo: false,
+              },
+              raster.groupId,
+            );
+          } catch (error) {
+            console.error(`Failed to import ArcGIS raster "${raster.name}"`, error);
+            imported.warnings.push({ layerName: raster.name, reason: "format" });
+          }
+        }
+      }
+      for (const service of imported.services) {
+        try {
+          const serviceLayerId = await addArcGISLayer(app, {
+            itemId: service.itemId,
+            layerType: "vector-tile",
+            name: service.name,
+            sourceType: "portal-item",
+            // The project's saved extent was applied by loadProject above, and
+            // this runs after it. Without the opt-out, each imported service
+            // would fit the map to its own bounds and throw that extent away.
+            zoomTo: false,
+          });
+          if (service.groupId) {
+            useAppStore.getState().moveLayerToGroup(serviceLayerId, service.groupId);
+          }
+          if (!service.visible) {
+            useAppStore.getState().setLayerVisibility(serviceLayerId, false);
+          }
+        } catch (error) {
+          console.error(`Failed to import ArcGIS service "${service.name}"`, error);
+          imported.warnings.push({ layerName: service.name, reason: "service" });
+        }
+      }
+      useAppStore.setState({ isDirty: true });
+      setArcgisImportWarnings(imported.warnings.length > 0 ? imported.warnings : null);
+    } catch (error) {
+      console.error("Failed to import ArcGIS project", error);
+      setActionError(
+        error instanceof Error ? error.message : t("toolbar.error.couldNotImportArcgisProject"),
+      );
+    }
+  };
+
   const handleOpenFromUrl = async (event: FormEvent<HTMLFormElement>) => {
     event.preventDefault();
     const normalizedUrl = normalizeProjectUrl(projectUrl);
@@ -830,6 +1005,8 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     setActionError,
     qgisImportWarnings,
     setQgisImportWarnings,
+    arcgisImportWarnings,
+    setArcgisImportWarnings,
     projectUrlDialogOpen,
     setProjectUrlDialogOpen,
     handleProjectUrlDialogOpenChange,
@@ -853,6 +1030,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     cancelSaveNamePrompt,
     handleOpenFromFile,
     handleImportQgisProject,
+    handleImportArcgisProject,
     handleOpenFromUrl,
     openProjectFromShareUrl,
     handleOpenRecent,