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

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

@@ -0,0 +1,7 @@
+import { computeValue } from "../../../core";
+const $isArray = (obj, expr, options) => {
+  return computeValue(obj, expr[0], null, options) instanceof Array;
+};
+export {
+  $isArray
+};

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

@@ -0,0 +1,19 @@
+import {
+  ComputeOptions,
+  computeValue
+} from "../../../core";
+import { assert, isArray, isNil } from "../../../util";
+import { $last as __last } from "../../accumulator";
+const $last = (obj, expr, options) => {
+  const copts = ComputeOptions.init(options);
+  if (obj instanceof Array)
+    return __last(obj, expr, copts.update());
+  const arr = computeValue(obj, expr, null, options);
+  if (isNil(arr))
+    return null;
+  assert(isArray(arr), "Must resolve to an array/null or missing");
+  return __last(arr, "$$this", options);
+};
+export {
+  $last
+};

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

@@ -0,0 +1,15 @@
+import { computeValue } from "../../../core";
+import { assert, isArray, isNil } from "../../../util";
+import { $lastN as __lastN } from "../../accumulator/lastN";
+const $lastN = (obj, expr, options) => {
+  if (obj instanceof Array)
+    return __lastN(obj, expr, options);
+  const { input, n } = computeValue(obj, expr, null, options);
+  if (isNil(input))
+    return null;
+  assert(isArray(input), "Must resolve to an array/null or missing");
+  return __lastN(input, { n, input: "$$this" }, options);
+};
+export {
+  $lastN
+};

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

@@ -0,0 +1,24 @@
+import {
+  ComputeOptions,
+  computeValue
+} from "../../../core";
+import { assert, isArray } from "../../../util";
+const $map = (obj, expr, options) => {
+  const input = computeValue(obj, expr.input, null, options);
+  assert(isArray(input), `$map 'input' expression must resolve to an array`);
+  const copts = ComputeOptions.init(options);
+  const k = expr.as || "this";
+  return input.map((o) => {
+    return computeValue(
+      obj,
+      expr.in,
+      null,
+      copts.update(copts.root, {
+        variables: { [k]: o }
+      })
+    );
+  });
+};
+export {
+  $map
+};

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

@@ -0,0 +1,15 @@
+import { computeValue } from "../../../core";
+import { assert, isArray, isNil } from "../../../util";
+import { $maxN as __maxN } from "../../accumulator/maxN";
+const $maxN = (obj, expr, options) => {
+  if (obj instanceof Array)
+    return __maxN(obj, expr, options);
+  const { input, n } = computeValue(obj, expr, null, options);
+  if (isNil(input))
+    return null;
+  assert(isArray(input), "Must resolve to an array/null or missing");
+  return __maxN(input, { n, input: "$$this" }, options);
+};
+export {
+  $maxN
+};

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

@@ -0,0 +1,15 @@
+import { computeValue } from "../../../core";
+import { assert, isArray, isNil } from "../../../util";
+import { $minN as __minN } from "../../accumulator/minN";
+const $minN = (obj, expr, options) => {
+  if (obj instanceof Array)
+    return __minN(obj, expr, options);
+  const { input, n } = computeValue(obj, expr, null, options);
+  if (isNil(input))
+    return null;
+  assert(isArray(input), "Must resolve to an array/null or missing");
+  return __minN(input, { n, input: "$$this" }, options);
+};
+export {
+  $minN
+};

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

@@ -0,0 +1,5 @@
+import { $nin as __nin, createExpressionOperator } from "../../_predicates";
+const $nin = createExpressionOperator(__nin);
+export {
+  $nin
+};

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

@@ -0,0 +1,17 @@
+import { computeValue } from "../../../core";
+const $range = (obj, expr, options) => {
+  const arr = computeValue(obj, expr, null, options);
+  const start = arr[0];
+  const end = arr[1];
+  const step = arr[2] || 1;
+  const result = new Array();
+  let counter = start;
+  while (counter < end && step > 0 || counter > end && step < 0) {
+    result.push(counter);
+    counter += step;
+  }
+  return result;
+};
+export {
+  $range
+};

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

