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

package/dist/lib/assetCache.esm.js

@@ -0,0 +1,21 @@
+import { SceneLoader as c } from "../node_modules/@babylonjs/core/Loading/sceneLoader.esm.js";
+const s = /* @__PURE__ */ new Map();
+async function u(e, n, a) {
+  return new Promise((i, r) => {
+    const t = s.get(e);
+    if (t && t.scene.uid === n.uid)
+      return i(t);
+    c.LoadAssetContainerAsync(
+      e,
+      void 0,
+      n,
+      a
+    ).then((o) => {
+      s.set(e, o), i(o);
+    }).catch(r);
+  });
+}
+export {
+  s as assetCache,
+  u as getAssetContainer
+};

package/dist/lib/configuration.esm.js

@@ -0,0 +1,98 @@
+import { Color4 as a, Color3 as g } from "../node_modules/@babylonjs/core/Maths/math.color.esm.js";
+class C {
+  constructor(t) {
+    this.getSceneClearColor = () => {
+      var i, s, n, r;
+      const o = (i = this.customOptions) != null && i.transparentBackground || (s = this.customOptions) != null && s.backgroundImage ? 0 : 1;
+      if (this.customOptions && ((n = this.customOptions) != null && n.transparentBackground) || (r = this.customOptions) != null && r.backgroundImage)
+        return new a(0, 0, 0, o).toLinearSpace();
+      if (this.customOptions && this.customOptions.backgroundColor) {
+        const e = g.FromHexString(
+          this.customOptions.backgroundColor
+        );
+        return new a(
+          e.r,
+          e.g,
+          e.b,
+          o
+        ).toLinearSpace();
+      }
+      return new a(0.98, 0.98, 0.98, o).toLinearSpace();
+    }, this.highlightColorFromConfig = () => this.customOptions && this.customOptions.highlightColor ? this.hexToColor4(this.customOptions.highlightColor) : new a(0.98, 0.98, 0.98, 1).toLinearSpace(), this.hexToColor4 = (o, i = 1) => {
+      const s = g.FromHexString(o);
+      return new a(
+        s.r,
+        s.g,
+        s.b,
+        i
+      ).toLinearSpace();
+    }, this.customOptions = t;
+  }
+  createCanvas() {
+    return this.customOptions.createCanvas ? this.customOptions.createCanvas() : document.createElement("canvas");
+  }
+  get options() {
+    return this.customOptions;
+  }
+  /**
+   * Configuration related to the scene
+   */
+  get scene() {
+    var t, o, i;
+    return {
+      clearColor: this.getSceneClearColor(),
+      transparentBackground: ((t = this.customOptions) == null ? void 0 : t.transparentBackground) || ((o = this.customOptions) == null ? void 0 : o.backgroundImage),
+      environmentFile: ((i = this.customOptions) == null ? void 0 : i.environmentFile) ?? "assets/model-viewer/default.env"
+    };
+  }
+  /**
+   * Configuration related to the camera used to view and interact with the scene.
+   */
+  get camera() {
+    var t, o, i, s, n, r, e, h, u, c, m, p, l;
+    return {
+      autoOrientation: ((t = this.customOptions) == null ? void 0 : t.disableAutomaticOrientation) ?? !0,
+      autoRotation: {
+        enabled: ((o = this.customOptions) == null ? void 0 : o.autoRotation) ?? !1,
+        idleTimeMs: ((i = this.customOptions) == null ? void 0 : i.idleTimeBeforeRotation) ?? 5e3
+      },
+      limits: {
+        min: {
+          alpha: (s = this.customOptions) != null && s.lowerAlphaLimitDeg ? ((n = this.customOptions) == null ? void 0 : n.lowerAlphaLimitDeg) * Math.PI / 180 : void 0,
+          beta: (r = this.customOptions) != null && r.lowerBetaLimitDeg ? ((e = this.customOptions) == null ? void 0 : e.lowerBetaLimitDeg) * Math.PI / 180 : void 0,
+          radius: (h = this.customOptions) == null ? void 0 : h.minZoomOverride
+        },
+        max: {
+          alpha: (u = this.customOptions) != null && u.upperAlphaLimitDeg ? ((c = this.customOptions) == null ? void 0 : c.upperAlphaLimitDeg) * Math.PI / 180 : void 0,
+          beta: (m = this.customOptions) != null && m.upperBetaLimitDeg ? ((p = this.customOptions) == null ? void 0 : p.upperBetaLimitDeg) * Math.PI / 180 : void 0,
+          radius: (l = this.customOptions) == null ? void 0 : l.maxZoomOverride
+        }
+      }
+    };
+  }
+  /**
+   * Configuration related to the highlighting system. Highlights are used to add
+   * a visual cue to the user that something is moused over in the preview.
+   */
+  get highlights() {
+    var t;
+    return {
+      enabled: ((t = this.customOptions) == null ? void 0 : t.highlightOnMaterialHover) ?? !1,
+      color: this.highlightColorFromConfig()
+    };
+  }
+  get lighting() {
+    var t, o, i, s;
+    return {
+      exposure: ((o = (t = this.customOptions) == null ? void 0 : t.lighting) == null ? void 0 : o.exposure) ?? 0.9,
+      contrast: ((s = (i = this.customOptions) == null ? void 0 : i.lighting) == null ? void 0 : s.contrast) ?? 1.6
+    };
+  }
+  get emissiveGlowIntensity() {
+    var t;
+    return ((t = this.customOptions) == null ? void 0 : t.emissiveGlowIntensity) ?? 0.5;
+  }
+}
+export {
+  C as Configuration
+};

