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

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

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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

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

@@ -1,8 +0,0 @@
-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

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

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

@@ -1,29 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

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

@@ -1,21 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

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

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

@@ -1,19 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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
-};