@vived/component-abb-6700 1.0.0

package/dist/flowGraphSetVariableBlock-D1oJiwLj.js

@@ -0,0 +1,47 @@
+import { S as b, aM as o, aK as p } from "./index-CS3Icp_r.js";
+class f extends b {
+  constructor(a) {
+    if (super(a), a.variables && a.variable)
+      throw new Error("FlowGraphSetVariableBlock: variable and variables are both defined");
+    if (a.variables)
+      for (const i of a.variables)
+        this.registerDataInput(i, o);
+    else
+      this.registerDataInput("value", o);
+  }
+  _execute(a, i) {
+    if (this.config?.variables)
+      for (const t of this.config.variables)
+        this._saveVariable(a, t);
+    else
+      this._saveVariable(a, this.config?.variable, "value");
+    this.out._activateSignal(a);
+  }
+  _saveVariable(a, i, t) {
+    const e = a._getGlobalContextVariable("currentlyRunningAnimationGroups", []);
+    for (const l of e) {
+      const s = a.assetsContext.animationGroups.find((r) => r.uniqueId == l);
+      if (s) {
+        for (const r of s.targetedAnimations)
+          if (r.target === a && r.animation.targetProperty === i) {
+            s.stop();
+            const n = e.indexOf(l);
+            n > -1 && e.splice(n, 1), a._setGlobalContextVariable("currentlyRunningAnimationGroups", e);
+            break;
+          }
+      }
+    }
+    const u = this.getDataInput(t || i)?.getValue(a);
+    a.setVariable(i, u);
+  }
+  getClassName() {
+    return "FlowGraphSetVariableBlock";
+  }
+  serialize(a) {
+    super.serialize(a), a.config.variable = this.config?.variable;
+  }
+}
+p("FlowGraphSetVariableBlock", f);
+export {
+  f as FlowGraphSetVariableBlock
+};

package/dist/flowGraphSoundEndedEventBlock-CubEwii0.js

@@ -0,0 +1,47 @@
+import { Q as r, aM as d, aK as o } from "./index-CS3Icp_r.js";
+class u extends r {
+  /**
+   * Constructs a new FlowGraphSoundEndedEventBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(e) {
+    super(e), this.sound = this.registerDataInput("sound", d);
+  }
+  /**
+   * @internal
+   */
+  _preparePendingTasks(e) {
+    const s = this.sound.getValue(e);
+    if (!s) {
+      this._reportError(e, "No sound provided for sound-ended event");
+      return;
+    }
+    const n = s.onEndedObservable.add(() => {
+      this._execute(e);
+    });
+    e._setExecutionVariable(this, "_soundEndedObserver", n), e._setExecutionVariable(this, "_subscribedSound", s);
+  }
+  /**
+   * @internal
+   */
+  _executeEvent(e, s) {
+    return !0;
+  }
+  /**
+   * @internal
+   */
+  _cancelPendingTasks(e) {
+    const s = e._getExecutionVariable(this, "_soundEndedObserver", null), n = e._getExecutionVariable(this, "_subscribedSound", null);
+    s && n && n.onEndedObservable.remove(s), e._setExecutionVariable(this, "_soundEndedObserver", null), e._setExecutionVariable(this, "_subscribedSound", null);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSoundEndedEventBlock";
+  }
+}
+o("FlowGraphSoundEndedEventBlock", u);
+export {
+  u as FlowGraphSoundEndedEventBlock
+};

package/dist/flowGraphStopAnimationBlock-B9inwIQx.js

