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

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_audio_emitter.esm.js

@@ -1,149 +0,0 @@
-import { Vector3 as _ } from "../../../../core/Maths/math.vector.esm.js";
-import { Tools as f } from "../../../../core/Misc/tools.esm.js";
-import { AnimationEvent as p } from "../../../../core/Animations/animationEvent.esm.js";
-import { Sound as y } from "../../../../core/Audio/sound.esm.js";
-import { WeightedSound as g } from "../../../../core/Audio/weightedsound.esm.js";
-import { GLTFLoader as h, ArrayItem as d } from "../glTFLoader.esm.js";
-const m = "MSFT_audio_emitter";
-class b {
-  /**
-   * @internal
-   */
-  constructor(s) {
-    this.name = m, this._loader = s, this.enabled = this._loader.isExtensionUsed(m);
-  }
-  /** @internal */
-  dispose() {
-    this._loader = null, this._clips = null, this._emitters = null;
-  }
-  /** @internal */
-  onLoading() {
-    const s = this._loader.gltf.extensions;
-    if (s && s[this.name]) {
-      const e = s[this.name];
-      this._clips = e.clips, this._emitters = e.emitters, d.Assign(this._clips), d.Assign(this._emitters);
-    }
-  }
-  /**
-   * @internal
-   */
-  loadSceneAsync(s, e) {
-    return h.LoadExtensionAsync(s, e, this.name, (o, t) => {
-      const r = new Array();
-      r.push(this._loader.loadSceneAsync(s, e));
-      for (const a of t.emitters) {
-        const n = d.Get(`${o}/emitters`, this._emitters, a);
-        if (n.refDistance != null || n.maxDistance != null || n.rolloffFactor != null || n.distanceModel != null || n.innerAngle != null || n.outerAngle != null)
-          throw new Error(`${o}: Direction or Distance properties are not allowed on emitters attached to a scene`);
-        r.push(this._loadEmitterAsync(`${o}/emitters/${n.index}`, n));
-      }
-      return Promise.all(r).then(() => {
-      });
-    });
-  }
-  /**
-   * @internal
-   */
-  loadNodeAsync(s, e, o) {
-    return h.LoadExtensionAsync(s, e, this.name, (t, r) => {
-      const a = new Array();
-      return this._loader.loadNodeAsync(t, e, (n) => {
-        for (const l of r.emitters) {
-          const i = d.Get(`${t}/emitters`, this._emitters, l);
-          a.push(this._loadEmitterAsync(`${t}/emitters/${i.index}`, i).then(() => {
-            for (const c of i._babylonSounds)
-              c.attachToMesh(n), (i.innerAngle != null || i.outerAngle != null) && (c.setLocalDirectionToMesh(_.Forward()), c.setDirectionalCone(2 * f.ToDegrees(i.innerAngle == null ? Math.PI : i.innerAngle), 2 * f.ToDegrees(i.outerAngle == null ? Math.PI : i.outerAngle), 0));
-          }));
-        }
-        o(n);
-      }).then((n) => Promise.all(a).then(() => n));
-    });
-  }
-  /**
-   * @internal
-   */
-  loadAnimationAsync(s, e) {
-    return h.LoadExtensionAsync(s, e, this.name, (o, t) => this._loader.loadAnimationAsync(s, e).then((r) => {
-      const a = new Array();
-      d.Assign(t.events);
-      for (const n of t.events)
-        a.push(this._loadAnimationEventAsync(`${o}/events/${n.index}`, s, e, n, r));
-      return Promise.all(a).then(() => r);
-    }));
-  }
-  _loadClipAsync(s, e) {
-    if (e._objectURL)
-      return e._objectURL;
-    let o;
-    if (e.uri)
-      o = this._loader.loadUriAsync(s, e, e.uri);
-    else {
-      const t = d.Get(`${s}/bufferView`, this._loader.gltf.bufferViews, e.bufferView);
-      o = this._loader.loadBufferViewAsync(`/bufferViews/${t.index}`, t);
-    }
-    return e._objectURL = o.then((t) => URL.createObjectURL(new Blob([t], { type: e.mimeType }))), e._objectURL;
-  }
-  _loadEmitterAsync(s, e) {
-    if (e._babylonSounds = e._babylonSounds || [], !e._babylonData) {
-      const o = new Array(), t = e.name || `emitter${e.index}`, r = {
-        loop: !1,
-        autoplay: !1,
-        volume: e.volume == null ? 1 : e.volume
-      };
-      for (let n = 0; n < e.clips.length; n++) {
-        const l = `/extensions/${this.name}/clips`, i = d.Get(l, this._clips, e.clips[n].clip);
-        o.push(this._loadClipAsync(`${l}/${e.clips[n].clip}`, i).then((c) => {
-          const u = e._babylonSounds[n] = new y(t, c, this._loader.babylonScene, null, r);
-          u.refDistance = e.refDistance || 1, u.maxDistance = e.maxDistance || 256, u.rolloffFactor = e.rolloffFactor || 1, u.distanceModel = e.distanceModel || "exponential";
-        }));
-      }
-      const a = Promise.all(o).then(() => {
-        const n = e.clips.map((i) => i.weight || 1), l = new g(e.loop || !1, e._babylonSounds, n);
-        e.innerAngle && (l.directionalConeInnerAngle = 2 * f.ToDegrees(e.innerAngle)), e.outerAngle && (l.directionalConeOuterAngle = 2 * f.ToDegrees(e.outerAngle)), e.volume && (l.volume = e.volume), e._babylonData.sound = l;
-      });
-      e._babylonData = {
-        loaded: a
-      };
-    }
-    return e._babylonData.loaded;
-  }
-  _getEventAction(s, e, o, t, r) {
-    switch (o) {
-      case "play":
-        return (a) => {
-          const n = (r || 0) + (a - t);
-          e.play(n);
-        };
-      case "stop":
-        return () => {
-          e.stop();
-        };
-      case "pause":
-        return () => {
-          e.pause();
-        };
-      default:
-        throw new Error(`${s}: Unsupported action ${o}`);
-    }
-  }
-  _loadAnimationEventAsync(s, e, o, t, r) {
-    if (r.targetedAnimations.length == 0)
-      return Promise.resolve();
-    const a = r.targetedAnimations[0], n = t.emitter, l = d.Get(`/extensions/${this.name}/emitters`, this._emitters, n);
-    return this._loadEmitterAsync(s, l).then(() => {
-      const i = l._babylonData.sound;
-      if (i) {
-        const c = new p(t.time, this._getEventAction(s, i, t.action, t.time, t.startOffset));
-        a.animation.addEvent(c), r.onAnimationGroupEndObservable.add(() => {
-          i.stop();
-        }), r.onAnimationGroupPauseObservable.add(() => {
-          i.pause();
-        });
-      }
-    });
-  }
-}
-h.RegisterExtension(m, (A) => new b(A));
-export {
-  b as MSFT_audio_emitter
-};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_lod.esm.js

