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

package/rust-client/node_modules/mingo/dist/esm/cursor.js

@@ -1,36 +1,39 @@
 import { Aggregator } from "./aggregator";
-import { compose, Lazy } from "./lazy";
+import { concat, Lazy } from "./lazy";
 import { isObject } from "./util";
 class Cursor {
+  #source;
+  #predicate;
+  #projection;
+  #options;
+  #operators = [];
+  #result = null;
+  #buffer = [];
   constructor(source, predicate, projection, options) {
-    this.source = source;
-    this.predicate = predicate;
-    this.projection = projection;
-    this.options = options;
-    this.operators = [];
-    this.result = null;
-    this.buffer = [];
+    this.#source = source;
+    this.#predicate = predicate;
+    this.#projection = projection;
+    this.#options = options;
   }
   /** Returns the iterator from running the query */
   fetch() {
-    if (this.result)
-      return this.result;
-    if (isObject(this.projection)) {
-      this.operators.push({ $project: this.projection });
+    if (this.#result) return this.#result;
+    if (isObject(this.#projection)) {
+      this.#operators.push({ $project: this.#projection });
     }
-    this.result = Lazy(this.source).filter(this.predicate);
-    if (this.operators.length > 0) {
-      this.result = new Aggregator(this.operators, this.options).stream(
-        this.result
+    this.#result = Lazy(this.#source).filter(this.#predicate);
+    if (this.#operators.length > 0) {
+      this.#result = new Aggregator(this.#operators, this.#options).stream(
+        this.#result
       );
     }
-    return this.result;
+    return this.#result;
   }
   /** Returns an iterator with the buffered data included */
   fetchAll() {
-    const buffered = Lazy([...this.buffer]);
-    this.buffer = [];
-    return compose(buffered, this.fetch());
+    const buffered = Lazy([...this.#buffer]);
+    this.#buffer = [];
+    return concat(buffered, this.fetch());
   }
   /**
    * Return remaining objects in the cursor as an array. This method exhausts the cursor
@@ -52,7 +55,7 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   skip(n) {
-    this.operators.push({ $skip: n });
+    this.#operators.push({ $skip: n });
     return this;
   }
   /**
@@ -61,16 +64,16 @@ class Cursor {
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   limit(n) {
-    this.operators.push({ $limit: n });
+    this.#operators.push({ $limit: n });
     return this;
   }
   /**
    * Returns results ordered according to a sort specification.
-   * @param {Object} modifier an object of key and values specifying the sort order. 1 for ascending and -1 for descending
+   * @param {AnyObject} modifier an object of key and values specifying the sort order. 1 for ascending and -1 for descending
    * @return {Cursor} Returns the cursor, so you can chain this call.
    */
   sort(modifier) {
-    this.operators.push({ $sort: modifier });
+    this.#operators.push({ $sort: modifier });
     return this;
   }
   /**
@@ -78,20 +81,19 @@ class Cursor {
    * @param {*} spec
    */
   collation(spec) {
-    this.options = { ...this.options, collation: spec };
+    this.#options = { ...this.#options, collation: spec };
     return this;
   }
   /**
    * Returns the next document in a cursor.
-   * @returns {Object | Boolean}
+   * @returns {AnyObject | Boolean}
    */
   next() {
-    if (this.buffer.length > 0) {
-      return this.buffer.pop();
+    if (this.#buffer.length > 0) {
+      return this.#buffer.pop();
     }
     const o = this.fetch().next();
-    if (o.done)
-      return;
+    if (o.done) return;
     return o.value;
   }
   /**
@@ -99,12 +101,10 @@ class Cursor {
    * @returns {boolean}
    */
   hasNext() {
-    if (this.buffer.length > 0)
-      return true;
+    if (this.#buffer.length > 0) return true;
     const o = this.fetch().next();
-    if (o.done)
-      return false;
-    this.buffer.push(o.value);
+    if (o.done) return false;
+    this.#buffer.push(o.value);
     return true;
   }
   /**

package/rust-client/node_modules/mingo/dist/esm/index.js

@@ -1,8 +1,10 @@
 import "./init/basic";
 import { Aggregator } from "./aggregator";
 import { Query } from "./query";
+import { createUpdater, update } from "./updater";
 import { Aggregator as Aggregator2 } from "./aggregator";
 import { Query as Query2 } from "./query";
+import { createUpdater as createUpdater2, update as update2 } from "./updater";
 function find(collection, criteria, projection, options) {
   return new Query(criteria, options).find(collection, projection);
 }
@@ -16,14 +18,18 @@ var src_default = {
   Aggregator,
   Query,
   aggregate,
+  createUpdater,
   find,
-  remove
+  remove,
+  update
 };
 export {
   Aggregator2 as Aggregator,
   Query2 as Query,
   aggregate,
+  createUpdater2 as createUpdater,
   src_default as default,
   find,
-  remove
+  remove,
+  update2 as update
 };

package/rust-client/node_modules/mingo/dist/esm/init/basic.js

@@ -1,25 +1,18 @@
-import { Context, OperatorType, useOperators } from "../core";
+import { useOperators } from "../core";
 import * as booleanOperators from "../operators/expression/boolean";
 import * as comparisonOperators from "../operators/expression/comparison";
 import { $limit, $project, $skip, $sort } from "../operators/pipeline";
 import * as projectionOperators from "../operators/projection";
 import * as queryOperators from "../operators/query";
-useOperators(OperatorType.EXPRESSION, {
+useOperators("expression", {
   ...booleanOperators,
   ...comparisonOperators
 });
-useOperators(OperatorType.PIPELINE, {
+useOperators("pipeline", {
   $project,
   $skip,
   $limit,
   $sort
 });
-useOperators(OperatorType.PROJECTION, projectionOperators);
-useOperators(OperatorType.QUERY, queryOperators);
-const BASIC_CONTEXT = Context.init().addExpressionOps({
-  ...booleanOperators,
-  ...comparisonOperators
-}).addPipelineOps({ $project, $skip, $limit, $sort }).addProjectionOps(projectionOperators).addQueryOps(queryOperators);
-export {
-  BASIC_CONTEXT
-};
+useOperators("projection", projectionOperators);
+useOperators("query", queryOperators);

package/rust-client/node_modules/mingo/dist/esm/init/system.js

@@ -1,13 +1,13 @@
-import { OperatorType, useOperators } from "../core";
+import { useOperators } from "../core";
 import * as accumulatorOperators from "../operators/accumulator";
 import * as expressionOperators from "../operators/expression";
 import * as pipelineOperators from "../operators/pipeline";
 import * as projectionOperators from "../operators/projection";
 import * as queryOperators from "../operators/query";
 import * as windowOperators from "../operators/window";
-useOperators(OperatorType.ACCUMULATOR, accumulatorOperators);
-useOperators(OperatorType.EXPRESSION, expressionOperators);
-useOperators(OperatorType.PIPELINE, pipelineOperators);
-useOperators(OperatorType.PROJECTION, projectionOperators);
-useOperators(OperatorType.QUERY, queryOperators);
-useOperators(OperatorType.WINDOW, windowOperators);
+useOperators("accumulator", accumulatorOperators);
+useOperators("expression", expressionOperators);
+useOperators("pipeline", pipelineOperators);
+useOperators("projection", projectionOperators);
+useOperators("query", queryOperators);
+useOperators("window", windowOperators);

package/rust-client/node_modules/mingo/dist/esm/lazy.js

@@ -1,14 +1,13 @@
-import { MingoError } from "./util";
+import { isArray, MingoError } from "./util";
 function Lazy(source) {
   return source instanceof Iterator ? source : new Iterator(source);
 }
-function compose(...iterators) {
+function concat(...iterators) {
   let index = 0;
   return Lazy(() => {
     while (index < iterators.length) {
       const o = iterators[index].next();
-      if (!o.done)
-        return o;
+      if (!o.done) return o;
       index++;
     }
     return { done: true };
@@ -36,47 +35,42 @@ function createCallback(nextFn, iteratees, buffer) {
   let bufferIndex = 0;
   return function(storeResult) {
     try {
-      outer:
-        while (!done) {
-          let o = nextFn();
-          index++;
-          let i = -1;
-          const size = iteratees.length;
-          let innerDone = false;
-          while (++i < size) {
-            const r = iteratees[i];
-            switch (r.action) {
-              case 0 /* MAP */:
-                o = r.func(o, index);
-                break;
-              case 1 /* FILTER */:
-                if (!r.func(o, index))
-                  continue outer;
-                break;
-              case 2 /* TAKE */:
-                --r.count;
-                if (!r.count)
-                  innerDone = true;
-                break;
-              case 3 /* DROP */:
-                --r.count;
-                if (!r.count)
-                  dropItem(iteratees, i);
-                continue outer;
-              default:
-                break outer;
-            }
-          }
-          done = innerDone;
-          if (storeResult) {
-            buffer[bufferIndex++] = o;
-          } else {
-            return { value: o, done: false };
+      outer: while (!done) {
+        let o = nextFn();
+        index++;
+        let i = -1;
+        const size = iteratees.length;
+        let innerDone = false;
+        while (++i < size) {
+          const r = iteratees[i];
+          switch (r.action) {
+            case 0 /* MAP */:
+              o = r.func(o, index);
+              break;
+            case 1 /* FILTER */:
+              if (!r.func(o, index)) continue outer;
+              break;
+            case 2 /* TAKE */:
+              --r.count;
+              if (!r.count) innerDone = true;
+              break;
+            case 3 /* DROP */:
+              --r.count;
+              if (!r.count) dropItem(iteratees, i);
+              continue outer;
+            default:
+              break outer;
           }
         }
+        done = innerDone;
+        if (storeResult) {
+          buffer[bufferIndex++] = o;
+        } else {
+          return { value: o, done: false };
+        }
+      }
     } catch (e) {
-      if (e !== DONE)
-        throw e;
+      if (e !== DONE) throw e;
     }
     done = true;
     return { done };
@@ -91,8 +85,8 @@ class Iterator {
    * @param {Function} fn An optional transformation function
    */
   constructor(source) {
-    this.iteratees = [];
-    this.yieldedValues = [];
+    this.#iteratees = [];
+    this.#yieldedValues = [];
     this.isDone = false;
     let nextVal;
     if (source instanceof Function) {
@@ -102,17 +96,15 @@ class Iterator {
       const src = source;
       nextVal = () => {
         const o = src.next();
-        if (o.done)
-          throw DONE;
+        if (o.done) throw DONE;
         return o.value;
       };
-    } else if (source instanceof Array) {
+    } else if (isArray(source)) {
       const data = source;
       const size = data.length;
       let index = 0;
       nextVal = () => {
-        if (index < size)
-          return data[index++];
+        if (index < size) return data[index++];
         throw DONE;
       };
     } else if (!(source instanceof Function)) {
@@ -120,21 +112,28 @@ class Iterator {
         `Lazy must be initialized with an array, generator, or function.`
       );
     }
-    this.getNext = createCallback(nextVal, this.iteratees, this.yieldedValues);
+    this.#getNext = createCallback(
+      nextVal,
+      this.#iteratees,
+      this.#yieldedValues
+    );
   }
+  #iteratees;
+  #yieldedValues;
+  #getNext;
   /**
    * Add an iteratee to this lazy sequence
    */
   push(action, value) {
     if (typeof value === "function") {
-      this.iteratees.push({ action, func: value });
+      this.#iteratees.push({ action, func: value });
     } else if (typeof value === "number") {
-      this.iteratees.push({ action, count: value });
+      this.#iteratees.push({ action, count: value });
     }
     return this;
   }
   next() {
-    return this.getNext();
+    return this.#getNext();
   }
   // Iteratees methods
   /**
@@ -170,7 +169,7 @@ class Iterator {
    * Returns a new lazy object with results of the transformation
    * The entire sequence is realized.
    *
-   * @param {Callback<Source, RawArray>} fn Tranform function of type (Array) => (Any)
+   * @param {Callback<Source, Any[]>} fn Tranform function of type (Array) => (Any)
    */
   transform(fn) {
     const self = this;
@@ -190,9 +189,9 @@ class Iterator {
    */
   value() {
     if (!this.isDone) {
-      this.isDone = this.getNext(true).done;
+      this.isDone = this.#getNext(true).done;
     }
-    return this.yieldedValues;
+    return this.#yieldedValues;
   }
   /**
    * Execute the funcion for each value. Will stop when an execution returns false.
@@ -202,10 +201,8 @@ class Iterator {
   each(f) {
     for (; ; ) {
       const o = this.next();
-      if (o.done)
-        break;
-      if (f(o.value) === false)
-        return false;
+      if (o.done) break;
+      if (f(o.value) === false) return false;
     }
     return true;
   }
@@ -243,5 +240,5 @@ class Iterator {
 export {
   Iterator,
   Lazy,
-  compose
+  concat
 };

package/rust-client/node_modules/mingo/dist/esm/operators/_predicates.js

@@ -6,8 +6,6 @@ import {
   compare as mingoCmp,
   ensureArray,
   flatten,
-  getType,
-  inArray,
   intersection,
   isArray,
   isBoolean,
@@ -20,13 +18,10 @@ import {
   isOperator,
   isRegExp,
   isString,
-  MAX_INT,
-  MAX_LONG,
-  MIN_INT,
-  MIN_LONG,
   MingoError,
   resolve,
-  truthy
+  truthy,
+  typeOf
 } from "../util";
 function createQueryOperator(predicate) {
   const f = (selector, value, options) => {
@@ -47,13 +42,10 @@ function createExpressionOperator(predicate) {
   };
 }
 function $eq(a, b, options) {
-  if (isEqual(a, b))
-    return true;
-  if (isNil(a) && isNil(b))
-    return true;
-  if (a instanceof Array) {
-    const eq = isEqual.bind(null, b);
-    return a.some(eq) || flatten(a, options?.depth).some(eq);
+  if (isEqual(a, b)) return true;
+  if (isNil(a) && isNil(b)) return true;
+  if (isArray(a)) {
+    return a.some((v) => isEqual(v, b)) || flatten(a, options?.depth).some((v) => isEqual(v, b));
   }
   return false;
 }
@@ -61,8 +53,7 @@ function $ne(a, b, options) {
   return !$eq(a, b, options);
 }
 function $in(a, b, options) {
-  if (isNil(a))
-    return b.some((v) => v === null);
+  if (isNil(a)) return b.some((v) => v === null);
   return intersection([ensureArray(a), b], options?.hashFunction).length > 0;
 }
 function $nin(a, b, options) {
@@ -99,11 +90,10 @@ function $all(values, queries, options) {
   }
   let matched = true;
   for (const query of queries) {
-    if (!matched)
-      break;
-    if (isObject(query) && inArray(Object.keys(query), "$elemMatch")) {
+    if (!matched) break;
+    if (isObject(query) && Object.keys(query).includes("$elemMatch")) {
       matched = $elemMatch(values, query["$elemMatch"], options);
-    } else if (query instanceof RegExp) {
+    } else if (isRegExp(query)) {
       matched = values.some((s) => typeof s === "string" && query.test(s));
     } else {
       matched = values.some((v) => isEqual(query, v));
@@ -135,22 +125,14 @@ function $elemMatch(a, b, options) {
   return false;
 }
 const isNull = (a) => a === null;
-const isInt = (a) => isNumber(a) && a >= MIN_INT && a <= MAX_INT && a.toString().indexOf(".") === -1;
-const isLong = (a) => isNumber(a) && a >= MIN_LONG && a <= MAX_LONG && a.toString().indexOf(".") === -1;
 const compareFuncs = {
   array: isArray,
-  bool: isBoolean,
   boolean: isBoolean,
   date: isDate,
-  decimal: isNumber,
-  double: isNumber,
-  int: isInt,
-  long: isLong,
   number: isNumber,
   null: isNull,
   object: isObject,
   regex: isRegExp,
-  regexp: isRegExp,
   string: isString,
   // added for completeness
   undefined: isNil,
@@ -170,8 +152,8 @@ const compareFuncs = {
   9: isDate,
   10: isNull,
   11: isRegExp,
-  16: isInt,
-  18: isLong,
+  16: isNumber,
+  18: isNumber,
   19: isNumber
   //decimal
 };
@@ -180,10 +162,10 @@ function compareType(a, b, _) {
   return f ? f(a) : false;
 }
 function $type(a, b, options) {
-  return Array.isArray(b) ? b.findIndex((t) => compareType(a, t, options)) >= 0 : compareType(a, b, options);
+  return isArray(b) ? b.findIndex((t) => compareType(a, t, options)) >= 0 : compareType(a, b, options);
 }
 function compare(a, b, f) {
-  return ensureArray(a).some((x) => getType(x) === getType(b) && f(x, b));
+  return ensureArray(a).some((x) => typeOf(x) === typeOf(b) && f(x, b));
 }
 export {
   $all,

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/_internal.js

@@ -7,10 +7,8 @@ function stddev(data, sampled = true) {
   );
 }
 function covariance(dataset, sampled = true) {
-  if (!dataset)
-    return null;
-  if (dataset.length < 2)
-    return sampled ? null : 0;
+  if (!dataset) return null;
+  if (dataset.length < 2) return sampled ? null : 0;
   let meanX = 0;
   let meanY = 0;
   for (const [x, y] of dataset) {

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/accumulator.js

@@ -8,8 +8,7 @@ const $accumulator = (collection, expr, options) => {
     !!options && options.scriptEnabled,
     "$accumulator operator requires 'scriptEnabled' option to be true"
   );
-  if (collection.length == 0)
-    return expr.initArgs;
+  if (collection.length == 0) return expr.initArgs;
   const copts = ComputeOptions.init(options);
   const initArgs = computeValue(
     {},

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/first.js

@@ -1,6 +1,11 @@
-import { computeValue } from "../../core";
+import {
+  ComputeOptions,
+  computeValue
+} from "../../core";
 const $first = (collection, expr, options) => {
-  return collection.length > 0 ? computeValue(collection[0], expr, null, options) : void 0;
+  if (collection.length === 0) return void 0;
+  const copts = ComputeOptions.init(options).update(collection[0]);
+  return computeValue(collection[0], expr, null, copts);
 };
 export {
   $first

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/last.js

@@ -1,6 +1,12 @@
-import { computeValue } from "../../core";
+import {
+  ComputeOptions,
+  computeValue
+} from "../../core";
 const $last = (collection, expr, options) => {
-  return collection.length > 0 ? computeValue(collection[collection.length - 1], expr, null, options) : void 0;
+  if (collection.length === 0) return void 0;
+  const obj = collection[collection.length - 1];
+  const copts = ComputeOptions.init(options).update(obj);
+  return computeValue(obj, expr, null, copts);
 };
 export {
   $last

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/max.js

@@ -1,12 +1,15 @@
-import { compare, isNotNaN } from "../../util";
+import { assert, compare, isArray, isEmpty, isNil } from "../../util";
 import { $push } from "./push";
 const $max = (collection, expr, options) => {
-  const nums = $push(collection, expr, options).filter(isNotNaN);
-  const n = nums.reduce(
-    (acc, n2) => compare(n2, acc) >= 0 ? n2 : acc,
-    -Infinity
-  );
-  return n === -Infinity ? void 0 : n;
+  const items = $push(collection, expr, options);
+  if (isEmpty(items)) return null;
+  assert(isArray(items), "$max: input must resolve to array");
+  let max = items[0];
+  for (const n of items) {
+    if (isNil(n) || isNaN(n)) continue;
+    if (compare(n, max) >= 0) max = n;
+  }
+  return max;
 };
 export {
   $max

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/mergeObjects.js

@@ -1,5 +1,9 @@
+import { computeValue } from "../../core";
 import { $mergeObjects as __mergeObjects } from "../expression/object/mergeObjects";
-const $mergeObjects = (collection, _, options) => __mergeObjects({ docs: collection }, "$docs", options);
+const $mergeObjects = (collection, expr, options) => {
+  const arr = computeValue(collection, expr, null, options);
+  return __mergeObjects(null, arr, options);
+};
 export {
   $mergeObjects
 };

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/min.js

@@ -1,9 +1,15 @@
-import { compare, isNotNaN } from "../../util";
+import { assert, compare, isArray, isEmpty, isNil } from "../../util";
 import { $push } from "./push";
 const $min = (collection, expr, options) => {
-  const nums = $push(collection, expr, options).filter(isNotNaN);
-  const n = nums.reduce((acc, n2) => compare(n2, acc) <= 0 ? n2 : acc, Infinity);
-  return n === Infinity ? void 0 : n;
+  const items = $push(collection, expr, options);
+  if (isEmpty(items)) return null;
+  assert(isArray(items), "$min: input must resolve to array");
+  let min = items[0];
+  for (const n of items) {
+    if (isNil(n) || isNaN(n)) continue;
+    if (compare(n, min) <= 0) min = n;
+  }
+  return min;
 };
 export {
   $min

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/push.js

@@ -4,8 +4,7 @@ import {
 } from "../../core";
 import { isNil } from "../../util";
 const $push = (collection, expr, options) => {
-  if (isNil(expr))
-    return collection;
+  if (isNil(expr)) return collection;
   const copts = ComputeOptions.init(options);
   return collection.map(
     (obj) => computeValue(obj, expr, null, copts.update(obj))

package/rust-client/node_modules/mingo/dist/esm/operators/accumulator/sum.js

@@ -1,10 +1,8 @@
 import { isArray, isNumber } from "../../util";
 import { $push } from "./push";
 const $sum = (collection, expr, options) => {
-  if (!isArray(collection))
-    return 0;
-  if (isNumber(expr))
-    return collection.length * expr;
+  if (!isArray(collection)) return 0;
+  if (isNumber(expr)) return collection.length * expr;
   const nums = $push(collection, expr, options).filter(isNumber);
   return nums.reduce((acc, n) => acc + n, 0);
 };