@valkey/valkey-glide-darwin-arm64 1.2.0-rc10 → 1.2.0-rc12

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

@@ -0,0 +1,247 @@
+import { MingoError } from "./util";
+function Lazy(source) {
+  return source instanceof Iterator ? source : new Iterator(source);
+}
+function compose(...iterators) {
+  let index = 0;
+  return Lazy(() => {
+    while (index < iterators.length) {
+      const o = iterators[index].next();
+      if (!o.done)
+        return o;
+      index++;
+    }
+    return { done: true };
+  });
+}
+function isGenerator(o) {
+  return !!o && typeof o === "object" && o?.next instanceof Function;
+}
+function dropItem(array, i) {
+  const rest = array.slice(i + 1);
+  array.splice(i);
+  Array.prototype.push.apply(array, rest);
+}
+const DONE = new Error();
+var Action = /* @__PURE__ */ ((Action2) => {
+  Action2[Action2["MAP"] = 0] = "MAP";
+  Action2[Action2["FILTER"] = 1] = "FILTER";
+  Action2[Action2["TAKE"] = 2] = "TAKE";
+  Action2[Action2["DROP"] = 3] = "DROP";
+  return Action2;
+})(Action || {});
+function createCallback(nextFn, iteratees, buffer) {
+  let done = false;
+  let index = -1;
+  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 };
+          }
+        }
+    } catch (e) {
+      if (e !== DONE)
+        throw e;
+    }
+    done = true;
+    return { done };
+  };
+}
+class Iterator {
+  /**
+   * @param {*} source An iterable object or function.
+   *    Array - return one element per cycle
+   *    Object{next:Function} - call next() for the next value (this also handles generator functions)
+   *    Function - call to return the next value
+   * @param {Function} fn An optional transformation function
+   */
+  constructor(source) {
+    this.iteratees = [];
+    this.yieldedValues = [];
+    this.isDone = false;
+    let nextVal;
+    if (source instanceof Function) {
+      source = { next: source };
+    }
+    if (isGenerator(source)) {
+      const src = source;
+      nextVal = () => {
+        const o = src.next();
+        if (o.done)
+          throw DONE;
+        return o.value;
+      };
+    } else if (source instanceof Array) {
+      const data = source;
+      const size = data.length;
+      let index = 0;
+      nextVal = () => {
+        if (index < size)
+          return data[index++];
+        throw DONE;
+      };
+    } else if (!(source instanceof Function)) {
+      throw new MingoError(
+        `Lazy must be initialized with an array, generator, or function.`
+      );
+    }
+    this.getNext = createCallback(nextVal, this.iteratees, this.yieldedValues);
+  }
+  /**
+   * Add an iteratee to this lazy sequence
+   */
+  push(action, value) {
+    if (typeof value === "function") {
+      this.iteratees.push({ action, func: value });
+    } else if (typeof value === "number") {
+      this.iteratees.push({ action, count: value });
+    }
+    return this;
+  }
+  next() {
+    return this.getNext();
+  }
+  // Iteratees methods
+  /**
+   * Transform each item in the sequence to a new value
+   * @param {Function} f
+   */
+  map(f) {
+    return this.push(0 /* MAP */, f);
+  }
+  /**
+   * Select only items matching the given predicate
+   * @param {Function} pred
+   */
+  filter(predicate) {
+    return this.push(1 /* FILTER */, predicate);
+  }
+  /**
+   * Take given numbe for values from sequence
+   * @param {Number} n A number greater than 0
+   */
+  take(n) {
+    return n > 0 ? this.push(2 /* TAKE */, n) : this;
+  }
+  /**
+   * Drop a number of values from the sequence
+   * @param {Number} n Number of items to drop greater than 0
+   */
+  drop(n) {
+    return n > 0 ? this.push(3 /* DROP */, n) : this;
+  }
+  // Transformations
+  /**
+   * 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)
+   */
+  transform(fn) {
+    const self = this;
+    let iter;
+    return Lazy(() => {
+      if (!iter) {
+        iter = Lazy(fn(self.value()));
+      }
+      return iter.next();
+    });
+  }
+  // Terminal methods
+  /**
+   * Returns the fully realized values of the iterators.
+   * The return value will be an array unless `lazy.first()` was used.
+   * The realized values are cached for subsequent calls.
+   */
+  value() {
+    if (!this.isDone) {
+      this.isDone = this.getNext(true).done;
+    }
+    return this.yieldedValues;
+  }
+  /**
+   * Execute the funcion for each value. Will stop when an execution returns false.
+   * @param {Function} f
+   * @returns {Boolean} false iff `f` return false for AnyVal execution, otherwise true
+   */
+  each(f) {
+    for (; ; ) {
+      const o = this.next();
+      if (o.done)
+        break;
+      if (f(o.value) === false)
+        return false;
+    }
+    return true;
+  }
+  /**
+   * Returns the reduction of sequence according the reducing function
+   *
+   * @param {*} f a reducing function
+   * @param {*} initialValue
+   */
+  reduce(f, initialValue) {
+    let o = this.next();
+    if (initialValue === void 0 && !o.done) {
+      initialValue = o.value;
+      o = this.next();
+    }
+    while (!o.done) {
+      initialValue = f(initialValue, o.value);
+      o = this.next();
+    }
+    return initialValue;
+  }
+  /**
+   * Returns the number of matched items in the sequence
+   */
+  size() {
+    return this.reduce(
+      (acc, _) => ++acc,
+      0
+    );
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+export {
+  Iterator,
+  Lazy,
+  compose
+};

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

@@ -0,0 +1,206 @@
+import {
+  computeValue
+} from "../core";
+import { Query } from "../query";
+import {
+  compare as mingoCmp,
+  ensureArray,
+  flatten,
+  getType,
+  inArray,
+  intersection,
+  isArray,
+  isBoolean,
+  isDate,
+  isEmpty,
+  isEqual,
+  isNil,
+  isNumber,
+  isObject,
+  isOperator,
+  isRegExp,
+  isString,
+  MAX_INT,
+  MAX_LONG,
+  MIN_INT,
+  MIN_LONG,
+  MingoError,
+  resolve,
+  truthy
+} from "../util";
+function createQueryOperator(predicate) {
+  const f = (selector, value, options) => {
+    const opts = { unwrapArray: true };
+    const depth = Math.max(1, selector.split(".").length - 1);
+    return (obj) => {
+      const lhs = resolve(obj, selector, opts);
+      return predicate(lhs, value, { ...options, depth });
+    };
+  };
+  f.op = "query";
+  return f;
+}
+function createExpressionOperator(predicate) {
+  return (obj, expr, options) => {
+    const args = computeValue(obj, expr, null, options);
+    return predicate(...args);
+  };
+}
+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);
+  }
+  return false;
+}
+function $ne(a, b, options) {
+  return !$eq(a, b, options);
+}
+function $in(a, b, options) {
+  if (isNil(a))
+    return b.some((v) => v === null);
+  return intersection([ensureArray(a), b], options?.hashFunction).length > 0;
+}
+function $nin(a, b, options) {
+  return !$in(a, b, options);
+}
+function $lt(a, b, _options) {
+  return compare(a, b, (x, y) => mingoCmp(x, y) < 0);
+}
+function $lte(a, b, _options) {
+  return compare(a, b, (x, y) => mingoCmp(x, y) <= 0);
+}
+function $gt(a, b, _options) {
+  return compare(a, b, (x, y) => mingoCmp(x, y) > 0);
+}
+function $gte(a, b, _options) {
+  return compare(a, b, (x, y) => mingoCmp(x, y) >= 0);
+}
+function $mod(a, b, _options) {
+  return ensureArray(a).some(
+    (x) => b.length === 2 && x % b[0] === b[1]
+  );
+}
+function $regex(a, b, options) {
+  const lhs = ensureArray(a);
+  const match = (x) => isString(x) && truthy(b.exec(x), options?.useStrictMode);
+  return lhs.some(match) || flatten(lhs, 1).some(match);
+}
+function $exists(a, b, _options) {
+  return (b === false || b === 0) && a === void 0 || (b === true || b === 1) && a !== void 0;
+}
+function $all(values, queries, options) {
+  if (!isArray(values) || !isArray(queries) || !values.length || !queries.length) {
+    return false;
+  }
+  let matched = true;
+  for (const query of queries) {
+    if (!matched)
+      break;
+    if (isObject(query) && inArray(Object.keys(query), "$elemMatch")) {
+      matched = $elemMatch(values, query["$elemMatch"], options);
+    } else if (query instanceof RegExp) {
+      matched = values.some((s) => typeof s === "string" && query.test(s));
+    } else {
+      matched = values.some((v) => isEqual(query, v));
+    }
+  }
+  return matched;
+}
+function $size(a, b, _options) {
+  return Array.isArray(a) && a.length === b;
+}
+function isNonBooleanOperator(name) {
+  return isOperator(name) && ["$and", "$or", "$nor"].indexOf(name) === -1;
+}
+function $elemMatch(a, b, options) {
+  if (isArray(a) && !isEmpty(a)) {
+    let format = (x) => x;
+    let criteria = b;
+    if (Object.keys(b).every(isNonBooleanOperator)) {
+      criteria = { temp: b };
+      format = (x) => ({ temp: x });
+    }
+    const query = new Query(criteria, options);
+    for (let i = 0, len = a.length; i < len; i++) {
+      if (query.test(format(a[i]))) {
+        return true;
+      }
+    }
+  }
+  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,
+  // deprecated
+  function: (_) => {
+    throw new MingoError("unsupported type key `function`.");
+  },
+  // Mongo identifiers
+  1: isNumber,
+  //double
+  2: isString,
+  3: isObject,
+  4: isArray,
+  6: isNil,
+  // deprecated
+  8: isBoolean,
+  9: isDate,
+  10: isNull,
+  11: isRegExp,
+  16: isInt,
+  18: isLong,
+  19: isNumber
+  //decimal
+};
+function compareType(a, b, _) {
+  const f = compareFuncs[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);
+}
+function compare(a, b, f) {
+  return ensureArray(a).some((x) => getType(x) === getType(b) && f(x, b));
+}
+export {
+  $all,
+  $elemMatch,
+  $eq,
+  $exists,
+  $gt,
+  $gte,
+  $in,
+  $lt,
+  $lte,
+  $mod,
+  $ne,
+  $nin,
+  $regex,
+  $size,
+  $type,
+  createExpressionOperator,
+  createQueryOperator
+};

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

