@spiffcommerce/preview 3.6.2-rc.3 → 3.6.2-rc.5

package/dist/lib/glbLoaderExtensions.esm.js

@@ -0,0 +1,137 @@
+import { PBRMaterial as d } from "../node_modules/@babylonjs/core/Materials/PBR/pbrMaterial.esm.js";
+import { MirrorTexture as p } from "../node_modules/@babylonjs/core/Materials/Textures/mirrorTexture.esm.js";
+import "../node_modules/@babylonjs/core/Maths/math.axis.esm.js";
+import { Color3 as m } from "../node_modules/@babylonjs/core/Maths/math.color.esm.js";
+import { Plane as P } from "../node_modules/@babylonjs/core/Maths/math.plane.esm.js";
+import "../node_modules/@babylonjs/core/Maths/math.path.esm.js";
+import { Vector3 as u } from "../node_modules/@babylonjs/core/Maths/math.vector.esm.js";
+import { ReflectionProbe as R } from "../node_modules/@babylonjs/core/Probes/reflectionProbe.esm.js";
+import { RenderingConfiguration as h, REFLECTION_PROBE_RESOLUTION as E } from "./renderConstants.esm.js";
+class B {
+  constructor(e) {
+    this.name = "glbPostProcessor", this.enabled = !0, this.loader = e;
+  }
+  onReady() {
+    this.applyReflections(this.loader.babylonScene);
+  }
+  /**
+   * Any custom properties set in blender on transform nodes will appear here. We can
+   * write the properties into the object metadata for retrieval at runtime.
+   */
+  loadNodeAsync(e, s, r) {
+    return this.loader.loadNodeAsync(
+      e,
+      s,
+      function(a) {
+        s.extras && Object.keys(s.extras).forEach((t) => {
+          const o = s.extras[t];
+          a.metadata[t] = o;
+        }), r(a);
+      }
+    );
+  }
+  /**
+   * Material properties can be set at load time as we don't depend
+   * on the entire scene graph being loaded (for reflection render lists).
+   * The need for these properties may go over time as the relevant exporters/importers are updated.
+   */
+  async loadMaterialPropertiesAsync(e, s, r) {
+    await this.loader.loadMaterialPropertiesAsync(
+      e,
+      s,
+      r
+    ), this.enableMaterialExtrasIfRequired(s, r), r.needDepthPrePass = !0;
+  }
+  dispose() {
+  }
+  /**
+   * With a given material descriptor and babylon material instance, looks for any
+   * metadata defined on the descriptor and applies to the babylon material.
+   * @param material A material descriptor
+   * @param babylonMaterial An instance of a material representation in babylon.
+   */
+  enableMaterialExtrasIfRequired(e, s) {
+    if (!(!e.extras || !(s instanceof d))) {
+      if (e.extras.sheen) {
+        const r = s;
+        r.sheen.isEnabled = !0, r.sheen.intensity = e.extras.sheen;
+      }
+      if (e.extras.translucency) {
+        const r = s;
+        r.subSurface.isTranslucencyEnabled = !0, r.subSurface.translucencyIntensity = e.extras.translucency, e.extras.translucencyR && e.extras.translucencyG && e.extras.translucencyB && (r.subSurface.tintColor = new m(
+          e.extras.translucencyR,
+          e.extras.translucencyG,
+          e.extras.translucencyB
+        ));
+      }
+      if (e.extras.refractionIOR) {
+        const r = s;
+        r.subSurface.isRefractionEnabled = !0, r.subSurface.volumeIndexOfRefraction = e.extras.refractionIOR;
+      }
+      if (e.extras.useDepthPrePass) {
+        const r = s;
+        r.needDepthPrePass = !0, r.forceIrradianceInFragment = !0;
+      }
+      if (e.extras.useParallax) {
+        const r = s;
+        r.useParallax = !0, r.useParallaxOcclusion = !0, r.parallaxScaleBias = e.extras.useParallax;
+      }
+    }
+  }
+  /**
+   * Called with a loaded scene. Will finish initialization
+   * of any reflective properties within the scene.
+   * @param scene The scene to parse.
+   */
+  applyReflections(e) {
+    function s(t) {
+      const o = [];
+      return t.transformNodes.forEach((n) => {
+        n.metadata && n.metadata.reflective && o.push(...n.getChildMeshes());
+      }), t.meshes.forEach((n) => {
+        n.metadata && n.metadata.reflective && !o.includes(n) && o.push(n);
+      }), o;
+    }
+    function r(t, o = 1) {
+      const n = t.material;
+      if (!n)
+        return;
+      const i = new p(
+        "mirror",
+        h.getMirrorTextureResolution(),
+        e,
+        !0
+      );
+      i.renderList = s(e);
+      const c = t.getVerticesData("normal");
+      if (!c)
+        throw new Error(
+          "Mirror attribute specified on: " + t.name + "But no normals exist to generate a mirror from!"
+        );
+      t.computeWorldMatrix(!0);
+      const f = t.getWorldMatrix(), l = u.TransformNormal(
+        new u(c[0], c[1], c[2]),
+        f
+      ).normalize(), x = P.FromPositionAndNormal(
+        t.position,
+        l.scale(-1)
+      );
+      i.mirrorPlane = x, i.level = o, n.reflectionTexture = i;
+    }
+    function a(t) {
+      const o = t.material, n = new R(
+        "probe-" + o.name,
+        E,
+        e
+      );
+      n.attachToMesh(t), n.renderList && n.renderList.push(...s(e)), o.reflectionTexture = n.cubeTexture;
+    }
+    e.meshes.forEach((t) => {
+      const o = t.metadata;
+      o && (o.mirrorTexture && r(t, o.mirrorTexture), o.reflectionProbe && a(t));
+    });
+  }
+}
+export {
+  B as GLBLoaderExtension
+};

