import { difference, flatten, isEqual, uniq } from "/_nuxt/node_modules/.cache/vite/client/deps/lodash-es.js?v=e4f18c29";
import {
  useThrottleFn,
  watchTriggerable,
  useMagicKeys,
  useEventListener
} from "/_nuxt/node_modules/@vueuse/core/index.mjs?v=e4f18c29";
import {
  ViewerEvent,
  VisualDiffMode,
  CameraController,
  DiffExtension,
  UpdateFlags,
  SectionOutlines,
  SectionToolEvent,
  SectionTool,
  SpeckleLoader,
  LargeModelStreamingLoader,
  ExplodeEvent,
  ExplodeExtension,
  LoaderEvent,
  SelectionExtension
} from "/_nuxt/@fs/D:/speckle-server/packages/viewer/dist/index.js";
import { Vector3 } from "/_nuxt/node_modules/.cache/vite/client/deps/three.js?v=e4f18c29";
import { useAuthManager } from "/_nuxt/lib/auth/composables/auth.ts";
import { ProjectCommentsUpdatedMessageType } from "/_nuxt/lib/common/generated/gql/graphql.ts";
import {
  useInjectedViewerState,
  useInjectedViewerInterfaceState
} from "/_nuxt/lib/viewer/composables/setup.ts";
import { useViewerSelectionEventHandler } from "/_nuxt/lib/viewer/composables/setup/selection.ts";
import {
  useGetObjectUrl,
  useOnViewerLoadComplete,
  useViewerCameraControlStartTracker,
  useViewerCameraTracker,
  useViewerEventListener
} from "/_nuxt/lib/viewer/composables/viewer.ts";
import {
  useCommentContext,
  useViewerCommentUpdateTracking
} from "/_nuxt/lib/viewer/composables/commentManagement.ts";
import { getCacheId } from "/_nuxt/lib/common/helpers/graphql.ts";
import {
  useViewerOpenedThreadUpdateEmitter,
  useViewerThreadTracking
} from "/_nuxt/lib/viewer/composables/commentBubbles.ts";
import { useGeneralProjectPageUpdateTracking } from "/_nuxt/lib/projects/composables/projectPages.ts";
import { arraysEqual, isNonNullable } from "/_nuxt/lib/common/helpers/utils.ts";
import { getTargetObjectIds } from "/_nuxt/lib/object-sidebar/helpers.ts";
import { areVectorsLooselyEqual } from "/_nuxt/lib/viewer/helpers/three.ts";
import { SafeLocalStorage } from "/_nuxt/@fs/D:/speckle-server/packages/shared/dist/esm/index.js";
import {
  useCameraUtilities,
  useSectionBoxUtilities
} from "/_nuxt/lib/viewer/composables/ui.ts";
import { ToastNotificationType, useGlobalToast } from "/_nuxt/lib/common/composables/toast.ts";
import { setupDebugMode } from "/_nuxt/lib/viewer/composables/setup/dev.ts";
import { useEmbed } from "/_nuxt/lib/viewer/composables/setup/embed.ts";
import { useMixpanel } from "/_nuxt/lib/core/composables/mp.ts";
import { graphql } from "/_nuxt/lib/common/generated/gql/index.ts";
import { useTreeManagement } from "/_nuxt/lib/viewer/composables/tree.ts";
import { useViewerSavedViewIntegration } from "/_nuxt/lib/viewer/composables/savedViews/state.ts";
import { useViewModesPostSetup } from "/_nuxt/lib/viewer/composables/setup/viewMode.ts";
import { useMeasurementsPostSetup } from "/_nuxt/lib/viewer/composables/setup/measurements.ts";
import { useFilterColoringPostSetup } from "/_nuxt/lib/viewer/composables/setup/coloring.ts";
import {
  usePropertyFilteringPostSetup,
  useManualFilteringPostSetup
} from "/_nuxt/lib/viewer/composables/setup/filters.ts";
import { useFilterUtilities } from "/_nuxt/lib/viewer/composables/filtering/filtering.ts";
import { useFilteringSetup } from "/_nuxt/lib/viewer/composables/filtering/setup.ts";
import {
  useHighlightingPostSetup,
  HighlightExtension
} from "/_nuxt/lib/viewer/composables/setup/highlighting.ts";
import { useProjectSavedViewsUpdateTracking } from "/_nuxt/lib/viewer/composables/savedViews/subscriptions.ts";