@@ -0,0 +1,27 @@
+import {
+  ComputeOptions,
+  computeValue
+} from "../../../core";
+import { assert, isArray, isNil } from "../../../util";
+const $reduce = (obj, expr, options) => {
+  const copts = ComputeOptions.init(options);
+  const input = computeValue(obj, expr.input, null, copts);
+  const initialValue = computeValue(obj, expr.initialValue, null, copts);
+  const inExpr = expr["in"];
+  if (isNil(input))
+    return null;
+  assert(isArray(input), "$reduce 'input' expression must resolve to an array");
+  return input.reduce((acc, n) => {
+    return computeValue(
+      n,
+      inExpr,
+      null,
+      copts.update(copts.root, {
+        variables: { value: acc }
+      })
+    );
+  }, initialValue);
+};
+export {
+  $reduce
+};

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

@@ -0,0 +1,14 @@
+import { computeValue } from "../../../core";
+import { assert, isArray, isNil } from "../../../util";
+const $reverseArray = (obj, expr, options) => {
+  const arr = computeValue(obj, expr, null, options);
+  if (isNil(arr))
+    return null;
+  assert(isArray(arr), "$reverseArray expression must resolve to an array");
+  const result = arr.slice(0);
+  result.reverse();
+  return result;
+};
+export {
+  $reverseArray
+};

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

@@ -0,0 +1,9 @@
+import { computeValue } from "../../../core";
+import { isArray } from "../../../util";
+const $size = (obj, expr, options) => {
+  const value = computeValue(obj, expr, null, options);
+  return isArray(value) ? value.length : void 0;
+};
+export {
+  $size
+};

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

@@ -0,0 +1,30 @@
+import { computeValue } from "../../../core";
+import { assert, isNil } from "../../../util";
+const $slice = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  const arr = args[0];
+  let skip = args[1];
+  let limit = args[2];
+  if (isNil(limit)) {
+    if (skip < 0) {
+      skip = Math.max(0, arr.length + skip);
+      limit = arr.length - skip + 1;
+    } else {
+      limit = skip;
+      skip = 0;
+    }
+  } else {
+    if (skip < 0) {
+      skip = Math.max(0, arr.length + skip);
+    }
+    assert(
+      limit > 0,
+      `Invalid argument for $slice operator. Limit must be a positive number`
+    );
+    limit += skip;
+  }
+  return arr.slice(skip, limit);
+};
+export {
+  $slice
+};

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

@@ -0,0 +1,20 @@
+import { Aggregator } from "../../../aggregator";
+import { computeValue } from "../../../core";
+import { assert, compare, isArray, isNil, isObject } from "../../../util";
+const $sortArray = (obj, expr, options) => {
+  const { input, sortBy } = computeValue(obj, expr, null, options);
+  if (isNil(input))
+    return null;
+  assert(isArray(input), "$sortArray expression must resolve to an array");
+  if (isObject(sortBy)) {
+    return new Aggregator([{ $sort: sortBy }]).run(input);
+  }
+  const result = [...input];
+  result.sort(compare);
+  if (sortBy === -1)
+    result.reverse();
+  return result;
+};
+export {
+  $sortArray
+};

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

@@ -0,0 +1,42 @@
+import { computeValue } from "../../../core";
+import { assert, isArray, isBoolean, isNil } from "../../../util";
+const $zip = (obj, expr, options) => {
+  const inputs = computeValue(
+    obj,
+    expr.inputs,
+    null,
+    options
+  );
+  const useLongestLength = expr.useLongestLength || false;
+  assert(isArray(inputs), "'inputs' expression must resolve to an array");
+  assert(isBoolean(useLongestLength), "'useLongestLength' must be a boolean");
+  if (isArray(expr.defaults)) {
+    assert(
+      useLongestLength,
+      "'useLongestLength' must be set to true to use 'defaults'"
+    );
+  }
+  let zipCount = 0;
+  for (let i = 0, len = inputs.length; i < len; i++) {
+    const arr = inputs[i];
+    if (isNil(arr))
+      return null;
+    assert(
+      isArray(arr),
+      "'inputs' expression values must resolve to an array or null"
+    );
+    zipCount = useLongestLength ? Math.max(zipCount, arr.length) : Math.min(zipCount || arr.length, arr.length);
+  }
+  const result = [];
+  const defaults = expr.defaults || [];
+  for (let i = 0; i < zipCount; i++) {
+    const temp = inputs.map((val, index) => {
+      return isNil(val[i]) ? defaults[index] || null : val[i];
+    });
+    result.push(temp);
+  }
+  return result;
+};
+export {
+  $zip
+};

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

