@valkey/valkey-glide-darwin-arm64 1.2.0-rc7 → 1.2.0-rc8

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/atan.js

@@ -0,0 +1,5 @@
+import { createTrignometryOperator } from "./_internal";
+const $atan = createTrignometryOperator(Math.atan);
+export {
+  $atan
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/atan2.js

@@ -0,0 +1,13 @@
+import { computeValue } from "../../../core";
+import { isNil } from "../../../util";
+const $atan2 = (obj, expr, options) => {
+  const [y, x] = computeValue(obj, expr, null, options);
+  if (isNaN(y) || isNil(y))
+    return y;
+  if (isNaN(x) || isNil(x))
+    return x;
+  return Math.atan2(y, x);
+};
+export {
+  $atan2
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/atanh.js

@@ -0,0 +1,8 @@
+import { createTrignometryOperator } from "./_internal";
+const $atanh = createTrignometryOperator(Math.atanh, {
+  1: Infinity,
+  "-1": -Infinity
+});
+export {
+  $atanh
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/cos.js

@@ -0,0 +1,5 @@
+import { createTrignometryOperator } from "./_internal";
+const $cos = createTrignometryOperator(Math.cos);
+export {
+  $cos
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/cosh.js

@@ -0,0 +1,9 @@
+import { createTrignometryOperator } from "./_internal";
+const $cosh = createTrignometryOperator(Math.cosh, {
+  "-Infinity": Infinity,
+  Infinity: Infinity
+  // [Math.PI]: -1,
+});
+export {
+  $cosh
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/degreesToRadians.js

@@ -0,0 +1,12 @@
+import { createTrignometryOperator } from "./_internal";
+const RADIANS_FACTOR = Math.PI / 180;
+const $degreesToRadians = createTrignometryOperator(
+  (n) => n * RADIANS_FACTOR,
+  {
+    Infinity: Infinity,
+    "-Infinity": Infinity
+  }
+);
+export {
+  $degreesToRadians
+};

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

@@ -0,0 +1,14 @@
+export * from "./acos";
+export * from "./acosh";
+export * from "./asin";
+export * from "./asinh";
+export * from "./atan";
+export * from "./atan2";
+export * from "./atanh";
+export * from "./cos";
+export * from "./cosh";
+export * from "./degreesToRadians";
+export * from "./radiansToDegrees";
+export * from "./sin";
+export * from "./sinh";
+export * from "./tan";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/radiansToDegrees.js

@@ -0,0 +1,12 @@
+import { createTrignometryOperator } from "./_internal";
+const DEGREES_FACTOR = 180 / Math.PI;
+const $radiansToDegrees = createTrignometryOperator(
+  (n) => n * DEGREES_FACTOR,
+  {
+    Infinity: Infinity,
+    "-Infinity": -Infinity
+  }
+);
+export {
+  $radiansToDegrees
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/sin.js

@@ -0,0 +1,5 @@
+import { createTrignometryOperator } from "./_internal";
+const $sin = createTrignometryOperator(Math.sin);
+export {
+  $sin
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/sinh.js

@@ -0,0 +1,8 @@
+import { createTrignometryOperator } from "./_internal";
+const $sinh = createTrignometryOperator(Math.sinh, {
+  "-Infinity": -Infinity,
+  Infinity: Infinity
+});
+export {
+  $sinh
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/trignometry/tan.js

@@ -0,0 +1,5 @@
+import { createTrignometryOperator } from "./_internal";
+const $tan = createTrignometryOperator(Math.tan);
+export {
+  $tan
+};

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

@@ -0,0 +1,29 @@
+import { computeValue } from "../../../core";
+import { isNil, isNumber, isString } from "../../../util";
+class TypeConvertError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+function toInteger(obj, expr, options, max, min, typename) {
+  const val = computeValue(obj, expr, null, options);
+  if (isNil(val))
+    return null;
+  if (val instanceof Date)
+    return val.getTime();
+  if (val === true)
+    return 1;
+  if (val === false)
+    return 0;
+  const n = Number(val);
+  if (isNumber(n) && n >= min && n <= max) {
+    if (!isString(val) || n.toString().indexOf(".") === -1) {
+      return Math.trunc(n);
+    }
+  }
+  throw new TypeConvertError(`cannot convert '${val}' to ${typename}`);
+}
+export {
+  TypeConvertError,
+  toInteger
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/type/convert.js

@@ -0,0 +1,48 @@
+import { computeValue } from "../../../core";
+import { isNil } from "../../../util";
+import { TypeConvertError } from "./_internal";
+import { $toBool } from "./toBool";
+import { $toDate } from "./toDate";
+import { $toDouble } from "./toDouble";
+import { $toInt } from "./toInt";
+import { $toLong } from "./toLong";
+import { $toString } from "./toString";
+const $convert = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  args.onNull = args.onNull === void 0 ? null : args.onNull;
+  if (isNil(args.input))
+    return args.onNull;
+  try {
+    switch (args.to) {
+      case 2:
+      case "string":
+        return $toString(obj, args.input, options);
+      case 8:
+      case "boolean":
+      case "bool":
+        return $toBool(obj, args.input, options);
+      case 9:
+      case "date":
+        return $toDate(obj, args.input, options);
+      case 1:
+      case 19:
+      case "double":
+      case "decimal":
+      case "number":
+        return $toDouble(obj, args.input, options);
+      case 16:
+      case "int":
+        return $toInt(obj, args.input, options);
+      case 18:
+      case "long":
+        return $toLong(obj, args.input, options);
+    }
+  } catch (e) {
+  }
+  if (args.onError !== void 0)
+    return args.onError;
+  throw new TypeConvertError(`could not convert to type ${args.to}.`);
+};
+export {
+  $convert
+};

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

@@ -0,0 +1,10 @@
+export * from "./convert";
+export * from "./isNumber";
+export * from "./toBool";
+export * from "./toDate";
+export * from "./toDecimal";
+export * from "./toDouble";
+export * from "./toInt";
+export * from "./toLong";
+export * from "./toString";
+export * from "./type";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/type/isNumber.js

@@ -0,0 +1,9 @@
+import { computeValue } from "../../../core";
+import { isNumber } from "../../../util";
+const $isNumber = (obj, expr, options) => {
+  const n = computeValue(obj, expr, null, options);
+  return isNumber(n);
+};
+export {
+  $isNumber
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/type/toBool.js

@@ -0,0 +1,13 @@
+import { computeValue } from "../../../core";
+import { isNil, isString } from "../../../util";
+const $toBool = (obj, expr, options) => {
+  const val = computeValue(obj, expr, null, options);
+  if (isNil(val))
+    return null;
+  if (isString(val))
+    return true;
+  return Boolean(val);
+};
+export {
+  $toBool
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/type/toDate.js

@@ -0,0 +1,18 @@
+import { computeValue } from "../../../core";
+import { isNil } from "../../../util";
+import { TypeConvertError } from "./_internal";
+const $toDate = (obj, expr, options) => {
+  const val = computeValue(obj, expr, null, options);
+  if (val instanceof Date)
+    return val;
+  if (isNil(val))
+    return null;
+  const d = new Date(val);
+  const n = d.getTime();
+  if (!isNaN(n))
+    return d;
+  throw new TypeConvertError(`cannot convert '${val}' to date`);
+};
+export {
+  $toDate
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/type/toDecimal.js

@@ -0,0 +1,5 @@
+import { $toDouble } from "./toDouble";
+const $toDecimal = $toDouble;
+export {
+  $toDecimal
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/type/toDouble.js

@@ -0,0 +1,21 @@
+import { computeValue } from "../../../core";
+import { isNil, isNumber } from "../../../util";
+import { TypeConvertError } from "./_internal";
+const $toDouble = (obj, expr, options) => {
+  const val = computeValue(obj, expr, null, options);
+  if (isNil(val))
+    return null;
+  if (val instanceof Date)
+    return val.getTime();
+  if (val === true)
+    return 1;
+  if (val === false)
+    return 0;
+  const n = Number(val);
+  if (isNumber(n))
+    return n;
+  throw new TypeConvertError(`cannot convert '${val}' to double/decimal`);
+};
+export {
+  $toDouble
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/type/toInt.js

@@ -0,0 +1,8 @@
+import { MAX_INT, MIN_INT } from "../../../util";
+import { toInteger } from "./_internal";
+const $toInt = (obj, expr, options) => {
+  return toInteger(obj, expr, options, MAX_INT, MIN_INT, "int");
+};
+export {
+  $toInt
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/type/toLong.js

@@ -0,0 +1,8 @@
+import { MAX_LONG, MIN_LONG } from "../../../util";
+import { toInteger } from "./_internal";
+const $toLong = (obj, expr, options) => {
+  return toInteger(obj, expr, options, MAX_LONG, MIN_LONG, "long");
+};
+export {
+  $toLong
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/type/toString.js

@@ -0,0 +1,20 @@
+import { computeValue } from "../../../core";
+import { isNil } from "../../../util";
+import { $dateToString } from "../date/dateToString";
+const $toString = (obj, expr, options) => {
+  const val = computeValue(obj, expr, null, options);
+  if (isNil(val))
+    return null;
+  if (val instanceof Date) {
+    const dateExpr = {
+      date: expr,
+      format: "%Y-%m-%dT%H:%M:%S.%LZ"
+    };
+    return $dateToString(obj, dateExpr, options);
+  } else {
+    return val.toString();
+  }
+};
+export {
+  $toString
+};

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

@@ -0,0 +1,22 @@
+import { computeValue } from "../../../core";
+import { getType, MAX_INT, MIN_INT } from "../../../util";
+const $type = (obj, expr, options) => {
+  const val = computeValue(obj, expr, null, options);
+  const typename = getType(val);
+  const nativeType = typename.toLowerCase();
+  switch (nativeType) {
+    case "boolean":
+      return "bool";
+    case "number":
+      if (val.toString().indexOf(".") >= 0)
+        return "double";
+      return val >= MIN_INT && val <= MAX_INT ? "int" : "long";
+    case "regexp":
+      return "regex";
+    default:
+      return nativeType;
+  }
+};
+export {
+  $type
+};

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

@@ -0,0 +1 @@
+export * from "./let";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/variable/let.js

@@ -0,0 +1,19 @@
+import {
+  ComputeOptions,
+  computeValue
+} from "../../../core";
+const $let = (obj, expr, options) => {
+  const variables = {};
+  for (const [key, val] of Object.entries(expr.vars)) {
+    variables[key] = computeValue(obj, val, null, options);
+  }
+  return computeValue(
+    obj,
+    expr.in,
+    null,
+    ComputeOptions.init(options, obj, { variables })
+  );
+};
+export {
+  $let
+};

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

@@ -0,0 +1,7 @@
+const isUnbounded = (window) => {
+  const boundary = window?.documents || window?.range;
+  return !boundary || boundary[0] === "unbounded" && boundary[1] === "unbounded";
+};
+export {
+  isUnbounded
+};

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

@@ -0,0 +1,22 @@
+import { computeValue } from "../../core";
+import { removeValue, setValue } from "../../util";
+const $addFields = (collection, expr, options) => {
+  const newFields = Object.keys(expr);
+  if (newFields.length === 0)
+    return collection;
+  return collection.map((obj) => {
+    const newObj = { ...obj };
+    for (const field of newFields) {
+      const newValue = computeValue(obj, expr[field], null, options);
+      if (newValue !== void 0) {
+        setValue(newObj, field, newValue);
+      } else {
+        removeValue(newObj, field);
+      }
+    }
+    return newObj;
+  });
+};
+export {
+  $addFields
+};

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

@@ -0,0 +1,81 @@
+import { computeValue } from "../../core";
+import { Lazy } from "../../lazy";
+import {
+  assert,
+  compare,
+  findInsertIndex,
+  getType,
+  into,
+  isNil
+} from "../../util";
+const $bucket = (collection, expr, options) => {
+  const boundaries = [...expr.boundaries];
+  const defaultKey = expr.default;
+  const lower = boundaries[0];
+  const upper = boundaries[boundaries.length - 1];
+  const outputExpr = expr.output || { count: { $sum: 1 } };
+  assert(
+    expr.boundaries.length > 2,
+    "$bucket 'boundaries' expression must have at least 3 elements"
+  );
+  const boundType = getType(lower);
+  for (let i = 0, len = boundaries.length - 1; i < len; i++) {
+    assert(
+      boundType === getType(boundaries[i + 1]),
+      "$bucket 'boundaries' must all be of the same type"
+    );
+    assert(
+      compare(boundaries[i], boundaries[i + 1]) < 0,
+      "$bucket 'boundaries' must be sorted in ascending order"
+    );
+  }
+  !isNil(defaultKey) && getType(expr.default) === getType(lower) && assert(
+    compare(expr.default, upper) >= 0 || compare(expr.default, lower) < 0,
+    "$bucket 'default' expression must be out of boundaries range"
+  );
+  const grouped = {};
+  for (const k of boundaries) {
+    grouped[k] = [];
+  }
+  if (!isNil(defaultKey))
+    grouped[defaultKey] = [];
+  let iterator;
+  return Lazy(() => {
+    if (!iterator) {
+      collection.each((obj) => {
+        const key = computeValue(obj, expr.groupBy, null, options);
+        if (isNil(key) || compare(key, lower) < 0 || compare(key, upper) >= 0) {
+          assert(
+            !isNil(defaultKey),
+            "$bucket require a default for out of range values"
+          );
+          grouped[defaultKey].push(obj);
+        } else {
+          assert(
+            compare(key, lower) >= 0 && compare(key, upper) < 0,
+            "$bucket 'groupBy' expression must resolve to a value in range of boundaries"
+          );
+          const index = findInsertIndex(boundaries, key);
+          const boundKey = boundaries[Math.max(0, index - 1)];
+          grouped[boundKey].push(obj);
+        }
+      });
+      boundaries.pop();
+      if (!isNil(defaultKey))
+        boundaries.push(defaultKey);
+      iterator = Lazy(boundaries).map((key) => {
+        const acc = computeValue(
+          grouped[key],
+          outputExpr,
+          null,
+          options
+        );
+        return into(acc, { _id: key });
+      });
+    }
+    return iterator.next();
+  });
+};
+export {
+  $bucket
+};

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

@@ -0,0 +1,79 @@
+import { computeValue } from "../../core";
+import { assert, has, into, isNil, memoize, sortBy } from "../../util";
+const ID_KEY = "_id";
+const $bucketAuto = (collection, expr, options) => {
+  const outputExpr = expr.output || { count: { $sum: 1 } };
+  const groupByExpr = expr.groupBy;
+  const bucketCount = expr.buckets;
+  assert(
+    bucketCount > 0,
+    `The $bucketAuto 'buckets' field must be greater than 0, but found: ${bucketCount}`
+  );
+  return collection.transform((coll) => {
+    const approxBucketSize = Math.max(1, Math.round(coll.length / bucketCount));
+    const computeValueOptimized = memoize(computeValue, options?.hashFunction);
+    const grouped = /* @__PURE__ */ new Map();
+    const remaining = [];
+    const sorted = sortBy(coll, (o) => {
+      const key = computeValueOptimized(o, groupByExpr, null, options);
+      if (isNil(key)) {
+        remaining.push(o);
+      } else {
+        if (!grouped.has(key))
+          grouped.set(key, []);
+        grouped.get(key).push(o);
+      }
+      return key;
+    });
+    const result = [];
+    let index = 0;
+    for (let i = 0, len = sorted.length; i < bucketCount && index < len; i++) {
+      const boundaries = {};
+      const bucketItems = [];
+      for (let j = 0; j < approxBucketSize && index < len; j++) {
+        let key = computeValueOptimized(
+          sorted[index],
+          groupByExpr,
+          null,
+          options
+        );
+        if (isNil(key))
+          key = null;
+        into(bucketItems, isNil(key) ? remaining : grouped.get(key));
+        index += isNil(key) ? remaining.length : grouped.get(key).length;
+        if (!has(boundaries, "min"))
+          boundaries.min = key;
+        if (result.length > 0) {
+          const lastBucket = result[result.length - 1];
+          lastBucket[ID_KEY].max = boundaries.min;
+        }
+      }
+      if (i == bucketCount - 1) {
+        into(bucketItems, sorted.slice(index));
+      }
+      const values = computeValue(
+        bucketItems,
+        outputExpr,
+        null,
+        options
+      );
+      result.push(
+        into(values, {
+          _id: boundaries
+        })
+      );
+    }
+    if (result.length > 0) {
+      result[result.length - 1][ID_KEY].max = computeValueOptimized(
+        sorted[sorted.length - 1],
+        groupByExpr,
+        null,
+        options
+      );
+    }
+    return result;
+  });
+};
+export {
+  $bucketAuto
+};

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

@@ -0,0 +1,16 @@
+import { Lazy } from "../../lazy";
+import { assert, isString } from "../../util";
+const $count = (collection, expr, _) => {
+  assert(
+    isString(expr) && expr.trim() !== "" && expr.indexOf(".") === -1 && expr.trim()[0] !== "$",
+    "Invalid expression value for $count"
+  );
+  return Lazy([
+    {
+      [expr]: collection.size()
+    }
+  ]);
+};
+export {
+  $count
+};

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

@@ -0,0 +1,17 @@
+import { Aggregator } from "../../aggregator";
+import { ProcessingMode } from "../../core";
+const $facet = (collection, expr, options) => {
+  return collection.transform((array) => {
+    const o = {};
+    for (const [k, pipeline] of Object.entries(expr)) {
+      o[k] = new Aggregator(pipeline, {
+        ...options,
+        processingMode: ProcessingMode.CLONE_INPUT
+      }).run(array);
+    }
+    return [o];
+  });
+};
+export {
+  $facet
+};

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

@@ -0,0 +1,59 @@
+import { initOptions } from "../../core";
+import { assert, has, isObject } from "../../util";
+import { $ifNull } from "../expression/conditional/ifNull";
+import { $linearFill } from "../window/linearFill";
+import { $locf } from "../window/locf";
+import { $addFields } from "./addFields";
+import { $setWindowFields } from "./setWindowFields";
+const FILL_METHODS = {
+  locf: "$locf",
+  linear: "$linearFill"
+};
+const $fill = (collection, expr, options) => {
+  assert(!expr.sortBy || isObject(expr.sortBy), "sortBy must be an object.");
+  assert(
+    !!expr.sortBy || Object.values(expr.output).every((m) => has(m, "value")),
+    "sortBy required if any output field specifies a 'method'."
+  );
+  assert(
+    !(expr.partitionBy && expr.partitionByFields),
+    "specify either partitionBy or partitionByFields."
+  );
+  assert(
+    !expr.partitionByFields || expr?.partitionByFields?.every((s) => s[0] !== "$"),
+    "fields in partitionByFields cannot begin with '$'."
+  );
+  options = initOptions(options);
+  options.context.addExpressionOps({ $ifNull });
+  options.context.addWindowOps({ $locf, $linearFill });
+  const partitionExpr = expr.partitionBy || expr?.partitionByFields?.map((s) => `$${s}`);
+  const valueExpr = {};
+  const methodExpr = {};
+  for (const [k, m] of Object.entries(expr.output)) {
+    if (has(m, "value")) {
+      valueExpr[k] = { $ifNull: [`$$CURRENT.${k}`, m["value"]] };
+    } else {
+      const fillOp = FILL_METHODS[m["method"]];
+      assert(!!fillOp, `invalid fill method '${m["method"]}'.`);
+      methodExpr[k] = { [fillOp]: "$" + k };
+    }
+  }
+  if (Object.keys(methodExpr).length > 0) {
+    collection = $setWindowFields(
+      collection,
+      {
+        sortBy: expr.sortBy || {},
+        partitionBy: partitionExpr,
+        output: methodExpr
+      },
+      options
+    );
+  }
+  if (Object.keys(valueExpr).length > 0) {
+    collection = $addFields(collection, valueExpr, options);
+  }
+  return collection;
+};
+export {
+  $fill
+};