package/dist/lib/glowLayerManager.esm.js

@@ -0,0 +1,19 @@
+import { GlowLayer as t } from "../node_modules/@babylonjs/core/Layers/glowLayer.esm.js";
+class o {
+  constructor(s, e) {
+    this.scene = s, this.intensity = e, this.meshCount = 0;
+  }
+  includeMeshes(s) {
+    this.glowLayer || (this.glowLayer = new t("glow", this.scene), this.glowLayer.intensity = this.intensity), s.forEach((e) => {
+      this.glowLayer.hasMesh(e) || (this.glowLayer.addIncludedOnlyMesh(e), this.meshCount++);
+    });
+  }
+  removeMeshes(s) {
+    this.glowLayer && (s.forEach((e) => {
+      this.glowLayer.hasMesh(e) && (this.glowLayer.removeIncludedOnlyMesh(e), this.meshCount--);
+    }), this.meshCount === 0 && (this.glowLayer.dispose(), this.glowLayer = void 0));
+  }
+}
+export {
+  o as default
+};

package/dist/lib/guid.esm.js

@@ -0,0 +1,7 @@
+function r() {
+  const t = () => Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
+  return t() + t() + "-" + t() + "-" + t() + "-" + t() + "-" + t() + t() + t();
+}
+export {
+  r as generateGuid
+};

package/dist/lib/material.esm.js

