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

package/dist/node_modules/@babylonjs/core/Actions/abstractActionManager.esm.js

@@ -0,0 +1,41 @@
+class r {
+  constructor() {
+    this.hoverCursor = "", this.actions = new Array(), this.isRecursive = !1;
+  }
+  /**
+   * Does exist one action manager with at least one trigger
+   **/
+  static get HasTriggers() {
+    for (const e in r.Triggers)
+      if (Object.prototype.hasOwnProperty.call(r.Triggers, e))
+        return !0;
+    return !1;
+  }
+  /**
+   * Does exist one action manager with at least one pick trigger
+   **/
+  static get HasPickTriggers() {
+    for (const e in r.Triggers)
+      if (Object.prototype.hasOwnProperty.call(r.Triggers, e)) {
+        const s = parseInt(e);
+        if (s >= 1 && s <= 7)
+          return !0;
+      }
+    return !1;
+  }
+  /**
+   * Does exist one action manager that handles actions of a given trigger
+   * @param trigger defines the trigger to be tested
+   * @returns a boolean indicating whether the trigger is handled by at least one action manager
+   **/
+  static HasSpecificTrigger(e) {
+    for (const s in r.Triggers)
+      if (Object.prototype.hasOwnProperty.call(r.Triggers, s) && parseInt(s) === e)
+        return !0;
+    return !1;
+  }
+}
+r.Triggers = {};
+export {
+  r as AbstractActionManager
+};

package/dist/node_modules/@babylonjs/core/Actions/action.esm.js

@@ -0,0 +1,122 @@
+import { Observable as s } from "../Misc/observable.esm.js";
+import { Vector2 as c, Vector3 as a } from "../Maths/math.vector.esm.js";
+import { Color3 as h, Color4 as _ } from "../Maths/math.color.esm.js";
+import { RegisterClass as f } from "../Misc/typeStore.esm.js";
+class o {
+  /**
+   * Creates a new Action
+   * @param triggerOptions the trigger, with or without parameters, for the action
+   * @param condition an optional determinant of action
+   */
+  constructor(e, i) {
+    this.triggerOptions = e, this.onBeforeExecuteObservable = new s(), e.parameter ? (this.trigger = e.trigger, this._triggerParameter = e.parameter) : e.trigger ? this.trigger = e.trigger : this.trigger = e, this._nextActiveAction = this, this._condition = i;
+  }
+  /**
+   * Internal only
+   * @internal
+   */
+  _prepare() {
+  }
+  /**
+   * Gets the trigger parameter
+   * @returns the trigger parameter
+   */
+  getTriggerParameter() {
+    return this._triggerParameter;
+  }
+  /**
+   * Sets the trigger parameter
+   * @param value defines the new trigger parameter
+   */
+  setTriggerParameter(e) {
+    this._triggerParameter = e;
+  }
+  /**
+   * Internal only - Returns if the current condition allows to run the action
+   * @internal
+   */
+  _evaluateConditionForCurrentFrame() {
+    const e = this._condition;
+    if (!e)
+      return !0;
+    const i = this._actionManager.getScene().getRenderId();
+    return e._evaluationId !== i && (e._evaluationId = i, e._currentResult = e.isValid()), e._currentResult;
+  }
+  /**
+   * Internal only - executes current action event
+   * @internal
+   */
+  _executeCurrent(e) {
+    this._evaluateConditionForCurrentFrame() && (this.onBeforeExecuteObservable.notifyObservers(this), this._nextActiveAction.execute(e), this.skipToNextActiveAction());
+  }
+  /**
+   * Execute placeholder for child classes
+   * @param evt optional action event
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  execute(e) {
+  }
+  /**
+   * Skips to next active action
+   */
+  skipToNextActiveAction() {
+    this._nextActiveAction._child ? (this._nextActiveAction._child._actionManager || (this._nextActiveAction._child._actionManager = this._actionManager), this._nextActiveAction = this._nextActiveAction._child) : this._nextActiveAction = this;
+  }
+  /**
+   * Adds action to chain of actions, may be a DoNothingAction
+   * @param action defines the next action to execute
+   * @returns The action passed in
+   * @see https://www.babylonjs-playground.com/#1T30HR#0
+   */
+  then(e) {
+    return this._child = e, e._actionManager = this._actionManager, e._prepare(), e;
+  }
+  /**
+   * Internal only
+   * @internal
+   */
+  _getProperty(e) {
+    return this._actionManager._getProperty(e);
+  }
+  /**
+   * @internal
+   */
+  _getEffectiveTarget(e, i) {
+    return this._actionManager._getEffectiveTarget(e, i);
+  }
+  /**
+   * Serialize placeholder for child classes
+   * @param parent of child
+   * @returns the serialized object
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  serialize(e) {
+  }
+  /**
+   * Internal only called by serialize
+   * @internal
+   */
+  _serialize(e, i) {
+    const r = {
+      type: 1,
+      children: [],
+      name: e.name,
+      properties: e.properties || []
+    };
+    if (this._child && this._child.serialize(r), this._condition) {
+      const n = this._condition.serialize();
+      return n.children.push(r), i && i.children.push(n), n;
+    }
+    return i && i.children.push(r), r;
+  }
+}
+o._SerializeValueAsString = (t) => typeof t == "number" ? t.toString() : typeof t == "boolean" ? t ? "true" : "false" : t instanceof c ? t.x + ", " + t.y : t instanceof a ? t.x + ", " + t.y + ", " + t.z : t instanceof h ? t.r + ", " + t.g + ", " + t.b : t instanceof _ ? t.r + ", " + t.g + ", " + t.b + ", " + t.a : t;
+o._GetTargetProperty = (t) => ({
+  name: "target",
+  targetType: t._isMesh ? "MeshProperties" : t._isLight ? "LightProperties" : t._isCamera ? "CameraProperties" : t._isMaterial ? "MaterialProperties" : "SceneProperties",
+  value: t._isScene ? "Scene" : t.name
+});
+f("BABYLON.Action", o);
+export {
+  o as Action
+};

