zeed 0.7.113 → 0.7.117

package/dist/{chunk-MN2DIK4K.js → chunk-AYKBI7RN.js}

@@ -5,7 +5,7 @@ import {
   __spreadValues,
   getGlobalContext,
   getTimestamp
-} from "./chunk-DUGVRMRT.js";
+} from "./chunk-G3LBBVZT.js";
 
 // src/common/data/bin.ts
 var log = Logger("bin");
@@ -272,6 +272,14 @@ function between(min, value, max) {
   return Math.max(min, Math.min(max, value));
 }
 __name(between, "between");
+function sum(array) {
+  return array.reduce((acc, value) => acc + value, 0);
+}
+__name(sum, "sum");
+function avg(array) {
+  return sum(array) / array.length;
+}
+__name(avg, "avg");
 
 // src/common/data/orderby.ts
 function parseOrderby(value = "") {
@@ -417,6 +425,25 @@ function arrayMin(...array) {
   return arrayFlatten(array).reduce((acc, value) => acc != null ? value < acc ? value : acc : value, void 0);
 }
 __name(arrayMin, "arrayMin");
+function arraySum(...array) {
+  return arrayFlatten(array).reduce((acc, value) => acc + value, 0);
+}
+__name(arraySum, "arraySum");
+function arrayAvg(...array) {
+  let flatArray = arrayFlatten(array);
+  return flatArray.reduce((acc, value) => acc + value, 0) / flatArray.length;
+}
+__name(arrayAvg, "arrayAvg");
+function arrayBatches(array, chunckLength) {
+  let chunks = [];
+  let i = 0;
+  const n = array.length;
+  while (i < n) {
+    chunks.push(array.slice(i, i += chunckLength));
+  }
+  return chunks;
+}
+__name(arrayBatches, "arrayBatches");
 function createArray(size2 = 0, item) {
   if (size2 <= 0)
     return [];
@@ -808,6 +835,7 @@ var Currency = _Currency;
 __name(Currency, "Currency");
 Currency.zero = new _Currency(0);
 Currency.one = new _Currency(1);
+Currency.hundred = new _Currency(100);
 function parse(value, opts, useRounding = true) {
   let v = 0, { decimal, errorOnInvalid, precision: decimals, fromCents } = opts, precision = pow(decimals), isNumber = typeof value === "number";
   if (value instanceof Currency && fromCents) {
@@ -1046,7 +1074,6 @@ var Day = class {
     if (mm === 0)
       mm = 12;
     let yy = Math.floor((m - 1) / 12);
-    console.log("calc", m, mm, yy, [this.year + yy, mm, this.day]);
     return Day.from([this.year + yy, mm, this.day]);
   }
   daysUntil(otherDay) {
@@ -1282,6 +1309,128 @@ function cloneJsonObject(obj) {
   return JSON.parse(JSON.stringify(obj));
 }
 __name(cloneJsonObject, "cloneJsonObject");
+function memoize(fn) {
+  let cache = /* @__PURE__ */ new Map();
+  return (n) => {
+    if (cache.has(n)) {
+      return cache.get(n);
+    }
+    let result = fn(n);
+    cache.set(n, result);
+    return result;
+  };
+}
+__name(memoize, "memoize");
+
+// src/common/data/xrx.ts
+var RX_WHITESPACE = /\\\s|\s+|#[^\n]*\n?/gm;
+var RX_REAL_GROUPS = /\(\?P?<(\w[\w\d_]+)>|\((?!\?(:|\!|=|<=|<\!))/gm;
+var RX_LOOK_BEHIND = /^((?:\(\?[\w$]+\))?)\(\?<([=!])([\s\S]*?)\)/gm;
+function regExpString(rx) {
+  return typeof rx === "string" ? rx : rx.source || "";
+}
+__name(regExpString, "regExpString");
+function regExpEscape(str) {
+  return str.replace(/[-\[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+__name(regExpEscape, "regExpEscape");
+var XRX = class {
+  constructor(pattern2, flags) {
+    this.namedGroups = {};
+    this.names = [];
+    let _flags = flags != null ? flags : "";
+    let _rx;
+    if (pattern2 instanceof RegExp) {
+      if (flags == null) {
+        _flags = pattern2.flags;
+      }
+      _rx = pattern2.source;
+    } else {
+      _rx = pattern2;
+    }
+    const extended = _flags && _flags.indexOf("x") !== -1;
+    if (extended) {
+      _flags = _flags.replace("x", "");
+      _rx = _rx.replace(RX_WHITESPACE, (r) => {
+        return r[0] === "\\" ? r : "";
+      });
+    }
+    if (!(pattern2 instanceof RegExp)) {
+      let index = 0;
+      _rx = _rx.replace(RX_REAL_GROUPS, (str, name) => {
+        index += 1;
+        if (name) {
+          if (name !== "index" && name !== "length" && !this.namedGroups[name]) {
+            this.namedGroups[name] = index;
+          } else {
+            console.error(`Unallowed or duplicate group name: ${name}`);
+          }
+          return "(";
+        }
+        return str;
+      });
+      this.names = Object.keys(this.namedGroups);
+    }
+    _rx = regExpString(_rx);
+    RX_LOOK_BEHIND.lastIndex = 0;
+    let parts = RX_LOOK_BEHIND.exec(_rx);
+    if (parts) {
+      this.lookBehind = {
+        rx: new RegExp(`${parts[3]}$(?!\\s)`),
+        expect: parts ? parts[2] === "=" : !parts
+      };
+      _rx = _rx.substr(parts[0].length);
+    }
+    this.rx = new RegExp(_rx, _flags);
+  }
+  get lastIndex() {
+    return this.rx.lastIndex;
+  }
+  set lastIndex(index) {
+    this.rx.lastIndex = index;
+  }
+  _handleMatch(m) {
+    if (this.lookBehind) {
+      let leftContext = m.input.slice(0, m.index);
+      if (this.lookBehind.expect !== this.lookBehind.rx.test(leftContext)) {
+        return null;
+      }
+    }
+    for (let name of this.names) {
+      m[name] = m[this.namedGroups[name]];
+    }
+    return m;
+  }
+  exec(str) {
+    let m;
+    while (m = this.rx.exec(str)) {
+      if (this.rx.lastIndex === m.index) {
+        this.rx.lastIndex++;
+      }
+      m = this._handleMatch(m);
+      if (m != null) {
+        return m;
+      }
+    }
+  }
+  execAll(str) {
+    let matches = [];
+    let m;
+    this.rx.lastIndex = 0;
+    while (m = this.exec(str)) {
+      matches.push(m);
+    }
+    this.rx.lastIndex = 0;
+    return matches;
+  }
+  replace(str, replacement) {
+    let fn = typeof replacement === "function" ? replacement : () => replacement;
+    return str.replace(this.rx, (m) => {
+      return fn(m);
+    });
+  }
+};
+__name(XRX, "XRX");
 
 // src/common/dispose-defer.ts
 var log3 = Logger("dispose");
@@ -2216,11 +2365,14 @@ __name(usePool, "usePool");
 
 // src/common/queue.ts
 var log6 = Logger("zeed:queue");
-var SerialQueue = class {
+var SerialQueue = class extends Emitter {
   constructor(opt = {}) {
+    super();
     this.queue = [];
     this.isPaused = false;
     this.waitToFinish = [];
+    this.max = 0;
+    this.resolved = 0;
     const { name = uname("queue"), logLevel } = opt;
     this.name = name;
     this.log = Logger(`zeed:queue:${name}`);
@@ -2242,6 +2394,10 @@ var SerialQueue = class {
       if (info == null) {
         break;
       }
+      if (this.resolved === 0) {
+        this.emit("didStart", this.max);
+        this.emit("didUpdate", this.max, 0);
+      }
       const { name, task, resolve } = info;
       this.currentTask = task();
       let result = void 0;
@@ -2254,6 +2410,13 @@ var SerialQueue = class {
       }
       resolve(result);
       this.currentTask = void 0;
+      this.resolved += 1;
+      this.emit("didUpdate", this.max, this.resolved);
+    }
+    if (this.queue.length === 0) {
+      this.emit("didFinish", this.max);
+      this.max = 0;
+      this.resolved = 0;
     }
     while (this.waitToFinish.length > 0) {
       this.waitToFinish.shift()();
@@ -2265,6 +2428,7 @@ var SerialQueue = class {
       this.log.info(`immediate execution ${name}`);
       return await task();
     }
+    this.max += 1;
     this.log(`enqueue ${name}`);
     return new Promise((resolve) => {
       this.queue.push({
@@ -2283,6 +2447,7 @@ var SerialQueue = class {
   }
   async cancelAll(unblock = true) {
     this.log(`cancelAll`);
+    this.emit("didCancel", this.queue.length);
     let resolver = this.queue.map((task) => task.resolve);
     this.queue = [];
     resolver.forEach((r) => r(void 0));
@@ -2451,6 +2616,8 @@ export {
   randomInt,
   randomFloat,
   between,
+  sum,
+  avg,
   parseOrderby,
   composeOrderby,
   cmp,
@@ -2475,6 +2642,9 @@ export {
   arrayRandomElement,
   arrayMax,
   arrayMin,
+  arraySum,
+  arrayAvg,
+  arrayBatches,
   createArray,
   useBase,
   encodeBase16,
@@ -2552,6 +2722,10 @@ export {
   empty,
   cloneObject,
   cloneJsonObject,
+  memoize,
+  regExpString,
+  regExpEscape,
+  XRX,
   useDispose,
   useDisposer,
   useDefer,
@@ -2607,4 +2781,4 @@ export {
   throttle,
   debounce
 };
-//# sourceMappingURL=chunk-MN2DIK4K.js.map
+//# sourceMappingURL=chunk-AYKBI7RN.js.map