@@ -0,0 +1,48 @@
+import { N as o, aM as e, aS as s, a7 as r, aK as p } from "./index-CS3Icp_r.js";
+class l extends o {
+  constructor(i) {
+    super(i), this.animationGroup = this.registerDataInput("animationGroup", e), this.stopAtFrame = this.registerDataInput("stopAtFrame", s, -1);
+  }
+  _preparePendingTasks(i) {
+    const a = this.animationGroup.getValue(i), t = this.stopAtFrame.getValue(i) ?? -1, n = i._getGlobalContextVariable("pendingStopAnimations", []);
+    n.push({ uniqueId: a.uniqueId, stopAtFrame: t }), i._setGlobalContextVariable("pendingStopAnimations", n);
+  }
+  _cancelPendingTasks(i) {
+    const a = this.animationGroup.getValue(i), t = i._getGlobalContextVariable("pendingStopAnimations", []);
+    for (let n = 0; n < t.length; n++)
+      if (t[n].uniqueId === a.uniqueId) {
+        t.splice(n, 1), i._setGlobalContextVariable("pendingStopAnimations", t);
+        break;
+      }
+  }
+  _execute(i) {
+    const a = this.animationGroup.getValue(i), t = this.stopAtFrame.getValue(i) ?? -1;
+    if (!a)
+      return r.Warn("No animation group provided to stop."), this._reportError(i, "No animation group provided to stop.");
+    if (isNaN(t))
+      return this._reportError(i, "Invalid stop time.");
+    t > 0 ? this._startPendingTasks(i) : this._stopAnimation(a, i), this.out._activateSignal(i);
+  }
+  _executeOnTick(i) {
+    const a = this.animationGroup.getValue(i), t = i._getGlobalContextVariable("pendingStopAnimations", []);
+    for (let n = 0; n < t.length; n++)
+      if (t[n].uniqueId === a.uniqueId && a.getCurrentFrame() >= t[n].stopAtFrame) {
+        this._stopAnimation(a, i), t.splice(n, 1), i._setGlobalContextVariable("pendingStopAnimations", t), this.done._activateSignal(i), i._removePendingBlock(this);
+        break;
+      }
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphStopAnimationBlock";
+  }
+  _stopAnimation(i, a) {
+    const t = a._getGlobalContextVariable("currentlyRunningAnimationGroups", []), n = t.indexOf(i.uniqueId);
+    n !== -1 && (i.stop(), t.splice(n, 1), a._setGlobalContextVariable("currentlyRunningAnimationGroups", t));
+  }
+}
+p("FlowGraphStopAnimationBlock", l);
+export {
+  l as FlowGraphStopAnimationBlock
+};

package/dist/flowGraphStopSoundBlock-BijIX2jC.js

@@ -0,0 +1,31 @@
+import { S as s, aM as a, aK as r } from "./index-CS3Icp_r.js";
+class e extends s {
+  /**
+   * Constructs a new FlowGraphStopSoundBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(o) {
+    super(o), this.sound = this.registerDataInput("sound", a);
+  }
+  /**
+   * @internal
+   */
+  _execute(o, u) {
+    const t = this.sound.getValue(o);
+    if (!t) {
+      this._reportError(o, "No sound provided"), this.out._activateSignal(o);
+      return;
+    }
+    t.stop(), this.out._activateSignal(o);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphStopSoundBlock";
+  }
+}
+r("FlowGraphStopSoundBlock", e);
+export {
+  e as FlowGraphStopSoundBlock
+};

package/dist/flowGraphSwitchBlock-BMhPb4OX.js