import { onMounted, onBeforeUnmount, watch, computed, ref } from "/_nuxt/node_modules/vue/dist/vue.runtime.esm-bundler.js?v=e4f18c29";
import { useApiOrigin } from "/_nuxt/composables/env.ts";
import { useActiveUser } from "/_nuxt/composables/globals.ts";
import { modifyObjectField } from "/_nuxt/utils/globals.ts";
function useViewerLoadCompleteEventHandler() {
  const state = useInjectedViewerState();
  const callback = () => {
    state.ui.loading.value = false;
  };
  onMounted(() => {
    state.viewer.instance.on(ViewerEvent.LoadComplete, callback);
  });
  onBeforeUnmount(() => {
    state.viewer.instance.removeListener(ViewerEvent.LoadComplete, callback);
  });
}
function useViewerObjectAutoLoading() {
  if (false) return;
  const disableViewerCache = SafeLocalStorage.get("FE2_FORCE_DISABLE_VIEWER_CACHE") === "true";
  const { effectiveAuthToken } = useAuthManager();
  const { triggerNotification } = useGlobalToast();
  const getObjectUrl = useGetObjectUrl();
  const apiOrigin = useApiOrigin({ forcePublic: true });
  const {
    projectId,
    viewer: {
      instance: viewer,
      init: { ref: isInitialized },
      hasDoneInitialLoad
    },
    resources: {
      request: {
        savedView: { id: savedViewId }
      },
      response: { resourceItems, savedView }
    },
    ui: { loadProgress, loading, spotlightUserSessionId, hasLoadedQueuedUpModels },
    urlHashState: { focusedThreadId }
  } = useInjectedViewerState();
  const loadingProgressMap = {};
  const derivativeNotificationKeys = /* @__PURE__ */ new Set();
  viewer.on(ViewerEvent.LoadComplete, (id) => {
    delete loadingProgressMap[id];
    consolidateProgressInternal({ id, progress: 1 });
  });
  const consolidateProgressInternal = (args) => {
    loadingProgressMap[args.id] = args.progress;
    const values = Object.values(loadingProgressMap);
    const min = values.length ? Math.min(...values) : 1;
    loadProgress.value = min;
    loading.value = min < 1;
  };
  const consolidateProgressThorttled = useThrottleFn(consolidateProgressInternal, 250);
  const getViewerDerivativeManifest = async (versionId) => {
    const res = await fetch(
      new URL(
        `/api/viewer-derivatives/${projectId.value}/${versionId}/manifest`,
        apiOrigin
      ),
      {
        headers: effectiveAuthToken.value ? { Authorization: `Bearer ${effectiveAuthToken.value}` } : void 0,
        cache: "no-store"
      }
    );
    if (res.status === 404) return void 0;
    if (!res.ok) return void 0;
    return await res.json();
  };
  const maybeLoadViewerDerivative = async (objectId, options) => {
    const resourceItem = resourceItems.value.find(
      (item) => item.objectId === objectId && item.versionId
    );
    if (!resourceItem?.versionId) return false;
    const derivative = await getViewerDerivativeManifest(resourceItem.versionId);
    if (!derivative || derivative.status === "missing") return false;
    const notificationKey = `${resourceItem.versionId}:${derivative.status}`;
    if (!derivativeNotificationKeys.has(notificationKey)) {
      derivativeNotificationKeys.add(notificationKey);
      triggerNotification({
        type: derivative.status === "failed" ? ToastNotificationType.Danger : ToastNotificationType.Info,
        title: "Large model streaming",
        description: derivative.status === "ready" ? "Loading viewer derivative." : derivative.status === "failed" ? derivative.errorMessage || "Viewer derivative generation failed." : "Viewer derivative generation is still processing."
      });
    }
    if (derivative.status === "ready" && derivative.manifest) {
      const objectUrl = getObjectUrl(projectId.value, objectId);
      const artifactBaseUrl = new URL(
        `/api/viewer-derivatives/${projectId.value}/${resourceItem.versionId}/artifacts`,
        apiOrigin
      ).toString();
      const loader = new LargeModelStreamingLoader(
        viewer.getWorldTree(),
        objectUrl,
        derivative.manifest,
        artifactBaseUrl,
        effectiveAuthToken.value || void 0
      );
      loader.on(LoaderEvent.LoadProgress, (args) => {
        consolidateProgressThorttled(args);
      });
      loader.on(LoaderEvent.LoadCancelled, (id) => {
        delete loadingProgressMap[id];
        consolidateProgressInternal({ id, progress: 1 });
      });
      await viewer.loadObject(loader, options?.zoomToObject);
      consolidateProgressInternal({ id: objectUrl, progress: 1 });
      return true;
    }
    consolidateProgressInternal({ id: objectId, progress: 1 });
    return true;
  };
  const loadObject = async (objectId, unload, options) => {
    const objectUrl = getObjectUrl(projectId.value, objectId);
    if (unload) {
      return viewer.unloadObject(objectUrl);
    } else {
      if (await maybeLoadViewerDerivative(objectId, options)) return;
      const loader = new SpeckleLoader(
        viewer.getWorldTree(),
        objectUrl,
        effectiveAuthToken.value || void 0,
        disableViewerCache ? false : void 0,
        void 0
      );
      loader.on(LoaderEvent.LoadProgress, (args) => {
        consolidateProgressThorttled(args);
      });
      loader.on(LoaderEvent.LoadCancelled, (id) => {
        delete loadingProgressMap[id];
        consolidateProgressInternal({ id, progress: 1 });
      });
      loader.on(LoaderEvent.LoadWarning, ({ message }) => {
        if (!message.startsWith("Viewer full-load guard:")) return;
        triggerNotification({
          type: ToastNotificationType.Danger,
          title: "Large model needs streaming",
          description: message
        });
      });
      return viewer.loadObject(loader, options?.zoomToObject);
    }
  };
  const getUniqueObjectIds = (resourceItems2) => uniq(resourceItems2.map((i) => i.objectId));
  const activeLoads = /* @__PURE__ */ new Set();
  watch(
    () => [resourceItems.value, isInitialized.value, hasDoneInitialLoad.value],
    async ([newResources, newIsInitialized, newHasDoneInitialLoad], oldData) => {
      if (!newIsInitialized) return;
      const [oldResources] = oldData || [[], false];
      const preventZooming = focusedThreadId.value || savedViewId.value || savedView.value || spotlightUserSessionId.value;
      const zoomToObject = !preventZooming;
      if (!newHasDoneInitialLoad) {
        const allObjectIds = getUniqueObjectIds(newResources);
        if (allObjectIds.length) {
          hasLoadedQueuedUpModels.value = false;
        }
        const res = [];
        const loadAll = async () => {
          for (const i of allObjectIds) {
            res.push(await loadObject(i, false, { zoomToObject }));
          }
        };
        const promise2 = loadAll().then(() => {
          activeLoads.delete(promise2);
        });
        activeLoads.add(promise2);
        await promise2;
        if (res.length) {
          hasDoneInitialLoad.value = true;
          if (!activeLoads.size) hasLoadedQueuedUpModels.value = true;
        }
        return;
      }
      const loadAndUnloadChanged = async () => {
        const newObjectIds = getUniqueObjectIds(newResources);
        const oldObjectIds = getUniqueObjectIds(oldResources);
        const removableObjectIds = difference(oldObjectIds, newObjectIds);
        const addableObjectIds = difference(newObjectIds, oldObjectIds);
        if (addableObjectIds.length) {
          hasLoadedQueuedUpModels.value = false;
        }
        await Promise.all(removableObjectIds.map((i) => loadObject(i, true)));
        await Promise.all(
          addableObjectIds.map((i) => loadObject(i, false, { zoomToObject: false }))
        );
      };
      const promise = loadAndUnloadChanged().then(() => {
        activeLoads.delete(promise);
      });
      activeLoads.add(promise);
      await promise;
      if (!activeLoads.size) hasLoadedQueuedUpModels.value = true;
    },
    { deep: true, immediate: true }
  );
  onBeforeUnmount(async () => {
    await viewer.unloadAll();
  });
}
function useViewerReceiveTracking() {
  const {
    resources: {
      response: { modelsAndVersionIds }
    }
  } = useInjectedViewerState();
  const mixpanel = useMixpanel();
  const { userId } = useActiveUser();
  const receivedVersions = /* @__PURE__ */ new Set();
  watch(modelsAndVersionIds, (newVal) => {
    for (const { model, versionId } of newVal) {
      if (receivedVersions.has(versionId)) {
        continue;
      }
      receivedVersions.add(versionId);
      mixpanel.track("Receive", {
        hostApp: "viewer",
        sourceHostApp: model.loadedVersion.items[0].sourceApplication,
        isMultiplayer: model.loadedVersion.items[0].authorUser?.id !== userId.value
      });
    }
  });
}
function useViewerSubscriptionEventTracker() {
  if (false) return;
  const {
    projectId,
    resources: {
      request: { resourceIdString, threadFilters }
    }
  } = useInjectedViewerState();
  useGeneralProjectPageUpdateTracking({
    projectId
  });
  useProjectSavedViewsUpdateTracking({ projectId });
  useViewerCommentUpdateTracking(
    {
      projectId,
      resourceIdString,
      loadedVersionsOnly: computed(() => threadFilters.value.loadedVersionsOnly)
    },
    (event, cache) => {
      const isArchived = event.type === ProjectCommentsUpdatedMessageType.Archived;
      const isNew = event.type === ProjectCommentsUpdatedMessageType.Created;
      const comment = event.comment;
      if (isArchived) {
        cache.modify({
          id: getCacheId("Comment", event.id),
          fields: {
            archived: () => true
          }
        });
        modifyObjectField(
          cache,
          getCacheId("Project", projectId.value),
          "commentThreads",
          ({ variables, helpers: { createUpdatedValue, readField } }) => {
            if (variables.filter?.includeArchived) return;
            return createUpdatedValue(({ update }) => {
              update("totalCount", (totalCount) => totalCount - 1);
              update(
                "items",
                (items) => items.filter((i) => readField(i, "id") !== event.id)
              );
            });
          }
        );
      } else if (isNew && comment) {
        const parentId = comment.parent?.id;
        if (parentId) {
          modifyObjectField(
            cache,
            getCacheId("Comment", parentId),
            "replies",
            ({ helpers: { createUpdatedValue, ref: ref2 } }) => createUpdatedValue(({ update }) => {
              update("totalCount", (totalCount) => totalCount + 1);
              update("items", (items) => [ref2("Comment", comment.id), ...items]);
            })
          );
        } else {
          modifyObjectField(
            cache,
            getCacheId("Project", projectId.value),
            "commentThreads",
            ({ helpers: { ref: ref2, createUpdatedValue, readField }, value }) => {
              const includesItem = value.items?.find(
                (i) => readField(i, "id") === comment.id
              );
              if (includesItem) return;
              return createUpdatedValue(({ update }) => {
                update("totalCount", (totalCount) => totalCount + 1);
                update("items", (items) => [ref2("Comment", comment.id), ...items]);
              });
            }
          );
        }
      }
    }
  );
}
function useViewerSectionBoxIntegration() {
  const {
    ui: {
      sectionBox,
      sectionBoxContext: { visible, edited }
    },
    viewer: { instance }
  } = useInjectedViewerState();
  const { sectionBoxDataToBox3, sectionBoxDataEquals } = useSectionBoxUtilities();
  const sectionTool = instance.getExtension(SectionTool);
  const onDragStart = () => {
    edited.value = true;
  };
  sectionTool.on(SectionToolEvent.DragStart, onDragStart);
  watch(
    sectionBox,
    (newVal, oldVal) => {
      if (newVal && oldVal && sectionBoxDataEquals(newVal, oldVal)) return;
      if (!newVal && !oldVal) return;
      if (oldVal && !newVal) {
        visible.value = false;
        edited.value = false;
        sectionTool.enabled = false;
        instance.requestRender(UpdateFlags.RENDER_RESET);
        return;
      }
      if (newVal && (!oldVal || !sectionBoxDataEquals(newVal, oldVal))) {
        visible.value = true;
        edited.value = false;
        const box3 = sectionBoxDataToBox3(newVal);
        sectionTool.setBox(box3);
        sectionTool.enabled = true;
        const outlines = instance.getExtension(SectionOutlines);
        if (outlines) outlines.requestUpdate();
        instance.requestRender(UpdateFlags.RENDER_RESET);
      }
    },
    { immediate: true, deep: true, flush: "sync" }
  );
  watch(
    visible,
    (newVal, oldVal) => {
      if (newVal && oldVal) return;
      if (!newVal && !oldVal) return;
      if (newVal) {
        sectionTool.visible = true;
      } else {
        sectionTool.visible = false;
      }
      instance.requestRender();
    },
    { immediate: true, deep: true, flush: "sync" }
  );
  onBeforeUnmount(() => {
    sectionTool.enabled = false;
    sectionTool.removeListener(SectionToolEvent.DragStart, onDragStart);
  });
}
function useViewerCameraIntegration() {
  const {
    viewer: { instance },
    ui: {
      camera: { isOrthoProjection, position, target },
      spotlightUserSessionId
    }
  } = useInjectedViewerState();
  const { forceViewToViewerSync, setView, cameraController } = useCameraUtilities();
  const hasInitialLoadFired = ref(false);
  const loadCameraDataFromViewer = () => {
    const extension = instance.getExtension(CameraController);
    const viewerPos = new Vector3().copy(extension.getPosition());
    const viewerTarget = new Vector3().copy(extension.getTarget());
    if (hasInitialLoadFired.value) {
      if (!areVectorsLooselyEqual(position.value, viewerPos)) {
        position.value = viewerPos.clone();
      }
      if (!areVectorsLooselyEqual(target.value, viewerTarget)) {
        target.value = viewerTarget.clone();
      }
    }
  };
  useViewerCameraTracker(
    () => {
      loadCameraDataFromViewer();
    },
    { throttleWait: 100 }
  );
  useOnViewerLoadComplete(({ isInitial }) => {
    if (isInitial) {
      hasInitialLoadFired.value = true;
      const hasInitCoords = position.value.equals(new Vector3()) && target.value.equals(new Vector3());
      if (hasInitCoords) {
        loadCameraDataFromViewer();
      } else {
        forceViewToViewerSync();
      }
      orthoProjectionUpdate(isOrthoProjection.value);
    } else {
      loadCameraDataFromViewer();
    }
  });
  useViewerCameraControlStartTracker(() => {
    if (spotlightUserSessionId.value) {
      spotlightUserSessionId.value = null;
    }
  });
  const orthoProjectionUpdate = (newVal) => {
    if (!hasInitialLoadFired.value) {
      throw new Error("Attempting to set projection too early");
    }
    if (newVal) {
      cameraController.setOrthoCameraOn();
    } else {
      cameraController.setPerspectiveCameraOn();
    }
    forceViewToViewerSync();
  };
  watch(
    isOrthoProjection,
    (newVal, oldVal) => {
      if (newVal === oldVal || !hasInitialLoadFired.value) return;
      orthoProjectionUpdate(newVal);
    },
    { immediate: true }
  );
  watch(
    position,
    (newVal, oldVal) => {
      if (!newVal && !oldVal || oldVal && areVectorsLooselyEqual(newVal, oldVal)) {
        return;
      }
      setView({
        position: newVal,
        target: target.value
      });
    }
    // { immediate: true }
  );
  watch(
    target,
    (newVal, oldVal) => {
      if (!newVal && !oldVal || oldVal && areVectorsLooselyEqual(newVal, oldVal)) {
        return;
      }
      setView({
        position: position.value,
        target: newVal
      });
    }
    // { immediate: true }
  );
}
function useViewerFiltersIntegration() {
  const state = useInjectedViewerState();
  const {
    viewer: { instance },
    ui: { filters }
  } = state;
  useFilteringSetup();
  useFilterUtilities({ state });
  watch(
    filters.selectedObjects,
    (newVal, oldVal) => {
      const newIds = flatten(
        newVal.map((v) => getTargetObjectIds(v))
      ).filter(isNonNullable);
      const oldIds = flatten(
        (oldVal || []).map((v) => getTargetObjectIds(v))
      ).filter(isNonNullable);
      if (arraysEqual(newIds, oldIds)) return;
      const selectionExtension = instance.getExtension(SelectionExtension);
      const currentViewerSelection = selectionExtension.getSelectedObjects().map((obj) => obj.id);
      if (currentViewerSelection.length === newIds.length && difference(currentViewerSelection, newIds).length === 0) {
        return;
      }
      state.ui.highlightedObjectIds.value = [];
      const highlightExtension = instance.getExtension(HighlightExtension);
      if (highlightExtension) {
        highlightExtension.clearSelection();
      }
      selectionExtension.clearSelection();
      if (newVal.length > 0) {
        selectionExtension.selectObjects(newIds);
      }
    },
    {
      immediate: true,
      flush: "sync"
    }
  );
}
function useLightConfigIntegration() {
  const {
    ui: { lightConfig },
    viewer: { instance }
  } = useInjectedViewerState();
  useViewerEventListener(
    ViewerEvent.LightConfigUpdated,
    (config) => {
      if (isEqual(lightConfig.value, config)) return;
      lightConfig.value = config;
    }
  );
  watch(
    lightConfig,
    (newVal, oldVal) => {
      if (newVal && oldVal && isEqual(newVal, oldVal)) return;
      instance.setLightConfiguration(newVal);
    },
    {
      immediate: true,
      deep: true,
      flush: "sync"
    }
  );
  useOnViewerLoadComplete(
    () => {
      instance.setLightConfiguration(lightConfig.value);
    },
    { initialOnly: true }
  );
}
function useExplodeFactorIntegration() {
  const {
    ui: { explodeFactor },
    viewer: { instance }
  } = useInjectedViewerState();
  const explodeExtension = instance.getExtension(ExplodeExtension);
  const updateOutlines = () => {
    const sectionOutlines = instance.getExtension(SectionOutlines);
    if (sectionOutlines && sectionOutlines.enabled) sectionOutlines.requestUpdate(true);
  };
  onMounted(() => {
    explodeExtension.on(ExplodeEvent.Finshed, updateOutlines);
  });
  onBeforeUnmount(() => {
    explodeExtension.removeListener(ExplodeEvent.Finshed, updateOutlines);
  });
  watch(
    explodeFactor,
    (newVal) => {
      explodeExtension.setExplode(newVal);
    },
    { immediate: true }
  );
  useOnViewerLoadComplete(
    () => {
      explodeExtension.setExplode(explodeFactor.value);
    },
    { initialOnly: true }
  );
}
function useDiffingIntegration() {
  const state = useInjectedViewerState();
  const { effectiveAuthToken } = useAuthManager();
  const getObjectUrl = useGetObjectUrl();
  const hasInitialLoadFired = ref(false);
  const diffExtension = state.viewer.instance.getExtension(DiffExtension);
  const { trigger: triggerDiffCommandWatch } = watchTriggerable(
    () => [state.ui.diff.oldVersion.value, state.ui.diff.newVersion.value],
    async (newVal, oldVal) => {
      if (!hasInitialLoadFired.value) return;
      const [oldVersion, newVersion] = newVal;
      const [oldOldVersion, oldNewVersion] = oldVal || [null, null];
      const versionId = (version) => version?.id || null;
      const commandId = (oldVersion2, newVersion2) => {
        const oldId = versionId(oldVersion2);
        const newId = versionId(newVersion2);
        return oldId && newId ? `${oldId}->${newId}` : null;
      };
      const newCommand = commandId(oldVersion, newVersion);
      const oldCommand = commandId(oldOldVersion, oldNewVersion);
      if (newCommand && oldCommand === newCommand || !!newCommand === !!oldCommand)
        return;
      if (!newCommand || oldVal) {
        await diffExtension.undiff();
        if (!newCommand) return;
      }
      const oldObjUrl = getObjectUrl(
        state.projectId.value,
        oldVersion?.referencedObject
      );
      const newObjUrl = getObjectUrl(
        state.projectId.value,
        newVersion?.referencedObject
      );
      state.ui.diff.result.value = await diffExtension.diff(
        oldObjUrl,
        newObjUrl,
        state.ui.diff.mode.value,
        effectiveAuthToken.value
      );
    },
    { immediate: true }
  );
  watch(state.ui.diff.result, (val) => {
    if (!val) return;
    ignoreDiffModeUpdates(() => {
      ignoreDiffTimeUpdates(() => {
        state.ui.diff.time.value = 0.5;
        state.ui.diff.mode.value = VisualDiffMode.COLORED;
        triggerDiffModeWatch();
      });
    });
  });
  const { ignoreUpdates: ignoreDiffTimeUpdates } = watchTriggerable(
    state.ui.diff.time,
    (val) => {
      if (!hasInitialLoadFired.value) return;
      if (!state.ui.diff.result.value) return;
      diffExtension.updateVisualDiff(val, state.ui.diff.mode.value);
    }
  );
  const { trigger: triggerDiffModeWatch, ignoreUpdates: ignoreDiffModeUpdates } = watchTriggerable(state.ui.diff.mode, (val) => {
    if (!hasInitialLoadFired.value) return;
    if (!state.ui.diff.result.value) return;
    diffExtension.updateVisualDiff(state.ui.diff.time.value, val);
  });
  useOnViewerLoadComplete(({ isInitial }) => {
    if (!isInitial) return;
    hasInitialLoadFired.value = true;
    triggerDiffCommandWatch();
  });
}
function useDisableZoomOnEmbed() {
  const { viewer } = useInjectedViewerState();
  const embedOptions = useEmbed();
  watch(
    () => embedOptions.noScroll.value,
    (newNoScrollValue) => {
      const cameraController = viewer.instance.getExtension(CameraController);
      if (newNoScrollValue) {
        cameraController.options = { enableZoom: false };
      } else {
        cameraController.options = { enableZoom: true };
      }
    },
    { immediate: true }
  );
}
function useViewerTreeIntegration() {
  const { viewer } = useInjectedViewerState();
  const { treeStateManager } = useTreeManagement();
  onMounted(() => treeStateManager.initialize(viewer.instance));
}
graphql(`
  fragment UseViewerSavedViewSetup_SavedView on SavedView {
    id
    viewerState
    ...ViewerPageSetup_SavedView
  }
`);
function useViewerCursorIntegration() {
  const {
    viewer: { container }
  } = useInjectedViewerState();
  const {
    filters: { selectedObjects }
  } = useInjectedViewerInterfaceState();
  const { shift } = useMagicKeys();
  const isDragging = ref(false);
  const handlePointerDown = (_event) => {
    if (shift.value && selectedObjects.value.length === 0) {
      isDragging.value = true;
    }
  };
  const handlePointerUp = () => {
    isDragging.value = false;
  };
  watch(
    [shift, selectedObjects, isDragging],
    () => {
      if (!container) return;
      const hasSelection = selectedObjects.value.length > 0;
      const shouldShowDrag = shift.value && !hasSelection;
      if (shouldShowDrag) {
        container.style.cursor = isDragging.value ? "grabbing" : "grab";
      } else {
        container.style.cursor = "";
      }
    },
    { immediate: true }
  );
  useEventListener(container, "pointerdown", handlePointerDown, { passive: true });
  useEventListener(document, "pointerup", handlePointerUp, { passive: true });
  onBeforeUnmount(() => {
    if (container) {
      container.style.cursor = "";
    }
  });
}
const useCommentContextIntegration = () => {
  const { cleanupThreadContext } = useCommentContext();
  onBeforeUnmount(() => {
    cleanupThreadContext();
  });
};
export function useViewerPostSetup() {
  if (false) return;
  useViewerObjectAutoLoading();
  useViewerSavedViewIntegration();
  useViewerReceiveTracking();
  useViewerSelectionEventHandler();
  useViewerLoadCompleteEventHandler();
  useViewerSubscriptionEventTracker();
  useViewerThreadTracking();
  useViewerOpenedThreadUpdateEmitter();
  useViewerSectionBoxIntegration();
  useViewerCameraIntegration();
  useViewerFiltersIntegration();
  useLightConfigIntegration();
  useExplodeFactorIntegration();
  useDiffingIntegration();
  useMeasurementsPostSetup();
  useFilterColoringPostSetup();
  usePropertyFilteringPostSetup();
  useManualFilteringPostSetup();
  useDisableZoomOnEmbed();
  useViewerCursorIntegration();
  useViewerTreeIntegration();
  useViewModesPostSetup();
  useHighlightingPostSetup();
  useCommentContextIntegration();
  setupDebugMode();
}

