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

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

@@ -0,0 +1,193 @@
+import { Action as a } from "./action.esm.js";
+import { RegisterClass as i } from "../Misc/typeStore.esm.js";
+class h {
+  /**
+   * Creates a new Condition
+   * @param actionManager the manager of the action the condition is applied to
+   */
+  constructor(e) {
+    this._actionManager = e;
+  }
+  /**
+   * Check if the current condition is valid
+   * @returns a boolean
+   */
+  isValid() {
+    return !0;
+  }
+  /**
+   * @internal
+   */
+  _getProperty(e) {
+    return this._actionManager._getProperty(e);
+  }
+  /**
+   * @internal
+   */
+  _getEffectiveTarget(e, r) {
+    return this._actionManager._getEffectiveTarget(e, r);
+  }
+  /**
+   * Serialize placeholder for child classes
+   * @returns the serialized object
+   */
+  serialize() {
+  }
+  /**
+   * @internal
+   */
+  _serialize(e) {
+    return {
+      type: 2,
+      children: [],
+      name: e.name,
+      properties: e.properties
+    };
+  }
+}
+class t extends h {
+  /**
+   * returns the number for IsEqual
+   */
+  static get IsEqual() {
+    return t._IsEqual;
+  }
+  /**
+   * Returns the number for IsDifferent
+   */
+  static get IsDifferent() {
+    return t._IsDifferent;
+  }
+  /**
+   * Returns the number for IsGreater
+   */
+  static get IsGreater() {
+    return t._IsGreater;
+  }
+  /**
+   * Returns the number for IsLesser
+   */
+  static get IsLesser() {
+    return t._IsLesser;
+  }
+  /**
+   * Creates a new ValueCondition
+   * @param actionManager manager for the action the condition applies to
+   * @param target for the action
+   * @param propertyPath path to specify the property of the target the conditional operator uses
+   * @param value the value compared by the conditional operator against the current value of the property
+   * @param operator the conditional operator, default ValueCondition.IsEqual
+   */
+  constructor(e, r, s, c, u = t.IsEqual) {
+    super(e), this.propertyPath = s, this.value = c, this.operator = u, this._target = r, this._effectiveTarget = this._getEffectiveTarget(r, this.propertyPath), this._property = this._getProperty(this.propertyPath);
+  }
+  /**
+   * Compares the given value with the property value for the specified conditional operator
+   * @returns the result of the comparison
+   */
+  isValid() {
+    switch (this.operator) {
+      case t.IsGreater:
+        return this._effectiveTarget[this._property] > this.value;
+      case t.IsLesser:
+        return this._effectiveTarget[this._property] < this.value;
+      case t.IsEqual:
+      case t.IsDifferent: {
+        let e;
+        return this.value.equals ? e = this.value.equals(this._effectiveTarget[this._property]) : e = this.value === this._effectiveTarget[this._property], this.operator === t.IsEqual ? e : !e;
+      }
+    }
+    return !1;
+  }
+  /**
+   * Serialize the ValueCondition into a JSON compatible object
+   * @returns serialization object
+   */
+  serialize() {
+    return this._serialize({
+      name: "ValueCondition",
+      properties: [
+        a._GetTargetProperty(this._target),
+        { name: "propertyPath", value: this.propertyPath },
+        { name: "value", value: a._SerializeValueAsString(this.value) },
+        { name: "operator", value: t.GetOperatorName(this.operator) }
+      ]
+    });
+  }
+  /**
+   * Gets the name of the conditional operator for the ValueCondition
+   * @param operator the conditional operator
+   * @returns the name
+   */
+  static GetOperatorName(e) {
+    switch (e) {
+      case t._IsEqual:
+        return "IsEqual";
+      case t._IsDifferent:
+        return "IsDifferent";
+      case t._IsGreater:
+        return "IsGreater";
+      case t._IsLesser:
+        return "IsLesser";
+      default:
+        return "";
+    }
+  }
+}
+t._IsEqual = 0;
+t._IsDifferent = 1;
+t._IsGreater = 2;
+t._IsLesser = 3;
+class n extends h {
+  /**
+   * Creates a new PredicateCondition
+   * @param actionManager manager for the action the condition applies to
+   * @param predicate defines the predicate function used to validate the condition
+   */
+  constructor(e, r) {
+    super(e), this.predicate = r;
+  }
+  /**
+   * @returns the validity of the predicate condition
+   */
+  isValid() {
+    return this.predicate();
+  }
+}
+class l extends h {
+  /**
+   * Creates a new StateCondition
+   * @param actionManager manager for the action the condition applies to
+   * @param target of the condition
+   * @param value to compare with target state
+   */
+  constructor(e, r, s) {
+    super(e), this.value = s, this._target = r;
+  }
+  /**
+   * Gets a boolean indicating if the current condition is met
+   * @returns the validity of the state
+   */
+  isValid() {
+    return this._target.state === this.value;
+  }
+  /**
+   * Serialize the StateCondition into a JSON compatible object
+   * @returns serialization object
+   */
+  serialize() {
+    return this._serialize({
+      name: "StateCondition",
+      properties: [a._GetTargetProperty(this._target), { name: "value", value: this.value }]
+    });
+  }
+}
+i("BABYLON.ValueCondition", t);
+i("BABYLON.PredicateCondition", n);
+i("BABYLON.StateCondition", l);
+export {
+  h as Condition,
+  n as PredicateCondition,
+  l as StateCondition,
+  t as ValueCondition
+};

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

