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

package/dist/node_modules/@babylonjs/core/Animations/animationEvent.esm.js

@@ -0,0 +1,18 @@
+class t {
+  /**
+   * Initializes the animation event
+   * @param frame The frame for which the event is triggered
+   * @param action The event to perform when triggered
+   * @param onlyOnce Specifies if the event should be triggered only once
+   */
+  constructor(s, n, e) {
+    this.frame = s, this.action = n, this.onlyOnce = e, this.isDone = !1;
+  }
+  /** @internal */
+  _clone() {
+    return new t(this.frame, this.action, this.onlyOnce);
+  }
+}
+export {
+  t as AnimationEvent
+};

package/dist/node_modules/@babylonjs/core/Animations/animationGroup.esm.js

@@ -0,0 +1,470 @@
+import { Animation as g } from "./animation.esm.js";
+import { Observable as h } from "../Misc/observable.esm.js";
+import { EngineStore as _ } from "../Engines/engineStore.esm.js";
+import { Tags as l } from "../Misc/tags.esm.js";
+class f {
+  /**
+   * Returns the string "TargetedAnimation"
+   * @returns "TargetedAnimation"
+   */
+  getClassName() {
+    return "TargetedAnimation";
+  }
+  /**
+   * Serialize the object
+   * @returns the JSON object representing the current entity
+   */
+  serialize() {
+    const t = {};
+    return t.animation = this.animation.serialize(), t.targetId = this.target.id, t;
+  }
+}
+class d {
+  /**
+   * Gets the first frame
+   */
+  get from() {
+    return this._from;
+  }
+  /**
+   * Gets the last frame
+   */
+  get to() {
+    return this._to;
+  }
+  /**
+   * Define if the animations are started
+   */
+  get isStarted() {
+    return this._isStarted;
+  }
+  /**
+   * Gets a value indicating that the current group is playing
+   */
+  get isPlaying() {
+    return this._isStarted && !this._isPaused;
+  }
+  /**
+   * Gets or sets the speed ratio to use for all animations
+   */
+  get speedRatio() {
+    return this._speedRatio;
+  }
+  /**
+   * Gets or sets the speed ratio to use for all animations
+   */
+  set speedRatio(t) {
+    if (this._speedRatio !== t) {
+      this._speedRatio = t;
+      for (let i = 0; i < this._animatables.length; i++) {
+        const e = this._animatables[i];
+        e.speedRatio = this._speedRatio;
+      }
+    }
+  }
+  /**
+   * Gets or sets if all animations should loop or not
+   */
+  get loopAnimation() {
+    return this._loopAnimation;
+  }
+  set loopAnimation(t) {
+    if (this._loopAnimation !== t) {
+      this._loopAnimation = t;
+      for (let i = 0; i < this._animatables.length; i++) {
+        const e = this._animatables[i];
+        e.loopAnimation = this._loopAnimation;
+      }
+    }
+  }
+  /**
+   * Gets or sets if all animations should be evaluated additively
+   */
+  get isAdditive() {
+    return this._isAdditive;
+  }
+  set isAdditive(t) {
+    if (this._isAdditive !== t) {
+      this._isAdditive = t;
+      for (let i = 0; i < this._animatables.length; i++) {
+        const e = this._animatables[i];
+        e.isAdditive = this._isAdditive;
+      }
+    }
+  }
+  /**
+   * Gets or sets the weight to apply to all animations of the group
+   */
+  get weight() {
+    return this._weight;
+  }
+  set weight(t) {
+    this._weight !== t && (this._weight = t, this.setWeightForAllAnimatables(this._weight));
+  }
+  /**
+   * Gets the targeted animations for this animation group
+   */
+  get targetedAnimations() {
+    return this._targetedAnimations;
+  }
+  /**
+   * returning the list of animatables controlled by this animation group.
+   */
+  get animatables() {
+    return this._animatables;
+  }
+  /**
+   * Gets the list of target animations
+   */
+  get children() {
+    return this._targetedAnimations;
+  }
+  /**
+   * Gets or sets the order of play of the animation group (default: 0)
+   */
+  get playOrder() {
+    return this._playOrder;
+  }
+  set playOrder(t) {
+    if (this._playOrder !== t && (this._playOrder = t, this._animatables.length > 0)) {
+      for (let i = 0; i < this._animatables.length; i++)
+        this._animatables[i].playOrder = this._playOrder;
+      this._scene.sortActiveAnimatables();
+    }
+  }
+  /**
+   * Allows the animations of the animation group to blend with current running animations
+   * Note: this method should be called after all targeted animations have been added to the group
+   * @param blendingSpeed defines the blending speed to use
+   */
+  enableBlending(t) {
+    for (let i = 0; i < this._targetedAnimations.length; ++i)
+      this._targetedAnimations[i].animation.enableBlending = !0, this._targetedAnimations[i].animation.blendingSpeed = t;
+  }
+  /**
+   * Disable animation blending
+   */
+  disableBlending() {
+    for (let t = 0; t < this._targetedAnimations.length; ++t)
+      this._targetedAnimations[t].animation.enableBlending = !1;
+  }
+  /**
+   * Merge the array of animation groups into a new animation group
+   * @param animationGroups List of animation groups to merge
+   * @param disposeSource If true, animation groups will be disposed after being merged (default: true)
+   * @param normalize If true, animation groups will be normalized before being merged, so that all animations have the same "from" and "to" frame (default: false)
+   * @param weight Weight for the new animation group. If not provided, it will inherit the weight from the first animation group of the array
+   * @returns The new animation group or null if no animation groups were passed
+   */
+  static MergeAnimationGroups(t, i = !0, e = !1, n) {
+    if (t.length === 0)
+      return null;
+    n = n ?? t[0].weight;
+    let s = Number.MAX_VALUE, o = Number.MIN_VALUE;
+    if (e)
+      for (const a of t)
+        a.from < s && (s = a.from), a.to > o && (o = a.to);
+    const r = new d(t[0].name + "_merged", t[0]._scene, n);
+    for (const a of t) {
+      e && a.normalize(s, o);
+      for (const m of a.targetedAnimations)
+        r.addTargetedAnimation(m.animation, m.target);
+      i && a.dispose();
+    }
+    return r;
+  }
+  /**
+   * Instantiates a new Animation Group.
+   * This helps managing several animations at once.
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/groupAnimations
+   * @param name Defines the name of the group
+   * @param scene Defines the scene the group belongs to
+   * @param weight Defines the weight to use for animations in the group (-1.0 by default, meaning "no weight")
+   * @param playOrder Defines the order of play of the animation group (default is 0)
+   */
+  constructor(t, i = null, e = -1, n = 0) {
+    this.name = t, this._targetedAnimations = new Array(), this._animatables = new Array(), this._from = Number.MAX_VALUE, this._to = -Number.MAX_VALUE, this._speedRatio = 1, this._loopAnimation = !1, this._isAdditive = !1, this._weight = -1, this._playOrder = 0, this._parentContainer = null, this.onAnimationEndObservable = new h(), this.onAnimationLoopObservable = new h(), this.onAnimationGroupLoopObservable = new h(), this.onAnimationGroupEndObservable = new h(), this.onAnimationGroupPauseObservable = new h(), this.onAnimationGroupPlayObservable = new h(), this.metadata = null, this._animationLoopFlags = [], this._scene = i || _.LastCreatedScene, this._weight = e, this._playOrder = n, this.uniqueId = this._scene.getUniqueId(), this._scene.addAnimationGroup(this);
+  }
+  /**
+   * Add an animation (with its target) in the group
+   * @param animation defines the animation we want to add
+   * @param target defines the target of the animation
+   * @returns the TargetedAnimation object
+   */
+  addTargetedAnimation(t, i) {
+    const e = new f();
+    e.animation = t, e.target = i;
+    const n = t.getKeys();
+    return this._from > n[0].frame && (this._from = n[0].frame), this._to < n[n.length - 1].frame && (this._to = n[n.length - 1].frame), this._targetedAnimations.push(e), e;
+  }
+  /**
+   * Remove an animation from the group
+   * @param animation defines the animation we want to remove
+   */
+  removeTargetedAnimation(t) {
+    for (let i = this._targetedAnimations.length - 1; i > -1; i--)
+      this._targetedAnimations[i].animation === t && this._targetedAnimations.splice(i, 1);
+  }
+  /**
+   * This function will normalize every animation in the group to make sure they all go from beginFrame to endFrame
+   * It can add constant keys at begin or end
+   * @param beginFrame defines the new begin frame for all animations or the smallest begin frame of all animations if null (defaults to null)
+   * @param endFrame defines the new end frame for all animations or the largest end frame of all animations if null (defaults to null)
+   * @returns the animation group
+   */
+  normalize(t = null, i = null) {
+    t == null && (t = this._from), i == null && (i = this._to);
+    for (let e = 0; e < this._targetedAnimations.length; e++) {
+      const s = this._targetedAnimations[e].animation.getKeys(), o = s[0], r = s[s.length - 1];
+      if (o.frame > t) {
+        const a = {
+          frame: t,
+          value: o.value,
+          inTangent: o.inTangent,
+          outTangent: o.outTangent,
+          interpolation: o.interpolation
+        };
+        s.splice(0, 0, a);
+      }
+      if (r.frame < i) {
+        const a = {
+          frame: i,
+          value: r.value,
+          inTangent: r.inTangent,
+          outTangent: r.outTangent,
+          interpolation: r.interpolation
+        };
+        s.push(a);
+      }
+    }
+    return this._from = t, this._to = i, this;
+  }
+  _processLoop(t, i, e) {
+    t.onAnimationLoop = () => {
+      this.onAnimationLoopObservable.notifyObservers(i), !this._animationLoopFlags[e] && (this._animationLoopFlags[e] = !0, this._animationLoopCount++, this._animationLoopCount === this._targetedAnimations.length && (this.onAnimationGroupLoopObservable.notifyObservers(this), this._animationLoopCount = 0, this._animationLoopFlags.length = 0));
+    };
+  }
+  /**
+   * Start all animations on given targets
+   * @param loop defines if animations must loop
+   * @param speedRatio defines the ratio to apply to animation speed (1 by default)
+   * @param from defines the from key (optional)
+   * @param to defines the to key (optional)
+   * @param isAdditive defines the additive state for the resulting animatables (optional)
+   * @returns the current animation group
+   */
+  start(t = !1, i = 1, e, n, s) {
+    if (this._isStarted || this._targetedAnimations.length === 0)
+      return this;
+    this._loopAnimation = t, this._animationLoopCount = 0, this._animationLoopFlags.length = 0;
+    for (let o = 0; o < this._targetedAnimations.length; o++) {
+      const r = this._targetedAnimations[o], a = this._scene.beginDirectAnimation(r.target, [r.animation], e !== void 0 ? e : this._from, n !== void 0 ? n : this._to, t, i, void 0, void 0, s !== void 0 ? s : this._isAdditive);
+      a.weight = this._weight, a.playOrder = this._playOrder, a.onAnimationEnd = () => {
+        this.onAnimationEndObservable.notifyObservers(r), this._checkAnimationGroupEnded(a);
+      }, this._processLoop(a, r, o), this._animatables.push(a);
+    }
+    return this._scene.sortActiveAnimatables(), this._speedRatio = i, this._isStarted = !0, this._isPaused = !1, this.onAnimationGroupPlayObservable.notifyObservers(this), this;
+  }
+  /**
+   * Pause all animations
+   * @returns the animation group
+   */
+  pause() {
+    if (!this._isStarted)
+      return this;
+    this._isPaused = !0;
+    for (let t = 0; t < this._animatables.length; t++)
+      this._animatables[t].pause();
+    return this.onAnimationGroupPauseObservable.notifyObservers(this), this;
+  }
+  /**
+   * Play all animations to initial state
+   * This function will start() the animations if they were not started or will restart() them if they were paused
+   * @param loop defines if animations must loop
+   * @returns the animation group
+   */
+  play(t) {
+    return this.isStarted && this._animatables.length === this._targetedAnimations.length ? (t !== void 0 && (this.loopAnimation = t), this.restart()) : (this.stop(), this.start(t, this._speedRatio)), this._isPaused = !1, this;
+  }
+  /**
+   * Reset all animations to initial state
+   * @returns the animation group
+   */
+  reset() {
+    if (!this._isStarted)
+      return this.play(), this.goToFrame(0), this.stop(), this;
+    for (let t = 0; t < this._animatables.length; t++)
+      this._animatables[t].reset();
+    return this;
+  }
+  /**
+   * Restart animations from key 0
+   * @returns the animation group
+   */
+  restart() {
+    if (!this._isStarted)
+      return this;
+    for (let t = 0; t < this._animatables.length; t++)
+      this._animatables[t].restart();
+    return this.onAnimationGroupPlayObservable.notifyObservers(this), this;
+  }
+  /**
+   * Stop all animations
+   * @returns the animation group
+   */
+  stop() {
+    if (!this._isStarted)
+      return this;
+    const t = this._animatables.slice();
+    for (let e = 0; e < t.length; e++)
+      t[e].stop(void 0, void 0, !0);
+    let i = 0;
+    for (let e = 0; e < this._scene._activeAnimatables.length; e++) {
+      const n = this._scene._activeAnimatables[e];
+      n._runtimeAnimations.length > 0 && (this._scene._activeAnimatables[i++] = n);
+    }
+    return this._scene._activeAnimatables.length = i, this._isStarted = !1, this;
+  }
+  /**
+   * Set animation weight for all animatables
+   *
+   * @since 6.12.4
+   *  You can pass the weight to the AnimationGroup constructor, or use the weight property to set it after the group has been created,
+   *  making it easier to define the overall animation weight than calling setWeightForAllAnimatables() after the animation group has been started
+   * @param weight defines the weight to use
+   * @returns the animationGroup
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-weights
+   */
+  setWeightForAllAnimatables(t) {
+    for (let i = 0; i < this._animatables.length; i++) {
+      const e = this._animatables[i];
+      e.weight = t;
+    }
+    return this;
+  }
+  /**
+   * Synchronize and normalize all animatables with a source animatable
+   * @param root defines the root animatable to synchronize with (null to stop synchronizing)
+   * @returns the animationGroup
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-weights
+   */
+  syncAllAnimationsWith(t) {
+    for (let i = 0; i < this._animatables.length; i++)
+      this._animatables[i].syncWith(t);
+    return this;
+  }
+  /**
+   * Goes to a specific frame in this animation group
+   * @param frame the frame number to go to
+   * @returns the animationGroup
+   */
+  goToFrame(t) {
+    if (!this._isStarted)
+      return this;
+    for (let i = 0; i < this._animatables.length; i++)
+      this._animatables[i].goToFrame(t);
+    return this;
+  }
+  /**
+   * Dispose all associated resources
+   */
+  dispose() {
+    this._targetedAnimations.length = 0, this._animatables.length = 0;
+    const t = this._scene.animationGroups.indexOf(this);
+    if (t > -1 && this._scene.animationGroups.splice(t, 1), this._parentContainer) {
+      const i = this._parentContainer.animationGroups.indexOf(this);
+      i > -1 && this._parentContainer.animationGroups.splice(i, 1), this._parentContainer = null;
+    }
+    this.onAnimationEndObservable.clear(), this.onAnimationGroupEndObservable.clear(), this.onAnimationGroupPauseObservable.clear(), this.onAnimationGroupPlayObservable.clear(), this.onAnimationLoopObservable.clear(), this.onAnimationGroupLoopObservable.clear();
+  }
+  _checkAnimationGroupEnded(t) {
+    const i = this._animatables.indexOf(t);
+    i > -1 && this._animatables.splice(i, 1), this._animatables.length === 0 && (this._isStarted = !1, this.onAnimationGroupEndObservable.notifyObservers(this));
+  }
+  /**
+   * Clone the current animation group and returns a copy
+   * @param newName defines the name of the new group
+   * @param targetConverter defines an optional function used to convert current animation targets to new ones
+   * @param cloneAnimations defines if the animations should be cloned or referenced
+   * @returns the new animation group
+   */
+  clone(t, i, e = !1) {
+    const n = new d(t || this.name, this._scene);
+    for (const s of this._targetedAnimations)
+      n.addTargetedAnimation(e ? s.animation.clone() : s.animation, i ? i(s.target) : s.target);
+    return n;
+  }
+  /**
+   * Serializes the animationGroup to an object
+   * @returns Serialized object
+   */
+  serialize() {
+    const t = {};
+    t.name = this.name, t.from = this.from, t.to = this.to, t.targetedAnimations = [];
+    for (let i = 0; i < this.targetedAnimations.length; i++) {
+      const e = this.targetedAnimations[i];
+      t.targetedAnimations[i] = e.serialize();
+    }
+    return l && l.HasTags(this) && (t.tags = l.GetTags(this)), this.metadata && (t.metadata = this.metadata), t;
+  }
+  // Statics
+  /**
+   * Returns a new AnimationGroup object parsed from the source provided.
+   * @param parsedAnimationGroup defines the source
+   * @param scene defines the scene that will receive the animationGroup
+   * @returns a new AnimationGroup
+   */
+  static Parse(t, i) {
+    const e = new d(t.name, i);
+    for (let n = 0; n < t.targetedAnimations.length; n++) {
+      const s = t.targetedAnimations[n], o = g.Parse(s.animation), r = s.targetId;
+      if (s.animation.property === "influence") {
+        const a = i.getMorphTargetById(r);
+        a && e.addTargetedAnimation(o, a);
+      } else {
+        const a = i.getNodeById(r);
+        a != null && e.addTargetedAnimation(o, a);
+      }
+    }
+    return t.from !== null && t.to !== null && e.normalize(t.from, t.to), l && l.AddTagsTo(e, t.tags), t.metadata !== void 0 && (e.metadata = t.metadata), e;
+  }
+  /**
+   * Convert the keyframes for all animations belonging to the group to be relative to a given reference frame.
+   * @param sourceAnimationGroup defines the AnimationGroup containing animations to convert
+   * @param referenceFrame defines the frame that keyframes in the range will be relative to
+   * @param range defines the name of the AnimationRange belonging to the animations in the group to convert
+   * @param cloneOriginal defines whether or not to clone the group and convert the clone or convert the original group (default is false)
+   * @param clonedName defines the name of the resulting cloned AnimationGroup if cloneOriginal is true
+   * @returns a new AnimationGroup if cloneOriginal is true or the original AnimationGroup if cloneOriginal is false
+   */
+  static MakeAnimationAdditive(t, i = 0, e, n = !1, s) {
+    let o = t;
+    n && (o = t.clone(s || o.name));
+    const r = o.targetedAnimations;
+    for (let a = 0; a < r.length; a++) {
+      const m = r[a];
+      g.MakeAnimationAdditive(m.animation, i, e);
+    }
+    return o.isAdditive = !0, o;
+  }
+  /**
+   * Returns the string "AnimationGroup"
+   * @returns "AnimationGroup"
+   */
+  getClassName() {
+    return "AnimationGroup";
+  }
+  /**
+   * Creates a detailed string about the object
+   * @param fullDetails defines if the output string will support multiple levels of logging within scene loading
+   * @returns a string representing the object
+   */
+  toString(t) {
+    let i = "Name: " + this.name;
+    return i += ", type: " + this.getClassName(), t && (i += ", from: " + this._from, i += ", to: " + this._to, i += ", isStarted: " + this._isStarted, i += ", speedRatio: " + this._speedRatio, i += ", targetedAnimations length: " + this._targetedAnimations.length, i += ", animatables length: " + this._animatables), i;
+  }
+}
+export {
+  d as AnimationGroup,
+  f as TargetedAnimation
+};