@@ -0,0 +1,31 @@
+function stddev(data, sampled = true) {
+  const sum = data.reduce((acc, n) => acc + n, 0);
+  const N = data.length || 1;
+  const avg = sum / N;
+  return Math.sqrt(
+    data.reduce((acc, n) => acc + Math.pow(n - avg, 2), 0) / (N - Number(sampled))
+  );
+}
+function covariance(dataset, sampled = true) {
+  if (!dataset)
+    return null;
+  if (dataset.length < 2)
+    return sampled ? null : 0;
+  let meanX = 0;
+  let meanY = 0;
+  for (const [x, y] of dataset) {
+    meanX += x;
+    meanY += y;
+  }
+  meanX /= dataset.length;
+  meanY /= dataset.length;
+  let result = 0;
+  for (const [x, y] of dataset) {
+    result += (x - meanX) * (y - meanY);
+  }
+  return result / (dataset.length - Number(sampled));
+}
+export {
+  covariance,
+  stddev
+};

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

@@ -0,0 +1,34 @@
+import {
+  ComputeOptions,
+  computeValue
+} from "../../core";
+import { assert } from "../../util";
+const $accumulator = (collection, expr, options) => {
+  assert(
+    !!options && options.scriptEnabled,
+    "$accumulator operator requires 'scriptEnabled' option to be true"
+  );
+  if (collection.length == 0)
+    return expr.initArgs;
+  const copts = ComputeOptions.init(options);
+  const initArgs = computeValue(
+    {},
+    expr.initArgs || [],
+    null,
+    copts.update(copts?.local?.groupId || {})
+  );
+  let state = expr.init.call(null, ...initArgs);
+  for (const doc of collection) {
+    const args = computeValue(
+      doc,
+      expr.accumulateArgs,
+      null,
+      copts.update(doc)
+    );
+    state = expr.accumulate.call(null, ...[state, ...args]);
+  }
+  return expr.finalize ? expr.finalize.call(null, state) : state;
+};
+export {
+  $accumulator
+};

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

