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

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

@@ -1,18 +0,0 @@
-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

@@ -1,470 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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
-};