@@ -1,170 +0,0 @@
-import { Observable as c } from "../../../../core/Misc/observable.esm.js";
-import { Deferred as O } from "../../../../core/Misc/deferred.esm.js";
-import { GLTFLoader as D, ArrayItem as g } from "../glTFLoader.esm.js";
-const m = "MSFT_lod";
-class b {
-  /**
-   * @internal
-   */
-  constructor(e) {
-    this.name = m, this.order = 100, this.maxLODsToLoad = 10, this.onNodeLODsLoadedObservable = new c(), this.onMaterialLODsLoadedObservable = new c(), this._bufferLODs = new Array(), this._nodeIndexLOD = null, this._nodeSignalLODs = new Array(), this._nodePromiseLODs = new Array(), this._nodeBufferLODs = new Array(), this._materialIndexLOD = null, this._materialSignalLODs = new Array(), this._materialPromiseLODs = new Array(), this._materialBufferLODs = new Array(), this._loader = e, this.enabled = this._loader.isExtensionUsed(m);
-  }
-  /** @internal */
-  dispose() {
-    this._loader = null, this._nodeIndexLOD = null, this._nodeSignalLODs.length = 0, this._nodePromiseLODs.length = 0, this._nodeBufferLODs.length = 0, this._materialIndexLOD = null, this._materialSignalLODs.length = 0, this._materialPromiseLODs.length = 0, this._materialBufferLODs.length = 0, this.onMaterialLODsLoadedObservable.clear(), this.onNodeLODsLoadedObservable.clear();
-  }
-  /** @internal */
-  onReady() {
-    for (let e = 0; e < this._nodePromiseLODs.length; e++) {
-      const r = Promise.all(this._nodePromiseLODs[e]).then(() => {
-        e !== 0 && (this._loader.endPerformanceCounter(`Node LOD ${e}`), this._loader.log(`Loaded node LOD ${e}`)), this.onNodeLODsLoadedObservable.notifyObservers(e), e !== this._nodePromiseLODs.length - 1 && (this._loader.startPerformanceCounter(`Node LOD ${e + 1}`), this._loadBufferLOD(this._nodeBufferLODs, e + 1), this._nodeSignalLODs[e] && this._nodeSignalLODs[e].resolve());
-      });
-      this._loader._completePromises.push(r);
-    }
-    for (let e = 0; e < this._materialPromiseLODs.length; e++) {
-      const r = Promise.all(this._materialPromiseLODs[e]).then(() => {
-        e !== 0 && (this._loader.endPerformanceCounter(`Material LOD ${e}`), this._loader.log(`Loaded material LOD ${e}`)), this.onMaterialLODsLoadedObservable.notifyObservers(e), e !== this._materialPromiseLODs.length - 1 && (this._loader.startPerformanceCounter(`Material LOD ${e + 1}`), this._loadBufferLOD(this._materialBufferLODs, e + 1), this._materialSignalLODs[e] && this._materialSignalLODs[e].resolve());
-      });
-      this._loader._completePromises.push(r);
-    }
-  }
-  /**
-   * @internal
-   */
-  loadSceneAsync(e, r) {
-    const s = this._loader.loadSceneAsync(e, r);
-    return this._loadBufferLOD(this._bufferLODs, 0), s;
-  }
-  /**
-   * @internal
-   */
-  loadNodeAsync(e, r, s) {
-    return D.LoadExtensionAsync(e, r, this.name, (t, o) => {
-      let a;
-      const d = this._getLODs(t, r, this._loader.gltf.nodes, o.ids);
-      this._loader.logOpen(`${t}`);
-      for (let n = 0; n < d.length; n++) {
-        const l = d[n];
-        n !== 0 && (this._nodeIndexLOD = n, this._nodeSignalLODs[n] = this._nodeSignalLODs[n] || new O());
-        const i = (_) => {
-          s(_), _.setEnabled(!1);
-        }, h = this._loader.loadNodeAsync(`/nodes/${l.index}`, l, i).then((_) => {
-          if (n !== 0) {
-            const L = d[n - 1];
-            L._babylonTransformNode && (this._disposeTransformNode(L._babylonTransformNode), delete L._babylonTransformNode);
-          }
-          return _.setEnabled(!0), _;
-        });
-        this._nodePromiseLODs[n] = this._nodePromiseLODs[n] || [], n === 0 ? a = h : (this._nodeIndexLOD = null, this._nodePromiseLODs[n].push(h));
-      }
-      return this._loader.logClose(), a;
-    });
-  }
-  /**
-   * @internal
-   */
-  _loadMaterialAsync(e, r, s, t, o) {
-    return this._nodeIndexLOD ? null : D.LoadExtensionAsync(e, r, this.name, (a, d) => {
-      let n;
-      const l = this._getLODs(a, r, this._loader.gltf.materials, d.ids);
-      this._loader.logOpen(`${a}`);
-      for (let i = 0; i < l.length; i++) {
-        const h = l[i];
-        i !== 0 && (this._materialIndexLOD = i);
-        const _ = this._loader._loadMaterialAsync(`/materials/${h.index}`, h, s, t, (L) => {
-          i === 0 && o(L);
-        }).then((L) => {
-          if (i !== 0) {
-            o(L);
-            const f = l[i - 1]._data;
-            f[t] && (this._disposeMaterials([f[t].babylonMaterial]), delete f[t]);
-          }
-          return L;
-        });
-        this._materialPromiseLODs[i] = this._materialPromiseLODs[i] || [], i === 0 ? n = _ : (this._materialIndexLOD = null, this._materialPromiseLODs[i].push(_));
-      }
-      return this._loader.logClose(), n;
-    });
-  }
-  /**
-   * @internal
-   */
-  _loadUriAsync(e, r, s) {
-    if (this._nodeIndexLOD !== null) {
-      this._loader.log("deferred");
-      const t = this._nodeIndexLOD - 1;
-      return this._nodeSignalLODs[t] = this._nodeSignalLODs[t] || new O(), this._nodeSignalLODs[this._nodeIndexLOD - 1].promise.then(() => this._loader.loadUriAsync(e, r, s));
-    } else if (this._materialIndexLOD !== null) {
-      this._loader.log("deferred");
-      const t = this._materialIndexLOD - 1;
-      return this._materialSignalLODs[t] = this._materialSignalLODs[t] || new O(), this._materialSignalLODs[t].promise.then(() => this._loader.loadUriAsync(e, r, s));
-    }
-    return null;
-  }
-  /**
-   * @internal
-   */
-  loadBufferAsync(e, r, s, t) {
-    if (this._loader.parent.useRangeRequests && !r.uri) {
-      if (!this._loader.bin)
-        throw new Error(`${e}: Uri is missing or the binary glTF is missing its binary chunk`);
-      const o = (a, d) => {
-        const n = s, l = n + t - 1;
-        let i = a[d];
-        return i ? (i.start = Math.min(i.start, n), i.end = Math.max(i.end, l)) : (i = { start: n, end: l, loaded: new O() }, a[d] = i), i.loaded.promise.then((h) => new Uint8Array(h.buffer, h.byteOffset + s - i.start, t));
-      };
-      return this._loader.log("deferred"), this._nodeIndexLOD !== null ? o(this._nodeBufferLODs, this._nodeIndexLOD) : this._materialIndexLOD !== null ? o(this._materialBufferLODs, this._materialIndexLOD) : o(this._bufferLODs, 0);
-    }
-    return null;
-  }
-  _loadBufferLOD(e, r) {
-    const s = e[r];
-    s && (this._loader.log(`Loading buffer range [${s.start}-${s.end}]`), this._loader.bin.readAsync(s.start, s.end - s.start + 1).then((t) => {
-      s.loaded.resolve(t);
-    }, (t) => {
-      s.loaded.reject(t);
-    }));
-  }
-  /**
-   * Gets an array of LOD properties from lowest to highest.
-   * @param context
-   * @param property
-   * @param array
-   * @param ids
-   */
-  _getLODs(e, r, s, t) {
-    if (this.maxLODsToLoad <= 0)
-      throw new Error("maxLODsToLoad must be greater than zero");
-    const o = new Array();
-    for (let a = t.length - 1; a >= 0; a--)
-      if (o.push(g.Get(`${e}/ids/${t[a]}`, s, t[a])), o.length === this.maxLODsToLoad)
-        return o;
-    return o.push(r), o;
-  }
-  _disposeTransformNode(e) {
-    const r = new Array(), s = e.material;
-    s && r.push(s);
-    for (const o of e.getChildMeshes())
-      o.material && r.push(o.material);
-    e.dispose();
-    const t = r.filter((o) => this._loader.babylonScene.meshes.every((a) => a.material != o));
-    this._disposeMaterials(t);
-  }
-  _disposeMaterials(e) {
-    const r = {};
-    for (const s of e) {
-      for (const t of s.getActiveTextures())
-        r[t.uniqueId] = t;
-      s.dispose();
-    }
-    for (const s in r)
-      for (const t of this._loader.babylonScene.materials)
-        t.hasTexture(r[s]) && delete r[s];
-    for (const s in r)
-      r[s].dispose();
-  }
-}
-D.RegisterExtension(m, (u) => new b(u));
-export {
-  b as MSFT_lod
-};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_minecraftMesh.esm.js