package/dist/node_modules/@babylonjs/core/Actions/actionEvent.esm.js

@@ -0,0 +1,59 @@
+class n {
+  /**
+   * Creates a new ActionEvent
+   * @param source The mesh or sprite that triggered the action
+   * @param pointerX The X mouse cursor position at the time of the event
+   * @param pointerY The Y mouse cursor position at the time of the event
+   * @param meshUnderPointer The mesh that is currently pointed at (can be null)
+   * @param sourceEvent the original (browser) event that triggered the ActionEvent
+   * @param additionalData additional data for the event
+   */
+  constructor(e, t, i, r, o, s) {
+    this.source = e, this.pointerX = t, this.pointerY = i, this.meshUnderPointer = r, this.sourceEvent = o, this.additionalData = s;
+  }
+  /**
+   * Helper function to auto-create an ActionEvent from a source mesh.
+   * @param source The source mesh that triggered the event
+   * @param evt The original (browser) event
+   * @param additionalData additional data for the event
+   * @returns the new ActionEvent
+   */
+  static CreateNew(e, t, i) {
+    const r = e.getScene();
+    return new n(e, r.pointerX, r.pointerY, r.meshUnderPointer || e, t, i);
+  }
+  /**
+   * Helper function to auto-create an ActionEvent from a source sprite
+   * @param source The source sprite that triggered the event
+   * @param scene Scene associated with the sprite
+   * @param evt The original (browser) event
+   * @param additionalData additional data for the event
+   * @returns the new ActionEvent
+   */
+  static CreateNewFromSprite(e, t, i, r) {
+    return new n(e, t.pointerX, t.pointerY, t.meshUnderPointer, i, r);
+  }
+  /**
+   * Helper function to auto-create an ActionEvent from a scene. If triggered by a mesh use ActionEvent.CreateNew
+   * @param scene the scene where the event occurred
+   * @param evt The original (browser) event
+   * @returns the new ActionEvent
+   */
+  static CreateNewFromScene(e, t) {
+    return new n(null, e.pointerX, e.pointerY, e.meshUnderPointer, t);
+  }
+  /**
+   * Helper function to auto-create an ActionEvent from a primitive
+   * @param prim defines the target primitive
+   * @param pointerPos defines the pointer position
+   * @param evt The original (browser) event
+   * @param additionalData additional data for the event
+   * @returns the new ActionEvent
+   */
+  static CreateNewFromPrimitive(e, t, i, r) {
+    return new n(e, t.x, t.y, null, i, r);
+  }
+}
+export {
+  n as ActionEvent
+};

package/dist/node_modules/@babylonjs/core/Actions/actionManager.esm.js

