speckle-server/scratch/edge-debug-selection/Default/Cache/Cache_Data/f_000109

import { useInjectedViewerState } from "/_nuxt/lib/viewer/composables/setup.ts";
import { CameraEvent, ViewerEvent } from "/_nuxt/@fs/D:/speckle-server/packages/viewer/dist/index.js";
import { isArray, throttle } from "/_nuxt/node_modules/.cache/vite/client/deps/lodash-es.js?v=e4f18c29";
import { until } from "/_nuxt/node_modules/@vueuse/core/index.mjs?v=e4f18c29";
import { TIME_MS, timeoutAt, TimeoutError } from "/_nuxt/@fs/D:/speckle-server/packages/shared/dist/esm/index.js";
import { Vector3 } from "/_nuxt/node_modules/.cache/vite/client/deps/three.js?v=e4f18c29";
import { areVectorsLooselyEqual } from "/_nuxt/lib/viewer/helpers/three.ts";
import {
  CameraController
} from "/_nuxt/@fs/D:/speckle-server/packages/viewer/dist/index.js";

import { onMounted, onBeforeUnmount, ref } from "/_nuxt/node_modules/vue/dist/vue.runtime.esm-bundler.js?v=e4f18c29";
import { useApiOrigin } from "/_nuxt/composables/env.ts";
import { useLogger } from "/_nuxt/composables/logging.ts";
const cacheTimeoutMs = 250;
let hitCache = null;
let lastCacheRefresh = Date.now();
function getFirstVisibleSelectionHit({ hits }, state) {
  const {
    viewer: {
      metadata: { filteringState }
    }
  } = state;
  if (Date.now() - lastCacheRefresh < cacheTimeoutMs && hitCache) {
    return hitCache;
  }
  hitCache = null;
  lastCacheRefresh = Date.now();
  const hasHiddenObjects = (filteringState.value?.hiddenObjects || []).length !== 0;
  const hasIsolatedObjects = !!filteringState.value?.isolatedObjects && filteringState.value?.isolatedObjects.length !== 0;
  for (const hit of hits) {
    if (hasHiddenObjects) {
      if (!filteringState.value?.hiddenObjects?.includes(
        hit.node.model.raw.id
      )) {
        hitCache = hit;
        return hitCache;
      }
    } else if (hasIsolatedObjects) {
      if (filteringState.value.isolatedObjects?.includes(
        hit.node.model.raw.id
      )) {
        hitCache = hit;
        return hitCache;
      }
    } else {
      hitCache = hit;
      return hitCache;
    }
  }
  return null;
}
export function useViewerEventListener(name, listener, options) {
  const {
    viewer: { instance }
  } = options?.state || useInjectedViewerState();
  const names = isArray(name) ? name : [name];
  const unmount = () => {
    for (const n of names) {
      instance.removeListener(n, listener);
    }
  };
  onMounted(() => {
    for (const n of names) {
      instance.on(n, listener);
    }
  });
  onBeforeUnmount(() => {
    unmount();
  });
  return unmount;
}
export function useViewerCameraTracker(callback, options) {
  const {
    viewer: { instance }
  } = useInjectedViewerState();
  const { throttleWait = 50, onlyInvokeOnMeaningfulChanges } = options || {};
  const lastPos = ref(null);
  const lastTarget = ref(null);
  const callbackChangeTrackerWrapper = (changed) => {
    if (!changed) return;
    if (!onlyInvokeOnMeaningfulChanges) {
      return callback();
    }
    const extension = instance.getExtension(CameraController);
    const viewerPos = new Vector3().copy(extension.renderingCamera.position);
    const viewerTarget = new Vector3().copy(extension.getTarget());
    let meaningfulChangeFound = false;
    if (!lastPos.value || !areVectorsLooselyEqual(lastPos.value, viewerPos)) {
      meaningfulChangeFound = true;
    }
    if (!lastTarget.value || !areVectorsLooselyEqual(lastTarget.value, viewerTarget)) {
      meaningfulChangeFound = true;
    }
    if (meaningfulChangeFound) {
      lastPos.value = viewerPos.clone();
      lastTarget.value = viewerTarget.clone();
      callback();
    }
  };
  const finalCallback = throttleWait ? throttle(callbackChangeTrackerWrapper, throttleWait) : callbackChangeTrackerWrapper;
  onMounted(() => {
    const extension = instance.getExtension(CameraController);
    extension.on(CameraEvent.LateFrameUpdate, finalCallback);
  });
  onBeforeUnmount(() => {
    instance.getExtension(CameraController).removeListener(CameraEvent.LateFrameUpdate, finalCallback);
  });
}
export function useViewerCameraControlStartTracker(callback) {
  const {
    viewer: { instance }
  } = useInjectedViewerState();
  const removeListener = () => instance.getExtension(CameraController).removeListener(CameraEvent.InteractionStarted, callback);
  onMounted(() => {
    instance.getExtension(CameraController).on(CameraEvent.InteractionStarted, callback);
  });
  onBeforeUnmount(() => {
    removeListener();
  });
  return removeListener;
}
export function useViewerCameraRestTracker(callback) {
  const {
    viewer: { instance }
  } = useInjectedViewerState();
  const removeListener = () => {
    const extension = instance.getExtension(CameraController);
    extension.removeListener(CameraEvent.Stationary, callback);
  };
  onMounted(() => {
    instance.getExtension(CameraController).on(CameraEvent.Stationary, callback);
  });
  onBeforeUnmount(() => {
    removeListener();
  });
  return removeListener;
}
export function useViewerCameraControlEndTracker(callback) {
  const {
    viewer: { instance }
  } = useInjectedViewerState();
  const removeListener = () => instance.getExtension(CameraController).removeListener(CameraEvent.Stationary, callback);
  onMounted(() => {
    instance.getExtension(CameraController).on(CameraEvent.Stationary, callback);
  });
  onBeforeUnmount(() => {
    removeListener();
  });
  return removeListener;
}
export function useSelectionEvents(params, options) {
  if (false) return;
  const { singleClickCallback, doubleClickCallback } = params;
  const state = options?.state || useInjectedViewerState();
  const {
    viewer: { instance }
  } = state;
  const handleSingleClick = singleClickCallback ? (event) => {
    const firstVisibleSelectionHit = event ? getFirstVisibleSelectionHit(event, state) : null;
    return singleClickCallback(event, { firstVisibleSelectionHit });
  } : void 0;
  const handleDoubleClick = doubleClickCallback ? (event) => {
    const firstVisibleSelectionHit = event ? getFirstVisibleSelectionHit(event, state) : null;
    return doubleClickCallback(event, { firstVisibleSelectionHit });
  } : void 0;
  onMounted(() => {
    if (handleDoubleClick) {
      instance.on(ViewerEvent.ObjectDoubleClicked, handleDoubleClick);
    }
    if (handleSingleClick) {
      instance.on(ViewerEvent.ObjectClicked, handleSingleClick);
    }
  });
  onBeforeUnmount(() => {
    if (handleDoubleClick) {
      instance.removeListener(ViewerEvent.ObjectDoubleClicked, handleDoubleClick);
    }
    if (handleSingleClick) {
      instance.removeListener(ViewerEvent.ObjectClicked, handleSingleClick);
    }
  });
}
export function useGetObjectUrl() {
  const apiOrigin = useApiOrigin({ forcePublic: true });
  return (projectId, objectId) => `${apiOrigin}/streams/${projectId}/objects/${objectId}`;
}
export function useOnViewerLoadComplete(listener, options) {
  const {
    ui: { loading: isLoading }
  } = useInjectedViewerState();
  const logger = useLogger();
  const { initialOnly, waitForLoadingOver = true } = options || {};
  const hasRun = ref(false);
  const cancel = useViewerEventListener(ViewerEvent.LoadComplete, async () => {
    if (initialOnly && hasRun.value) {
      cancel();
      return;
    }
    try {
      await (waitForLoadingOver ? Promise.race([
        until(isLoading).toBe(false),
        timeoutAt(TIME_MS.second, "Waiting for loading to complete timed out")
      ]) : Promise.resolve());
    } catch (e) {
      if (!(e instanceof TimeoutError)) throw e;
      logger.warn(e.message);
    }
    listener({ isInitial: !hasRun.value });
    hasRun.value = true;
    if (initialOnly) cancel();
  });
}