@@ -0,0 +1,50 @@
+import { Color3 as f } from "../node_modules/@babylonjs/core/Maths/math.color.esm.js";
+import { MaterialEffectMode as r } from "./types.esm.js";
+const p = {
+  albedoTexture: "albedoMap",
+  bumpTexture: "normalMap",
+  ambientTexture: "ambientMap",
+  emissiveTexture: "emissionMap",
+  opacityTexture: "alphaMap",
+  metallicTexture: "metallicMap",
+  refractionTexture: "refractionMap"
+};
+function m(o, e, s, i) {
+  [
+    "albedoTexture",
+    "bumpTexture",
+    "ambientTexture",
+    "emissiveTexture",
+    "opacityTexture",
+    "metallicTexture",
+    "refractionTexture"
+  ].forEach((l) => {
+    T(
+      l,
+      o,
+      e,
+      s,
+      i
+    );
+  }), d(o, e);
+}
+function T(o, e, s, i, u) {
+  const l = p[o];
+  if (!l)
+    throw new Error("Unexpected texture name encountered.");
+  const n = e[l], c = n == null ? void 0 : n.fileLink;
+  c ? i.addTextureTask(o, c, !1, !1) : u && s[o] && (s[o] && s[o].dispose(), s[o] = null, x(o, s));
+}
+function x(o, e) {
+  o === "opacityTexture" && (e.useAlphaFromAlbedoTexture = !0), o === "metallicTexture" && (e.useRoughnessFromMetallicTextureAlpha = !1, e.useRoughnessFromMetallicTextureGreen = !1, e.useMetallnessFromMetallicTextureBlue = !1), o === "refractionTexture" && (e.subSurface.isRefractionEnabled = !1, e.subSurface.refractionIntensity = 1), o === "emissiveTexture" && (e.emissiveIntensity = 0, e.emissiveColor = new f(0, 0, 0));
+}
+function b(o, e, s, i) {
+  o === "opacityTexture" && (e.useAlphaFromAlbedoTexture = !1), o === "metallicTexture" && (e.useRoughnessFromMetallicTextureAlpha = !1, e.useRoughnessFromMetallicTextureGreen = !0, e.useMetallnessFromMetallicTextureBlue = !0), o === "refractionTexture" && (e.subSurface.isRefractionEnabled = !0, e.subSurface.refractionIntensity = s.refractionIntensity || 1), e[o] = i, o === "emissiveTexture" && (e.emissiveColor = new f(1, 1, 1), e.emissiveIntensity = 1);
+}
+function d(o, e) {
+  o.clearCoat && (o.clearCoat === r.RemoveWhenSelected ? (e.clearCoat.isEnabled = !1, e.clearCoat.indexOfRefraction = 1.5) : o.clearCoat === r.ApplyWhenSelected && (e.clearCoat.isEnabled = !0, e.clearCoat.indexOfRefraction = o.clearCoatIOR || e.clearCoat.indexOfRefraction));
+}
+export {
+  b as applyDownloadedTexture,
+  m as calculateMaterialProperties
+};

package/dist/lib/modelContainer.esm.js

