@cadenza.io/core 3.13.2 → 3.14.0

package/dist/index.mjs

@@ -42,11 +42,227 @@ function formatTimestamp(timestamp) {
 
 // src/engine/SignalBroker.ts
 import { v4 as uuid } from "uuid";
+
+// node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// node_modules/lodash-es/now.js
+var now = function() {
+  return root_default.Date.now();
+};
+var now_default = now;
+
+// node_modules/lodash-es/_trimmedEndIndex.js
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
+  }
+  return index;
+}
+var trimmedEndIndex_default = trimmedEndIndex;
+
+// node_modules/lodash-es/_baseTrim.js
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex_default(string) + 1).replace(reTrimStart, "") : string;
+}
+var baseTrim_default = baseTrim;
+
+// node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// node_modules/lodash-es/isSymbol.js
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
+}
+var isSymbol_default = isSymbol;
+
+// node_modules/lodash-es/toNumber.js
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol_default(value)) {
+    return NAN;
+  }
+  if (isObject_default(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject_default(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim_default(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var toNumber_default = toNumber;
+
+// node_modules/lodash-es/debounce.js
+var FUNC_ERROR_TEXT = "Expected a function";
+var nativeMax = Math.max;
+var nativeMin = Math.min;
+function debounce(func, wait, options) {
+  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+  if (typeof func != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber_default(wait) || 0;
+  if (isObject_default(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? nativeMax(toNumber_default(options.maxWait) || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now_default();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now_default());
+  }
+  function debounced() {
+    var time = now_default(), isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+var debounce_default = debounce;
+
+// src/engine/SignalBroker.ts
 var SignalBroker = class _SignalBroker {
   // execId -> emitted signals
   constructor() {
     this.debug = false;
     this.verbose = false;
+    this.debouncedEmitters = /* @__PURE__ */ new Map();
     // TODO: Signals should be a class with a the observers, registered flag and other data.
     this.signalObservers = /* @__PURE__ */ new Map();
     this.emitStacks = /* @__PURE__ */ new Map();
@@ -133,15 +349,15 @@ var SignalBroker = class _SignalBroker {
         }
       }));
       return {
-        __signals: processedSignals,
+        signals: processedSignals,
         ...ctx
       };
     });
     this.registerSignalTask = Cadenza.createMetaTask(
       "Register signal",
       (ctx) => {
-        const { __signalName } = ctx;
-        this.signalObservers.get(__signalName).registered = true;
+        const { signalName } = ctx;
+        this.signalObservers.get(signalName).registered = true;
       }
     ).doOn("meta.signal.registered");
   }
@@ -210,20 +426,20 @@ var SignalBroker = class _SignalBroker {
     }
     const emit = () => this.emit(signal, context);
     if (leading) {
-      const now = Date.now();
+      const now2 = Date.now();
       const start = startDateTime?.getTime();
-      if (!start || start <= now) {
+      if (!start || start <= now2) {
         emit();
       }
     }
     let firstDelay = intervalMs;
     if (startDateTime) {
       let slot = startDateTime.getTime();
-      const now = Date.now();
-      while (slot < now) {
+      const now2 = Date.now();
+      while (slot < now2) {
         slot += intervalMs;
       }
-      firstDelay = slot - now;
+      firstDelay = slot - now2;
     }
     let timer = null;
     let stopped = false;
@@ -240,6 +456,19 @@ var SignalBroker = class _SignalBroker {
       }
     };
   }
+  debounce(signal, context, delayMs = 500) {
+    let debouncedEmitter = this.debouncedEmitters.get(signal);
+    if (!debouncedEmitter) {
+      this.debouncedEmitters.set(
+        signal,
+        debounce_default((ctx) => {
+          this.emit(signal, ctx);
+        }, delayMs)
+      );
+      debouncedEmitter = this.debouncedEmitters.get(signal);
+    }
+    debouncedEmitter(context);
+  }
   /**
    * Emits a signal with the specified context, triggering any associated handlers for that signal.
    *
@@ -407,7 +636,7 @@ var SignalBroker = class _SignalBroker {
           return;
         }
       }
-      this.emit("meta.signal_broker.added", { __signalName: _signal });
+      this.emit("meta.signal_broker.added", { signalName: _signal });
     }
   }
   /**
@@ -2383,6 +2612,7 @@ var Task = class _Task extends SignalEmitter {
    */
   doAfter(...tasks) {
     for (const pred of tasks) {
+      if (!pred) continue;
       if (this.predecessorTasks.has(pred)) continue;
       pred.nextTasks.add(this);
       this.predecessorTasks.add(pred);
@@ -2413,6 +2643,7 @@ var Task = class _Task extends SignalEmitter {
    */
   then(...tasks) {
     for (const next of tasks) {
+      if (!next) continue;
       if (this.nextTasks.has(next)) continue;
       this.nextTasks.add(next);
       next.predecessorTasks.add(this);
@@ -4286,6 +4517,9 @@ var Cadenza = class {
       startDateTime
     );
   }
+  static debounce(signalName, context, delayMs) {
+    this.broker?.debounce(signalName, context, delayMs);
+  }
   static get(taskName) {
     return this.registry?.tasks.get(taskName);
   }