@@ -0,0 +1,54 @@
+import { R as a, aM as u, bZ as c, bT as l, aK as o } from "./index-CS3Icp_r.js";
+class r extends a {
+  constructor(t) {
+    super(t), this.config = t, this.default = this._registerSignalOutput("default"), this._caseToOutputFlow = /* @__PURE__ */ new Map(), this.case = this.registerDataInput("case", u);
+    const e = this.config.cases || [];
+    for (const s of e)
+      this._caseToOutputFlow.set(s, this._registerSignalOutput(`out_${s}`));
+  }
+  _execute(t, e) {
+    const s = this.case.getValue(t);
+    let i;
+    c(s) ? i = this._getOutputFlowForCase(l(s)) : i = this._getOutputFlowForCase(s), i ? i._activateSignal(t) : this.default._activateSignal(t);
+  }
+  /**
+   * Adds a new case to the switch block.
+   * @param newCase the new case to add.
+   */
+  addCase(t) {
+    this.config.cases.includes(t) || (this.config.cases.push(t), this._caseToOutputFlow.set(t, this._registerSignalOutput(`out_${t}`)));
+  }
+  /**
+   * Removes a case from the switch block.
+   * @param caseToRemove the case to remove.
+   */
+  removeCase(t) {
+    if (!this.config.cases.includes(t))
+      return;
+    const e = this.config.cases.indexOf(t);
+    this.config.cases.splice(e, 1), this._caseToOutputFlow.delete(t);
+  }
+  /**
+   * @internal
+   */
+  _getOutputFlowForCase(t) {
+    return this._caseToOutputFlow.get(t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSwitchBlock";
+  }
+  /**
+   * Serialize the block to a JSON representation.
+   * @param serializationObject the object to serialize to.
+   */
+  serialize(t) {
+    super.serialize(t), t.cases = this.config.cases;
+  }
+}
+o("FlowGraphSwitchBlock", r);
+export {
+  r as FlowGraphSwitchBlock
+};

package/dist/flowGraphThrottleBlock-C7vrnkb1.js

@@ -0,0 +1,37 @@
+import { S as u, aS as l, aK as h } from "./index-CS3Icp_r.js";
+class o extends u {
+  constructor(i) {
+    super(i), this.reset = this._registerSignalInput("reset"), this.duration = this.registerDataInput("duration", l), this.lastRemainingTime = this.registerDataOutput("lastRemainingTime", l, NaN);
+  }
+  _execute(i, n) {
+    if (n === this.reset) {
+      this.lastRemainingTime.setValue(NaN, i), i._setExecutionVariable(this, "lastRemainingTime", NaN), i._setExecutionVariable(this, "timestamp", 0);
+      return;
+    }
+    const e = this.duration.getValue(i);
+    if (e <= 0 || isNaN(e) || !isFinite(e))
+      return this._reportError(i, "Invalid duration in Throttle block");
+    const m = i._getExecutionVariable(this, "lastRemainingTime", NaN), a = Date.now();
+    if (isNaN(m))
+      return this.lastRemainingTime.setValue(0, i), i._setExecutionVariable(this, "lastRemainingTime", 0), i._setExecutionVariable(this, "timestamp", a), this.out._activateSignal(i);
+    {
+      const t = a - i._getExecutionVariable(this, "timestamp", 0), s = e * 1e3;
+      if (s <= t)
+        return this.lastRemainingTime.setValue(0, i), i._setExecutionVariable(this, "lastRemainingTime", 0), i._setExecutionVariable(this, "timestamp", a), this.out._activateSignal(i);
+      {
+        const r = s - t;
+        this.lastRemainingTime.setValue(r / 1e3, i), i._setExecutionVariable(this, "lastRemainingTime", r);
+      }
+    }
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphThrottleBlock";
+  }
+}
+h("FlowGraphThrottleBlock", o);
+export {
+  o as FlowGraphThrottleBlock
+};

package/dist/flowGraphTransformCoordinatesSystemBlock-DoISqaUG.js

@@ -0,0 +1,29 @@
+import { O as c, aM as e, aW as r, b8 as a, bf as m, aK as h } from "./index-CS3Icp_r.js";
+class y extends c {
+  /**
+   * Creates a new FlowGraphCoordinateTransformBlock
+   * @param config optional configuration for this block
+   */
+  constructor(t) {
+    super(t), this.sourceSystem = this.registerDataInput("sourceSystem", e), this.destinationSystem = this.registerDataInput("destinationSystem", e), this.inputCoordinates = this.registerDataInput("inputCoordinates", r), this.outputCoordinates = this.registerDataOutput("outputCoordinates", r);
+  }
+  _updateOutputs(t) {
+    const i = this.sourceSystem.getValue(t), n = this.destinationSystem.getValue(t), u = this.inputCoordinates.getValue(t), l = i.getWorldMatrix(), p = n.getWorldMatrix(), s = a.Matrix[0].copyFrom(p);
+    s.invert();
+    const o = a.Matrix[1];
+    s.multiplyToRef(l, o);
+    const d = this.outputCoordinates.getValue(t);
+    m.TransformCoordinatesToRef(u, o, d);
+  }
+  /**
+   * Gets the class name of this block
+   * @returns the class name
+   */
+  getClassName() {
+    return "FlowGraphTransformCoordinatesSystemBlock";
+  }
+}
+h("FlowGraphTransformCoordinatesSystemBlock", y);
+export {
+  y as FlowGraphTransformCoordinatesSystemBlock
+};

package/dist/flowGraphTypeToTypeBlocks-CSML6QWx.js

@@ -0,0 +1,57 @@
+import { F as r } from "./flowGraphUnaryOperationBlock-B0Shf-lJ.js";
+import { aS as n, aO as s, T as t, aN as F, aK as l } from "./index-CS3Icp_r.js";
+class p extends r {
+  constructor(a) {
+    super(F, n, (o) => +o, "FlowGraphBooleanToFloat", a);
+  }
+}
+l("FlowGraphBooleanToFloat", p);
+class u extends r {
+  constructor(a) {
+    super(F, s, (o) => t.FromValue(+o), "FlowGraphBooleanToInt", a);
+  }
+}
+l("FlowGraphBooleanToInt", u);
+class c extends r {
+  constructor(a) {
+    super(n, F, (o) => !!o, "FlowGraphFloatToBoolean", a);
+  }
+}
+l("FlowGraphFloatToBoolean", c);
+class h extends r {
+  constructor(a) {
+    super(s, F, (o) => !!o.value, "FlowGraphIntToBoolean", a);
+  }
+}
+l("FlowGraphIntToBoolean", h);
+class w extends r {
+  constructor(a) {
+    super(s, n, (o) => o.value, "FlowGraphIntToFloat", a);
+  }
+}
+l("FlowGraphIntToFloat", w);
+class T extends r {
+  constructor(a) {
+    super(n, s, (o) => {
+      switch (a?.roundingMode) {
+        case "floor":
+          return t.FromValue(Math.floor(o));
+        case "ceil":
+          return t.FromValue(Math.ceil(o));
+        case "round":
+          return t.FromValue(Math.round(o));
+        default:
+          return t.FromValue(o);
+      }
+    }, "FlowGraphFloatToInt", a);
+  }
+}
+l("FlowGraphFloatToInt", T);
+export {
+  p as FlowGraphBooleanToFloat,
+  u as FlowGraphBooleanToInt,
+  c as FlowGraphFloatToBoolean,
+  T as FlowGraphFloatToInt,
+  h as FlowGraphIntToBoolean,
+  w as FlowGraphIntToFloat
+};

package/dist/flowGraphUnaryOperationBlock-B0Shf-lJ.js

@@ -0,0 +1,24 @@
+import { F as o } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+class p extends o {
+  constructor(a, t, s, e, r) {
+    super(t, r), this._operation = s, this._className = e, this.a = this.registerDataInput("a", a);
+  }
+  /**
+   * the operation performed by this block
+   * @param context the graph context
+   * @returns the result of the operation
+   */
+  _doOperation(a) {
+    return this._operation(this.a.getValue(a));
+  }
+  /**
+   * Gets the class name of this block
+   * @returns the class name
+   */
+  getClassName() {
+    return this._className;
+  }
+}
+export {
+  p as F
+};

package/dist/flowGraphVectorMathBlocks-DoTRR_E0.js

@@ -0,0 +1,178 @@
+import { aJ as w, x as k, bf as F, aW as a, aT as c, O as f, aS as i, aN as y, aP as A, bW as m, aV as d, aM as h, bm as u, bg as C, aK as s } from "./index-CS3Icp_r.js";
+import { F as n } from "./flowGraphBinaryOperationBlock-Bj7TANCc.js";
+import { F as g } from "./flowGraphUnaryOperationBlock-B0Shf-lJ.js";
+function T(o, e) {
+  return o.x * e.x + o.y * e.y + o.z * e.z;
+}
+function D(o, e) {
+  return o.x * e.x + o.y * e.y + o.z * e.z + o.w * e.w;
+}
+function N(o, e) {
+  return Math.acos(k(D(o, e), -1, 1)) * 2;
+}
+function R(o, e) {
+  const r = new w();
+  return Q(o, e, r), r;
+}
+function Q(o, e, r) {
+  const t = F.Cross(o, e), l = Math.acos(k(T(o, e), -1, 1));
+  return w.RotationAxisToRef(t, l, r), r;
+}
+const G = "cachedOperationAxis", V = "cachedOperationAngle", x = "cachedExecutionId";
+class z extends g {
+  constructor(e) {
+    super(h, i, (r) => this._polymorphicLength(r), "FlowGraphLengthBlock", e);
+  }
+  _polymorphicLength(e) {
+    switch (u(e)) {
+      case "Vector2":
+      case "Vector3":
+      case "Vector4":
+      case "Quaternion":
+        return e.length();
+      default:
+        throw new Error(`Cannot compute length of value ${e}`);
+    }
+  }
+}
+s("FlowGraphLengthBlock", z);
+class _ extends g {
+  constructor(e) {
+    super(h, h, (r) => this._polymorphicNormalize(r), "FlowGraphNormalizeBlock", e);
+  }
+  _polymorphicNormalize(e) {
+    const r = u(e);
+    let t;
+    switch (r) {
+      case "Vector2":
+      case "Vector3":
+      case "Vector4":
+      case "Quaternion":
+        return t = e.normalizeToNew(), this.config?.nanOnZeroLength && e.length() === 0 && t.setAll(NaN), t;
+      default:
+        throw new Error(`Cannot normalize value ${e}`);
+    }
+  }
+}
+s("FlowGraphNormalizeBlock", _);
+class E extends n {
+  constructor(e) {
+    super(h, h, i, (r, t) => this._polymorphicDot(r, t), "FlowGraphDotBlock", e);
+  }
+  _polymorphicDot(e, r) {
+    switch (u(e)) {
+      case "Vector2":
+      case "Vector3":
+      case "Vector4":
+      case "Quaternion":
+        return e.dot(r);
+      default:
+        throw new Error(`Cannot get dot product of ${e} and ${r}`);
+    }
+  }
+}
+s("FlowGraphDotBlock", E);
+class O extends n {
+  constructor(e) {
+    super(a, a, a, (r, t) => F.Cross(r, t), "FlowGraphCrossBlock", e);
+  }
+}
+s("FlowGraphCrossBlock", O);
+class M extends n {
+  constructor(e) {
+    super(d, i, d, (r, t) => r.rotate(t), "FlowGraphRotate2DBlock", e);
+  }
+}
+s("FlowGraphRotate2DBlock", M);
+class I extends n {
+  constructor(e) {
+    super(a, c, a, (r, t) => r.applyRotationQuaternion(t), "FlowGraphRotate3DBlock", e);
+  }
+}
+s("FlowGraphRotate3DBlock", I);
+function L(o, e) {
+  switch (u(o)) {
+    case "Vector2":
+      return e.transformVector(o);
+    case "Vector3":
+      return e.transformVector(o);
+    case "Vector4":
+      return o = o, new C(o.x * e.m[0] + o.y * e.m[1] + o.z * e.m[2] + o.w * e.m[3], o.x * e.m[4] + o.y * e.m[5] + o.z * e.m[6] + o.w * e.m[7], o.x * e.m[8] + o.y * e.m[9] + o.z * e.m[10] + o.w * e.m[11], o.x * e.m[12] + o.y * e.m[13] + o.z * e.m[14] + o.w * e.m[15]);
+    default:
+      throw new Error(`Cannot transform value ${o}`);
+  }
+}
+class v extends n {
+  constructor(e) {
+    const r = e?.vectorType || "Vector3", t = r === "Vector2" ? "Matrix2D" : r === "Vector3" ? "Matrix3D" : "Matrix";
+    super(m(r), m(t), m(r), L, "FlowGraphTransformVectorBlock", e);
+  }
+}
+s("FlowGraphTransformVectorBlock", v);
+class $ extends n {
+  constructor(e) {
+    super(a, A, a, (r, t) => F.TransformCoordinates(r, t), "FlowGraphTransformCoordinatesBlock", e);
+  }
+}
+s("FlowGraphTransformCoordinatesBlock", $);
+class j extends g {
+  constructor(e) {
+    super(c, c, (r) => r.conjugate(), "FlowGraphConjugateBlock", e);
+  }
+}
+s("FlowGraphConjugateBlock", j);
+class W extends n {
+  constructor(e) {
+    super(c, c, i, (r, t) => N(r, t), "FlowGraphAngleBetweenBlock", e);
+  }
+}
+s("FlowGraphAngleBetweenBlock", W);
+class J extends n {
+  constructor(e) {
+    super(a, i, c, (r, t) => w.RotationAxis(r, t), "FlowGraphQuaternionFromAxisAngleBlock", e);
+  }
+}
+s("FlowGraphQuaternionFromAxisAngleBlock", J);
+class K extends f {
+  constructor(e) {
+    super(e), this.a = this.registerDataInput("a", c), this.axis = this.registerDataOutput("axis", a), this.angle = this.registerDataOutput("angle", i), this.isValid = this.registerDataOutput("isValid", y);
+  }
+  /** @override */
+  _updateOutputs(e) {
+    const r = e._getExecutionVariable(this, x, -1), t = e._getExecutionVariable(this, G, null), l = e._getExecutionVariable(this, V, null);
+    if (t != null && l !== void 0 && l !== null && r === e.executionId)
+      this.axis.setValue(t, e), this.angle.setValue(l, e);
+    else
+      try {
+        const { axis: p, angle: B } = this.a.getValue(e).toAxisAngle();
+        e._setExecutionVariable(this, G, p), e._setExecutionVariable(this, V, B), e._setExecutionVariable(this, x, e.executionId), this.axis.setValue(p, e), this.angle.setValue(B, e), this.isValid.setValue(!0, e);
+      } catch {
+        this.isValid.setValue(!1, e);
+      }
+  }
+  /** @override */
+  getClassName() {
+    return "FlowGraphAxisAngleFromQuaternionBlock";
+  }
+}
+s("FlowGraphAxisAngleFromQuaternionBlock", K);
+class Z extends n {
+  constructor(e) {
+    super(a, a, c, (r, t) => R(r, t), "FlowGraphQuaternionFromDirectionsBlock", e);
+  }
+}
+export {
+  W as FlowGraphAngleBetweenBlock,
+  K as FlowGraphAxisAngleFromQuaternionBlock,
+  j as FlowGraphConjugateBlock,
+  O as FlowGraphCrossBlock,
+  E as FlowGraphDotBlock,
+  z as FlowGraphLengthBlock,
+  _ as FlowGraphNormalizeBlock,
+  J as FlowGraphQuaternionFromAxisAngleBlock,
+  Z as FlowGraphQuaternionFromDirectionsBlock,
+  M as FlowGraphRotate2DBlock,
+  I as FlowGraphRotate3DBlock,
+  v as FlowGraphTransformBlock,
+  $ as FlowGraphTransformCoordinatesBlock
+};

package/dist/flowGraphWaitAllBlock-BvmDMc24.js

@@ -0,0 +1,54 @@
+import { S as n, aO as l, T as a, aK as o } from "./index-CS3Icp_r.js";
+class r extends n {
+  constructor(i) {
+    super(i), this.config = i, this.inFlows = [], this._cachedActivationState = [], this.reset = this._registerSignalInput("reset"), this.completed = this._registerSignalOutput("completed"), this.remainingInputs = this.registerDataOutput("remainingInputs", l, new a(this.config.inputSignalCount || 0));
+    for (let e = 0; e < this.config.inputSignalCount; e++)
+      this.inFlows.push(this._registerSignalInput(`in_${e}`));
+    this._unregisterSignalInput("in");
+  }
+  _getCurrentActivationState(i) {
+    const e = this._cachedActivationState;
+    if (e.length = 0, i._hasExecutionVariable(this, "activationState")) {
+      const s = i._getExecutionVariable(this, "activationState", []);
+      for (let t = 0; t < s.length; t++)
+        e.push(s[t]);
+    } else
+      for (let s = 0; s < this.config.inputSignalCount; s++)
+        e.push(!1);
+    return e;
+  }
+  _execute(i, e) {
+    const s = this._getCurrentActivationState(i);
+    if (e === this.reset)
+      for (let t = 0; t < this.config.inputSignalCount; t++)
+        s[t] = !1;
+    else {
+      const t = this.inFlows.indexOf(e);
+      t >= 0 && (s[t] = !0);
+    }
+    if (this.remainingInputs.setValue(new a(s.filter((t) => !t).length), i), i._setExecutionVariable(this, "activationState", s.slice()), s.includes(!1))
+      e !== this.reset && this.out._activateSignal(i);
+    else {
+      this.completed._activateSignal(i);
+      for (let t = 0; t < this.config.inputSignalCount; t++)
+        s[t] = !1;
+    }
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphWaitAllBlock";
+  }
+  /**
+   * Serializes this block into a object
+   * @param serializationObject the object to serialize to
+   */
+  serialize(i) {
+    super.serialize(i), i.config.inputFlows = this.config.inputSignalCount;
+  }
+}
+o("FlowGraphWaitAllBlock", r);
+export {
+  r as FlowGraphWaitAllBlock
+};

package/dist/flowGraphWhileLoopBlock-BaIq4-K2.js

@@ -0,0 +1,27 @@
+import { S as a, aN as l, a7 as n, aK as s } from "./index-CS3Icp_r.js";
+class t extends a {
+  constructor(i) {
+    super(i), this.config = i, this.condition = this.registerDataInput("condition", l), this.executionFlow = this._registerSignalOutput("executionFlow"), this.completed = this._registerSignalOutput("completed"), this._unregisterSignalOutput("out");
+  }
+  _execute(i, h) {
+    let e = this.condition.getValue(i);
+    this.config?.doWhile && !e && this.executionFlow._activateSignal(i);
+    let o = 0;
+    for (; e; ) {
+      if (this.executionFlow._activateSignal(i), ++o, o >= t.MaxLoopCount) {
+        n.Warn("FlowGraphWhileLoopBlock: Max loop count reached. Breaking.");
+        break;
+      }
+      e = this.condition.getValue(i);
+    }
+    this.completed._activateSignal(i);
+  }
+  getClassName() {
+    return "FlowGraphWhileLoopBlock";
+  }
+}
+t.MaxLoopCount = 1e3;
+s("FlowGraphWhileLoopBlock", t);
+export {
+  t as FlowGraphWhileLoopBlock
+};