@@ -0,0 +1,335 @@
+import { Vector3 as k, Vector4 as w } from "../Maths/math.vector.esm.js";
+import { Color3 as C, Color4 as N } from "../Maths/math.color.esm.js";
+import { ValueCondition as S, Condition as x } from "./condition.esm.js";
+import { Action as F } from "./action.esm.js";
+import { DoNothingAction as b } from "./directActions.esm.js";
+import { EngineStore as v } from "../Engines/engineStore.esm.js";
+import { Logger as D } from "../Misc/logger.esm.js";
+import { DeepCopier as L } from "../Misc/deepCopier.esm.js";
+import { GetClass as B } from "../Misc/typeStore.esm.js";
+import { AbstractActionManager as I } from "./abstractActionManager.esm.js";
+class t extends I {
+  /**
+   * Creates a new action manager
+   * @param scene defines the hosting scene
+   */
+  constructor(e) {
+    super(), e = e || v.LastCreatedScene, e && (this._scene = e, e.actionManagers.push(this));
+  }
+  // Methods
+  /**
+   * Releases all associated resources
+   */
+  dispose() {
+    const e = this._scene.actionManagers.indexOf(this);
+    for (let r = 0; r < this.actions.length; r++) {
+      const i = this.actions[r];
+      t.Triggers[i.trigger]--, t.Triggers[i.trigger] === 0 && delete t.Triggers[i.trigger];
+    }
+    e > -1 && this._scene.actionManagers.splice(e, 1);
+  }
+  /**
+   * Gets hosting scene
+   * @returns the hosting scene
+   */
+  getScene() {
+    return this._scene;
+  }
+  /**
+   * Does this action manager handles actions of any of the given triggers
+   * @param triggers defines the triggers to be tested
+   * @returns a boolean indicating whether one (or more) of the triggers is handled
+   */
+  hasSpecificTriggers(e) {
+    for (let r = 0; r < this.actions.length; r++) {
+      const i = this.actions[r];
+      if (e.indexOf(i.trigger) > -1)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Does this action manager handles actions of any of the given triggers. This function takes two arguments for
+   * speed.
+   * @param triggerA defines the trigger to be tested
+   * @param triggerB defines the trigger to be tested
+   * @returns a boolean indicating whether one (or more) of the triggers is handled
+   */
+  hasSpecificTriggers2(e, r) {
+    for (let i = 0; i < this.actions.length; i++) {
+      const s = this.actions[i];
+      if (e == s.trigger || r == s.trigger)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Does this action manager handles actions of a given trigger
+   * @param trigger defines the trigger to be tested
+   * @param parameterPredicate defines an optional predicate to filter triggers by parameter
+   * @returns whether the trigger is handled
+   */
+  hasSpecificTrigger(e, r) {
+    for (let i = 0; i < this.actions.length; i++) {
+      const s = this.actions[i];
+      if (s.trigger === e)
+        if (r) {
+          if (r(s.getTriggerParameter()))
+            return !0;
+        } else
+          return !0;
+    }
+    return !1;
+  }
+  /**
+   * Does this action manager has pointer triggers
+   */
+  get hasPointerTriggers() {
+    for (let e = 0; e < this.actions.length; e++) {
+      const r = this.actions[e];
+      if (r.trigger >= t.OnPickTrigger && r.trigger <= t.OnPointerOutTrigger)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Does this action manager has pick triggers
+   */
+  get hasPickTriggers() {
+    for (let e = 0; e < this.actions.length; e++) {
+      const r = this.actions[e];
+      if (r.trigger >= t.OnPickTrigger && r.trigger <= t.OnPickUpTrigger)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Registers an action to this action manager
+   * @param action defines the action to be registered
+   * @returns the action amended (prepared) after registration
+   */
+  registerAction(e) {
+    return e.trigger === t.OnEveryFrameTrigger && this.getScene().actionManager !== this ? (D.Warn("OnEveryFrameTrigger can only be used with scene.actionManager"), null) : (this.actions.push(e), this.getScene()._registeredActions++, t.Triggers[e.trigger] ? t.Triggers[e.trigger]++ : t.Triggers[e.trigger] = 1, e._actionManager = this, e._prepare(), e);
+  }
+  /**
+   * Unregisters an action to this action manager
+   * @param action defines the action to be unregistered
+   * @returns a boolean indicating whether the action has been unregistered
+   */
+  unregisterAction(e) {
+    const r = this.actions.indexOf(e);
+    return r !== -1 ? (this.actions.splice(r, 1), t.Triggers[e.trigger] -= 1, t.Triggers[e.trigger] === 0 && delete t.Triggers[e.trigger], e._actionManager = null, this.getScene()._registeredActions--, !0) : !1;
+  }
+  /**
+   * Process a specific trigger
+   * @param trigger defines the trigger to process
+   * @param evt defines the event details to be processed
+   */
+  processTrigger(e, r) {
+    for (let i = 0; i < this.actions.length; i++) {
+      const s = this.actions[i];
+      if (s.trigger === e) {
+        if (r && (e === t.OnKeyUpTrigger || e === t.OnKeyDownTrigger)) {
+          const o = s.getTriggerParameter();
+          if (typeof o == "function") {
+            if (!o(r))
+              continue;
+          } else if (o && o !== r.sourceEvent.keyCode) {
+            if (!o.toLowerCase)
+              continue;
+            const T = o.toLowerCase();
+            if (T !== r.sourceEvent.key) {
+              const P = r.sourceEvent.charCode ? r.sourceEvent.charCode : r.sourceEvent.keyCode;
+              if (String.fromCharCode(P).toLowerCase() !== T)
+                continue;
+            }
+          }
+        }
+        s._executeCurrent(r);
+      }
+    }
+  }
+  /**
+   * @internal
+   */
+  _getEffectiveTarget(e, r) {
+    const i = r.split(".");
+    for (let s = 0; s < i.length - 1; s++)
+      e = e[i[s]];
+    return e;
+  }
+  /**
+   * @internal
+   */
+  _getProperty(e) {
+    const r = e.split(".");
+    return r[r.length - 1];
+  }
+  /**
+   * Serialize this manager to a JSON object
+   * @param name defines the property name to store this manager
+   * @returns a JSON representation of this manager
+   */
+  serialize(e) {
+    const r = {
+      children: new Array(),
+      name: e,
+      type: 3,
+      properties: new Array()
+      // Empty for root but required
+    };
+    for (let i = 0; i < this.actions.length; i++) {
+      const s = {
+        type: 0,
+        children: new Array(),
+        name: t.GetTriggerName(this.actions[i].trigger),
+        properties: new Array()
+      }, o = this.actions[i].triggerOptions;
+      if (o && typeof o != "number")
+        if (o.parameter instanceof Node)
+          s.properties.push(F._GetTargetProperty(o.parameter));
+        else if (typeof o.parameter == "object") {
+          const T = {};
+          L.DeepCopy(o.parameter, T, ["mesh"]), o.parameter && o.parameter.mesh && (T._meshId = o.parameter.mesh.id), s.properties.push({ name: "parameter", targetType: null, value: T });
+        } else
+          s.properties.push({ name: "parameter", targetType: null, value: o.parameter });
+      this.actions[i].serialize(s), r.children.push(s);
+    }
+    return r;
+  }
+  /**
+   * Creates a new ActionManager from a JSON data
+   * @param parsedActions defines the JSON data to read from
+   * @param object defines the hosting mesh
+   * @param scene defines the hosting scene
+   */
+  static Parse(e, r, i) {
+    const s = new t(i);
+    r === null ? i.actionManager = s : r.actionManager = s;
+    const o = (g, f) => {
+      const n = B("BABYLON." + g);
+      return n && new n(...f);
+    }, T = (g, f, n, c) => {
+      if (c === null) {
+        const h = parseFloat(f);
+        return f === "true" || f === "false" ? f === "true" : isNaN(h) ? f : h;
+      }
+      const p = c.split("."), l = f.split(",");
+      for (let h = 0; h < p.length; h++)
+        n = n[p[h]];
+      if (typeof n == "boolean")
+        return l[0] === "true";
+      if (typeof n == "string")
+        return l[0];
+      const m = new Array();
+      for (let h = 0; h < l.length; h++)
+        m.push(parseFloat(l[h]));
+      return n instanceof k ? k.FromArray(m) : n instanceof w ? w.FromArray(m) : n instanceof C ? C.FromArray(m) : n instanceof N ? N.FromArray(m) : parseFloat(l[0]);
+    }, P = (g, f, n, c, p = null) => {
+      if (g.detached)
+        return;
+      const l = new Array();
+      let m = null, h = null;
+      const E = g.combine && g.combine.length > 0;
+      if (g.type === 2 ? l.push(s) : l.push(f), E) {
+        const u = new Array();
+        for (let a = 0; a < g.combine.length; a++)
+          P(g.combine[a], t.NothingTrigger, n, c, u);
+        l.push(u);
+      } else
+        for (let u = 0; u < g.properties.length; u++) {
+          let a = g.properties[u].value;
+          const y = g.properties[u].name, d = g.properties[u].targetType;
+          y === "target" ? d === "SceneProperties" ? a = m = i : d === "MaterialProperties" ? a = m = i.getMaterialByName(a) : a = m = i.getNodeByName(a) : y === "parent" ? a = i.getNodeByName(a) : y === "sound" ? i.getSoundByName && (a = i.getSoundByName(a)) : y !== "propertyPath" ? g.type === 2 && y === "operator" ? a = S[a] : a = T(y, a, m, y === "value" ? h : null) : h = a, l.push(a);
+        }
+      if (p === null ? l.push(n) : l.push(null), g.name === "InterpolateValueAction") {
+        const u = l[l.length - 2];
+        l[l.length - 1] = u, l[l.length - 2] = n;
+      }
+      let O = o(g.name, l);
+      if (O instanceof x && n !== null) {
+        const u = new b(f, n);
+        c ? c.then(u) : s.registerAction(u), c = u;
+      }
+      p === null ? O instanceof x ? (n = O, O = c) : (n = null, c ? c.then(O) : s.registerAction(O)) : p.push(O);
+      for (let u = 0; u < g.children.length; u++)
+        P(g.children[u], f, n, O, null);
+    };
+    for (let g = 0; g < e.children.length; g++) {
+      let f;
+      const n = e.children[g];
+      if (n.properties.length > 0) {
+        const c = n.properties[0].value, p = n.properties[0].targetType === null ? c : i.getMeshByName(c);
+        p._meshId && (p.mesh = i.getMeshById(p._meshId)), f = { trigger: t[n.name], parameter: p };
+      } else
+        f = t[n.name];
+      for (let c = 0; c < n.children.length; c++)
+        n.detached || P(n.children[c], f, null, null);
+    }
+  }
+  /**
+   * Get a trigger name by index
+   * @param trigger defines the trigger index
+   * @returns a trigger name
+   */
+  static GetTriggerName(e) {
+    switch (e) {
+      case 0:
+        return "NothingTrigger";
+      case 1:
+        return "OnPickTrigger";
+      case 2:
+        return "OnLeftPickTrigger";
+      case 3:
+        return "OnRightPickTrigger";
+      case 4:
+        return "OnCenterPickTrigger";
+      case 5:
+        return "OnPickDownTrigger";
+      case 6:
+        return "OnDoublePickTrigger";
+      case 7:
+        return "OnPickUpTrigger";
+      case 8:
+        return "OnLongPressTrigger";
+      case 9:
+        return "OnPointerOverTrigger";
+      case 10:
+        return "OnPointerOutTrigger";
+      case 11:
+        return "OnEveryFrameTrigger";
+      case 12:
+        return "OnIntersectionEnterTrigger";
+      case 13:
+        return "OnIntersectionExitTrigger";
+      case 14:
+        return "OnKeyDownTrigger";
+      case 15:
+        return "OnKeyUpTrigger";
+      case 16:
+        return "OnPickOutTrigger";
+      default:
+        return "";
+    }
+  }
+}
+t.NothingTrigger = 0;
+t.OnPickTrigger = 1;
+t.OnLeftPickTrigger = 2;
+t.OnRightPickTrigger = 3;
+t.OnCenterPickTrigger = 4;
+t.OnPickDownTrigger = 5;
+t.OnDoublePickTrigger = 6;
+t.OnPickUpTrigger = 7;
+t.OnPickOutTrigger = 16;
+t.OnLongPressTrigger = 8;
+t.OnPointerOverTrigger = 9;
+t.OnPointerOutTrigger = 10;
+t.OnEveryFrameTrigger = 11;
+t.OnIntersectionEnterTrigger = 12;
+t.OnIntersectionExitTrigger = 13;
+t.OnKeyDownTrigger = 14;
+t.OnKeyUpTrigger = 15;
+export {
+  t as ActionManager
+};