npm - @valkey/valkey-glide-darwin-arm64 - Versions diffs - 1.2.0 → 1.2.1-rc0 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (439) hide show

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/arrayElemAt.js CHANGED Viewed

@@ -25,11 +25,10 @@ var import_util = require("../../../util");
 const $arrayElemAt = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
   (0, import_util.assert)(
-    args instanceof Array && args.length === 2,
+    (0, import_util.isArray)(args) && args.length === 2,
     "$arrayElemAt expression must resolve to array(2)"
   );
-  if (args.some(import_util.isNil))
-    return null;
+  if (args.some(import_util.isNil)) return null;
   const index = args[1];
   const arr = args[0];
   if (index < 0 && Math.abs(index) <= arr.length) {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/arrayToObject.js CHANGED Viewed

@@ -24,11 +24,10 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $arrayToObject = (obj, expr, options) => {
   const arr = (0, import_core.computeValue)(obj, expr, null, options);
-  (0, import_util.assert)((0, import_util.isArray)(arr), "$arrayToObject expression must resolve to an array");
+  (0, import_util.assert)((0, import_util.isArray)(arr), "$arrayToObject: expression must resolve to an array");
   return arr.reduce((newObj, val) => {
-    while ((0, import_util.isArray)(val) && val.length === 1)
-      val = val[0];
-    if (val instanceof Array && val.length == 2) {
+    while ((0, import_util.isArray)(val) && val.length === 1) val = val[0];
+    if ((0, import_util.isArray)(val) && val.length == 2) {
       newObj[val[0]] = val[1];
     } else {
       const valObj = val;

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/concatArrays.js CHANGED Viewed

@@ -23,11 +23,17 @@ module.exports = __toCommonJS(concatArrays_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $concatArrays = (obj, expr, options) => {
-  const arr = (0, import_core.computeValue)(obj, expr, null, options);
-  (0, import_util.assert)((0, import_util.isArray)(arr), "$concatArrays must resolve to an array");
-  if (arr.some(import_util.isNil))
-    return null;
-  return arr.reduce((acc, item) => (0, import_util.into)(acc, item), []);
+  const nArray = (0, import_core.computeValue)(obj, expr, null, options);
+  (0, import_util.assert)((0, import_util.isArray)(nArray), "$concatArrays: input must resolve to an array");
+  let size = 0;
+  for (const arr of nArray) {
+    if ((0, import_util.isNil)(arr)) return null;
+    size += arr.length;
+  }
+  const result = new Array(size);
+  let i = 0;
+  for (const arr of nArray) for (const item of arr) result[i++] = item;
+  return result;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/filter.js CHANGED Viewed

@@ -24,6 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $filter = (obj, expr, options) => {
   const input = (0, import_core.computeValue)(obj, expr.input, null, options);
+  if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)((0, import_util.isArray)(input), "$filter 'input' expression must resolve to an array");
   const copts = import_core.ComputeOptions.init(options, obj);
   const k = expr.as || "this";

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/first.js CHANGED Viewed

@@ -22,16 +22,16 @@ __export(first_exports, {
 module.exports = __toCommonJS(first_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../util");
-var import_accumulator = require("../../accumulator");
+var import_first = require("../../accumulator/first");
 const $first = (obj, expr, options) => {
-  const copts = import_core.ComputeOptions.init(options);
-  if (obj instanceof Array)
-    return (0, import_accumulator.$first)(obj, expr, copts.update());
+  if ((0, import_util.isArray)(obj)) return (0, import_first.$first)(obj, expr, options);
   const arr = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(arr))
-    return null;
-  (0, import_util.assert)((0, import_util.isArray)(arr), "Must resolve to an array/null or missing");
-  return (0, import_accumulator.$first)(arr, "$$this", options);
+  if ((0, import_util.isNil)(arr)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isArray)(arr) && arr.length > 0,
+    "$first must resolve to a non-empty array."
+  );
+  return (0, import_util.flatten)(arr)[0];
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/firstN.js CHANGED Viewed

@@ -24,11 +24,9 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 var import_firstN = require("../../accumulator/firstN");
 const $firstN = (obj, expr, options) => {
-  if (obj instanceof Array)
-    return (0, import_firstN.$firstN)(obj, expr, options);
+  if ((0, import_util.isArray)(obj)) return (0, import_firstN.$firstN)(obj, expr, options);
   const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(input))
-    return null;
+  if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)((0, import_util.isArray)(input), "Must resolve to an array/null or missing");
   return (0, import_firstN.$firstN)(input, { n, input: "$$this" }, options);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/in.js CHANGED Viewed

@@ -25,7 +25,7 @@ var import_util = require("../../../util");
 const $in = (obj, expr, options) => {
   const [item, arr] = (0, import_core.computeValue)(obj, expr, null, options);
   (0, import_util.assert)((0, import_util.isArray)(arr), "$in second argument must be an array");
-  return arr.some(import_util.isEqual.bind(null, item));
+  return arr.some((v) => (0, import_util.isEqual)(v, item));
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/indexOfArray.js CHANGED Viewed

@@ -24,19 +24,15 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $indexOfArray = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(args))
-    return null;
+  if ((0, import_util.isNil)(args)) return null;
   let arr = args[0];
   const searchValue = args[1];
-  if ((0, import_util.isNil)(arr))
-    return null;
+  if ((0, import_util.isNil)(arr)) return null;
   (0, import_util.assert)((0, import_util.isArray)(arr), "$indexOfArray expression must resolve to an array.");
   const start = args[2] || 0;
   let end = args[3];
-  if ((0, import_util.isNil)(end))
-    end = arr.length;
-  if (start > end)
-    return -1;
+  if ((0, import_util.isNil)(end)) end = arr.length;
+  if (start > end) return -1;
   (0, import_util.assert)(start >= 0 && end >= 0, "$indexOfArray expression is invalid");
   if (start > 0 || end < arr.length) {
     arr = arr.slice(start, end);
@@ -44,8 +40,7 @@ const $indexOfArray = (obj, expr, options) => {
   let index = -1;
   arr.some((v, i) => {
     const b = (0, import_util.isEqual)(v, searchValue);
-    if (b)
-      index = i;
+    if (b) index = i;
     return b;
   });
   return index + start;

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/isArray.js CHANGED Viewed

@@ -21,9 +21,8 @@ __export(isArray_exports, {
 });
 module.exports = __toCommonJS(isArray_exports);
 var import_core = require("../../../core");
-const $isArray = (obj, expr, options) => {
-  return (0, import_core.computeValue)(obj, expr[0], null, options) instanceof Array;
-};
+var import_util = require("../../../util");
+const $isArray = (obj, expr, options) => (0, import_util.isArray)((0, import_core.computeValue)(obj, expr[0], null, options));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $isArray

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/last.js CHANGED Viewed

@@ -22,16 +22,16 @@ __export(last_exports, {
 module.exports = __toCommonJS(last_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../util");
-var import_accumulator = require("../../accumulator");
+var import_last = require("../../accumulator/last");
 const $last = (obj, expr, options) => {
-  const copts = import_core.ComputeOptions.init(options);
-  if (obj instanceof Array)
-    return (0, import_accumulator.$last)(obj, expr, copts.update());
+  if ((0, import_util.isArray)(obj)) return (0, import_last.$last)(obj, expr, options);
   const arr = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(arr))
-    return null;
-  (0, import_util.assert)((0, import_util.isArray)(arr), "Must resolve to an array/null or missing");
-  return (0, import_accumulator.$last)(arr, "$$this", options);
+  if ((0, import_util.isNil)(arr)) return null;
+  (0, import_util.assert)(
+    (0, import_util.isArray)(arr) && arr.length > 0,
+    "$last must resolve to a non-empty array."
+  );
+  return (0, import_util.flatten)(arr)[arr.length - 1];
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/lastN.js CHANGED Viewed

@@ -24,11 +24,9 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 var import_lastN = require("../../accumulator/lastN");
 const $lastN = (obj, expr, options) => {
-  if (obj instanceof Array)
-    return (0, import_lastN.$lastN)(obj, expr, options);
+  if ((0, import_util.isArray)(obj)) return (0, import_lastN.$lastN)(obj, expr, options);
   const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(input))
-    return null;
+  if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)((0, import_util.isArray)(input), "Must resolve to an array/null or missing");
   return (0, import_lastN.$lastN)(input, { n, input: "$$this" }, options);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/map.js CHANGED Viewed

@@ -24,6 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $map = (obj, expr, options) => {
   const input = (0, import_core.computeValue)(obj, expr.input, null, options);
+  if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)((0, import_util.isArray)(input), `$map 'input' expression must resolve to an array`);
   const copts = import_core.ComputeOptions.init(options);
   const k = expr.as || "this";

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/maxN.js CHANGED Viewed

@@ -24,11 +24,9 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 var import_maxN = require("../../accumulator/maxN");
 const $maxN = (obj, expr, options) => {
-  if (obj instanceof Array)
-    return (0, import_maxN.$maxN)(obj, expr, options);
+  if ((0, import_util.isArray)(obj)) return (0, import_maxN.$maxN)(obj, expr, options);
   const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(input))
-    return null;
+  if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)((0, import_util.isArray)(input), "Must resolve to an array/null or missing");
   return (0, import_maxN.$maxN)(input, { n, input: "$$this" }, options);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/minN.js CHANGED Viewed

@@ -24,11 +24,9 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 var import_minN = require("../../accumulator/minN");
 const $minN = (obj, expr, options) => {
-  if (obj instanceof Array)
-    return (0, import_minN.$minN)(obj, expr, options);
+  if ((0, import_util.isArray)(obj)) return (0, import_minN.$minN)(obj, expr, options);
   const { input, n } = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(input))
-    return null;
+  if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)((0, import_util.isArray)(input), "Must resolve to an array/null or missing");
   return (0, import_minN.$minN)(input, { n, input: "$$this" }, options);
 };

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/reduce.js CHANGED Viewed

@@ -27,8 +27,7 @@ const $reduce = (obj, expr, options) => {
   const input = (0, import_core.computeValue)(obj, expr.input, null, copts);
   const initialValue = (0, import_core.computeValue)(obj, expr.initialValue, null, copts);
   const inExpr = expr["in"];
-  if ((0, import_util.isNil)(input))
-    return null;
+  if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)((0, import_util.isArray)(input), "$reduce 'input' expression must resolve to an array");
   return input.reduce((acc, n) => {
     return (0, import_core.computeValue)(

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/reverseArray.js CHANGED Viewed

@@ -24,8 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $reverseArray = (obj, expr, options) => {
   const arr = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(arr))
-    return null;
+  if ((0, import_util.isNil)(arr)) return null;
   (0, import_util.assert)((0, import_util.isArray)(arr), "$reverseArray expression must resolve to an array");
   const result = arr.slice(0);
   result.reverse();

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/sortArray.js CHANGED Viewed

@@ -25,16 +25,14 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $sortArray = (obj, expr, options) => {
   const { input, sortBy } = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(input))
-    return null;
+  if ((0, import_util.isNil)(input)) return null;
   (0, import_util.assert)((0, import_util.isArray)(input), "$sortArray expression must resolve to an array");
   if ((0, import_util.isObject)(sortBy)) {
     return new import_aggregator.Aggregator([{ $sort: sortBy }]).run(input);
   }
   const result = [...input];
   result.sort(import_util.compare);
-  if (sortBy === -1)
-    result.reverse();
+  if (sortBy === -1) result.reverse();
   return result;
 };
 // Annotate the CommonJS export names for ESM import in node:

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/array/zip.js CHANGED Viewed

@@ -23,13 +23,9 @@ module.exports = __toCommonJS(zip_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $zip = (obj, expr, options) => {
-  const inputs = (0, import_core.computeValue)(
-    obj,
-    expr.inputs,
-    null,
-    options
-  );
+  const inputs = (0, import_core.computeValue)(obj, expr.inputs, null, options);
   const useLongestLength = expr.useLongestLength || false;
+  if ((0, import_util.isNil)(inputs)) return null;
   (0, import_util.assert)((0, import_util.isArray)(inputs), "'inputs' expression must resolve to an array");
   (0, import_util.assert)((0, import_util.isBoolean)(useLongestLength), "'useLongestLength' must be a boolean");
   if ((0, import_util.isArray)(expr.defaults)) {
@@ -39,10 +35,8 @@ const $zip = (obj, expr, options) => {
     );
   }
   let zipCount = 0;
-  for (let i = 0, len = inputs.length; i < len; i++) {
-    const arr = inputs[i];
-    if ((0, import_util.isNil)(arr))
-      return null;
+  for (const arr of inputs) {
+    if ((0, import_util.isNil)(arr)) return null;
     (0, import_util.assert)(
       (0, import_util.isArray)(arr),
       "'inputs' expression values must resolve to an array or null"

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/bitwise/_internal.js CHANGED Viewed

@@ -25,8 +25,7 @@ var import_util = require("../../../util");
 const bitwise = (op, compute) => (obj, expr, options) => {
   (0, import_util.assert)((0, import_util.isArray)(expr), `${op}: expression must be an array.`);
   const nums = (0, import_core.computeValue)(obj, expr, null, options);
-  if (nums.some(import_util.isNil))
-    return null;
+  if (nums.some(import_util.isNil)) return null;
   (0, import_util.assert)(
     nums.every(import_util.isNumber),
     `${op}: expression must evalue to array of numbers.`

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/bitwise/bitNot.js CHANGED Viewed

@@ -24,10 +24,8 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $bitNot = (obj, expr, options) => {
   const n = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isNil)(n))
-    return null;
-  if ((0, import_util.isNumber)(n))
-    return ~n;
+  if ((0, import_util.isNil)(n)) return null;
+  if ((0, import_util.isNumber)(n)) return ~n;
   throw new import_util.MingoError("$bitNot: expression must evaluate to a number.");
 };
 // Annotate the CommonJS export names for ESM import in node:

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/boolean/not.js CHANGED Viewed

@@ -24,11 +24,9 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $not = (obj, expr, options) => {
   const booleanExpr = (0, import_util.ensureArray)(expr);
-  if (booleanExpr.length == 0)
-    return false;
-  if (booleanExpr.length == 1)
-    return !(0, import_core.computeValue)(obj, booleanExpr[0], null, options);
-  throw "Expression $not takes exactly 1 argument";
+  if (booleanExpr.length == 0) return false;
+  (0, import_util.assert)(booleanExpr.length == 1, "Expression $not takes exactly 1 argument");
+  return !(0, import_core.computeValue)(obj, booleanExpr[0], null, options);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/comparison/cmp.js CHANGED Viewed

@@ -21,13 +21,14 @@ __export(cmp_exports, {
 });
 module.exports = __toCommonJS(cmp_exports);
 var import_core = require("../../../core");
+var import_util = require("../../../util");
 const $cmp = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  if (args[0] > args[1])
-    return 1;
-  if (args[0] < args[1])
-    return -1;
-  return 0;
+  (0, import_util.assert)(
+    (0, import_util.isArray)(args) && args.length == 2,
+    "$cmp: expression must resolve to array of size 2."
+  );
+  return (0, import_util.compare)(args[0], args[1]);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/conditional/cond.js CHANGED Viewed

@@ -27,7 +27,7 @@ const $cond = (obj, expr, options) => {
   let thenExpr;
   let elseExpr;
   const errorMsg = "$cond: invalid arguments";
-  if (expr instanceof Array) {
+  if ((0, import_util.isArray)(expr)) {
     (0, import_util.assert)(expr.length === 3, errorMsg);
     ifExpr = expr[0];
     thenExpr = expr[1];

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/conditional/ifNull.js CHANGED Viewed

@@ -24,7 +24,7 @@ var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $ifNull = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  return args.find((arg) => !(0, import_util.isNil)(arg));
+  return args.find((arg) => !(0, import_util.isNil)(arg)) ?? args[args.length - 1];
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/rust-client/node_modules/mingo/dist/cjs/operators/expression/conditional/switch.js CHANGED Viewed

@@ -29,8 +29,7 @@ const $switch = (obj, expr, options) => {
       (0, import_core.computeValue)(obj, b.case, null, options),
       options.useStrictMode
     );
-    if (condition)
-      thenExpr = b.then;
+    if (condition) thenExpr = b.then;
     return condition;
   });
   return (0, import_core.computeValue)(