@@ -0,0 +1,354 @@
+import { Logger as c } from "../Misc/logger.esm.js";
+import { Vector3 as l } from "../Maths/math.vector.esm.js";
+import { Action as i } from "./action.esm.js";
+import { RegisterClass as a } from "../Misc/typeStore.esm.js";
+class u extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param target defines the object containing the boolean
+   * @param propertyPath defines the path to the boolean property in the target object
+   * @param condition defines the trigger related conditions
+   */
+  constructor(e, t, r, s) {
+    super(e, s), this.propertyPath = r, this._target = this._effectiveTarget = t;
+  }
+  /** @internal */
+  _prepare() {
+    this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath), this._property = this._getProperty(this.propertyPath);
+  }
+  /**
+   * Execute the action toggle the boolean value.
+   */
+  execute() {
+    this._effectiveTarget[this._property] = !this._effectiveTarget[this._property];
+  }
+  /**
+   * Serializes the actions and its related information.
+   * @param parent defines the object to serialize in
+   * @returns the serialized object
+   */
+  serialize(e) {
+    return super._serialize({
+      name: "SwitchBooleanAction",
+      properties: [i._GetTargetProperty(this._target), { name: "propertyPath", value: this.propertyPath }]
+    }, e);
+  }
+}
+class _ extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param target defines the object containing the state property
+   * @param value defines the value to store in the state field
+   * @param condition defines the trigger related conditions
+   */
+  constructor(e, t, r, s) {
+    super(e, s), this.value = r, this._target = t;
+  }
+  /**
+   * Execute the action and store the value on the target state property.
+   */
+  execute() {
+    this._target.state = this.value;
+  }
+  /**
+   * Serializes the actions and its related information.
+   * @param parent defines the object to serialize in
+   * @returns the serialized object
+   */
+  serialize(e) {
+    return super._serialize({
+      name: "SetStateAction",
+      properties: [i._GetTargetProperty(this._target), { name: "value", value: this.value }]
+    }, e);
+  }
+}
+class g extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param target defines the object containing the property
+   * @param propertyPath defines the path of the property to set in the target
+   * @param value defines the value to set in the property
+   * @param condition defines the trigger related conditions
+   */
+  constructor(e, t, r, s, o) {
+    super(e, o), this.propertyPath = r, this.value = s, this._target = this._effectiveTarget = t;
+  }
+  /** @internal */
+  _prepare() {
+    this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath), this._property = this._getProperty(this.propertyPath);
+  }
+  /**
+   * Execute the action and set the targeted property to the desired value.
+   */
+  execute() {
+    this._effectiveTarget[this._property] = this.value, this._target.markAsDirty && this._target.markAsDirty(this._property);
+  }
+  /**
+   * Serializes the actions and its related information.
+   * @param parent defines the object to serialize in
+   * @returns the serialized object
+   */
+  serialize(e) {
+    return super._serialize({
+      name: "SetValueAction",
+      properties: [
+        i._GetTargetProperty(this._target),
+        { name: "propertyPath", value: this.propertyPath },
+        { name: "value", value: i._SerializeValueAsString(this.value) }
+      ]
+    }, e);
+  }
+}
+class A extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param target defines the object containing the property
+   * @param propertyPath defines the path of the property to increment in the target
+   * @param value defines the value value we should increment the property by
+   * @param condition defines the trigger related conditions
+   */
+  constructor(e, t, r, s, o) {
+    super(e, o), this.propertyPath = r, this.value = s, this._target = this._effectiveTarget = t;
+  }
+  /** @internal */
+  _prepare() {
+    this._effectiveTarget = this._getEffectiveTarget(this._effectiveTarget, this.propertyPath), this._property = this._getProperty(this.propertyPath), typeof this._effectiveTarget[this._property] != "number" && c.Warn("Warning: IncrementValueAction can only be used with number values");
+  }
+  /**
+   * Execute the action and increment the target of the value amount.
+   */
+  execute() {
+    this._effectiveTarget[this._property] += this.value, this._target.markAsDirty && this._target.markAsDirty(this._property);
+  }
+  /**
+   * Serializes the actions and its related information.
+   * @param parent defines the object to serialize in
+   * @returns the serialized object
+   */
+  serialize(e) {
+    return super._serialize({
+      name: "IncrementValueAction",
+      properties: [
+        i._GetTargetProperty(this._target),
+        { name: "propertyPath", value: this.propertyPath },
+        { name: "value", value: i._SerializeValueAsString(this.value) }
+      ]
+    }, e);
+  }
+}
+class f extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param target defines the target animation or animation name
+   * @param from defines from where the animation should start (animation frame)
+   * @param to defines where the animation should stop (animation frame)
+   * @param loop defines if the animation should loop or stop after the first play
+   * @param condition defines the trigger related conditions
+   */
+  constructor(e, t, r, s, o, p) {
+    super(e, p), this.from = r, this.to = s, this.loop = o, this._target = t;
+  }
+  /** @internal */
+  _prepare() {
+  }
+  /**
+   * Execute the action and play the animation.
+   */
+  execute() {
+    this._actionManager.getScene().beginAnimation(this._target, this.from, this.to, this.loop);
+  }
+  /**
+   * Serializes the actions and its related information.
+   * @param parent defines the object to serialize in
+   * @returns the serialized object
+   */
+  serialize(e) {
+    return super._serialize({
+      name: "PlayAnimationAction",
+      properties: [
+        i._GetTargetProperty(this._target),
+        { name: "from", value: String(this.from) },
+        { name: "to", value: String(this.to) },
+        { name: "loop", value: i._SerializeValueAsString(this.loop) || !1 }
+      ]
+    }, e);
+  }
+}
+class m extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param target defines the target animation or animation name
+   * @param condition defines the trigger related conditions
+   */
+  constructor(e, t, r) {
+    super(e, r), this._target = t;
+  }
+  /** @internal */
+  _prepare() {
+  }
+  /**
+   * Execute the action and stop the animation.
+   */
+  execute() {
+    this._actionManager.getScene().stopAnimation(this._target);
+  }
+  /**
+   * Serializes the actions and its related information.
+   * @param parent defines the object to serialize in
+   * @returns the serialized object
+   */
+  serialize(e) {
+    return super._serialize({
+      name: "StopAnimationAction",
+      properties: [i._GetTargetProperty(this._target)]
+    }, e);
+  }
+}
+class y extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param condition defines the trigger related conditions
+   */
+  constructor(e = 0, t) {
+    super(e, t);
+  }
+  /**
+   * Execute the action and do nothing.
+   */
+  execute() {
+  }
+  /**
+   * Serializes the actions and its related information.
+   * @param parent defines the object to serialize in
+   * @returns the serialized object
+   */
+  serialize(e) {
+    return super._serialize({
+      name: "DoNothingAction",
+      properties: []
+    }, e);
+  }
+}
+class v extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param children defines the list of aggregated animations to run
+   * @param condition defines the trigger related conditions
+   * @param enableChildrenConditions defines if the children actions conditions should be check before execution
+   */
+  constructor(e, t, r, s = !0) {
+    super(e, r), this.children = t, this.enableChildrenConditions = s;
+  }
+  /** @internal */
+  _prepare() {
+    for (let e = 0; e < this.children.length; e++)
+      this.children[e]._actionManager = this._actionManager, this.children[e]._prepare();
+  }
+  /**
+   * Execute the action and executes all the aggregated actions.
+   * @param evt
+   */
+  execute(e) {
+    for (const t of this.children)
+      (!this.enableChildrenConditions || t._evaluateConditionForCurrentFrame()) && t.execute(e);
+  }
+  /**
+   * Serializes the actions and its related information.
+   * @param parent defines the object to serialize in
+   * @returns the serialized object
+   */
+  serialize(e) {
+    const t = super._serialize({
+      name: "CombineAction",
+      properties: [],
+      combine: []
+    }, e);
+    for (let r = 0; r < this.children.length; r++)
+      t.combine.push(this.children[r].serialize(null));
+    return t;
+  }
+}
+class P extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param func defines the callback function to run
+   * @param condition defines the trigger related conditions
+   */
+  constructor(e, t, r) {
+    super(e, r), this.func = t;
+  }
+  /**
+   * Execute the action and run the attached code.
+   * @param evt
+   */
+  execute(e) {
+    this.func(e);
+  }
+}
+class h extends i {
+  /**
+   * Instantiate the action
+   * @param triggerOptions defines the trigger options
+   * @param target defines the target containing the parent property
+   * @param parent defines from where the animation should start (animation frame)
+   * @param condition defines the trigger related conditions
+   */
+  constructor(e, t, r, s) {
+    super(e, s), this._target = t, this._parent = r;
+  }
+  /** @internal */
+  _prepare() {
+  }
+  /**
+   * Execute the action and set the parent property.
+   */
+  execute() {
+    if (this._target.parent === this._parent)
+      return;
+    const e = this._parent.getWorldMatrix().clone();
+    e.invert(), this._target.position = l.TransformCoordinates(this._target.position, e), this._target.parent = this._parent;
+  }
+  /**
+   * Serializes the actions and its related information.
+   * @param parent defines the object to serialize in
+   * @returns the serialized object
+   */
+  serialize(e) {
+    return super._serialize({
+      name: "SetParentAction",
+      properties: [i._GetTargetProperty(this._target), i._GetTargetProperty(this._parent)]
+    }, e);
+  }
+}
+a("BABYLON.SetParentAction", h);
+a("BABYLON.ExecuteCodeAction", P);
+a("BABYLON.DoNothingAction", y);
+a("BABYLON.StopAnimationAction", m);
+a("BABYLON.PlayAnimationAction", f);
+a("BABYLON.IncrementValueAction", A);
+a("BABYLON.SetValueAction", g);
+a("BABYLON.SetStateAction", _);
+a("BABYLON.SetParentAction", h);
+a("BABYLON.SwitchBooleanAction", u);
+a("BABYLON.CombineAction", v);
+export {
+  v as CombineAction,
+  y as DoNothingAction,
+  P as ExecuteCodeAction,
+  A as IncrementValueAction,
+  f as PlayAnimationAction,
+  h as SetParentAction,
+  _ as SetStateAction,
+  g as SetValueAction,
+  m as StopAnimationAction,
+  u as SwitchBooleanAction
+};