package/dist/lib/core.esm.js

@@ -0,0 +1,417 @@
+import { ArcRotateCamera as p } from "../node_modules/@babylonjs/core/Cameras/arcRotateCamera.esm.js";
+import { Engine as v } from "../node_modules/@babylonjs/core/Engines/engine.esm.js";
+import { NullEngine as C } from "../node_modules/@babylonjs/core/Engines/nullEngine.esm.js";
+import { HighlightLayer as w } from "../node_modules/@babylonjs/core/Layers/highlightLayer.esm.js";
+import { SceneLoader as L } from "../node_modules/@babylonjs/core/Loading/sceneLoader.esm.js";
+import { CubeTexture as b } from "../node_modules/@babylonjs/core/Materials/Textures/cubeTexture.esm.js";
+import { Color3 as d } from "../node_modules/@babylonjs/core/Maths/math.color.esm.js";
+import { Vector3 as l } from "../node_modules/@babylonjs/core/Maths/math.vector.esm.js";
+import { DracoCompression as P } from "../node_modules/@babylonjs/core/Meshes/Compression/dracoCompression.esm.js";
+import { Observable as m } from "../node_modules/@babylonjs/core/Misc/observable.esm.js";
+import { Tools as y } from "../node_modules/@babylonjs/core/Misc/tools.esm.js";
+import { Scene as E } from "../node_modules/@babylonjs/core/scene.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/glTFFileLoader.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/glTFValidation.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/1.0/glTFBinaryExtension.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/1.0/glTFLoader.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderInterfaces.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderUtils.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/1.0/glTFMaterialsCommonExtension.esm.js";
+import { GLTFLoader as M } from "../node_modules/@babylonjs/loaders/glTF/2.0/glTFLoader.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_lights_image_based.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_mesh_gpu_instancing.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_meshopt_compression.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_texture_webp.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_draco_mesh_compression.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_lights_punctual.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_pbrSpecularGlossiness.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_unlit.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_clearcoat.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_iridescence.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_anisotropy.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_emissive_strength.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_sheen.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_specular.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_ior.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_variants.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_transmission.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_translucency.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_materials_volume.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_mesh_quantization.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_texture_basisu.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_texture_transform.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_xmp_json_ld.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/KHR_animation_pointer.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_audio_emitter.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_lod.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_minecraftMesh.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_sRGBFactors.esm.js";
+import "../node_modules/@babylonjs/loaders/glTF/2.0/Extensions/ExtrasAsMetadata.esm.js";
+import { Configuration as z } from "./configuration.esm.js";
+import { GLBLoaderExtension as x } from "./glbLoaderExtensions.esm.js";
+import R from "./glowLayerManager.esm.js";
+import { ModelContainerImpl as I } from "./modelContainer.esm.js";
+import { resetSceneModelAnimations as S, animateCameraInScene as k } from "./productAnimations.esm.js";
+import { ProductCamera as O } from "./productCamera.esm.js";
+import { RenderingPipeline as A } from "./renderingPipeline.esm.js";
+import { ProductCameraRig as u } from "./types.esm.js";
+import "../node_modules/@babylonjs/core/Engines/Extensions/engine.views.esm.js";
+import "../node_modules/@babylonjs/core/Meshes/instancedMesh.esm.js";
+import "../node_modules/@babylonjs/core/Materials/Textures/Loaders/ddsTextureLoader.esm.js";
+import "../node_modules/@babylonjs/core/Materials/Textures/Loaders/envTextureLoader.esm.js";
+import "../node_modules/@babylonjs/core/Materials/Textures/Loaders/ktxTextureLoader.esm.js";
+import "../node_modules/@babylonjs/core/Animations/animatable.esm.js";
+import "../node_modules/@babylonjs/core/Misc/screenshotTools.esm.js";
+import "../node_modules/@babylonjs/core/Rendering/boundingBoxRenderer.esm.js";
+M.RegisterExtension("glbPostProcessor", function(o) {
+  return new x(o);
+});
+L.OnPluginActivatedObservable.add((o) => {
+  if (o.name === "gltf") {
+    const e = o;
+    e.transparencyAsCoverage = !0;
+  }
+});
+const c = "initialScene";
+class $e {
+  constructor(e) {
+    this.loadProgress = /* @__PURE__ */ new Map([
+      [c, 0]
+    ]), this.focusLostNotified = !1, this.loadObservable = new m(), this.focusLostObservable = new m(), this.initializedCallbacks = [], this.isInitialized = !1, this.modelLoadEventCallbacks = [], this.modelContainers = /* @__PURE__ */ new Map(), this.plugins = [], this.configuration = new z(e);
+    const t = (() => {
+      if (!(e != null && e.noRender))
+        return this.configuration.createCanvas();
+    })(), r = "1.5.6";
+    P.Configuration = {
+      decoder: {
+        wasmUrl: `https://www.gstatic.com/draco/versioned/decoders/${r}/draco_wasm_wrapper_gltf.js`,
+        wasmBinaryUrl: `https://www.gstatic.com/draco/versioned/decoders/${r}/draco_decoder_gltf.wasm`,
+        fallbackUrl: `https://www.gstatic.com/draco/versioned/decoders/${r}/draco_decoder_gltf.js`
+      }
+    }, t && (t.getContext("webgl2") || t.getContext("webgl"));
+    const s = console.log;
+    console.log = () => {
+    };
+    const a = t ? new v(t, !0, {
+      adaptToDeviceRatio: !0,
+      limitDeviceRatio: 2,
+      premultipliedAlpha: !1,
+      preserveDrawingBuffer: !!(e != null && e.backgroundImage),
+      audioEngine: !1,
+      stencil: this.configuration.highlights.enabled,
+      forceSRGBBufferSupportState: !0
+    }) : new C();
+    console.log = s, a.hideLoadingUI(), window.addEventListener("resize", this.fireResizeEvent.bind(this)), this.engine = a, this.scene = new E(a), this.camera = O.create(this.scene, this.configuration), this.renderingPipeline = new A(
+      this.scene,
+      !1,
+      this.camera
+    ), this.scene.imageProcessingConfiguration.exposure = this.configuration.lighting.exposure, this.scene.imageProcessingConfiguration.contrast = this.configuration.lighting.contrast, this.glowLayerManager = new R(
+      this.scene,
+      this.configuration.emissiveGlowIntensity
+    );
+  }
+  getEngineContext() {
+    return {
+      engine: this.engine,
+      scene: this.scene,
+      camera: this.camera
+    };
+  }
+  registerFocusLostListener(e) {
+    this.focusLostObservable.add(e);
+  }
+  unregisterFocusLostListener(e) {
+    this.focusLostObservable.removeCallback(e);
+  }
+  registerLoadProgressListener(e) {
+    this.loadObservable.add(e), e(this.getLoadListenerEvent());
+  }
+  unregisterLoadProgressListener(e) {
+    this.loadObservable.removeCallback(e);
+  }
+  registerInitializedListener(e) {
+    this.isInitialized || !this.isInitialized && this.initializedCallbacks.push(e);
+  }
+  unregisterInitializedListener(e) {
+    if (this.isInitialized)
+      return;
+    const i = this.initializedCallbacks.indexOf(e);
+    i > -1 && this.initializedCallbacks.splice(i, 1);
+  }
+  getIsInitialized() {
+    return this.isInitialized;
+  }
+  registerModelLoadEventListener(e) {
+    this.modelLoadEventCallbacks.push(e);
+  }
+  unregisterModelLoadEventListener(e) {
+    const i = this.modelLoadEventCallbacks.indexOf(e);
+    i > -1 && this.modelLoadEventCallbacks.splice(i, 1);
+  }
+  registerView(e) {
+    const i = e.height, t = e.width;
+    this.engine.registerView(e), e.setAttribute("height", i.toString()), e.setAttribute("width", t.toString()), this.orbitEnabled() || this.setCameraState(u.Pan), this.reattachControls(e);
+  }
+  getNumViewports() {
+    var e;
+    return ((e = this.engine.views) == null ? void 0 : e.length) || 0;
+  }
+  unregisterView(e) {
+    this.engine.unRegisterView(e);
+  }
+  shutdown() {
+    this.plugins.forEach((e) => e.dispose(!0)), this.renderingPipeline.dispose(), this.engine && this.engine.dispose(), window.removeEventListener("resize", this.fireResizeEvent);
+  }
+  getSceneInitializationProgress() {
+    return this.loadProgress.get(c);
+  }
+  async initialize(e) {
+    var t, r;
+    this.scene.clearColor = this.configuration.scene.clearColor, this.scene.environmentTexture = b.CreateFromPrefilteredData(
+      this.configuration.scene.environmentFile,
+      this.scene
+    );
+    let i;
+    return e && (i = await this.loadModel(
+      e,
+      (a) => {
+        this.loadProgress.set(
+          c,
+          a.loaded * 100 / a.total
+        ), this.notifyLoadHandlers();
+      }
+    ).getInitializationPromise()), this.loadProgress.set(c, 100), this.notifyLoadHandlers(), this.scene.activeCamera = this.camera, this.camera.rerunFramingBehavior(void 0, 1), S(this.scene), ((t = this.engine.views) == null ? void 0 : t.length) >= 1 && this.reattachControls(
+      this.engine.views[this.engine.views.length - 1].target
+    ), this.queuedCameraAnimation && (this.executeCameraAnimation(this.queuedCameraAnimation), this.queuedCameraAnimation = void 0), this.isInitialized = !0, await Promise.all(this.initializedCallbacks.map((s) => s())), this.initializedCallbacks = [], (r = this.configuration.options) != null && r.renderingPipelineConfiguration && this.renderingPipeline.setConfiguration(
+      this.configuration.options.renderingPipelineConfiguration
+    ), this.engine.runRenderLoop(() => {
+      this.engine.views && (this.modelContainers.forEach((s) => {
+        s.updateDynamicTextures();
+      }), this.configuration.scene.transparentBackground && this.engine.views.forEach((s) => {
+        const a = this.engine.getRenderingCanvas();
+        s.target.getContext("2d").clearRect(
+          0,
+          0,
+          a.width,
+          a.height
+        );
+      }), this.scene.render(), !this.camera.target.equalsWithEpsilon(this.camera.lastFocus, 0.1) && !this.focusLostNotified && (this.focusLostObservable.notifyObservers(void 0), this.focusLostNotified = !0), this.screenshotPrepareResolve && (this.screenshotPrepareResolve(), this.screenshotPrepareResolve = void 0));
+    }), i;
+  }
+  executeCameraAnimation(e) {
+    if (this.getSceneInitializationProgress() !== 100 || !this.camera || this.scene.activeCamera !== this.camera) {
+      this.queuedCameraAnimation = e;
+      return;
+    }
+    k(
+      this.scene,
+      this.scene.activeCamera,
+      e
+    );
+  }
+  getCameraPose() {
+    if (this.scene && this.camera)
+      return {
+        lonDeg: Math.round(this.camera.alpha * 180 / Math.PI),
+        latDeg: Math.round(this.camera.beta * 180 / Math.PI),
+        radius: Math.round((this.camera.radius + Number.EPSILON) * 1e4) / 1e4,
+        target: {
+          x: this.camera.target.x,
+          y: this.camera.target.y,
+          z: this.camera.target.z
+        }
+      };
+  }
+  setCameraPose(e) {
+    this.scene && this.camera && (this.camera.target = new l(
+      e.target.x,
+      e.target.y,
+      e.target.z
+    ), this.camera.radius = e.radius, this.camera.alpha = e.latDeg, this.camera.beta = e.lonDeg);
+  }
+  setCameraState(e) {
+    var i, t;
+    if (!((i = this.engine) != null && i.views) || !((t = this.engine) != null && t.views[0]))
+      throw new Error(
+        "No views attached, camera state requires a view to attach controls onto."
+      );
+    e === u.Orbit ? this.reattachControls(this.engine.views[0].target, 2) : this.reattachControls(this.engine.views[0].target, 0);
+  }
+  animateToLastCameraFocus() {
+    return new Promise((e) => {
+      const i = this.configuration;
+      this.camera.rerunFramingBehavior(() => {
+        this.focusLostNotified = !1, i.camera.limits.min.radius && (this.camera.lowerRadiusLimit = i.camera.limits.min.radius), i.camera.limits.max.radius && (this.camera.upperRadiusLimit = i.camera.limits.max.radius), e();
+      });
+    });
+  }
+  setAutoRotation(e) {
+    !this.configuration.camera.autoRotation.enabled || !this.camera || (e ? this.camera.enableAutoRotationBehavior(
+      this.configuration.camera.autoRotation.idleTimeMs
+    ) : this.camera.disableAutoRotationBehavior());
+  }
+  getCurrentConfiguration() {
+    return this.configuration.options;
+  }
+  async renderSceneScreenshot(e, i) {
+    if (!this.camera)
+      throw new Error("Missing product camera, cannot render screenshot!");
+    const t = new p(
+      "screenshotCamera",
+      0,
+      0,
+      0,
+      l.Zero(),
+      this.scene
+    );
+    try {
+      const r = i.latDeg * Math.PI / 180, s = i.lonDeg * Math.PI / 180;
+      t.target = i.target ? new l(i.target.x, i.target.y, i.target.z) : l.Zero(), t.alpha = s, t.beta = r, t.radius = i.radius || this.camera.radius, t.minZ = 0.01, this.scene.render();
+      const a = await y.CreateScreenshotUsingRenderTargetAsync(
+        this.engine,
+        t,
+        e,
+        "image/png",
+        2,
+        !0
+      );
+      return t.dispose(), a;
+    } catch {
+      throw t.isDisposed() || t.dispose(), new Error("Failed to render screenshot");
+    }
+  }
+  orbitEnabled() {
+    const e = this.configuration;
+    if (!e)
+      return !0;
+    const i = e.camera.limits.min.alpha, t = e.camera.limits.max.alpha, r = e.camera.limits.min.beta, s = e.camera.limits.max.beta;
+    if (i === void 0 || t === void 0 || r === void 0 || s === void 0)
+      return !0;
+    const a = [i, t], n = [r, s], h = a.every((g) => g === i), f = n.every((g) => g === r);
+    return !h && !f;
+  }
+  fireResizeEvent() {
+    this.getNumViewports() > 0 && this.engine.resize();
+  }
+  setHighlights(e, i) {
+    var r;
+    e.length === 0 && ((r = this.highlightLayer) == null || r.dispose(), this.highlightLayer = void 0), this.highlightLayer || (this.highlightLayer = new w("highlights", this.scene, {
+      isStroke: !0,
+      blurVerticalSize: 0.85,
+      blurHorizontalSize: 0.85
+    }), this.highlightLayer.innerGlow = !0, this.highlightLayer.outerGlow = !1), this.highlightLayer.removeAllMeshes();
+    const t = i ? new d(i[0], i[1], i[2]).toLinearSpace() : void 0;
+    e.forEach((s) => {
+      const a = this.scene.materials.find(
+        (n) => n.name === s.name && n.id === s.id
+      );
+      a && a.getBindedMeshes().forEach(
+        (n) => {
+          var h;
+          return (h = this.highlightLayer) == null ? void 0 : h.addMesh(
+            n,
+            t || d.FromHexString("#fcba03")
+          );
+        }
+      );
+    });
+  }
+  setRenderingPipelineConfiguration(e) {
+    this.renderingPipeline && this.renderingPipeline.setConfiguration(e);
+  }
+  loadModel(e, i) {
+    const t = new I({
+      enablePicking: this.configuration.highlights.enabled,
+      modelDetails: e,
+      scene: this.scene,
+      previewService: this,
+      progressHandler: i
+    });
+    return t.registerMaterialVariantListener(
+      (r) => this.handleMaterialProgressCallback(
+        r.remainingCount,
+        r.totalCount,
+        r.taskName
+      )
+    ), t.registerModelVariantListener(
+      (r) => this.handleModelProgressCallback(r, r.key)
+    ), this.configuration.highlights.enabled && (t.registerMaterialSelectedCallback((r) => {
+      this.setHighlights([r]);
+    }), t.registerMaterialDeselectedCallback(() => {
+      this.setHighlights([]);
+    })), this.modelContainers.set(t.getId(), t), this.triggerModelLoadEvent({
+      eventType: "load",
+      modelContainer: t
+    }), t;
+  }
+  getAllModels() {
+    return Array.from(this.modelContainers.values());
+  }
+  getModelById(e) {
+    return this.modelContainers.get(e);
+  }
+  registerPlugin(e) {
+    this.plugins.push(e), e.initialize(this, {
+      camera: this.camera,
+      engine: this.engine,
+      scene: this.scene
+    });
+  }
+  unregisterPlugin(e) {
+    const i = this.plugins.indexOf(e);
+    i > -1 && this.plugins.splice(i, 1).forEach((r) => r.dispose(!1));
+  }
+  getGlowLayerManager() {
+    return this.glowLayerManager;
+  }
+  modelUnloaded(e) {
+    this.modelContainers.delete(e.getId()), this.triggerModelLoadEvent({
+      eventType: "unload",
+      modelContainer: e
+    });
+  }
+  triggerModelLoadEvent(e) {
+    this.modelLoadEventCallbacks.forEach((i) => i(e));
+  }
+  handleMaterialProgressCallback(e, i, t) {
+    this.loadProgress.set(`key_${t}`, e / i * 100), this.notifyLoadHandlers();
+  }
+  handleModelProgressCallback(e, i) {
+    this.loadProgress.set(i, e.loaded * 100 / e.total), this.notifyLoadHandlers();
+  }
+  /**
+   * Given a valid canvas element, will remove any existing input controls
+   * and re-attach them to the given canvas. The pan mouse button can be set
+   * to either 0 (left mouse) or 2 (right mouse).
+   */
+  reattachControls(e, i = 2) {
+    if (this.scene.detachControl(), this.engine.inputElement = e, this.camera) {
+      this.camera.attachControl(!0, !1, i);
+      const t = this.camera.inputs.attached.pointers;
+      t.multiTouchPanning = !1;
+    }
+    this.scene.attachControl(!0, !0, !0);
+  }
+  /**
+   * Computes a load listener event based on current state of scene.
+   */
+  getLoadListenerEvent() {
+    const e = Array.from(this.loadProgress.values()).filter(
+      (r) => r < 100
+    ), t = e.reduce((r, s) => r + s, 0) / e.length || 0;
+    return {
+      loadValue: e.length === 0 ? 100 : t,
+      sceneInitialized: this.getSceneInitializationProgress() === 100
+    };
+  }
+  /**
+   * Computes the average loading time across all loading events and notifies
+   * listeners of the current load progress.
+   */
+  notifyLoadHandlers() {
+    this.loadObservable.notifyObservers(this.getLoadListenerEvent());
+  }
+}
+export {
+  $e as SpiffCommerce3DPreviewService
+};