@@ -0,0 +1,11 @@
+import { unique } from "../../util";
+import { $push } from "./push";
+const $addToSet = (collection, expr, options) => {
+  return unique(
+    $push(collection, expr, options),
+    options?.hashFunction
+  );
+};
+export {
+  $addToSet
+};

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

@@ -0,0 +1,10 @@
+import { isNumber } from "../../util";
+import { $push } from "./push";
+const $avg = (collection, expr, options) => {
+  const data = $push(collection, expr, options).filter(isNumber);
+  const sum = data.reduce((acc, n) => acc + n, 0);
+  return sum / (data.length || 1);
+};
+export {
+  $avg
+};

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

@@ -0,0 +1,5 @@
+import { $bottomN } from "./bottomN";
+const $bottom = (collection, expr, options) => $bottomN(collection, { ...expr, n: 1 }, options);
+export {
+  $bottom
+};

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

@@ -0,0 +1,22 @@
+import { Aggregator } from "../../aggregator";
+import {
+  ComputeOptions,
+  computeValue
+} from "../../core";
+import { $push } from "./push";
+const $bottomN = (collection, expr, options) => {
+  const copts = ComputeOptions.init(options);
+  const { n, sortBy } = computeValue(
+    copts.local.groupId,
+    expr,
+    null,
+    copts
+  );
+  const result = new Aggregator([{ $sort: sortBy }], copts).run(collection);
+  const m = result.length;
+  const p = n;
+  return $push(m <= p ? result : result.slice(m - p), expr.output, copts);
+};
+export {
+  $bottomN
+};

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