@@ -0,0 +1,351 @@
+import { ActionManager as h } from "../node_modules/@babylonjs/core/Actions/actionManager.esm.js";
+import { ExecuteCodeAction as m } from "../node_modules/@babylonjs/core/Actions/directActions.esm.js";
+import { PBRMaterial as g } from "../node_modules/@babylonjs/core/Materials/PBR/pbrMaterial.esm.js";
+import { Vector3 as o } from "../node_modules/@babylonjs/core/Maths/math.vector.esm.js";
+import { Mesh as p } from "../node_modules/@babylonjs/core/Meshes/mesh.esm.js";
+import { TransformNode as f } from "../node_modules/@babylonjs/core/Meshes/transformNode.esm.js";
+import { Observable as l } from "../node_modules/@babylonjs/core/Misc/observable.esm.js";
+import { getAssetContainer as b } from "./assetCache.esm.js";
+import { attachDynamicTextures as v } from "./dynamicTexture.esm.js";
+import { generateGuid as C } from "./guid.esm.js";
+import { resetAnimationGroups as M, executeAnimationGroups as I } from "./productAnimations.esm.js";
+import w, { getAllMaterialsForInstance as y } from "./variants.esm.js";
+function u(d, e = "") {
+  return d.map((t) => ({
+    name: t.name.substring(e.length),
+    loop: t.loopAnimation,
+    to: t.to,
+    from: t.from
+  }));
+}
+class E {
+  constructor(e) {
+    this.metadata = /* @__PURE__ */ new Map(), this.materialSelectedObservable = new l(), this.materialDeselectedObservable = new l(), this.materialVariantObservable = new l(), this.modelVariantObservable = new l(), this.materialReadyToLoadCallbacks = /* @__PURE__ */ new Map(), this.modelReadyToLoadCallbacks = /* @__PURE__ */ new Map(), this.dynamicTextures = /* @__PURE__ */ new Map(), this.queuedMaterialChanges = /* @__PURE__ */ new Map(), this.materialChangesInProgress = [], this.queuedModelChanges = /* @__PURE__ */ new Map(), this.modelChangesInProgress = [], this.animations = [], this.initialized = !1, this.materials = [];
+    const {
+      enablePicking: t,
+      modelDetails: i,
+      previewService: a,
+      progressHandler: r,
+      scene: s
+    } = e;
+    this.enablePicking = t, this.contextService = i.contextService, this.id = C(), this.previewService = a, this.scene = s, this.variantManager = new w(
+      s,
+      this.renameClonedAsset.bind(this),
+      this.setEnabled.bind(this)
+    ), this.previewService.registerInitializedListener(
+      async () => await this.processQueuedEvents()
+    ), this.transformRoot = new f("root", this.scene);
+    const n = async () => (this.assetContainer = await b(
+      i.model,
+      s,
+      r
+    ), this.initialized = !0, this.instantiate(), this);
+    this.importPromise = n();
+  }
+  //#region Interface implementation
+  async applyMaterialVariant(e, t, i, a) {
+    if (this.previewService.getSceneInitializationProgress() !== 100 || !this.initialized) {
+      if (this.materialReadyToLoadCallbacks.has(e)) {
+        const s = this.materialReadyToLoadCallbacks.get(e);
+        s == null || s.set(
+          t,
+          this.applyMaterialVariant.bind(
+            this,
+            e,
+            t,
+            i,
+            a
+          )
+        );
+      } else {
+        this.materialReadyToLoadCallbacks.set(
+          e,
+          /* @__PURE__ */ new Map()
+        );
+        const s = this.materialReadyToLoadCallbacks.get(e);
+        s == null || s.set(
+          t,
+          this.applyMaterialVariant.bind(
+            this,
+            e,
+            t,
+            i,
+            a
+          )
+        );
+      }
+      return;
+    }
+    const r = async () => {
+      await this.variantManager.applyMaterial(
+        e,
+        i,
+        (s, n, c) => {
+          this.materialVariantObservable.notifyObservers({
+            remainingCount: s,
+            totalCount: n,
+            taskName: c
+          });
+        },
+        a
+      );
+    };
+    if (this.materialChangesInProgress.includes(e)) {
+      if (this.queuedMaterialChanges.has(e)) {
+        const s = this.queuedMaterialChanges.get(e);
+        s == null || s.set(t, r);
+      } else {
+        this.queuedMaterialChanges.set(
+          e,
+          /* @__PURE__ */ new Map()
+        );
+        const s = this.queuedMaterialChanges.get(e);
+        s == null || s.set(t, r);
+      }
+      return;
+    }
+    this.materialChangesInProgress.push(e), await r(), this.queuedMaterialChanges.has(e) && (this.queuedMaterialChanges.get(e).forEach(async (n) => {
+      await n();
+    }), this.queuedMaterialChanges.delete(e)), this.materialChangesInProgress.splice(
+      this.materialChangesInProgress.indexOf(e),
+      1
+    ), this.configureGlowLayer();
+  }
+  async applyModelVariant(e, t, i) {
+    if (!this.previewService.getIsInitialized() || !this.initialized) {
+      this.modelReadyToLoadCallbacks.set(
+        e,
+        this.applyModelVariant.bind(
+          this,
+          e,
+          t,
+          i
+        )
+      );
+      return;
+    }
+    const a = () => this.variantManager.applyModel(
+      e,
+      i,
+      t == null ? void 0 : t.model,
+      (n) => {
+        this.modelVariantObservable.notifyObservers({
+          ...n,
+          key: e
+        });
+      }
+    );
+    if (this.modelChangesInProgress.includes(e)) {
+      this.queuedModelChanges.set(e, a);
+      return;
+    }
+    const s = await (async () => {
+      this.modelChangesInProgress.push(e);
+      let n = await a();
+      return this.queuedModelChanges.has(e) && (n = await this.queuedModelChanges.get(e)(), this.queuedModelChanges.delete(e)), this.modelChangesInProgress.splice(
+        this.modelChangesInProgress.indexOf(e),
+        1
+      ), n;
+    })();
+    this.modelInstance && M(this.modelInstance.animationGroups), this.contextService || (this.contextService = t == null ? void 0 : t.contextService), s ? this.configureModelInstance(s) : this.configureGlowLayer();
+  }
+  dispose() {
+    var e;
+    this.destroyInstance(), this.variantManager.dispose(), this.dynamicTextures.forEach((t) => t == null ? void 0 : t.dispose()), this.dynamicTextures.clear(), this.materials.forEach((t) => t && (t == null ? void 0 : t.dispose())), this.materials = [], (e = this.transformRoot) == null || e.dispose(), this.transformRoot = void 0, this.previewService.modelUnloaded(this);
+  }
+  executeAnimation(e) {
+    if (!this.previewService.getIsInitialized()) {
+      this.queuedModelAnimation = e;
+      return;
+    }
+    this.modelInstance && I(
+      [
+        ...this.modelInstance.animationGroups,
+        ...this.variantManager.getAnimationGroups()
+      ],
+      e.loop,
+      e.to,
+      e.from,
+      e.name ? this.renameClonedAsset(e.name) : void 0
+    );
+  }
+  getAnimations(e) {
+    return [
+      ...this.animations,
+      ...e ? u(
+        this.variantManager.getAnimationGroups(),
+        this.renameClonedAsset("")
+      ) : []
+    ];
+  }
+  getId() {
+    return this.id;
+  }
+  listMaterials() {
+    var t;
+    const e = (t = this.scene) == null ? void 0 : t.materials.filter(
+      (i) => i.name.startsWith(this.id)
+    );
+    return e ? e.map((i) => ({
+      id: i.id,
+      name: this.stripIdFromName(i.name)
+    })) : [];
+  }
+  registerMaterialSelectedCallback(e) {
+    this.materialSelectedObservable.add(e);
+  }
+  unregisterMaterialSelectedCallback(e) {
+    this.materialSelectedObservable.removeCallback(e);
+  }
+  registerMaterialDeselectedCallback(e) {
+    this.materialDeselectedObservable.add(e);
+  }
+  unregisterMaterialDeselectedCallback(e) {
+    this.materialDeselectedObservable.removeCallback(e);
+  }
+  get position() {
+    return this.transformRoot.position;
+  }
+  set position(e) {
+    this.transformRoot.position = new o(e.x, e.y, e.z);
+  }
+  get rotation() {
+    return this.transformRoot.rotation;
+  }
+  set rotation(e) {
+    this.transformRoot.rotation = new o(e.x, e.y, e.z);
+  }
+  get scale() {
+    return this.transformRoot.scaling;
+  }
+  set scale(e) {
+    this.transformRoot.scaling = new o(e.x, e.y, e.z);
+  }
+  //#endregion
+  //#region Custom implementation functions
+  attachPickingHandler(e) {
+    e.rootNodes.forEach((t) => {
+      t.getChildMeshes(!1).forEach((i) => {
+        i.name === "targetcube_t" || i.name === "backgroundShell" || (i.actionManager || (i.actionManager = new h(this.scene)), i.actionManager.registerAction(
+          new m(h.OnPointerOverTrigger, (a) => {
+            a.meshUnderPointer && i.material && this.materialSelectedObservable.notifyObservers({
+              id: i.material.id,
+              name: this.stripIdFromName(i.material.name)
+            });
+          })
+        ), i.actionManager.registerAction(
+          new m(h.OnPointerOutTrigger, () => {
+            i.material && this.materialDeselectedObservable.notifyObservers({
+              id: i.material.id,
+              name: this.stripIdFromName(i.material.name)
+            });
+          })
+        ));
+      });
+    });
+  }
+  /**
+   * Returns a promise which resolves when the model has been initialized.
+   */
+  getInitializationPromise() {
+    return this.importPromise;
+  }
+  /**
+   * Returns true if the model has been initialized.
+   */
+  getIsInitialized() {
+    return this.initialized;
+  }
+  getQueuedMaterialVariantCount() {
+    return this.materialReadyToLoadCallbacks.size;
+  }
+  getQueuedModelVariantCount() {
+    return this.modelReadyToLoadCallbacks.size;
+  }
+  configureGlowLayer() {
+    const e = (i) => i instanceof g && i.emissiveTexture !== null;
+    this.materials.some(e) || this.variantManager.getAllMaterials().some(e) ? this.previewService.getGlowLayerManager().includeMeshes(this.getAllMeshes()) : this.previewService.getGlowLayerManager().removeMeshes(this.getAllMeshes());
+  }
+  configureModelInstance(e) {
+    var r;
+    const t = this.transformRoot.position, i = this.transformRoot.rotation, a = this.transformRoot.scaling;
+    this.transformRoot.position = o.Zero(), this.transformRoot.rotation = o.Zero(), this.transformRoot.scaling = o.One(), e.rootNodes.forEach((s) => {
+      s.parent = this.transformRoot;
+    }), this.transformRoot.position = t, this.transformRoot.rotation = i, this.transformRoot.scaling = a, this.canvasPanels = ((r = this.contextService) == null ? void 0 : r.getAll()) || /* @__PURE__ */ new Map(), v(
+      this.materials.concat(this.variantManager.getAllMaterials()),
+      this.scene,
+      this.canvasPanels,
+      this.dynamicTextures,
+      `${this.id}_`
+    ), this.enablePicking && this.attachPickingHandler(e), this.configureGlowLayer();
+  }
+  /**
+   * Destroys the model instance.
+   */
+  destroyInstance() {
+    var e;
+    (e = this.modelInstance) == null || e.dispose(), this.modelInstance = void 0;
+  }
+  getAllMeshes() {
+    var e;
+    return (e = this.modelInstance) == null ? void 0 : e.rootNodes.map(
+      (t) => t.getChildMeshes(!1).filter((i) => i instanceof p)
+    ).flat();
+  }
+  instantiate() {
+    this.modelInstance = this.assetContainer.instantiateModelsToScene(
+      this.renameClonedAsset.bind(this),
+      !0
+    ), this.materials = y(this.modelInstance), this.configureModelInstance(this.modelInstance), this.animations = u(
+      this.modelInstance.animationGroups,
+      this.renameClonedAsset("")
+    ), this.processQueuedEvents();
+  }
+  renameClonedAsset(e) {
+    return `${this.id}_${e}`;
+  }
+  setEnabled(e) {
+    e && !this.modelInstance ? this.instantiate() : !e && this.modelInstance && this.destroyInstance();
+  }
+  updateDynamicTextures() {
+    var e;
+    (e = this.canvasPanels) == null || e.forEach(
+      (t, i) => {
+        const a = this.dynamicTextures.get(i);
+        a && t.getStaticContextDirty() && a.isReady() && (a.update(!1), t.setStaticContextDirty(!1));
+      }
+    );
+  }
+  //#region Listeners
+  registerMaterialVariantListener(e) {
+    this.materialVariantObservable.add(e);
+  }
+  unregisterMaterialVariantListener(e) {
+    this.materialVariantObservable.removeCallback(e);
+  }
+  registerModelVariantListener(e) {
+    this.modelVariantObservable.add(e);
+  }
+  unregisterModelVariantListener(e) {
+    this.modelVariantObservable.removeCallback(e);
+  }
+  //#endregion
+  stripIdFromName(e) {
+    return e.substring(this.id.length + 1);
+  }
+  async processQueuedEvents() {
+    this.previewService.getIsInitialized() && (await Promise.all(
+      Array.from(this.materialReadyToLoadCallbacks.values()).map(
+        (e) => Array.from(e.values()).map((t) => t())
+      )
+    ), this.materialReadyToLoadCallbacks.clear(), await Promise.all(
+      Array.from(this.modelReadyToLoadCallbacks.values()).map(
+        (e) => e()
+      )
+    ), this.modelReadyToLoadCallbacks.clear(), this.queuedModelAnimation && (this.executeAnimation(this.queuedModelAnimation), this.queuedModelAnimation = void 0));
+  }
+  //#endregion
+}
+export {
+  E as ModelContainerImpl
+};

