@valkey/valkey-glide-darwin-arm64 1.2.0 → 1.2.1-rc1

package/rust-client/node_modules/mingo/dist/cjs/operators/pipeline/bucket.js

@@ -24,70 +24,70 @@ var import_core = require("../../core");
 var import_lazy = require("../../lazy");
 var import_util = require("../../util");
 const $bucket = (collection, expr, options) => {
-  const boundaries = [...expr.boundaries];
+  const bounds = [...expr.boundaries];
   const defaultKey = expr.default;
-  const lower = boundaries[0];
-  const upper = boundaries[boundaries.length - 1];
+  const lower = bounds[0];
+  const upper = bounds[bounds.length - 1];
   const outputExpr = expr.output || { count: { $sum: 1 } };
+  (0, import_util.assert)(bounds.length > 1, "$bucket must specify at least two boundaries.");
+  const isValid = bounds.every(
+    (v, i) => i === 0 || (0, import_util.typeOf)(v) === (0, import_util.typeOf)(bounds[i - 1]) && (0, import_util.compare)(v, bounds[i - 1]) > 0
+  );
   (0, import_util.assert)(
-    expr.boundaries.length > 2,
-    "$bucket 'boundaries' expression must have at least 3 elements"
+    isValid,
+    `$bucket: bounds must be of same type and in ascending order`
   );
-  const boundType = (0, import_util.getType)(lower);
-  for (let i = 0, len = boundaries.length - 1; i < len; i++) {
+  if (!(0, import_util.isNil)(defaultKey) && (0, import_util.typeOf)(defaultKey) === (0, import_util.typeOf)(lower)) {
     (0, import_util.assert)(
-      boundType === (0, import_util.getType)(boundaries[i + 1]),
-      "$bucket 'boundaries' must all be of the same type"
+      (0, import_util.compare)(defaultKey, upper) >= 0 || (0, import_util.compare)(defaultKey, lower) < 0,
+      "$bucket 'default' expression must be out of boundaries range"
     );
+  }
+  const createBuckets = () => {
+    const buckets = /* @__PURE__ */ new Map();
+    for (let i = 0; i < bounds.length - 1; i++) {
+      buckets.set(bounds[i], []);
+    }
+    if (!(0, import_util.isNil)(defaultKey)) buckets.set(defaultKey, []);
+    collection.each((obj) => {
+      const key = (0, import_core.computeValue)(obj, expr.groupBy, null, options);
+      if ((0, import_util.isNil)(key) || (0, import_util.compare)(key, lower) < 0 || (0, import_util.compare)(key, upper) >= 0) {
+        (0, import_util.assert)(
+          !(0, import_util.isNil)(defaultKey),
+          "$bucket require a default for out of range values"
+        );
+        buckets.get(defaultKey).push(obj);
+      } else {
+        (0, import_util.assert)(
+          (0, import_util.compare)(key, lower) >= 0 && (0, import_util.compare)(key, upper) < 0,
+          "$bucket 'groupBy' expression must resolve to a value in range of boundaries"
+        );
+        const index = (0, import_util.findInsertIndex)(bounds, key);
+        const boundKey = bounds[Math.max(0, index - 1)];
+        buckets.get(boundKey).push(obj);
+      }
+    });
+    bounds.pop();
+    if (!(0, import_util.isNil)(defaultKey)) bounds.push(defaultKey);
     (0, import_util.assert)(
-      (0, import_util.compare)(boundaries[i], boundaries[i + 1]) < 0,
-      "$bucket 'boundaries' must be sorted in ascending order"
+      buckets.size === bounds.length,
+      "bounds and groups must be of equal size."
     );
-  }
-  !(0, import_util.isNil)(defaultKey) && (0, import_util.getType)(expr.default) === (0, import_util.getType)(lower) && (0, import_util.assert)(
-    (0, import_util.compare)(expr.default, upper) >= 0 || (0, import_util.compare)(expr.default, lower) < 0,
-    "$bucket 'default' expression must be out of boundaries range"
-  );
-  const grouped = {};
-  for (const k of boundaries) {
-    grouped[k] = [];
-  }
-  if (!(0, import_util.isNil)(defaultKey))
-    grouped[defaultKey] = [];
-  let iterator;
-  return (0, import_lazy.Lazy)(() => {
-    if (!iterator) {
-      collection.each((obj) => {
-        const key = (0, import_core.computeValue)(obj, expr.groupBy, null, options);
-        if ((0, import_util.isNil)(key) || (0, import_util.compare)(key, lower) < 0 || (0, import_util.compare)(key, upper) >= 0) {
-          (0, import_util.assert)(
-            !(0, import_util.isNil)(defaultKey),
-            "$bucket require a default for out of range values"
-          );
-          grouped[defaultKey].push(obj);
-        } else {
-          (0, import_util.assert)(
-            (0, import_util.compare)(key, lower) >= 0 && (0, import_util.compare)(key, upper) < 0,
-            "$bucket 'groupBy' expression must resolve to a value in range of boundaries"
-          );
-          const index = (0, import_util.findInsertIndex)(boundaries, key);
-          const boundKey = boundaries[Math.max(0, index - 1)];
-          grouped[boundKey].push(obj);
-        }
-      });
-      boundaries.pop();
-      if (!(0, import_util.isNil)(defaultKey))
-        boundaries.push(defaultKey);
-      iterator = (0, import_lazy.Lazy)(boundaries).map((key) => {
-        const acc = (0, import_core.computeValue)(
-          grouped[key],
+    return (0, import_lazy.Lazy)(bounds).map((key) => {
+      return {
+        ...(0, import_core.computeValue)(
+          buckets.get(key),
           outputExpr,
           null,
           options
-        );
-        return (0, import_util.into)(acc, { _id: key });
-      });
-    }
+        ),
+        _id: key
+      };
+    });
+  };
+  let iterator;
+  return (0, import_lazy.Lazy)(() => {
+    if (!iterator) iterator = createBuckets();
     return iterator.next();
   });
 };