//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"AAAA,SAAS,YAAY,SAAS,SAAS,YAAY;AACnD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,eAAe;AACxB,SAAS,sBAAsB;AAE/B,SAAS,yCAAyC;AAClD;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,sCAAsC;AAC/C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,kBAAkB;AAC3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,2CAA2C;AACpD,SAAS,aAAa,qBAAqB;AAC3C,SAAS,0BAA0B;AACnC,SAAS,8BAA8B;AACvC,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,uBAAuB,sBAAsB;AACtD,SAAS,sBAAsB;AAC/B,SAAS,gBAAgB;AACzB,SAAS,mBAAmB;AAC5B,SAAS,eAAe;AACxB,SAAS,yBAAyB;AAClC,SAAS,qCAAqC;AAC9C,SAAS,6BAA6B;AACtC,SAAS,gCAAgC;AACzC,SAAS,kCAAkC;AAC3C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,0CAA0C;;;;;;AAEnD,SAAS,oCAAoC;AAC3C,QAAM,QAAQ,uBAAuB;AAErC,QAAM,WAAW,MAAM;AACrB,UAAM,GAAG,QAAQ,QAAQ;AAAA,EAC3B;AACA,YAAU,MAAM;AACd,UAAM,OAAO,SAAS,GAAG,YAAY,cAAc,QAAQ;AAAA,EAC7D,CAAC;AAED,kBAAgB,MAAM;AACpB,UAAM,OAAO,SAAS,eAAe,YAAY,cAAc,QAAQ;AAAA,EACzE,CAAC;AACH;AAKA,SAAS,6BAA6B;AACpC,MAAI,KAAY,CAAQ;AAyBxB,QAAM,qBACJ,iBAAiB,IAAI,gCAAgC,MAAM;AAC7D,QAAM,EAAE,mBAAmB,IAAI,eAAe;AAC9C,QAAM,EAAE,oBAAoB,IAAI,eAAe;AAC/C,QAAM,eAAe,gBAAgB;AACrC,QAAM,YAAY,aAAa,EAAE,aAAa,KAAK,CAAC;AACpD,QAAM;AAAA,IACJ;AAAA,IACA,QAAQ;AAAA,MACN,UAAU;AAAA,MACV,MAAM,EAAE,KAAK,cAAc;AAAA,MAC3B;AAAA,IACF;AAAA,IACA,WAAW;AAAA,MACT,SAAS;AAAA,QACP,WAAW,EAAE,IAAI,YAAY;AAAA,MAC/B;AAAA,MACA,UAAU,EAAE,eAAe,UAAU;AAAA,IACvC;AAAA,IACA,IAAI,EAAE,cAAc,SAAS,wBAAwB,wBAAwB;AAAA,IAC7E,cAAc,EAAE,gBAAgB;AAAA,EAClC,IAAI,uBAAuB;AAE3B,QAAM,qBAA+C,CAAC;AACtD,QAAM,6BAA6B,oBAAI,IAAY;AAEnD,SAAO,GAAG,YAAY,cAAc,CAAC,OAAO;AAC1C,WAAO,mBAAmB,EAAE;AAC5B,gCAA4B,EAAE,IAAI,UAAU,EAAE,CAAC;AAAA,EACjD,CAAC;AAED,QAAM,8BAA8B,CAAC,SAA2C;AAC9E,uBAAmB,KAAK,EAAE,IAAI,KAAK;AACnC,UAAM,SAAS,OAAO,OAAO,kBAAkB;AAC/C,UAAM,MAAM,OAAO,SAAS,KAAK,IAAI,GAAG,MAAM,IAAI;AAElD,iBAAa,QAAQ;AACrB,YAAQ,QAAQ,MAAM;AAAA,EACxB;AAEA,QAAM,+BAA+B,cAAc,6BAA6B,GAAG;AAEnF,QAAM,8BAA8B,OAClC,cAC0D;AAC1D,UAAM,MAAM,MAAM;AAAA,MAChB,IAAI;AAAA,QACF,2BAA2B,UAAU,KAAK,IAAI,SAAS;AAAA,QACvD;AAAA,MACF;AAAA,MACA;AAAA,QACE,SAAS,mBAAmB,QACxB,EAAE,eAAe,UAAU,mBAAmB,KAAK,GAAG,IACtD;AAAA,QACJ,OAAO;AAAA,MACT;AAAA,IACF;AAEA,QAAI,IAAI,WAAW,IAAK,QAAO;AAC/B,QAAI,CAAC,IAAI,GAAI,QAAO;AAEpB,WAAQ,MAAM,IAAI,KAAK;AAAA,EACzB;AAEA,QAAM,4BAA4B,OAChC,UACA,YACG;AACH,UAAM,eAAe,cAAc,MAAM;AAAA,MACvC,CAAC,SAAS,KAAK,aAAa,YAAY,KAAK;AAAA,IAC/C;AACA,QAAI,CAAC,cAAc,UAAW,QAAO;AAErC,UAAM,aAAa,MAAM,4BAA4B,aAAa,SAAS;AAC3E,QAAI,CAAC,cAAc,WAAW,WAAW,UAAW,QAAO;AAE3D,UAAM,kBAAkB,GAAG,aAAa,SAAS,IAAI,WAAW,MAAM;AACtE,QAAI,CAAC,2BAA2B,IAAI,eAAe,GAAG;AACpD,iCAA2B,IAAI,eAAe;AAC9C,0BAAoB;AAAA,QAClB,MACE,WAAW,WAAW,WAClB,sBAAsB,SACtB,sBAAsB;AAAA,QAC5B,OAAO;AAAA,QACP,aACE,WAAW,WAAW,UAClB,+BACA,WAAW,WAAW,WACtB,WAAW,gBAAgB,yCAC3B;AAAA,MACR,CAAC;AAAA,IACH;AAEA,QAAI,WAAW,WAAW,WAAW,WAAW,UAAU;AACxD,YAAM,YAAY,aAAa,UAAU,OAAO,QAAQ;AACxD,YAAM,kBAAkB,IAAI;AAAA,QAC1B,2BAA2B,UAAU,KAAK,IAAI,aAAa,SAAS;AAAA,QACpE;AAAA,MACF,EAAE,SAAS;AACX,YAAM,SAAS,IAAI;AAAA,QACjB,OAAO,aAAa;AAAA,QACpB;AAAA,QACA,WAAW;AAAA,QACX;AAAA,QACA,mBAAmB,SAAS;AAAA,MAC9B;AACA,aAAO,GAAG,YAAY,cAAc,CAAC,SAAS;AAC5C,qCAA6B,IAAI;AAAA,MACnC,CAAC;AACD,aAAO,GAAG,YAAY,eAAe,CAAC,OAAO;AAC3C,eAAO,mBAAmB,EAAE;AAC5B,oCAA4B,EAAE,IAAI,UAAU,EAAE,CAAC;AAAA,MACjD,CAAC;AACD,YAAM,OAAO,WAAW,QAAQ,SAAS,YAAY;AACrD,kCAA4B,EAAE,IAAI,WAAW,UAAU,EAAE,CAAC;AAC1D,aAAO;AAAA,IACT;AAEA,gCAA4B,EAAE,IAAI,UAAU,UAAU,EAAE,CAAC;AACzD,WAAO;AAAA,EACT;AAEA,QAAM,aAAa,OACjB,UACA,QACA,YACG;AACH,UAAM,YAAY,aAAa,UAAU,OAAO,QAAQ;AAExD,QAAI,QAAQ;AACV,aAAO,OAAO,aAAa,SAAS;AAAA,IACtC,OAAO;AACL,UAAI,MAAM,0BAA0B,UAAU,OAAO,EAAG;AAExD,YAAM,SAAS,IAAI;AAAA,QACjB,OAAO,aAAa;AAAA,QACpB;AAAA,QACA,mBAAmB,SAAS;AAAA,QAC5B,qBAAqB,QAAQ;AAAA,QAC7B;AAAA,MACF;AAEA,aAAO,GAAG,YAAY,cAAc,CAAC,SAAS;AAC5C,qCAA6B,IAAI;AAAA,MACnC,CAAC;AACD,aAAO,GAAG,YAAY,eAAe,CAAC,OAAO;AAC3C,eAAO,mBAAmB,EAAE;AAC5B,oCAA4B,EAAE,IAAI,UAAU,EAAE,CAAC;AAAA,MACjD,CAAC;AACD,aAAO,GAAG,YAAY,aAAa,CAAC,EAAE,QAAQ,MAAM;AAClD,YAAI,CAAC,QAAQ,WAAW,yBAAyB,EAAG;AAEpD,4BAAoB;AAAA,UAClB,MAAM,sBAAsB;AAAA,UAC5B,OAAO;AAAA,UACP,aAAa;AAAA,QACf,CAAC;AAAA,MACH,CAAC;AAED,aAAO,OAAO,WAAW,QAAQ,SAAS,YAAY;AAAA,IACxD;AAAA,EACF;AAEA,QAAM,qBAAqB,CAACA,mBAC1B,KAAKA,eAAc,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC;AAE3C,QAAM,cAAc,oBAAI,IAAmB;AAC3C;AAAA,IACE,MAAa,CAAC,cAAc,OAAO,cAAc,OAAO,mBAAmB,KAAK;AAAA,IAChF,OAAO,CAAC,cAAc,kBAAkB,qBAAqB,GAAG,YAAY;AAE1E,UAAI,CAAC,iBAAkB;AAEvB,YAAM,CAAC,YAAY,IAAI,WAAW,CAAC,CAAC,GAAG,KAAK;AAI5C,YAAM,iBACJ,gBAAgB,SAChB,YAAY,SACZ,UAAU,SACV,uBAAuB;AACzB,YAAM,eAAe,CAAC;AAGtB,UAAI,CAAC,uBAAuB;AAC1B,cAAM,eAAe,mBAAmB,YAAY;AACpD,YAAI,aAAa,QAAQ;AAEvB,kCAAwB,QAAQ;AAAA,QAClC;AAGA,cAAM,MAAM,CAAC;AACb,cAAM,UAAU,YAAY;AAC1B,qBAAW,KAAK,cAAc;AAC5B,gBAAI,KAAK,MAAM,WAAW,GAAG,OAAO,EAAE,aAAa,CAAC,CAAC;AAAA,UACvD;AAAA,QACF;AAGA,cAAMC,WAAU,QAAQ,EAAE,KAAK,MAAM;AACnC,sBAAY,OAAOA,QAAO;AAAA,QAC5B,CAAC;AACD,oBAAY,IAAIA,QAAO;AACvB,cAAMA;AAEN,YAAI,IAAI,QAAQ;AACd,6BAAmB,QAAQ;AAC3B,cAAI,CAAC,YAAY,KAAM,yBAAwB,QAAQ;AAAA,QACzD;AAEA;AAAA,MACF;AAGA,YAAM,uBAAuB,YAAY;AACvC,cAAM,eAAe,mBAAmB,YAAY;AACpD,cAAM,eAAe,mBAAmB,YAAY;AACpD,cAAM,qBAAqB,WAAW,cAAc,YAAY;AAChE,cAAM,mBAAmB,WAAW,cAAc,YAAY;AAE9D,YAAI,iBAAiB,QAAQ;AAE3B,kCAAwB,QAAQ;AAAA,QAClC;AAEA,cAAM,QAAQ,IAAI,mBAAmB,IAAI,CAAC,MAAM,WAAW,GAAG,IAAI,CAAC,CAAC;AACpE,cAAM,QAAQ;AAAA,UACZ,iBAAiB,IAAI,CAAC,MAAM,WAAW,GAAG,OAAO,EAAE,cAAc,MAAM,CAAC,CAAC;AAAA,QAC3E;AAAA,MACF;AAGA,YAAM,UAAU,qBAAqB,EAAE,KAAK,MAAM;AAChD,oBAAY,OAAO,OAAO;AAAA,MAC5B,CAAC;AACD,kBAAY,IAAI,OAAO;AACvB,YAAM;AAEN,UAAI,CAAC,YAAY,KAAM,yBAAwB,QAAQ;AAAA,IACzD;AAAA,IACA,EAAE,MAAM,MAAM,WAAW,KAAK;AAAA,EAChC;AAEA,kBAAgB,YAAY;AAC1B,UAAM,OAAO,UAAU;AAAA,EACzB,CAAC;AACH;AAMA,SAAS,2BAA2B;AAElC,QAAM;AAAA,IACJ,WAAW;AAAA,MACT,UAAU,EAAE,oBAAoB;AAAA,IAClC;AAAA,EACF,IAAI,uBAAuB;AAC3B,QAAM,WAAW,YAAY;AAC7B,QAAM,EAAE,OAAO,IAAI,cAAc;AACjC,QAAM,mBAAmB,oBAAI,IAAY;AACzC,QAAM,qBAAqB,CAAC,WAAW;AACrC,eAAW,EAAE,OAAO,UAAU,KAAK,QAAQ;AACzC,UAAI,iBAAiB,IAAI,SAAS,GAAG;AACnC;AAAA,MACF;AACA,uBAAiB,IAAI,SAAS;AAC9B,eAAS,MAAM,WAAW;AAAA,QACxB,SAAS;AAAA,QACT,eAAe,MAAM,cAAc,MAAM,CAAC,EAAE;AAAA,QAC5C,eAAe,MAAM,cAAc,MAAM,CAAC,EAAE,YAAY,OAAO,OAAO;AAAA,MACxE,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AACH;AAMA,SAAS,oCAAoC;AAC3C,MAAI,KAAY,CAAQ;AAExB,QAAM;AAAA,IACJ;AAAA,IACA,WAAW;AAAA,MACT,SAAS,EAAE,kBAAkB,cAAc;AAAA,IAC7C;AAAA,EACF,IAAI,uBAAuB;AAG3B,sCAAoC;AAAA,IAClC;AAAA,EACF,CAAC;AAGD,qCAAmC,EAAE,UAAU,CAAC;AAGhD;AAAA,IACE;AAAA,MACE;AAAA,MACA;AAAA,MACA,oBAAoB,SAAS,MAAM,cAAc,MAAM,kBAAkB;AAAA,IAC3E;AAAA,IACA,CAAC,OAAO,UAAU;AAChB,YAAM,aAAa,MAAM,SAAS,kCAAkC;AACpE,YAAM,QAAQ,MAAM,SAAS,kCAAkC;AAC/D,YAAM,UAAU,MAAM;AAEtB,UAAI,YAAY;AAEd,cAAM,OAAO;AAAA,UACX,IAAI,WAAW,WAAW,MAAM,EAAE;AAAA,UAClC,QAAQ;AAAA,YACN,UAAU,MAAM;AAAA,UAClB;AAAA,QACF,CAAC;AAGD;AAAA,UACE;AAAA,UACA,WAAW,WAAW,UAAU,KAAK;AAAA,UACrC;AAAA,UACA,CAAC,EAAE,WAAW,SAAS,EAAE,oBAAoB,UAAU,EAAE,MAAM;AAC7D,gBAAI,UAAU,QAAQ,gBAAiB;AAEvC,mBAAO,mBAAmB,CAAC,EAAE,OAAO,MAAM;AACxC,qBAAO,cAAc,CAAC,eAAe,aAAa,CAAC;AACnD;AAAA,gBAAO;AAAA,gBAAS,CAAC,UACf,MAAM,OAAO,CAAC,MAAM,UAAU,GAAG,IAAI,MAAM,MAAM,EAAE;AAAA,cACrD;AAAA,YACF,CAAC;AAAA,UACH;AAAA,QACF;AAAA,MACF,WAAW,SAAS,SAAS;AAC3B,cAAM,WAAW,QAAQ,QAAQ;AAGjC,YAAI,UAAU;AACZ;AAAA,YACE;AAAA,YACA,WAAW,WAAW,QAAQ;AAAA,YAC9B;AAAA,YACA,CAAC,EAAE,SAAS,EAAE,oBAAoB,KAAAC,KAAI,EAAE,MACtC,mBAAmB,CAAC,EAAE,OAAO,MAAM;AACjC,qBAAO,cAAc,CAAC,eAAe,aAAa,CAAC;AACnD,qBAAO,SAAS,CAAC,UAAU,CAACA,KAAI,WAAW,QAAQ,EAAE,GAAG,GAAG,KAAK,CAAC;AAAA,YACnE,CAAC;AAAA,UACL;AAAA,QACF,OAAO;AAEL;AAAA,YACE;AAAA,YACA,WAAW,WAAW,UAAU,KAAK;AAAA,YACrC;AAAA,YACA,CAAC,EAAE,SAAS,EAAE,KAAAA,MAAK,oBAAoB,UAAU,GAAG,MAAM,MAAM;AAG9D,oBAAM,eAAe,MAAM,OAAO;AAAA,gBAChC,CAAC,MAAM,UAAU,GAAG,IAAI,MAAM,QAAQ;AAAA,cACxC;AACA,kBAAI,aAAc;AAElB,qBAAO,mBAAmB,CAAC,EAAE,OAAO,MAAM;AACxC,uBAAO,cAAc,CAAC,eAAe,aAAa,CAAC;AACnD,uBAAO,SAAS,CAAC,UAAU,CAACA,KAAI,WAAW,QAAQ,EAAE,GAAG,GAAG,KAAK,CAAC;AAAA,cACnE,CAAC;AAAA,YACH;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,iCAAiC;AACxC,QAAM;AAAA,IACJ,IAAI;AAAA,MACF;AAAA,MACA,mBAAmB,EAAE,SAAS,OAAO;AAAA,IACvC;AAAA,IACA,QAAQ,EAAE,SAAS;AAAA,EACrB,IAAI,uBAAuB;AAE3B,QAAM,EAAE,sBAAsB,qBAAqB,IAAI,uBAAuB;AAG9E,QAAM,cAAc,SAAS,aAAa,WAAW;AACrD,QAAM,cAAc,MAAM;AACxB,WAAO,QAAQ;AAAA,EACjB;AACA,cAAY,GAAG,iBAAiB,WAAW,WAAW;AAMtD;AAAA,IACE;AAAA,IACA,CAAC,QAAQ,WAAW;AAClB,UAAI,UAAU,UAAU,qBAAqB,QAAQ,MAAM,EAAG;AAC9D,UAAI,CAAC,UAAU,CAAC,OAAQ;AAExB,UAAI,UAAU,CAAC,QAAQ;AACrB,gBAAQ,QAAQ;AAChB,eAAO,QAAQ;AAEf,oBAAY,UAAU;AACtB,iBAAS,cAAc,YAAY,YAAY;AAC/C;AAAA,MACF;AAEA,UAAI,WAAW,CAAC,UAAU,CAAC,qBAAqB,QAAQ,MAAM,IAAI;AAChE,gBAAQ,QAAQ;AAChB,eAAO,QAAQ;AAEf,cAAM,OAAO,qBAAqB,MAAM;AACxC,oBAAY,OAAO,IAAI;AACvB,oBAAY,UAAU;AACtB,cAAM,WAAW,SAAS,aAAa,eAAe;AACtD,YAAI,SAAU,UAAS,cAAc;AACrC,iBAAS,cAAc,YAAY,YAAY;AAAA,MACjD;AAAA,IACF;AAAA,IACA,EAAE,WAAW,MAAM,MAAM,MAAM,OAAO,OAAO;AAAA,EAC/C;AAEA;AAAA,IACE;AAAA,IACA,CAAC,QAAQ,WAAW;AAClB,UAAI,UAAU,OAAQ;AACtB,UAAI,CAAC,UAAU,CAAC,OAAQ;AAExB,UAAI,QAAQ;AACV,oBAAY,UAAU;AAAA,MACxB,OAAO;AACL,oBAAY,UAAU;AAAA,MACxB;AACA,eAAS,cAAc;AAAA,IACzB;AAAA,IACA,EAAE,WAAW,MAAM,MAAM,MAAM,OAAO,OAAO;AAAA,EAC/C;AAEA,kBAAgB,MAAM;AACpB,gBAAY,UAAU;AACtB,gBAAY,eAAe,iBAAiB,WAAW,WAAW;AAAA,EACpE,CAAC;AACH;AAEA,SAAS,6BAA6B;AACpC,QAAM;AAAA,IACJ,QAAQ,EAAE,SAAS;AAAA,IACnB,IAAI;AAAA,MACF,QAAQ,EAAE,mBAAmB,UAAU,OAAO;AAAA,MAC9C;AAAA,IACF;AAAA,EACF,IAAI,uBAAuB;AAC3B,QAAM,EAAE,uBAAuB,SAAS,iBAAiB,IAAI,mBAAmB;AAEhF,QAAM,sBAAsB,IAAI,KAAK;AAErC,QAAM,2BAA2B,MAAM;AACrC,UAAM,YAA8B,SAAS,aAAa,gBAAgB;AAE1E,UAAM,YAAY,IAAI,QAAQ,EAAE,KAAK,UAAU,YAAY,CAAC;AAC5D,UAAM,eAAe,IAAI,QAAQ,EAAE,KAAK,UAAU,UAAU,CAAC;AAE7D,QAAI,oBAAoB,OAAO;AAC7B,UAAI,CAAC,uBAAuB,SAAS,OAAO,SAAS,GAAG;AACtD,iBAAS,QAAQ,UAAU,MAAM;AAAA,MACnC;AACA,UAAI,CAAC,uBAAuB,OAAO,OAAO,YAAY,GAAG;AACvD,eAAO,QAAQ,aAAa,MAAM;AAAA,MACpC;AAAA,IACF;AAAA,EACF;AAIA;AAAA,IACE,MAAM;AACJ,+BAAyB;AAAA,IAC3B;AAAA,IACA,EAAE,cAAc,IAAI;AAAA,EACtB;AAEA,0BAAwB,CAAC,EAAE,UAAU,MAAM;AACzC,QAAI,WAAW;AACb,0BAAoB,QAAQ;AAK5B,YAAM,gBACJ,SAAS,MAAM,OAAO,IAAI,QAAQ,CAAC,KAAK,OAAO,MAAM,OAAO,IAAI,QAAQ,CAAC;AAC3E,UAAI,eAAe;AACjB,iCAAyB;AAAA,MAC3B,OAAO;AACL,8BAAsB;AAAA,MACxB;AAGA,4BAAsB,kBAAkB,KAAK;AAAA,IAC/C,OAAO;AACL,+BAAyB;AAAA,IAC3B;AAAA,EACF,CAAC;AAED,qCAAmC,MAAM;AACvC,QAAI,uBAAuB,OAAO;AAChC,6BAAuB,QAAQ;AAAA,IACjC;AAAA,EACF,CAAC;AAED,QAAM,wBAAwB,CAAC,WAAoB;AACjD,QAAI,CAAC,oBAAoB,OAAO;AAC9B,YAAM,IAAI,MAAM,wCAAwC;AAAA,IAC1D;AAEA,QAAI,QAAQ;AACV,uBAAiB,iBAAiB;AAAA,IACpC,OAAO;AACL,uBAAiB,uBAAuB;AAAA,IAC1C;AAGA,0BAAsB;AAAA,EACxB;AAGA;AAAA,IACE;AAAA,IACA,CAAC,QAAQ,WAAW;AAClB,UAAI,WAAW,UAAU,CAAC,oBAAoB,MAAO;AACrD,4BAAsB,MAAM;AAAA,IAC9B;AAAA,IACA,EAAE,WAAW,KAAK;AAAA,EACpB;AAEA;AAAA,IACE;AAAA,IACA,CAAC,QAAQ,WAAW;AAClB,UAAK,CAAC,UAAU,CAAC,UAAY,UAAU,uBAAuB,QAAQ,MAAM,GAAI;AAC9E;AAAA,MACF;AACA,cAAQ;AAAA,QACN,UAAU;AAAA,QACV,QAAQ,OAAO;AAAA,MACjB,CAAC;AAAA,IACH;AAAA;AAAA,EAEF;AAEA;AAAA,IACE;AAAA,IACA,CAAC,QAAQ,WAAW;AAClB,UAAK,CAAC,UAAU,CAAC,UAAY,UAAU,uBAAuB,QAAQ,MAAM,GAAI;AAC9E;AAAA,MACF;AAEA,cAAQ;AAAA,QACN,UAAU,SAAS;AAAA,QACnB,QAAQ;AAAA,MACV,CAAC;AAAA,IACH;AAAA;AAAA,EAEF;AACF;AAEA,SAAS,8BAA8B;AACrC,QAAM,QAAQ,uBAAuB;AACrC,QAAM;AAAA,IACJ,QAAQ,EAAE,SAAS;AAAA,IACnB,IAAI,EAAE,QAAQ;AAAA,EAChB,IAAI;AAEJ,oBAAkB;AAClB,qBAAmB,EAAE,MAAM,CAAC;AAE5B;AAAA,IACE,QAAQ;AAAA,IACR,CAAC,QAAQ,WAAW;AAClB,YAAM,SAAS;AAAA,QACb,OAAO,IAAI,CAAC,MAAM,mBAAmB,CAA4B,CAAC;AAAA,MACpE,EAAE,OAAO,aAAa;AACtB,YAAM,SAAS;AAAA,SACZ,UAAU,CAAC,GAAG,IAAI,CAAC,MAAM,mBAAmB,CAA4B,CAAC;AAAA,MAC5E,EAAE,OAAO,aAAa;AACtB,UAAI,YAAY,QAAQ,MAAM,EAAG;AAEjC,YAAM,qBAAqB,SAAS,aAAa,kBAAkB;AACnE,YAAM,yBAAyB,mBAC5B,mBAAmB,EACnB,IAAI,CAAC,QAAQ,IAAI,EAAY;AAEhC,UACE,uBAAuB,WAAW,OAAO,UACzC,WAAW,wBAAwB,MAAM,EAAE,WAAW,GACtD;AACA;AAAA,MACF;AAEA,YAAM,GAAG,qBAAqB,QAAQ,CAAC;AACvC,YAAM,qBAAqB,SAAS,aAAa,kBAAkB;AACnE,UAAI,oBAAoB;AACtB,2BAAmB,eAAe;AAAA,MACpC;AAEA,yBAAmB,eAAe;AAClC,UAAI,OAAO,SAAS,GAAG;AACrB,2BAAmB,cAAc,MAAM;AAAA,MACzC;AAAA,IACF;AAAA,IACA;AAAA,MACE,WAAW;AAAA,MACX,OAAO;AAAA,IACT;AAAA,EACF;AACF;AAEA,SAAS,4BAA4B;AACnC,QAAM;AAAA,IACJ,IAAI,EAAE,YAAY;AAAA,IAClB,QAAQ,EAAE,SAAS;AAAA,EACrB,IAAI,uBAAuB;AAG3B;AAAA,IACE,YAAY;AAAA,IACZ,CAAC,WAAkC;AACjC,UAAI,QAAQ,YAAY,OAAO,MAAM,EAAG;AACxC,kBAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAGA;AAAA,IACE;AAAA,IACA,CAAC,QAAQ,WAAW;AAClB,UAAI,UAAU,UAAU,QAAQ,QAAQ,MAAM,EAAG;AACjD,eAAS,sBAAsB,MAAM;AAAA,IACvC;AAAA,IACA;AAAA,MACE,WAAW;AAAA,MACX,MAAM;AAAA,MACN,OAAO;AAAA,IACT;AAAA,EACF;AAEA;AAAA,IACE,MAAM;AACJ,eAAS,sBAAsB,YAAY,KAAK;AAAA,IAClD;AAAA,IACA,EAAE,aAAa,KAAK;AAAA,EACtB;AACF;AAEA,SAAS,8BAA8B;AACrC,QAAM;AAAA,IACJ,IAAI,EAAE,cAAc;AAAA,IACpB,QAAQ,EAAE,SAAS;AAAA,EACrB,IAAI,uBAAuB;AAE3B,QAAM,mBAAmB,SAAS,aAAa,gBAAgB;AAE/D,QAAM,iBAAiB,MAAM;AAC3B,UAAM,kBAAkB,SAAS,aAAa,eAAe;AAC7D,QAAI,mBAAmB,gBAAgB,QAAS,iBAAgB,cAAc,IAAI;AAAA,EACpF;AACA,YAAU,MAAM;AACd,qBAAiB,GAAG,aAAa,SAAS,cAAc;AAAA,EAC1D,CAAC;AAED,kBAAgB,MAAM;AACpB,qBAAiB,eAAe,aAAa,SAAS,cAAc;AAAA,EACtE,CAAC;AAGD;AAAA,IACE;AAAA,IACA,CAAC,WAAW;AACV,uBAAiB,WAAW,MAAM;AAAA,IACpC;AAAA,IACA,EAAE,WAAW,KAAK;AAAA,EACpB;AAEA;AAAA,IACE,MAAM;AACJ,uBAAiB,WAAW,cAAc,KAAK;AAAA,IACjD;AAAA,IACA,EAAE,aAAa,KAAK;AAAA,EACtB;AACF;AAEA,SAAS,wBAAwB;AAC/B,QAAM,QAAQ,uBAAuB;AACrC,QAAM,EAAE,mBAAmB,IAAI,eAAe;AAC9C,QAAM,eAAe,gBAAgB;AAErC,QAAM,sBAAsB,IAAI,KAAK;AACrC,QAAM,gBAAgB,MAAM,OAAO,SAAS,aAAa,aAAa;AAEtE,QAAM,EAAE,SAAS,wBAAwB,IAAI;AAAA,IAC3C,MAAa,CAAC,MAAM,GAAG,KAAK,WAAW,OAAO,MAAM,GAAG,KAAK,WAAW,KAAK;AAAA,IAC5E,OAAO,QAAQ,WAAW;AACxB,UAAI,CAAC,oBAAoB,MAAO;AAChC,YAAM,CAAC,YAAY,UAAU,IAAI;AACjC,YAAM,CAAC,eAAe,aAAa,IAAI,UAAU,CAAC,MAAM,IAAI;AAE5D,YAAM,YAAY,CAAC,YAAkC,SAAS,MAAM;AACpE,YAAM,YAAY,CAChBC,aACAC,gBACG;AACH,cAAM,QAAQ,UAAUD,WAAU;AAClC,cAAM,QAAQ,UAAUC,WAAU;AAClC,eAAO,SAAS,QAAQ,GAAG,KAAK,KAAK,KAAK,KAAK;AAAA,MACjD;AAEA,YAAM,aAAa,UAAU,YAAY,UAAU;AACnD,YAAM,aAAa,UAAU,eAAe,aAAa;AAEzD,UAAK,cAAc,eAAe,cAAe,CAAC,CAAC,eAAe,CAAC,CAAC;AAClE;AAEF,UAAI,CAAC,cAAc,QAAQ;AACzB,cAAM,cAAc,OAAO;AAC3B,YAAI,CAAC,WAAY;AAAA,MACnB;AAGA,YAAM,YAAY;AAAA,QAChB,MAAM,UAAU;AAAA,QAChB,YAAY;AAAA,MACd;AACA,YAAM,YAAY;AAAA,QAChB,MAAM,UAAU;AAAA,QAChB,YAAY;AAAA,MACd;AAEA,YAAM,GAAG,KAAK,OAAO,QAAQ,MAAM,cAAc;AAAA,QAC/C;AAAA,QACA;AAAA,QACA,MAAM,GAAG,KAAK,KAAK;AAAA,QACnB,mBAAmB;AAAA,MACrB;AAAA,IACF;AAAA,IACA,EAAE,WAAW,KAAK;AAAA,EACpB;AAGA,QAAM,MAAM,GAAG,KAAK,QAAQ,CAAC,QAAQ;AACnC,QAAI,CAAC,IAAK;AAKV,0BAAsB,MAAM;AAC1B,4BAAsB,MAAM;AAC1B,cAAM,GAAG,KAAK,KAAK,QAAQ;AAC3B,cAAM,GAAG,KAAK,KAAK,QAAQ,eAAe;AAG1C,6BAAqB;AAAA,MACvB,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AAED,QAAM,EAAE,eAAe,sBAAsB,IAAI;AAAA,IAC/C,MAAM,GAAG,KAAK;AAAA,IACd,CAAC,QAAQ;AACP,UAAI,CAAC,oBAAoB,MAAO;AAChC,UAAI,CAAC,MAAM,GAAG,KAAK,OAAO,MAAO;AAEjC,oBAAc,iBAAiB,KAAK,MAAM,GAAG,KAAK,KAAK,KAAK;AAAA,IAC9D;AAAA,EACF;AAEA,QAAM,EAAE,SAAS,sBAAsB,eAAe,sBAAsB,IAC1E,iBAAiB,MAAM,GAAG,KAAK,MAAM,CAAC,QAAQ;AAC5C,QAAI,CAAC,oBAAoB,MAAO;AAChC,QAAI,CAAC,MAAM,GAAG,KAAK,OAAO,MAAO;AAEjC,kBAAc,iBAAiB,MAAM,GAAG,KAAK,KAAK,OAAO,GAAG;AAAA,EAC9D,CAAC;AAEH,0BAAwB,CAAC,EAAE,UAAU,MAAM;AACzC,QAAI,CAAC,UAAW;AAChB,wBAAoB,QAAQ;AAE5B,4BAAwB;AAAA,EAC1B,CAAC;AACH;AAEA,SAAS,wBAAwB;AAC/B,QAAM,EAAE,OAAO,IAAI,uBAAuB;AAC1C,QAAM,eAAe,SAAS;AAE9B;AAAA,IACE,MAAM,aAAa,SAAS;AAAA,IAC5B,CAAC,qBAAqB;AACpB,YAAM,mBACJ,OAAO,SAAS,aAAa,gBAAgB;AAE/C,UAAI,kBAAkB;AACpB,yBAAiB,UAAU,EAAE,YAAY,MAAM;AAAA,MACjD,OAAO;AACL,yBAAiB,UAAU,EAAE,YAAY,KAAK;AAAA,MAChD;AAAA,IACF;AAAA,IACA,EAAE,WAAW,KAAK;AAAA,EACpB;AACF;AAEA,SAAS,2BAA2B;AAClC,QAAM,EAAE,OAAO,IAAI,uBAAuB;AAC1C,QAAM,EAAE,iBAAiB,IAAI,kBAAkB;AAG/C,YAAU,MAAM,iBAAiB,WAAW,OAAO,QAAQ,CAAC;AAC9D;AAEA,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,CAMP;AAED,SAAS,6BAA6B;AACpC,QAAM;AAAA,IACJ,QAAQ,EAAE,UAAU;AAAA,EACtB,IAAI,uBAAuB;AAE3B,QAAM;AAAA,IACJ,SAAS,EAAE,gBAAgB;AAAA,EAC7B,IAAI,gCAAgC;AAEpC,QAAM,EAAE,MAAM,IAAI,aAAa;AAC/B,QAAM,aAAa,IAAI,KAAK;AAG5B,QAAM,oBAAoB,CAAC,WAAyB;AAClD,QAAI,MAAM,SAAS,gBAAgB,MAAM,WAAW,GAAG;AACrD,iBAAW,QAAQ;AAAA,IACrB;AAAA,EACF;AAEA,QAAM,kBAAkB,MAAM;AAC5B,eAAW,QAAQ;AAAA,EACrB;AAGA;AAAA,IACE,CAAC,OAAO,iBAAiB,UAAU;AAAA,IACnC,MAAM;AACJ,UAAI,CAAC,UAAW;AAEhB,YAAM,eAAe,gBAAgB,MAAM,SAAS;AACpD,YAAM,iBAAiB,MAAM,SAAS,CAAC;AAEvC,UAAI,gBAAgB;AAClB,kBAAU,MAAM,SAAS,WAAW,QAAQ,aAAa;AAAA,MAC3D,OAAO;AACL,kBAAU,MAAM,SAAS;AAAA,MAC3B;AAAA,IACF;AAAA,IACA,EAAE,WAAW,KAAK;AAAA,EACpB;AAEA,mBAAiB,WAAW,eAAe,mBAAmB,EAAE,SAAS,KAAK,CAAC;AAC/E,mBAAiB,UAAU,aAAa,iBAAiB,EAAE,SAAS,KAAK,CAAC;AAE1E,kBAAgB,MAAM;AACpB,QAAI,WAAW;AACb,gBAAU,MAAM,SAAS;AAAA,IAC3B;AAAA,EACF,CAAC;AACH;AAEA,MAAM,+BAA+B,MAAM;AACzC,QAAM,EAAE,qBAAqB,IAAI,kBAAkB;AAEnD,kBAAgB,MAAM;AACpB,yBAAqB;AAAA,EACvB,CAAC;AACH;AAEO,gBAAS,qBAAqB;AACnC,MAAI,KAAY,CAAQ;AACxB,6BAA2B;AAC3B,gCAA8B;AAC9B,2BAAyB;AACzB,iCAA+B;AAC/B,oCAAkC;AAClC,oCAAkC;AAClC,0BAAwB;AACxB,qCAAmC;AACnC,iCAA+B;AAC/B,6BAA2B;AAC3B,8BAA4B;AAC5B,4BAA0B;AAC1B,8BAA4B;AAC5B,wBAAsB;AACtB,2BAAyB;AACzB,6BAA2B;AAC3B,gCAA8B;AAC9B,8BAA4B;AAC5B,wBAAsB;AACtB,6BAA2B;AAC3B,2BAAyB;AACzB,wBAAsB;AACtB,2BAAyB;AACzB,+BAA6B;AAC7B,iBAAe;AACjB","names":["resourceItems","promise","ref","oldVersion","newVersion"],"ignoreList":[],"sources":["postSetup.ts"],"sourcesContent":["import { difference, flatten, isEqual, uniq } from 'lodash-es'\r\nimport {\r\n  useThrottleFn,\r\n  watchTriggerable,\r\n  useMagicKeys,\r\n  useEventListener\r\n} from '@vueuse/core'\r\nimport {\r\n  ViewerEvent,\r\n  VisualDiffMode,\r\n  CameraController,\r\n  DiffExtension,\r\n  UpdateFlags,\r\n  SectionOutlines,\r\n  SectionToolEvent,\r\n  SectionTool,\r\n  SpeckleLoader,\r\n  LargeModelStreamingLoader,\r\n  ExplodeEvent,\r\n  ExplodeExtension,\r\n  LoaderEvent,\r\n  SelectionExtension,\r\n  type SunLightConfiguration\r\n} from '@speckle/viewer'\r\nimport { Vector3 } from 'three'\r\nimport { useAuthManager } from '~~/lib/auth/composables/auth'\r\nimport type { ViewerResourceItem } from '~~/lib/common/generated/gql/graphql'\r\nimport { ProjectCommentsUpdatedMessageType } from '~~/lib/common/generated/gql/graphql'\r\nimport {\r\n  useInjectedViewerState,\r\n  useInjectedViewerInterfaceState\r\n} from '~~/lib/viewer/composables/setup'\r\nimport { useViewerSelectionEventHandler } from '~~/lib/viewer/composables/setup/selection'\r\nimport {\r\n  useGetObjectUrl,\r\n  useOnViewerLoadComplete,\r\n  useViewerCameraControlStartTracker,\r\n  useViewerCameraTracker,\r\n  useViewerEventListener\r\n} from '~~/lib/viewer/composables/viewer'\r\nimport {\r\n  useCommentContext,\r\n  useViewerCommentUpdateTracking\r\n} from '~~/lib/viewer/composables/commentManagement'\r\nimport { getCacheId } from '~~/lib/common/helpers/graphql'\r\nimport {\r\n  useViewerOpenedThreadUpdateEmitter,\r\n  useViewerThreadTracking\r\n} from '~~/lib/viewer/composables/commentBubbles'\r\nimport { useGeneralProjectPageUpdateTracking } from '~~/lib/projects/composables/projectPages'\r\nimport { arraysEqual, isNonNullable } from '~~/lib/common/helpers/utils'\r\nimport { getTargetObjectIds } from '~~/lib/object-sidebar/helpers'\r\nimport { areVectorsLooselyEqual } from '~~/lib/viewer/helpers/three'\r\nimport { SafeLocalStorage } from '@speckle/shared'\r\nimport {\r\n  useCameraUtilities,\r\n  useSectionBoxUtilities\r\n} from '~~/lib/viewer/composables/ui'\r\nimport { ToastNotificationType, useGlobalToast } from '~~/lib/common/composables/toast'\r\nimport { setupDebugMode } from '~~/lib/viewer/composables/setup/dev'\r\nimport { useEmbed } from '~/lib/viewer/composables/setup/embed'\r\nimport { useMixpanel } from '~~/lib/core/composables/mp'\r\nimport { graphql } from '~/lib/common/generated/gql'\r\nimport { useTreeManagement } from '~~/lib/viewer/composables/tree'\r\nimport { useViewerSavedViewIntegration } from '~/lib/viewer/composables/savedViews/state'\r\nimport { useViewModesPostSetup } from '~/lib/viewer/composables/setup/viewMode'\r\nimport { useMeasurementsPostSetup } from '~/lib/viewer/composables/setup/measurements'\r\nimport { useFilterColoringPostSetup } from '~/lib/viewer/composables/setup/coloring'\r\nimport {\r\n  usePropertyFilteringPostSetup,\r\n  useManualFilteringPostSetup\r\n} from '~/lib/viewer/composables/setup/filters'\r\nimport { useFilterUtilities } from '~/lib/viewer/composables/filtering/filtering'\r\nimport { useFilteringSetup } from '~/lib/viewer/composables/filtering/setup'\r\nimport {\r\n  useHighlightingPostSetup,\r\n  HighlightExtension\r\n} from '~/lib/viewer/composables/setup/highlighting'\r\nimport { useProjectSavedViewsUpdateTracking } from '~/lib/viewer/composables/savedViews/subscriptions'\r\n\r\nfunction useViewerLoadCompleteEventHandler() {\r\n  const state = useInjectedViewerState()\r\n\r\n  const callback = () => {\r\n    state.ui.loading.value = false\r\n  }\r\n  onMounted(() => {\r\n    state.viewer.instance.on(ViewerEvent.LoadComplete, callback)\r\n  })\r\n\r\n  onBeforeUnmount(() => {\r\n    state.viewer.instance.removeListener(ViewerEvent.LoadComplete, callback)\r\n  })\r\n}\r\n\r\n/**\r\n * Automatically loads & unloads objects into the viewer depending on the global URL resource identifier state\r\n */\r\nfunction useViewerObjectAutoLoading() {\r\n  if (import.meta.server) return\r\n\r\n  type ViewerDerivativeManifestResponse = {\r\n    status: 'missing' | 'queued' | 'processing' | 'ready' | 'failed'\r\n    stage?: string | null\r\n    progress?: number | null\r\n    errorMessage?: string | null\n    manifest?: {\n      bounds?: number[]\n      tiles: Array<{\n        id?: string\n        bbox?: number[]\n        lods: Array<{\n          level?: number\n          url: string\n          bytes?: number\n          meshes?: number\n          vertexCount?: number\n          indexCount?: number\n          triangleCount?: number\n        }>\n      }>\n    }\n  }\r\n\r\n  const disableViewerCache =\r\n    SafeLocalStorage.get('FE2_FORCE_DISABLE_VIEWER_CACHE') === 'true'\r\n  const { effectiveAuthToken } = useAuthManager()\n  const { triggerNotification } = useGlobalToast()\n  const getObjectUrl = useGetObjectUrl()\n  const apiOrigin = useApiOrigin({ forcePublic: true })\n  const {\r\n    projectId,\r\n    viewer: {\r\n      instance: viewer,\r\n      init: { ref: isInitialized },\r\n      hasDoneInitialLoad\r\n    },\r\n    resources: {\r\n      request: {\r\n        savedView: { id: savedViewId }\r\n      },\r\n      response: { resourceItems, savedView }\r\n    },\r\n    ui: { loadProgress, loading, spotlightUserSessionId, hasLoadedQueuedUpModels },\r\n    urlHashState: { focusedThreadId }\r\n  } = useInjectedViewerState()\r\n\r\n  const loadingProgressMap: { [id: string]: number } = {}\r\n  const derivativeNotificationKeys = new Set<string>()\r\n\r\n  viewer.on(ViewerEvent.LoadComplete, (id) => {\r\n    delete loadingProgressMap[id]\r\n    consolidateProgressInternal({ id, progress: 1 })\r\n  })\r\n\r\n  const consolidateProgressInternal = (args: { progress: number; id: string }) => {\r\n    loadingProgressMap[args.id] = args.progress\r\n    const values = Object.values(loadingProgressMap)\r\n    const min = values.length ? Math.min(...values) : 1\r\n\r\n    loadProgress.value = min\r\n    loading.value = min < 1\r\n  }\r\n\r\n  const consolidateProgressThorttled = useThrottleFn(consolidateProgressInternal, 250)\r\n\r\n  const getViewerDerivativeManifest = async (\n    versionId: string\n  ): Promise<ViewerDerivativeManifestResponse | undefined> => {\n    const res = await fetch(\n      new URL(\n        `/api/viewer-derivatives/${projectId.value}/${versionId}/manifest`,\n        apiOrigin\n      ),\n      {\n        headers: effectiveAuthToken.value\n          ? { Authorization: `Bearer ${effectiveAuthToken.value}` }\n          : undefined,\n        cache: 'no-store'\n      }\n    )\n\r\n    if (res.status === 404) return undefined\r\n    if (!res.ok) return undefined\r\n\r\n    return (await res.json()) as ViewerDerivativeManifestResponse\r\n  }\r\n\r\n  const maybeLoadViewerDerivative = async (\r\n    objectId: string,\r\n    options?: Partial<{ zoomToObject: boolean }>\r\n  ) => {\r\n    const resourceItem = resourceItems.value.find(\r\n      (item) => item.objectId === objectId && item.versionId\r\n    )\r\n    if (!resourceItem?.versionId) return false\r\n\r\n    const derivative = await getViewerDerivativeManifest(resourceItem.versionId)\r\n    if (!derivative || derivative.status === 'missing') return false\r\n\r\n    const notificationKey = `${resourceItem.versionId}:${derivative.status}`\r\n    if (!derivativeNotificationKeys.has(notificationKey)) {\r\n      derivativeNotificationKeys.add(notificationKey)\r\n      triggerNotification({\r\n        type:\r\n          derivative.status === 'failed'\r\n            ? ToastNotificationType.Danger\r\n            : ToastNotificationType.Info,\r\n        title: 'Large model streaming',\r\n        description:\r\n          derivative.status === 'ready'\r\n            ? 'Loading viewer derivative.'\r\n            : derivative.status === 'failed'\r\n            ? derivative.errorMessage || 'Viewer derivative generation failed.'\r\n            : 'Viewer derivative generation is still processing.'\r\n      })\r\n    }\r\n\r\n    if (derivative.status === 'ready' && derivative.manifest) {\r\n      const objectUrl = getObjectUrl(projectId.value, objectId)\n      const artifactBaseUrl = new URL(\n        `/api/viewer-derivatives/${projectId.value}/${resourceItem.versionId}/artifacts`,\n        apiOrigin\n      ).toString()\n      const loader = new LargeModelStreamingLoader(\n        viewer.getWorldTree(),\n        objectUrl,\n        derivative.manifest,\n        artifactBaseUrl,\n        effectiveAuthToken.value || undefined\n      )\n      loader.on(LoaderEvent.LoadProgress, (args) => {\r\n        consolidateProgressThorttled(args)\r\n      })\r\n      loader.on(LoaderEvent.LoadCancelled, (id) => {\r\n        delete loadingProgressMap[id]\r\n        consolidateProgressInternal({ id, progress: 1 })\r\n      })\r\n      await viewer.loadObject(loader, options?.zoomToObject)\n      consolidateProgressInternal({ id: objectUrl, progress: 1 })\n      return true\n    }\n\r\n    consolidateProgressInternal({ id: objectId, progress: 1 })\r\n    return true\r\n  }\r\n\r\n  const loadObject = async (\r\n    objectId: string,\r\n    unload?: boolean,\r\n    options?: Partial<{ zoomToObject: boolean }>\r\n  ) => {\r\n    const objectUrl = getObjectUrl(projectId.value, objectId)\r\n\r\n    if (unload) {\r\n      return viewer.unloadObject(objectUrl)\r\n    } else {\r\n      if (await maybeLoadViewerDerivative(objectId, options)) return\r\n\r\n      const loader = new SpeckleLoader(\r\n        viewer.getWorldTree(),\r\n        objectUrl,\r\n        effectiveAuthToken.value || undefined,\r\n        disableViewerCache ? false : undefined,\r\n        undefined\r\n      )\r\n\r\n      loader.on(LoaderEvent.LoadProgress, (args) => {\r\n        consolidateProgressThorttled(args)\r\n      })\r\n      loader.on(LoaderEvent.LoadCancelled, (id) => {\r\n        delete loadingProgressMap[id]\r\n        consolidateProgressInternal({ id, progress: 1 })\r\n      })\r\n      loader.on(LoaderEvent.LoadWarning, ({ message }) => {\r\n        if (!message.startsWith('Viewer full-load guard:')) return\r\n\r\n        triggerNotification({\r\n          type: ToastNotificationType.Danger,\r\n          title: 'Large model needs streaming',\r\n          description: message\r\n        })\r\n      })\r\n\r\n      return viewer.loadObject(loader, options?.zoomToObject)\r\n    }\r\n  }\r\n\r\n  const getUniqueObjectIds = (resourceItems: ViewerResourceItem[]) =>\r\n    uniq(resourceItems.map((i) => i.objectId))\r\n\r\n  const activeLoads = new Set<Promise<void>>()\r\n  watch(\r\n    () => <const>[resourceItems.value, isInitialized.value, hasDoneInitialLoad.value],\r\n    async ([newResources, newIsInitialized, newHasDoneInitialLoad], oldData) => {\r\n      // Wait till viewer loaded in\r\n      if (!newIsInitialized) return\r\n\r\n      const [oldResources] = oldData || [[], false]\r\n\r\n      // we dont want to zoom to object, if we're loading specific coords because of a thread,\r\n      // or spotlight mode or a saved view etc.\r\n      const preventZooming =\r\n        focusedThreadId.value ||\r\n        savedViewId.value ||\r\n        savedView.value ||\r\n        spotlightUserSessionId.value\r\n      const zoomToObject = !preventZooming\r\n\r\n      // Viewer initialized - load in all resources\r\n      if (!newHasDoneInitialLoad) {\r\n        const allObjectIds = getUniqueObjectIds(newResources)\r\n        if (allObjectIds.length) {\r\n          // only mark, if anything to load\r\n          hasLoadedQueuedUpModels.value = false\r\n        }\r\n\r\n        /** Load sequentially */\r\n        const res = []\r\n        const loadAll = async () => {\r\n          for (const i of allObjectIds) {\r\n            res.push(await loadObject(i, false, { zoomToObject }))\r\n          }\r\n        }\r\n\r\n        // Register for accurate 'is anything loading' reporting\r\n        const promise = loadAll().then(() => {\r\n          activeLoads.delete(promise)\r\n        })\r\n        activeLoads.add(promise)\r\n        await promise\r\n\r\n        if (res.length) {\r\n          hasDoneInitialLoad.value = true\r\n          if (!activeLoads.size) hasLoadedQueuedUpModels.value = true\r\n        }\r\n\r\n        return\r\n      }\r\n\r\n      // Resources changed?\r\n      const loadAndUnloadChanged = async () => {\r\n        const newObjectIds = getUniqueObjectIds(newResources)\r\n        const oldObjectIds = getUniqueObjectIds(oldResources)\r\n        const removableObjectIds = difference(oldObjectIds, newObjectIds)\r\n        const addableObjectIds = difference(newObjectIds, oldObjectIds)\r\n\r\n        if (addableObjectIds.length) {\r\n          // only mark, if anything to load\r\n          hasLoadedQueuedUpModels.value = false\r\n        }\r\n\r\n        await Promise.all(removableObjectIds.map((i) => loadObject(i, true)))\r\n        await Promise.all(\r\n          addableObjectIds.map((i) => loadObject(i, false, { zoomToObject: false }))\r\n        )\r\n      }\r\n\r\n      // Register for accurate 'is anything loading' reporting\r\n      const promise = loadAndUnloadChanged().then(() => {\r\n        activeLoads.delete(promise)\r\n      })\r\n      activeLoads.add(promise)\r\n      await promise\r\n\r\n      if (!activeLoads.size) hasLoadedQueuedUpModels.value = true\r\n    },\r\n    { deep: true, immediate: true }\r\n  )\r\n\r\n  onBeforeUnmount(async () => {\r\n    await viewer.unloadAll()\r\n  })\r\n}\r\n\r\n/**\r\n * Here we make the viewer pretend it's a connector and send out receive events. Note, this is important for us to track to be able to get a picture of how much data is consumed\r\n * in our viewer.\r\n */\r\nfunction useViewerReceiveTracking() {\r\n  //\r\n  const {\r\n    resources: {\r\n      response: { modelsAndVersionIds }\r\n    }\r\n  } = useInjectedViewerState()\r\n  const mixpanel = useMixpanel()\r\n  const { userId } = useActiveUser()\r\n  const receivedVersions = new Set<string>()\r\n  watch(modelsAndVersionIds, (newVal) => {\r\n    for (const { model, versionId } of newVal) {\r\n      if (receivedVersions.has(versionId)) {\r\n        continue\r\n      }\r\n      receivedVersions.add(versionId)\r\n      mixpanel.track('Receive', {\r\n        hostApp: 'viewer',\r\n        sourceHostApp: model.loadedVersion.items[0].sourceApplication,\r\n        isMultiplayer: model.loadedVersion.items[0].authorUser?.id !== userId.value\r\n      })\r\n    }\r\n  })\r\n}\r\n\r\n/**\r\n * Listening to model/version updates through subscriptions and making various\r\n * cache updates so that we don't need to always refetch queries\r\n */\r\nfunction useViewerSubscriptionEventTracker() {\r\n  if (import.meta.server) return\r\n\r\n  const {\r\n    projectId,\r\n    resources: {\r\n      request: { resourceIdString, threadFilters }\r\n    }\r\n  } = useInjectedViewerState()\r\n\r\n  // Track all project/model/version updates\r\n  useGeneralProjectPageUpdateTracking({\r\n    projectId\r\n  })\r\n\r\n  // Track saved views\r\n  useProjectSavedViewsUpdateTracking({ projectId })\r\n\r\n  // Also track updates to comments\r\n  useViewerCommentUpdateTracking(\r\n    {\r\n      projectId,\r\n      resourceIdString,\r\n      loadedVersionsOnly: computed(() => threadFilters.value.loadedVersionsOnly)\r\n    },\r\n    (event, cache) => {\r\n      const isArchived = event.type === ProjectCommentsUpdatedMessageType.Archived\r\n      const isNew = event.type === ProjectCommentsUpdatedMessageType.Created\r\n      const comment = event.comment\r\n\r\n      if (isArchived) {\r\n        // Mark as archived\r\n        cache.modify({\r\n          id: getCacheId('Comment', event.id),\r\n          fields: {\r\n            archived: () => true\r\n          }\r\n        })\r\n\r\n        // Remove from project.commentThreads\r\n        modifyObjectField(\r\n          cache,\r\n          getCacheId('Project', projectId.value),\r\n          'commentThreads',\r\n          ({ variables, helpers: { createUpdatedValue, readField } }) => {\r\n            if (variables.filter?.includeArchived) return // we want it in that list\r\n\r\n            return createUpdatedValue(({ update }) => {\r\n              update('totalCount', (totalCount) => totalCount - 1)\r\n              update('items', (items) =>\r\n                items.filter((i) => readField(i, 'id') !== event.id)\r\n              )\r\n            })\r\n          }\r\n        )\r\n      } else if (isNew && comment) {\r\n        const parentId = comment.parent?.id\r\n\r\n        // Add reply to parent\r\n        if (parentId) {\r\n          modifyObjectField(\r\n            cache,\r\n            getCacheId('Comment', parentId),\r\n            'replies',\r\n            ({ helpers: { createUpdatedValue, ref } }) =>\r\n              createUpdatedValue(({ update }) => {\r\n                update('totalCount', (totalCount) => totalCount + 1)\r\n                update('items', (items) => [ref('Comment', comment.id), ...items])\r\n              })\r\n          )\r\n        } else {\r\n          // Add comment thread\r\n          modifyObjectField(\r\n            cache,\r\n            getCacheId('Project', projectId.value),\r\n            'commentThreads',\r\n            ({ helpers: { ref, createUpdatedValue, readField }, value }) => {\r\n              // In case this is actually an unarchived comment, we only want to add it if it doesnt\r\n              // exist in the includesArchived list already\r\n              const includesItem = value.items?.find(\r\n                (i) => readField(i, 'id') === comment.id\r\n              )\r\n              if (includesItem) return\r\n\r\n              return createUpdatedValue(({ update }) => {\r\n                update('totalCount', (totalCount) => totalCount + 1)\r\n                update('items', (items) => [ref('Comment', comment.id), ...items])\r\n              })\r\n            }\r\n          )\r\n        }\r\n      }\r\n    }\r\n  )\r\n}\r\n\r\nfunction useViewerSectionBoxIntegration() {\r\n  const {\r\n    ui: {\r\n      sectionBox,\r\n      sectionBoxContext: { visible, edited }\r\n    },\r\n    viewer: { instance }\r\n  } = useInjectedViewerState()\r\n\r\n  const { sectionBoxDataToBox3, sectionBoxDataEquals } = useSectionBoxUtilities()\r\n\r\n  // Change edited=true when user starts changing the section box by dragging it\r\n  const sectionTool = instance.getExtension(SectionTool)\r\n  const onDragStart = () => {\r\n    edited.value = true\r\n  }\r\n  sectionTool.on(SectionToolEvent.DragStart, onDragStart)\r\n\r\n  // No two-way sync for section boxes, because once you set a Box3 into the viewer\r\n  // the viewer transforms it into something else causing the updates going into an infinite loop\r\n\r\n  // state -> viewer\r\n  watch(\r\n    sectionBox,\r\n    (newVal, oldVal) => {\r\n      if (newVal && oldVal && sectionBoxDataEquals(newVal, oldVal)) return\r\n      if (!newVal && !oldVal) return\r\n\r\n      if (oldVal && !newVal) {\r\n        visible.value = false\r\n        edited.value = false\r\n\r\n        sectionTool.enabled = false\r\n        instance.requestRender(UpdateFlags.RENDER_RESET)\r\n        return\r\n      }\r\n\r\n      if (newVal && (!oldVal || !sectionBoxDataEquals(newVal, oldVal))) {\r\n        visible.value = true\r\n        edited.value = false\r\n\r\n        const box3 = sectionBoxDataToBox3(newVal)\r\n        sectionTool.setBox(box3)\r\n        sectionTool.enabled = true\r\n        const outlines = instance.getExtension(SectionOutlines)\r\n        if (outlines) outlines.requestUpdate()\r\n        instance.requestRender(UpdateFlags.RENDER_RESET)\r\n      }\r\n    },\r\n    { immediate: true, deep: true, flush: 'sync' }\r\n  )\r\n\r\n  watch(\r\n    visible,\r\n    (newVal, oldVal) => {\r\n      if (newVal && oldVal) return\r\n      if (!newVal && !oldVal) return\r\n\r\n      if (newVal) {\r\n        sectionTool.visible = true\r\n      } else {\r\n        sectionTool.visible = false\r\n      }\r\n      instance.requestRender()\r\n    },\r\n    { immediate: true, deep: true, flush: 'sync' }\r\n  )\r\n\r\n  onBeforeUnmount(() => {\r\n    sectionTool.enabled = false\r\n    sectionTool.removeListener(SectionToolEvent.DragStart, onDragStart)\r\n  })\r\n}\r\n\r\nfunction useViewerCameraIntegration() {\r\n  const {\r\n    viewer: { instance },\r\n    ui: {\r\n      camera: { isOrthoProjection, position, target },\r\n      spotlightUserSessionId\r\n    }\r\n  } = useInjectedViewerState()\r\n  const { forceViewToViewerSync, setView, cameraController } = useCameraUtilities()\r\n\r\n  const hasInitialLoadFired = ref(false)\r\n\r\n  const loadCameraDataFromViewer = () => {\r\n    const extension: CameraController = instance.getExtension(CameraController)\r\n\r\n    const viewerPos = new Vector3().copy(extension.getPosition())\r\n    const viewerTarget = new Vector3().copy(extension.getTarget())\r\n\r\n    if (hasInitialLoadFired.value) {\r\n      if (!areVectorsLooselyEqual(position.value, viewerPos)) {\r\n        position.value = viewerPos.clone()\r\n      }\r\n      if (!areVectorsLooselyEqual(target.value, viewerTarget)) {\r\n        target.value = viewerTarget.clone()\r\n      }\r\n    }\r\n  }\r\n\r\n  // viewer -> state\r\n  // debouncing pos/target updates to avoid jitteriness + spotlight mode unnecessarily disabling\r\n  useViewerCameraTracker(\r\n    () => {\r\n      loadCameraDataFromViewer()\r\n    },\r\n    { throttleWait: 100 }\r\n  )\r\n\r\n  useOnViewerLoadComplete(({ isInitial }) => {\r\n    if (isInitial) {\r\n      hasInitialLoadFired.value = true\r\n\r\n      // Load camera position so we can return to it correctly\r\n      // ONLY if we don't already have specific coordinates (e.g. from opened thread)\r\n      // otherwise - load current pos/target into viewer\r\n      const hasInitCoords =\r\n        position.value.equals(new Vector3()) && target.value.equals(new Vector3())\r\n      if (hasInitCoords) {\r\n        loadCameraDataFromViewer()\r\n      } else {\r\n        forceViewToViewerSync()\r\n      }\r\n\r\n      // Only now set projection, we can't do it too early\r\n      orthoProjectionUpdate(isOrthoProjection.value)\r\n    } else {\r\n      loadCameraDataFromViewer()\r\n    }\r\n  })\r\n\r\n  useViewerCameraControlStartTracker(() => {\r\n    if (spotlightUserSessionId.value) {\r\n      spotlightUserSessionId.value = null // cancel\r\n    }\r\n  })\r\n\r\n  const orthoProjectionUpdate = (newVal: boolean) => {\r\n    if (!hasInitialLoadFired.value) {\r\n      throw new Error('Attempting to set projection too early')\r\n    }\r\n\r\n    if (newVal) {\r\n      cameraController.setOrthoCameraOn()\r\n    } else {\r\n      cameraController.setPerspectiveCameraOn()\r\n    }\r\n\r\n    // reset camera pos, cause we've switched cameras now and it might not have the new ones\r\n    forceViewToViewerSync()\r\n  }\r\n\r\n  // state -> viewer\r\n  watch(\r\n    isOrthoProjection,\r\n    (newVal, oldVal) => {\r\n      if (newVal === oldVal || !hasInitialLoadFired.value) return\r\n      orthoProjectionUpdate(newVal)\r\n    },\r\n    { immediate: true }\r\n  )\r\n\r\n  watch(\r\n    position,\r\n    (newVal, oldVal) => {\r\n      if ((!newVal && !oldVal) || (oldVal && areVectorsLooselyEqual(newVal, oldVal))) {\r\n        return\r\n      }\r\n      setView({\r\n        position: newVal,\r\n        target: target.value\r\n      })\r\n    }\r\n    // { immediate: true }\r\n  )\r\n\r\n  watch(\r\n    target,\r\n    (newVal, oldVal) => {\r\n      if ((!newVal && !oldVal) || (oldVal && areVectorsLooselyEqual(newVal, oldVal))) {\r\n        return\r\n      }\r\n\r\n      setView({\r\n        position: position.value,\r\n        target: newVal\r\n      })\r\n    }\r\n    // { immediate: true }\r\n  )\r\n}\r\n\r\nfunction useViewerFiltersIntegration() {\r\n  const state = useInjectedViewerState()\r\n  const {\r\n    viewer: { instance },\r\n    ui: { filters }\r\n  } = state\r\n\r\n  useFilteringSetup()\r\n  useFilterUtilities({ state })\r\n\r\n  watch(\r\n    filters.selectedObjects,\r\n    (newVal, oldVal) => {\r\n      const newIds = flatten(\n        newVal.map((v) => getTargetObjectIds(v as Record<string, unknown>))\n      ).filter(isNonNullable)\n      const oldIds = flatten(\n        (oldVal || []).map((v) => getTargetObjectIds(v as Record<string, unknown>))\n      ).filter(isNonNullable)\n      if (arraysEqual(newIds, oldIds)) return\r\n\r\n      const selectionExtension = instance.getExtension(SelectionExtension)\r\n      const currentViewerSelection = selectionExtension\r\n        .getSelectedObjects()\r\n        .map((obj) => obj.id as string)\r\n\r\n      if (\r\n        currentViewerSelection.length === newIds.length &&\r\n        difference(currentViewerSelection, newIds).length === 0\r\n      ) {\r\n        return\r\n      }\r\n\r\n      state.ui.highlightedObjectIds.value = []\r\n      const highlightExtension = instance.getExtension(HighlightExtension)\r\n      if (highlightExtension) {\r\n        highlightExtension.clearSelection()\r\n      }\r\n\r\n      selectionExtension.clearSelection()\r\n      if (newVal.length > 0) {\r\n        selectionExtension.selectObjects(newIds)\r\n      }\r\n    },\r\n    {\r\n      immediate: true,\r\n      flush: 'sync'\r\n    }\r\n  )\r\n}\r\n\r\nfunction useLightConfigIntegration() {\r\n  const {\r\n    ui: { lightConfig },\r\n    viewer: { instance }\r\n  } = useInjectedViewerState()\r\n\r\n  // viewer -> state\r\n  useViewerEventListener(\r\n    ViewerEvent.LightConfigUpdated,\r\n    (config: SunLightConfiguration) => {\r\n      if (isEqual(lightConfig.value, config)) return\r\n      lightConfig.value = config\r\n    }\r\n  )\r\n\r\n  // state -> viewer\r\n  watch(\r\n    lightConfig,\r\n    (newVal, oldVal) => {\r\n      if (newVal && oldVal && isEqual(newVal, oldVal)) return\r\n      instance.setLightConfiguration(newVal)\r\n    },\r\n    {\r\n      immediate: true,\r\n      deep: true,\r\n      flush: 'sync'\r\n    }\r\n  )\r\n\r\n  useOnViewerLoadComplete(\r\n    () => {\r\n      instance.setLightConfiguration(lightConfig.value)\r\n    },\r\n    { initialOnly: true }\r\n  )\r\n}\r\n\r\nfunction useExplodeFactorIntegration() {\r\n  const {\r\n    ui: { explodeFactor },\r\n    viewer: { instance }\r\n  } = useInjectedViewerState()\r\n\r\n  const explodeExtension = instance.getExtension(ExplodeExtension)\r\n\r\n  const updateOutlines = () => {\r\n    const sectionOutlines = instance.getExtension(SectionOutlines)\r\n    if (sectionOutlines && sectionOutlines.enabled) sectionOutlines.requestUpdate(true)\r\n  }\r\n  onMounted(() => {\r\n    explodeExtension.on(ExplodeEvent.Finshed, updateOutlines)\r\n  })\r\n\r\n  onBeforeUnmount(() => {\r\n    explodeExtension.removeListener(ExplodeEvent.Finshed, updateOutlines)\r\n  })\r\n\r\n  // state -> viewer only. we don't need the reverse.\r\n  watch(\r\n    explodeFactor,\r\n    (newVal) => {\r\n      explodeExtension.setExplode(newVal)\r\n    },\r\n    { immediate: true }\r\n  )\r\n\r\n  useOnViewerLoadComplete(\r\n    () => {\r\n      explodeExtension.setExplode(explodeFactor.value)\r\n    },\r\n    { initialOnly: true }\r\n  )\r\n}\r\n\r\nfunction useDiffingIntegration() {\r\n  const state = useInjectedViewerState()\r\n  const { effectiveAuthToken } = useAuthManager()\r\n  const getObjectUrl = useGetObjectUrl()\r\n\r\n  const hasInitialLoadFired = ref(false)\r\n  const diffExtension = state.viewer.instance.getExtension(DiffExtension)\r\n\r\n  const { trigger: triggerDiffCommandWatch } = watchTriggerable(\r\n    () => <const>[state.ui.diff.oldVersion.value, state.ui.diff.newVersion.value],\r\n    async (newVal, oldVal) => {\r\n      if (!hasInitialLoadFired.value) return\r\n      const [oldVersion, newVersion] = newVal\r\n      const [oldOldVersion, oldNewVersion] = oldVal || [null, null]\r\n\r\n      const versionId = (version: typeof oldOldVersion) => version?.id || null\r\n      const commandId = (\r\n        oldVersion: typeof oldOldVersion,\r\n        newVersion: typeof oldOldVersion\r\n      ) => {\r\n        const oldId = versionId(oldVersion)\r\n        const newId = versionId(newVersion)\r\n        return oldId && newId ? `${oldId}->${newId}` : null\r\n      }\r\n\r\n      const newCommand = commandId(oldVersion, newVersion)\r\n      const oldCommand = commandId(oldOldVersion, oldNewVersion)\r\n\r\n      if ((newCommand && oldCommand === newCommand) || !!newCommand === !!oldCommand)\r\n        return\r\n\r\n      if (!newCommand || oldVal) {\r\n        await diffExtension.undiff()\r\n        if (!newCommand) return\r\n      }\r\n\r\n      // values shouldn't be undefined cause commandId() generation succeeded\r\n      const oldObjUrl = getObjectUrl(\r\n        state.projectId.value,\r\n        oldVersion?.referencedObject as string\r\n      )\r\n      const newObjUrl = getObjectUrl(\r\n        state.projectId.value,\r\n        newVersion?.referencedObject as string\r\n      )\r\n\r\n      state.ui.diff.result.value = await diffExtension.diff(\r\n        oldObjUrl,\r\n        newObjUrl,\r\n        state.ui.diff.mode.value,\r\n        effectiveAuthToken.value\r\n      )\r\n    },\r\n    { immediate: true }\r\n  )\r\n\r\n  // const preventWatchers = 0\r\n  watch(state.ui.diff.result, (val) => {\r\n    if (!val) return\r\n    // reset visual diff time and mode on new diff result\r\n    // sometimes the watcher won't fire even when the values are updated, because they're updated to\r\n    // the same values that they were already. because of that we're manually & forcefully running\r\n    // the relevant watchers when diffResult changes\r\n    ignoreDiffModeUpdates(() => {\r\n      ignoreDiffTimeUpdates(() => {\r\n        state.ui.diff.time.value = 0.5\r\n        state.ui.diff.mode.value = VisualDiffMode.COLORED\r\n\r\n        // this watcher also updates diffTime, so no need to invoke that separately\r\n        triggerDiffModeWatch()\r\n      })\r\n    })\r\n  })\r\n\r\n  const { ignoreUpdates: ignoreDiffTimeUpdates } = watchTriggerable(\r\n    state.ui.diff.time,\r\n    (val) => {\r\n      if (!hasInitialLoadFired.value) return\r\n      if (!state.ui.diff.result.value) return\r\n\r\n      diffExtension.updateVisualDiff(val, state.ui.diff.mode.value)\r\n    }\r\n  )\r\n\r\n  const { trigger: triggerDiffModeWatch, ignoreUpdates: ignoreDiffModeUpdates } =\r\n    watchTriggerable(state.ui.diff.mode, (val) => {\r\n      if (!hasInitialLoadFired.value) return\r\n      if (!state.ui.diff.result.value) return\r\n\r\n      diffExtension.updateVisualDiff(state.ui.diff.time.value, val)\r\n    })\r\n\r\n  useOnViewerLoadComplete(({ isInitial }) => {\r\n    if (!isInitial) return\r\n    hasInitialLoadFired.value = true\r\n\r\n    triggerDiffCommandWatch()\r\n  })\r\n}\r\n\r\nfunction useDisableZoomOnEmbed() {\r\n  const { viewer } = useInjectedViewerState()\r\n  const embedOptions = useEmbed()\r\n\r\n  watch(\r\n    () => embedOptions.noScroll.value,\r\n    (newNoScrollValue) => {\r\n      const cameraController: CameraController =\r\n        viewer.instance.getExtension(CameraController)\r\n\r\n      if (newNoScrollValue) {\r\n        cameraController.options = { enableZoom: false }\r\n      } else {\r\n        cameraController.options = { enableZoom: true }\r\n      }\r\n    },\r\n    { immediate: true }\r\n  )\r\n}\r\n\r\nfunction useViewerTreeIntegration() {\r\n  const { viewer } = useInjectedViewerState()\r\n  const { treeStateManager } = useTreeManagement()\r\n\r\n  // Initialize the tree state manager with viewer instance\r\n  onMounted(() => treeStateManager.initialize(viewer.instance))\r\n}\r\n\r\ngraphql(`\r\n  fragment UseViewerSavedViewSetup_SavedView on SavedView {\r\n    id\r\n    viewerState\r\n    ...ViewerPageSetup_SavedView\r\n  }\r\n`)\r\n\r\nfunction useViewerCursorIntegration() {\r\n  const {\r\n    viewer: { container }\r\n  } = useInjectedViewerState()\r\n\r\n  const {\r\n    filters: { selectedObjects }\r\n  } = useInjectedViewerInterfaceState()\r\n\r\n  const { shift } = useMagicKeys()\r\n  const isDragging = ref(false)\r\n\r\n  // Handle mouse down/up to track dragging state\r\n  const handlePointerDown = (_event: PointerEvent) => {\r\n    if (shift.value && selectedObjects.value.length === 0) {\r\n      isDragging.value = true\r\n    }\r\n  }\r\n\r\n  const handlePointerUp = () => {\r\n    isDragging.value = false\r\n  }\r\n\r\n  // Show different cursors: grab (ready to drag) vs grabbing (actively dragging)\r\n  watch(\r\n    [shift, selectedObjects, isDragging],\r\n    () => {\r\n      if (!container) return\r\n\r\n      const hasSelection = selectedObjects.value.length > 0\r\n      const shouldShowDrag = shift.value && !hasSelection\r\n\r\n      if (shouldShowDrag) {\r\n        container.style.cursor = isDragging.value ? 'grabbing' : 'grab'\r\n      } else {\r\n        container.style.cursor = ''\r\n      }\r\n    },\r\n    { immediate: true }\r\n  )\r\n\r\n  useEventListener(container, 'pointerdown', handlePointerDown, { passive: true })\r\n  useEventListener(document, 'pointerup', handlePointerUp, { passive: true })\r\n\r\n  onBeforeUnmount(() => {\r\n    if (container) {\r\n      container.style.cursor = ''\r\n    }\r\n  })\r\n}\r\n\r\nconst useCommentContextIntegration = () => {\r\n  const { cleanupThreadContext } = useCommentContext()\r\n\r\n  onBeforeUnmount(() => {\r\n    cleanupThreadContext()\r\n  })\r\n}\r\n\r\nexport function useViewerPostSetup() {\r\n  if (import.meta.server) return\r\n  useViewerObjectAutoLoading()\r\n  useViewerSavedViewIntegration()\r\n  useViewerReceiveTracking()\r\n  useViewerSelectionEventHandler()\r\n  useViewerLoadCompleteEventHandler()\r\n  useViewerSubscriptionEventTracker()\r\n  useViewerThreadTracking()\r\n  useViewerOpenedThreadUpdateEmitter()\r\n  useViewerSectionBoxIntegration()\r\n  useViewerCameraIntegration()\r\n  useViewerFiltersIntegration()\r\n  useLightConfigIntegration()\r\n  useExplodeFactorIntegration()\r\n  useDiffingIntegration()\r\n  useMeasurementsPostSetup()\r\n  useFilterColoringPostSetup()\r\n  usePropertyFilteringPostSetup()\r\n  useManualFilteringPostSetup()\r\n  useDisableZoomOnEmbed()\r\n  useViewerCursorIntegration()\r\n  useViewerTreeIntegration()\r\n  useViewModesPostSetup()\r\n  useHighlightingPostSetup()\r\n  useCommentContextIntegration()\r\n  setupDebugMode()\r\n}\r\n"],"file":"D:/speckle-server/packages/frontend-2/lib/viewer/composables/setup/postSetup.ts"}