package/dist/lib/dynamicTexture.esm.js

@@ -0,0 +1,51 @@
+import { Engine as d } from "../node_modules/@babylonjs/core/Engines/engine.esm.js";
+import { PBRMaterial as m } from "../node_modules/@babylonjs/core/Materials/PBR/pbrMaterial.esm.js";
+import { DynamicTexture as T } from "../node_modules/@babylonjs/core/Materials/Textures/dynamicTexture.esm.js";
+import { Texture as g } from "../node_modules/@babylonjs/core/Materials/Textures/texture.esm.js";
+import { RenderingConfiguration as x } from "./renderConstants.esm.js";
+function I(o, t, r, e, n = "") {
+  r.forEach((a) => {
+    const c = a.getID(), p = a.getName(), u = x.getDynamicTextureResolution();
+    o.filter((f) => f.name === n + p).forEach((f) => {
+      const s = e.get(c), l = !1;
+      if (s)
+        w(f, s), s.update(l);
+      else {
+        const i = D(
+          p,
+          t,
+          u.width,
+          u.height
+        );
+        e.set(c, i), a.setStaticContext(
+          i.getContext()
+        ), w(f, i), i.onLoadObservable.addOnce(() => {
+          i.update(l);
+        });
+      }
+    });
+  });
+}
+function D(o, t, r, e) {
+  const n = new T(
+    o,
+    { width: r, height: e },
+    t,
+    x.shouldMipMap(),
+    g.TRILINEAR_SAMPLINGMODE,
+    d.TEXTUREFORMAT_RGBA
+  ), a = n.getContext();
+  return a && (a.fillStyle = "#f5f5f5", a.fillRect(0, 0, r, e), n.update()), n;
+}
+function w(o, t) {
+  if (o instanceof m) {
+    const r = o, e = r.albedoTexture;
+    e ? (t.wrapU = e.wrapU, t.wrapV = e.wrapV) : (t.wrapU = 1, t.wrapV = 1), r.albedoTexture = t;
+  } else {
+    const r = o, e = r.diffuseTexture;
+    e && (t.wrapU = e.wrapU, t.wrapV = e.wrapV), r.diffuseTexture = t;
+  }
+}
+export {
+  I as attachDynamicTextures
+};