@@ -0,0 +1,16 @@
+import { computeValue } from "../../../core";
+import { assert, isArray, isNil, isNumber } from "../../../util";
+const bitwise = (op, compute) => (obj, expr, options) => {
+  assert(isArray(expr), `${op}: expression must be an array.`);
+  const nums = computeValue(obj, expr, null, options);
+  if (nums.some(isNil))
+    return null;
+  assert(
+    nums.every(isNumber),
+    `${op}: expression must evalue to array of numbers.`
+  );
+  return compute(nums);
+};
+export {
+  bitwise
+};

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

@@ -0,0 +1,8 @@
+import { bitwise } from "./_internal";
+const $bitAnd = bitwise(
+  "$bitAnd",
+  (nums) => nums.reduce((a, b) => a & b, -1)
+);
+export {
+  $bitAnd
+};

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

@@ -0,0 +1,13 @@
+import { computeValue } from "../../../core";
+import { isNil, isNumber, MingoError } from "../../../util";
+const $bitNot = (obj, expr, options) => {
+  const n = computeValue(obj, expr, null, options);
+  if (isNil(n))
+    return null;
+  if (isNumber(n))
+    return ~n;
+  throw new MingoError("$bitNot: expression must evaluate to a number.");
+};
+export {
+  $bitNot
+};

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

@@ -0,0 +1,8 @@
+import { bitwise } from "./_internal";
+const $bitOr = bitwise(
+  "$bitOr",
+  (nums) => nums.reduce((a, b) => a | b, 0)
+);
+export {
+  $bitOr
+};

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

@@ -0,0 +1,8 @@
+import { bitwise } from "./_internal";
+const $bitXor = bitwise(
+  "$bitXor",
+  (nums) => nums.reduce((a, b) => a ^ b, 0)
+);
+export {
+  $bitXor
+};

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

@@ -0,0 +1,4 @@
+export * from "./bitAnd";
+export * from "./bitNot";
+export * from "./bitOr";
+export * from "./bitXor";

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

@@ -0,0 +1,9 @@
+import { computeValue } from "../../../core";
+import { truthy } from "../../../util";
+const $and = (obj, expr, options) => {
+  const value = computeValue(obj, expr, null, options);
+  return truthy(value, options.useStrictMode) && value.every((v) => truthy(v, options.useStrictMode));
+};
+export {
+  $and
+};

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

@@ -0,0 +1,3 @@
+export * from "./and";
+export * from "./not";
+export * from "./or";

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

@@ -0,0 +1,13 @@
+import { computeValue } from "../../../core";
+import { ensureArray } from "../../../util";
+const $not = (obj, expr, options) => {
+  const booleanExpr = ensureArray(expr);
+  if (booleanExpr.length == 0)
+    return false;
+  if (booleanExpr.length == 1)
+    return !computeValue(obj, booleanExpr[0], null, options);
+  throw "Expression $not takes exactly 1 argument";
+};
+export {
+  $not
+};

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

@@ -0,0 +1,10 @@
+import { computeValue } from "../../../core";
+import { truthy } from "../../../util";
+const $or = (obj, expr, options) => {
+  const value = computeValue(obj, expr, null, options);
+  const strict = options.useStrictMode;
+  return truthy(value, strict) && value.some((v) => truthy(v, strict));
+};
+export {
+  $or
+};

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