//# sourceMappingURL=data:application/json;base64,{"version":3,"mappings":"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","names":[],"ignoreList":[],"sources":["viewer.ts"],"sourcesContent":["import { useInjectedViewerState } from '~~/lib/viewer/composables/setup'\r\nimport type {\r\n  InitialStateWithRequestAndResponse,\r\n  InjectableViewerState\r\n} from '~~/lib/viewer/composables/setup'\r\nimport { CameraEvent, ViewerEvent } from '@speckle/viewer'\r\nimport { isArray, throttle } from 'lodash-es'\r\nimport { until } from '@vueuse/core'\r\nimport { TIME_MS, timeoutAt, TimeoutError } from '@speckle/shared'\r\nimport type { MaybeAsync, Nullable } from '@speckle/shared'\r\nimport { Vector3 } from 'three'\r\nimport { areVectorsLooselyEqual } from '~~/lib/viewer/helpers/three'\r\nimport {\r\n  CameraController,\r\n  type ViewerEventPayload,\r\n  type SelectionEvent,\r\n  type TreeNode\r\n} from '@speckle/viewer'\r\nimport type { SpeckleObject } from '~/lib/viewer/helpers/sceneExplorer'\r\n\r\n// NOTE: this is a preformance optimisation - this function is hot, and has to do\r\n// potentially large searches if many elements are hidden/isolated. We cache the\r\n// result for 250ms, which represents a single click.\r\n// NOTE: in the near future, this will hopefully not be needed as we'll have\r\n// viewer bound modules to help us with selection and visibility state management.\r\nconst cacheTimeoutMs = 250\r\nlet hitCache: Nullable<{\r\n  node: TreeNode\r\n  point: Vector3\r\n}> = null\r\nlet lastCacheRefresh: number = Date.now()\r\n\r\nfunction getFirstVisibleSelectionHit(\r\n  { hits }: SelectionEvent,\r\n  state: Pick<InjectableViewerState, 'viewer'>\r\n) {\r\n  const {\r\n    viewer: {\r\n      metadata: { filteringState }\r\n    }\r\n  } = state\r\n\r\n  if (Date.now() - lastCacheRefresh < cacheTimeoutMs && hitCache) {\r\n    return hitCache\r\n  }\r\n  hitCache = null\r\n  lastCacheRefresh = Date.now()\r\n\r\n  const hasHiddenObjects = (filteringState.value?.hiddenObjects || []).length !== 0\r\n  const hasIsolatedObjects =\r\n    !!filteringState.value?.isolatedObjects &&\r\n    filteringState.value?.isolatedObjects.length !== 0\r\n\r\n  for (const hit of hits) {\r\n    if (hasHiddenObjects) {\r\n      if (\r\n        !filteringState.value?.hiddenObjects?.includes(\r\n          ((hit.node.model as Record<string, unknown>).raw as SpeckleObject)\r\n            .id as string\r\n        )\r\n      ) {\r\n        hitCache = hit\r\n        return hitCache\r\n      }\r\n    } else if (hasIsolatedObjects) {\r\n      if (\r\n        filteringState.value.isolatedObjects?.includes(\r\n          ((hit.node.model as Record<string, unknown>).raw as SpeckleObject)\r\n            .id as string\r\n        )\r\n      ) {\r\n        hitCache = hit\r\n        return hitCache\r\n      }\r\n    } else {\r\n      hitCache = hit\r\n      return hitCache\r\n    }\r\n  }\r\n  return null\r\n}\r\n\r\nexport function useViewerEventListener<K extends ViewerEvent>(\r\n  name: K | K[],\r\n  listener: (args: ViewerEventPayload[K]) => MaybeAsync<void>,\r\n  options?: Partial<{\r\n    state: InitialStateWithRequestAndResponse\r\n  }>\r\n) {\r\n  const {\r\n    viewer: { instance }\r\n  } = options?.state || useInjectedViewerState()\r\n  const names = isArray(name) ? name : [name]\r\n\r\n  const unmount = () => {\r\n    for (const n of names) {\r\n      instance.removeListener(n, listener)\r\n    }\r\n  }\r\n\r\n  onMounted(() => {\r\n    for (const n of names) {\r\n      instance.on(n, listener)\r\n    }\r\n  })\r\n\r\n  onBeforeUnmount(() => {\r\n    unmount()\r\n  })\r\n\r\n  return unmount\r\n}\r\n\r\nexport function useViewerCameraTracker(\r\n  callback: () => void,\r\n  options?: Partial<{\r\n    throttleWait: number\r\n    onlyInvokeOnMeaningfulChanges: boolean\r\n  }>\r\n): void {\r\n  const {\r\n    viewer: { instance }\r\n  } = useInjectedViewerState()\r\n  const { throttleWait = 50, onlyInvokeOnMeaningfulChanges } = options || {}\r\n\r\n  const lastPos = ref(null as Nullable<Vector3>)\r\n  const lastTarget = ref(null as Nullable<Vector3>)\r\n\r\n  const callbackChangeTrackerWrapper = (changed: boolean) => {\r\n    if (!changed) return\r\n\r\n    if (!onlyInvokeOnMeaningfulChanges) {\r\n      return callback()\r\n    }\r\n\r\n    // Only invoke callback if position/target changed in a meaningful way\r\n    const extension: CameraController = instance.getExtension(CameraController)\r\n    const viewerPos = new Vector3().copy(extension.renderingCamera.position)\r\n    const viewerTarget = new Vector3().copy(extension.getTarget())\r\n\r\n    let meaningfulChangeFound = false\r\n    if (!lastPos.value || !areVectorsLooselyEqual(lastPos.value, viewerPos)) {\r\n      meaningfulChangeFound = true\r\n    }\r\n    if (!lastTarget.value || !areVectorsLooselyEqual(lastTarget.value, viewerTarget)) {\r\n      meaningfulChangeFound = true\r\n    }\r\n\r\n    if (meaningfulChangeFound) {\r\n      lastPos.value = viewerPos.clone()\r\n      lastTarget.value = viewerTarget.clone()\r\n      callback()\r\n    }\r\n  }\r\n\r\n  const finalCallback = throttleWait\r\n    ? throttle(callbackChangeTrackerWrapper, throttleWait)\r\n    : callbackChangeTrackerWrapper\r\n\r\n  onMounted(() => {\r\n    const extension = instance.getExtension(CameraController)\r\n    extension.on(CameraEvent.LateFrameUpdate, finalCallback)\r\n  })\r\n\r\n  onBeforeUnmount(() => {\r\n    instance\r\n      .getExtension(CameraController)\r\n      .removeListener(CameraEvent.LateFrameUpdate, finalCallback)\r\n  })\r\n}\r\n\r\nexport function useViewerCameraControlStartTracker(callback: () => void) {\r\n  const {\r\n    viewer: { instance }\r\n  } = useInjectedViewerState()\r\n  // Might need different event\r\n  const removeListener = () =>\r\n    instance\r\n      .getExtension(CameraController)\r\n      .removeListener(CameraEvent.InteractionStarted, callback)\r\n\r\n  onMounted(() => {\r\n    instance.getExtension(CameraController).on(CameraEvent.InteractionStarted, callback)\r\n  })\r\n\r\n  onBeforeUnmount(() => {\r\n    removeListener()\r\n  })\r\n\r\n  return removeListener\r\n}\r\n\r\nexport function useViewerCameraRestTracker(callback: () => void) {\r\n  const {\r\n    viewer: { instance }\r\n  } = useInjectedViewerState()\r\n\r\n  const removeListener = () => {\r\n    const extension = instance.getExtension(CameraController)\r\n    extension.removeListener(CameraEvent.Stationary, callback)\r\n  }\r\n\r\n  onMounted(() => {\r\n    instance.getExtension(CameraController).on(CameraEvent.Stationary, callback)\r\n  })\r\n\r\n  onBeforeUnmount(() => {\r\n    removeListener()\r\n  })\r\n\r\n  return removeListener\r\n}\r\n\r\nexport function useViewerCameraControlEndTracker(callback: () => void) {\r\n  const {\r\n    viewer: { instance }\r\n  } = useInjectedViewerState()\r\n  // Might need different event\r\n  const removeListener = () =>\r\n    instance\r\n      .getExtension(CameraController)\r\n      .removeListener(CameraEvent.Stationary, callback)\r\n\r\n  onMounted(() => {\r\n    instance.getExtension(CameraController).on(CameraEvent.Stationary, callback)\r\n  })\r\n\r\n  onBeforeUnmount(() => {\r\n    removeListener()\r\n  })\r\n\r\n  return removeListener\r\n}\r\n\r\nexport function useSelectionEvents(\r\n  params: {\r\n    singleClickCallback?: (\r\n      event: Nullable<SelectionEvent>,\r\n      extra: { firstVisibleSelectionHit: Nullable<SelectionEvent['hits'][0]> }\r\n    ) => void\r\n    doubleClickCallback?: (\r\n      event: Nullable<SelectionEvent>,\r\n      extra: { firstVisibleSelectionHit: Nullable<SelectionEvent['hits'][0]> }\r\n    ) => void\r\n  },\r\n  options?: Partial<{\r\n    state: InitialStateWithRequestAndResponse\r\n  }>\r\n) {\r\n  if (import.meta.server) return\r\n  const { singleClickCallback, doubleClickCallback } = params\r\n  const state = options?.state || useInjectedViewerState()\r\n  const {\r\n    viewer: { instance }\r\n  } = state\r\n\r\n  const handleSingleClick = singleClickCallback\r\n    ? (event: Nullable<SelectionEvent>) => {\r\n        const firstVisibleSelectionHit = event\r\n          ? getFirstVisibleSelectionHit(event, state)\r\n          : null\r\n        return singleClickCallback(event, { firstVisibleSelectionHit })\r\n      }\r\n    : undefined\r\n  const handleDoubleClick = doubleClickCallback\r\n    ? (event: Nullable<SelectionEvent>) => {\r\n        const firstVisibleSelectionHit = event\r\n          ? getFirstVisibleSelectionHit(event, state)\r\n          : null\r\n        return doubleClickCallback(event, { firstVisibleSelectionHit })\r\n      }\r\n    : undefined\r\n\r\n  onMounted(() => {\r\n    if (handleDoubleClick) {\r\n      instance.on(ViewerEvent.ObjectDoubleClicked, handleDoubleClick)\r\n    }\r\n    if (handleSingleClick) {\r\n      instance.on(ViewerEvent.ObjectClicked, handleSingleClick)\r\n    }\r\n  })\r\n\r\n  onBeforeUnmount(() => {\r\n    if (handleDoubleClick) {\r\n      instance.removeListener(ViewerEvent.ObjectDoubleClicked, handleDoubleClick)\r\n    }\r\n    if (handleSingleClick) {\r\n      instance.removeListener(ViewerEvent.ObjectClicked, handleSingleClick)\r\n    }\r\n  })\r\n}\r\n\r\nexport function useGetObjectUrl() {\n  const apiOrigin = useApiOrigin({ forcePublic: true })\n  return (projectId: string, objectId: string) =>\n    `${apiOrigin}/streams/${projectId}/objects/${objectId}`\n}\n\r\nexport function useOnViewerLoadComplete(\r\n  listener: (params: { isInitial: boolean }) => MaybeAsync<void>,\r\n  options?: Partial<{\r\n    /**\r\n     * Whether to only invoke the listener once on the very first LoadComplete event. Default: false\r\n     */\r\n    initialOnly: boolean\r\n    /**\r\n     * If true, will trigger the listener after the next loading=false event that comes after LoadComplete. Default: true\r\n     */\r\n    waitForLoadingOver: boolean\r\n  }>\r\n) {\r\n  const {\r\n    ui: { loading: isLoading }\r\n  } = useInjectedViewerState()\r\n  const logger = useLogger()\r\n  const { initialOnly, waitForLoadingOver = true } = options || {}\r\n\r\n  const hasRun = ref(false)\r\n\r\n  const cancel = useViewerEventListener(ViewerEvent.LoadComplete, async () => {\r\n    if (initialOnly && hasRun.value) {\r\n      cancel()\r\n      return\r\n    }\r\n\r\n    try {\r\n      await (waitForLoadingOver\r\n        ? Promise.race([\r\n            until(isLoading).toBe(false),\r\n            timeoutAt(TIME_MS.second, 'Waiting for loading to complete timed out')\r\n          ])\r\n        : Promise.resolve())\r\n    } catch (e) {\r\n      if (!(e instanceof TimeoutError)) throw e\r\n      logger.warn(e.message)\r\n    }\r\n\r\n    listener({ isInitial: !hasRun.value })\r\n    hasRun.value = true\r\n\r\n    if (initialOnly) cancel()\r\n  })\r\n}\r\n"],"file":"D:/speckle-server/packages/frontend-2/lib/viewer/composables/viewer.ts"}