package/dist/lib/productAnimations.esm.js

@@ -0,0 +1,123 @@
+import { Animation as p } from "../node_modules/@babylonjs/core/Animations/animation.esm.js";
+import { EasingFunction as T, QuadraticEase as I } from "../node_modules/@babylonjs/core/Animations/easing.esm.js";
+import { Vector3 as c } from "../node_modules/@babylonjs/core/Maths/math.vector.esm.js";
+const A = 60, f = 1;
+function d(n) {
+  return n.targetedAnimations.map((e) => e.animation.framePerSecond).reduce((e, o) => e + o, 0) / n.targetedAnimations.length || 0;
+}
+function F(n, t, e, o, r) {
+  const i = r ? n.filter((s) => s.name === r) : n;
+  if (i.length === 0) {
+    console.warn(`No animations found for name: ${r}`);
+    return;
+  }
+  if (o !== void 0 && e !== void 0 && o === e) {
+    i.forEach((s) => {
+      s.stop();
+      const u = d(s), a = o * u;
+      s.start(t, f, a, a);
+    });
+    return;
+  }
+  i.forEach((s) => {
+    s.stop();
+    const u = d(s), a = o !== void 0 ? o * u : void 0, g = e !== void 0 ? e * u : void 0;
+    s.start(t, f, a, g);
+  });
+}
+function O(n) {
+  n.forEach((t) => {
+    t.stop();
+  });
+}
+function v(n) {
+  const t = n.animationGroups;
+  O(t);
+}
+function P(n, t, e) {
+  n.stopAnimation(t), t.animations = [], Math.abs(t.alpha) > 2 * Math.PI && (t.alpha = M(t.alpha, 0, 2 * Math.PI));
+  const o = [], r = e.target, i = 0, s = r ? 1 : 0;
+  if (e.target && Object.keys(e.target).length > 0 && o.push(
+    h(
+      "cameraTargetLerp",
+      "target",
+      new c().copyFrom(t.target),
+      new c(
+        e.target.x,
+        e.target.y,
+        e.target.z
+      ),
+      p.ANIMATIONTYPE_VECTOR3,
+      i
+    )
+  ), o.push(
+    h(
+      "cameraAlphaLerp",
+      "alpha",
+      t.alpha,
+      E(e.lonDeg),
+      p.ANIMATIONTYPE_FLOAT,
+      s
+    )
+  ), o.push(
+    h(
+      "cameraBetaLerp",
+      "beta",
+      t.beta,
+      E(e.latDeg),
+      p.ANIMATIONTYPE_FLOAT,
+      s
+    )
+  ), e.radius !== void 0) {
+    const g = Math.max(0.01, e.radius);
+    o.push(
+      h(
+        "cameraRadiusLerp",
+        "radius",
+        t.radius,
+        g,
+        p.ANIMATIONTYPE_FLOAT,
+        s
+      )
+    );
+  }
+  t.animations.push(...o);
+  const a = t.useAutoRotationBehavior;
+  t.disableAutoRotationBehavior(), n.beginAnimation(
+    t,
+    0,
+    r ? A * 2 : A,
+    !1,
+    1,
+    () => {
+      t.animations = [], a && t.enableAutoRotationBehavior();
+    }
+  );
+}
+function E(n) {
+  return n * Math.PI / 180;
+}
+function h(n, t, e, o, r, i = 0, s = p.ANIMATIONLOOPMODE_CONSTANT) {
+  const u = new I();
+  u.setEasingMode(T.EASINGMODE_EASEINOUT);
+  const a = new p(
+    n,
+    t,
+    A,
+    r,
+    s
+  ), g = [];
+  return i > 0 && g.push({ frame: 0, value: e }), g.push({ frame: A * i, value: e }), g.push({
+    frame: A * (i + 1),
+    value: o
+  }), a.setKeys(g), a.setEasingFunction(u), a;
+}
+function M(n, t, e) {
+  return n < t ? n = e - (t - n) % (e - t) : n = t + (n - t) % (e - t);
+}
+export {
+  P as animateCameraInScene,
+  F as executeAnimationGroups,
+  O as resetAnimationGroups,
+  v as resetSceneModelAnimations
+};