@@ -1,29 +0,0 @@
-import { PBRMaterial as h } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
-import { GLTFLoader as n } from "../glTFLoader.esm.js";
-const t = "MSFT_minecraftMesh";
-class p {
-  /** @internal */
-  constructor(r) {
-    this.name = t, this._loader = r, this.enabled = this._loader.isExtensionUsed(t);
-  }
-  /** @internal */
-  dispose() {
-    this._loader = null;
-  }
-  /** @internal */
-  loadMaterialPropertiesAsync(r, i, e) {
-    return n.LoadExtraAsync(r, i, this.name, (o, d) => {
-      if (d) {
-        if (!(e instanceof h))
-          throw new Error(`${o}: Material type not supported`);
-        const c = this._loader.loadMaterialPropertiesAsync(r, i, e);
-        return e.needAlphaBlending() && (e.forceDepthWrite = !0, e.separateCullingPass = !0), e.backFaceCulling = e.forceDepthWrite, e.twoSidedLighting = !0, c;
-      }
-      return null;
-    });
-  }
-}
-n.RegisterExtension(t, (s) => new p(s));
-export {
-  p as MSFT_minecraftMesh
-};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/MSFT_sRGBFactors.esm.js

@@ -1,29 +0,0 @@
-import { PBRMaterial as p } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
-import { GLTFLoader as n } from "../glTFLoader.esm.js";
-const o = "MSFT_sRGBFactors";
-class u {
-  /** @internal */
-  constructor(r) {
-    this.name = o, this._loader = r, this.enabled = this._loader.isExtensionUsed(o);
-  }
-  /** @internal */
-  dispose() {
-    this._loader = null;
-  }
-  /** @internal */
-  loadMaterialPropertiesAsync(r, t, e) {
-    return n.LoadExtraAsync(r, t, this.name, (c, d) => {
-      if (d) {
-        if (!(e instanceof p))
-          throw new Error(`${c}: Material type not supported`);
-        const f = this._loader.loadMaterialPropertiesAsync(r, t, e), i = e.getScene().getEngine().useExactSrgbConversions;
-        return e.albedoTexture || e.albedoColor.toLinearSpaceToRef(e.albedoColor, i), e.reflectivityTexture || e.reflectivityColor.toLinearSpaceToRef(e.reflectivityColor, i), f;
-      }
-      return null;
-    });
-  }
-}
-n.RegisterExtension(o, (s) => new u(s));
-export {
-  u as MSFT_sRGBFactors
-};