@@ -0,0 +1,12 @@
+import { computeValue } from "../../../core";
+const $cmp = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  if (args[0] > args[1])
+    return 1;
+  if (args[0] < args[1])
+    return -1;
+  return 0;
+};
+export {
+  $cmp
+};

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

@@ -0,0 +1,5 @@
+import { $eq as __eq, createExpressionOperator } from "../../_predicates";
+const $eq = createExpressionOperator(__eq);
+export {
+  $eq
+};

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

@@ -0,0 +1,5 @@
+import { $gt as __gt, createExpressionOperator } from "../../_predicates";
+const $gt = createExpressionOperator(__gt);
+export {
+  $gt
+};

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

@@ -0,0 +1,5 @@
+import { $gte as __gte, createExpressionOperator } from "../../_predicates";
+const $gte = createExpressionOperator(__gte);
+export {
+  $gte
+};

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

@@ -0,0 +1,7 @@
+export * from "./cmp";
+export * from "./eq";
+export * from "./gt";
+export * from "./gte";
+export * from "./lt";
+export * from "./lte";
+export * from "./ne";

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

@@ -0,0 +1,5 @@
+import { $lt as __lt, createExpressionOperator } from "../../_predicates";
+const $lt = createExpressionOperator(__lt);
+export {
+  $lt
+};

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

@@ -0,0 +1,5 @@
+import { $lte as __lte, createExpressionOperator } from "../../_predicates";
+const $lte = createExpressionOperator(__lte);
+export {
+  $lte
+};

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

@@ -0,0 +1,5 @@
+import { $ne as __ne, createExpressionOperator } from "../../_predicates";
+const $ne = createExpressionOperator(__ne);
+export {
+  $ne
+};

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

@@ -0,0 +1,27 @@
+import { computeValue } from "../../../core";
+import { assert, isObject, truthy } from "../../../util";
+const $cond = (obj, expr, options) => {
+  let ifExpr;
+  let thenExpr;
+  let elseExpr;
+  const errorMsg = "$cond: invalid arguments";
+  if (expr instanceof Array) {
+    assert(expr.length === 3, errorMsg);
+    ifExpr = expr[0];
+    thenExpr = expr[1];
+    elseExpr = expr[2];
+  } else {
+    assert(isObject(expr), errorMsg);
+    ifExpr = expr.if;
+    thenExpr = expr.then;
+    elseExpr = expr.else;
+  }
+  const condition = truthy(
+    computeValue(obj, ifExpr, null, options),
+    options.useStrictMode
+  );
+  return computeValue(obj, condition ? thenExpr : elseExpr, null, options);
+};
+export {
+  $cond
+};

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

@@ -0,0 +1,9 @@
+import { computeValue } from "../../../core";
+import { isNil } from "../../../util";
+const $ifNull = (obj, expr, options) => {
+  const args = computeValue(obj, expr, null, options);
+  return args.find((arg) => !isNil(arg));
+};
+export {
+  $ifNull
+};

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

@@ -0,0 +1,3 @@
+export * from "./cond";
+export * from "./ifNull";
+export * from "./switch";

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

@@ -0,0 +1,23 @@
+import { computeValue } from "../../../core";
+import { truthy } from "../../../util";
+const $switch = (obj, expr, options) => {
+  let thenExpr = null;
+  expr.branches.some((b) => {
+    const condition = truthy(
+      computeValue(obj, b.case, null, options),
+      options.useStrictMode
+    );
+    if (condition)
+      thenExpr = b.then;
+    return condition;
+  });
+  return computeValue(
+    obj,
+    thenExpr !== null ? thenExpr : expr.default,
+    null,
+    options
+  );
+};
+export {
+  $switch
+};

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

@@ -0,0 +1,13 @@
+import { computeValue } from "../../../core";
+import { assert } from "../../../util";
+const $function = (obj, expr, options) => {
+  assert(
+    options.scriptEnabled,
+    "$function operator requires 'scriptEnabled' option to be true"
+  );
+  const fn = computeValue(obj, expr, null, options);
+  return fn.body.apply(null, fn.args);
+};
+export {
+  $function
+};

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

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