package/dist/node_modules/@babylonjs/core/Animations/animationKey.esm.js

@@ -0,0 +1,7 @@
+var N;
+(function(E) {
+  E[E.NONE = 0] = "NONE", E[E.STEP = 1] = "STEP";
+})(N || (N = {}));
+export {
+  N as AnimationKeyInterpolation
+};

package/dist/node_modules/@babylonjs/core/Animations/animationRange.esm.js

@@ -0,0 +1,21 @@
+class t {
+  /**
+   * Initializes the range of an animation
+   * @param name The name of the animation range
+   * @param from The starting frame of the animation
+   * @param to The ending frame of the animation
+   */
+  constructor(s, o, r) {
+    this.name = s, this.from = o, this.to = r;
+  }
+  /**
+   * Makes a copy of the animation range
+   * @returns A copy of the animation range
+   */
+  clone() {
+    return new t(this.name, this.from, this.to);
+  }
+}
+export {
+  t as AnimationRange
+};

package/dist/node_modules/@babylonjs/core/Animations/easing.esm.js

@@ -0,0 +1,93 @@
+import "../Maths/math.path.esm.js";
+class s {
+  constructor() {
+    this._easingMode = s.EASINGMODE_EASEIN;
+  }
+  /**
+   * Sets the easing mode of the current function.
+   * @param easingMode Defines the willing mode (EASINGMODE_EASEIN, EASINGMODE_EASEOUT or EASINGMODE_EASEINOUT)
+   */
+  setEasingMode(e) {
+    const t = Math.min(Math.max(e, 0), 2);
+    this._easingMode = t;
+  }
+  /**
+   * Gets the current easing mode.
+   * @returns the easing mode
+   */
+  getEasingMode() {
+    return this._easingMode;
+  }
+  /**
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  easeInCore(e) {
+    throw new Error("You must implement this method");
+  }
+  /**
+   * Given an input gradient between 0 and 1, this returns the corresponding value
+   * of the easing function.
+   * @param gradient Defines the value between 0 and 1 we want the easing value for
+   * @returns the corresponding value on the curve defined by the easing function
+   */
+  ease(e) {
+    switch (this._easingMode) {
+      case s.EASINGMODE_EASEIN:
+        return this.easeInCore(e);
+      case s.EASINGMODE_EASEOUT:
+        return 1 - this.easeInCore(1 - e);
+    }
+    return e >= 0.5 ? (1 - this.easeInCore((1 - e) * 2)) * 0.5 + 0.5 : this.easeInCore(e * 2) * 0.5;
+  }
+}
+s.EASINGMODE_EASEIN = 0;
+s.EASINGMODE_EASEOUT = 1;
+s.EASINGMODE_EASEINOUT = 2;
+class o extends s {
+  /**
+   * Instantiates a back ease easing
+   * @see https://easings.net/#easeInBack
+   * @param amplitude Defines the amplitude of the function
+   */
+  constructor(e = 1) {
+    super(), this.amplitude = e;
+  }
+  /**
+   * @internal
+   */
+  easeInCore(e) {
+    const t = Math.max(0, this.amplitude);
+    return Math.pow(e, 3) - e * t * Math.sin(3.141592653589793 * e);
+  }
+}
+class a extends s {
+  /**
+   * Instantiates an exponential easing function
+   * @see https://easings.net/#easeInExpo
+   * @param exponent Defines the exponent of the function
+   */
+  constructor(e = 2) {
+    super(), this.exponent = e;
+  }
+  /**
+   * @internal
+   */
+  easeInCore(e) {
+    return this.exponent <= 0 ? e : (Math.exp(this.exponent * e) - 1) / (Math.exp(this.exponent) - 1);
+  }
+}
+class E extends s {
+  /**
+   * @internal
+   */
+  easeInCore(e) {
+    return e * e;
+  }
+}
+export {
+  o as BackEase,
+  s as EasingFunction,
+  a as ExponentialEase,
+  E as QuadraticEase
+};