@@ -0,0 +1,4 @@
+const $count = (collection, _expr, _options) => collection.length;
+export {
+  $count
+};

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

@@ -0,0 +1,6 @@
+import { covariance } from "./_internal";
+import { $push } from "./push";
+const $covariancePop = (collection, expr, options) => covariance($push(collection, expr, options), false);
+export {
+  $covariancePop
+};

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

@@ -0,0 +1,6 @@
+import { covariance } from "./_internal";
+import { $push } from "./push";
+const $covarianceSamp = (collection, expr, options) => covariance($push(collection, expr, options), true);
+export {
+  $covarianceSamp
+};

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

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

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

@@ -0,0 +1,18 @@
+import {
+  ComputeOptions,
+  computeValue
+} from "../../core";
+import { $push } from "./push";
+const $firstN = (collection, expr, options) => {
+  const copts = ComputeOptions.init(options);
+  const m = collection.length;
+  const n = computeValue(copts?.local?.groupId, expr.n, null, copts);
+  return $push(
+    m <= n ? collection : collection.slice(0, n),
+    expr.input,
+    options
+  );
+};
+export {
+  $firstN
+};

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

@@ -0,0 +1,25 @@
+export * from "./accumulator";
+export * from "./addToSet";
+export * from "./avg";
+export * from "./bottom";
+export * from "./bottomN";
+export * from "./count";
+export * from "./covariancePop";
+export * from "./covarianceSamp";
+export * from "./first";
+export * from "./firstN";
+export * from "./last";
+export * from "./lastN";
+export * from "./max";
+export * from "./maxN";
+export * from "./median";
+export * from "./mergeObjects";
+export * from "./min";
+export * from "./minN";
+export * from "./percentile";
+export * from "./push";
+export * from "./stdDevPop";
+export * from "./stdDevSamp";
+export * from "./sum";
+export * from "./top";
+export * from "./topN";

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

@@ -0,0 +1,7 @@
+import { computeValue } from "../../core";
+const $last = (collection, expr, options) => {
+  return collection.length > 0 ? computeValue(collection[collection.length - 1], expr, null, options) : void 0;
+};
+export {
+  $last
+};

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

@@ -0,0 +1,18 @@
+import {
+  ComputeOptions,
+  computeValue
+} from "../../core";
+import { $push } from "./push";
+const $lastN = (collection, expr, options) => {
+  const copts = ComputeOptions.init(options);
+  const m = collection.length;
+  const n = computeValue(copts?.local?.groupId, expr.n, null, copts);
+  return $push(
+    m <= n ? collection : collection.slice(m - n),
+    expr.input,
+    options
+  );
+};
+export {
+  $lastN
+};

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

@@ -0,0 +1,13 @@
+import { compare, isNotNaN } 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;
+};
+export {
+  $max
+};