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

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

@@ -0,0 +1,76 @@
+import {
+  compare,
+  groupBy,
+  into,
+  isEmpty,
+  isObject,
+  isString,
+  resolve
+} from "../../util";
+const $sort = (collection, sortKeys, options) => {
+  if (isEmpty(sortKeys) || !isObject(sortKeys))
+    return collection;
+  let cmp = compare;
+  const collationSpec = options.collation;
+  if (isObject(collationSpec) && isString(collationSpec.locale)) {
+    cmp = collationComparator(collationSpec);
+  }
+  return collection.transform((coll) => {
+    const modifiers = Object.keys(sortKeys);
+    for (const key of modifiers.reverse()) {
+      const groups = groupBy(
+        coll,
+        (obj) => resolve(obj, key),
+        options.hashFunction
+      );
+      const sortedKeys = Array.from(groups.keys()).sort(cmp);
+      if (sortKeys[key] === -1)
+        sortedKeys.reverse();
+      coll = [];
+      sortedKeys.reduce(
+        (acc, key2) => into(acc, groups.get(key2)),
+        coll
+      );
+    }
+    return coll;
+  });
+};
+const COLLATION_STRENGTH = {
+  // Only strings that differ in base letters compare as unequal. Examples: a ≠ b, a = á, a = A.
+  1: "base",
+  //  Only strings that differ in base letters or accents and other diacritic marks compare as unequal.
+  // Examples: a ≠ b, a ≠ á, a = A.
+  2: "accent",
+  // Strings that differ in base letters, accents and other diacritic marks, or case compare as unequal.
+  // Other differences may also be taken into consideration. Examples: a ≠ b, a ≠ á, a ≠ A
+  3: "variant"
+  // case - Only strings that differ in base letters or case compare as unequal. Examples: a ≠ b, a = á, a ≠ A.
+};
+function collationComparator(spec) {
+  const localeOpt = {
+    sensitivity: COLLATION_STRENGTH[spec.strength || 3],
+    caseFirst: spec.caseFirst === "off" ? "false" : spec.caseFirst || "false",
+    numeric: spec.numericOrdering || false,
+    ignorePunctuation: spec.alternate === "shifted"
+  };
+  if ((spec.caseLevel || false) === true) {
+    if (localeOpt.sensitivity === "base")
+      localeOpt.sensitivity = "case";
+    if (localeOpt.sensitivity === "accent")
+      localeOpt.sensitivity = "variant";
+  }
+  const collator = new Intl.Collator(spec.locale, localeOpt);
+  return (a, b) => {
+    if (!isString(a) || !isString(b))
+      return compare(a, b);
+    const i = collator.compare(a, b);
+    if (i < 0)
+      return -1;
+    if (i > 0)
+      return 1;
+    return 0;
+  };
+}
+export {
+  $sort
+};

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

@@ -0,0 +1,10 @@
+import { $group } from "./group";
+import { $sort } from "./sort";
+const $sortByCount = (collection, expr, options) => {
+  const newExpr = { count: { $sum: 1 } };
+  newExpr["_id"] = expr;
+  return $sort($group(collection, newExpr, options), { count: -1 }, options);
+};
+export {
+  $sortByCount
+};

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

@@ -0,0 +1,14 @@
+import { Aggregator } from "../../aggregator";
+import { compose, Lazy } from "../../lazy";
+import { isString } from "../../util";
+const $unionWith = (collection, expr, options) => {
+  const array = isString(expr.coll) ? options.collectionResolver(expr.coll) : expr.coll;
+  const iterators = [collection];
+  iterators.push(
+    expr.pipeline ? new Aggregator(expr.pipeline, options).stream(array) : Lazy(array)
+  );
+  return compose(...iterators);
+};
+export {
+  $unionWith
+};

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

@@ -0,0 +1,12 @@
+import { ensureArray } from "../../util";
+import { $project } from "./project";
+const $unset = (collection, expr, options) => {
+  expr = ensureArray(expr);
+  const doc = {};
+  for (const k of expr)
+    doc[k] = 0;
+  return $project(collection, doc, options);
+};
+export {
+  $unset
+};

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

@@ -0,0 +1,57 @@
+import { Iterator, Lazy } from "../../lazy";
+import {
+  isEmpty,
+  isString,
+  removeValue,
+  resolve,
+  resolveGraph,
+  setValue
+} from "../../util";
+const $unwind = (collection, expr, _options) => {
+  if (isString(expr))
+    expr = { path: expr };
+  const path = expr.path;
+  const field = path.substring(1);
+  const includeArrayIndex = expr?.includeArrayIndex || false;
+  const preserveNullAndEmptyArrays = expr.preserveNullAndEmptyArrays || false;
+  const format = (o, i) => {
+    if (includeArrayIndex !== false)
+      o[includeArrayIndex] = i;
+    return o;
+  };
+  let value;
+  return Lazy(() => {
+    for (; ; ) {
+      if (value instanceof Iterator) {
+        const tmp = value.next();
+        if (!tmp.done)
+          return tmp;
+      }
+      const wrapper = collection.next();
+      if (wrapper.done)
+        return wrapper;
+      const obj = wrapper.value;
+      value = resolve(obj, field);
+      if (value instanceof Array) {
+        if (value.length === 0 && preserveNullAndEmptyArrays === true) {
+          value = null;
+          removeValue(obj, field);
+          return { value: format(obj, null), done: false };
+        } else {
+          value = Lazy(value).map((item, i) => {
+            const newObj = resolveGraph(obj, field, {
+              preserveKeys: true
+            });
+            setValue(newObj, field, item);
+            return format(newObj, i);
+          });
+        }
+      } else if (!isEmpty(value) || preserveNullAndEmptyArrays === true) {
+        return { value: format(obj, null), done: false };
+      }
+    }
+  });
+};
+export {
+  $unwind
+};

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

@@ -0,0 +1,19 @@
+import { Query } from "../../query";
+import { assert, resolve } from "../../util";
+const $elemMatch = (obj, expr, field, options) => {
+  const arr = resolve(obj, field);
+  const query = new Query(expr, options);
+  assert(arr instanceof Array, "$elemMatch: argument must resolve to array");
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (query.test(arr[i])) {
+      if (options.useStrictMode)
+        return [arr[i]];
+      result.push(arr[i]);
+    }
+  }
+  return result.length > 0 ? result : void 0;
+};
+export {
+  $elemMatch
+};

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

@@ -0,0 +1,2 @@
+export * from "./elemMatch";
+export * from "./slice";

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

@@ -0,0 +1,16 @@
+import { isArray, resolve } from "../../util";
+import { $slice as __slice } from "../expression/array/slice";
+const $slice = (obj, expr, field, options) => {
+  const xs = resolve(obj, field);
+  const exprAsArray = expr;
+  if (!isArray(xs))
+    return xs;
+  return __slice(
+    obj,
+    expr instanceof Array ? [xs, ...exprAsArray] : [xs, expr],
+    options
+  );
+};
+export {
+  $slice
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/array/all.js

@@ -0,0 +1,5 @@
+import { $all as __all, createQueryOperator } from "../../_predicates";
+const $all = createQueryOperator(__all);
+export {
+  $all
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/array/elemMatch.js

@@ -0,0 +1,8 @@
+import {
+  $elemMatch as __elemMatch,
+  createQueryOperator
+} from "../../_predicates";
+const $elemMatch = createQueryOperator(__elemMatch);
+export {
+  $elemMatch
+};

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

@@ -0,0 +1,3 @@
+export * from "./all";
+export * from "./elemMatch";
+export * from "./size";

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

@@ -0,0 +1,5 @@
+import { $size as __size, createQueryOperator } from "../../_predicates";
+const $size = createQueryOperator(__size);
+export {
+  $size
+};

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

@@ -0,0 +1,18 @@
+import { createQueryOperator } from "../../_predicates";
+const createBitwiseOperator = (predicate) => {
+  return createQueryOperator(
+    (value, mask, options) => {
+      let b = 0;
+      if (mask instanceof Array) {
+        for (const n of mask)
+          b = b | 1 << n;
+      } else {
+        b = mask;
+      }
+      return predicate(value & b, b);
+    }
+  );
+};
+export {
+  createBitwiseOperator
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/bitwise/bitsAllClear.js

@@ -0,0 +1,5 @@
+import { createBitwiseOperator } from "./_internal";
+const $bitsAllClear = createBitwiseOperator((result, _) => result == 0);
+export {
+  $bitsAllClear
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/bitwise/bitsAllSet.js

@@ -0,0 +1,7 @@
+import { createBitwiseOperator } from "./_internal";
+const $bitsAllSet = createBitwiseOperator(
+  (result, mask) => result == mask
+);
+export {
+  $bitsAllSet
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/bitwise/bitsAnyClear.js

@@ -0,0 +1,7 @@
+import { createBitwiseOperator } from "./_internal";
+const $bitsAnyClear = createBitwiseOperator(
+  (result, mask) => result < mask
+);
+export {
+  $bitsAnyClear
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/bitwise/bitsAnySet.js

@@ -0,0 +1,5 @@
+import { createBitwiseOperator } from "./_internal";
+const $bitsAnySet = createBitwiseOperator((result, _) => result > 0);
+export {
+  $bitsAnySet
+};

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

@@ -0,0 +1,10 @@
+import { $bitsAllClear } from "./bitsAllClear";
+import { $bitsAllSet } from "./bitsAllSet";
+import { $bitsAnyClear } from "./bitsAnyClear";
+import { $bitsAnySet } from "./bitsAnySet";
+export {
+  $bitsAllClear,
+  $bitsAllSet,
+  $bitsAnyClear,
+  $bitsAnySet
+};

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

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

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

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

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

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

package/rust-client/node_modules/mingo/dist/esm/operators/query/comparison/in.js

@@ -0,0 +1,5 @@
+import { $in as __in, createQueryOperator } from "../../_predicates";
+const $in = createQueryOperator(__in);
+export {
+  $in
+};

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

@@ -0,0 +1,18 @@
+import { $eq } from "./eq";
+import { $gt } from "./gt";
+import { $gte } from "./gte";
+import { $in } from "./in";
+import { $lt } from "./lt";
+import { $lte } from "./lte";
+import { $ne } from "./ne";
+import { $nin } from "./nin";
+export {
+  $eq,
+  $gt,
+  $gte,
+  $in,
+  $lt,
+  $lte,
+  $ne,
+  $nin
+};

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

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

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

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

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

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

package/rust-client/node_modules/mingo/dist/esm/operators/query/comparison/nin.js

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

package/rust-client/node_modules/mingo/dist/esm/operators/query/element/exists.js

@@ -0,0 +1,5 @@
+import { $exists as __exists, createQueryOperator } from "../../_predicates";
+const $exists = createQueryOperator(__exists);
+export {
+  $exists
+};

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

@@ -0,0 +1,2 @@
+export * from "./exists";
+export * from "./type";

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

@@ -0,0 +1,5 @@
+import { $type as __type, createQueryOperator } from "../../_predicates";
+const $type = createQueryOperator(__type);
+export {
+  $type
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/evaluation/expr.js

@@ -0,0 +1,7 @@
+import { computeValue } from "../../../core";
+function $expr(_, rhs, options) {
+  return (obj) => computeValue(obj, rhs, null, options);
+}
+export {
+  $expr
+};

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

@@ -0,0 +1,5 @@
+export * from "./expr";
+export * from "./jsonSchema";
+export * from "./mod";
+export * from "./regex";
+export * from "./where";

package/rust-client/node_modules/mingo/dist/esm/operators/query/evaluation/jsonSchema.js

@@ -0,0 +1,13 @@
+import { MingoError } from "../../../util";
+function $jsonSchema(_, schema, options) {
+  if (!options?.jsonSchemaValidator) {
+    throw new MingoError(
+      "Missing option 'jsonSchemaValidator'. Configure to use '$jsonSchema' operator."
+    );
+  }
+  const validate = options?.jsonSchemaValidator(schema);
+  return (obj) => validate(obj);
+}
+export {
+  $jsonSchema
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/evaluation/mod.js

@@ -0,0 +1,5 @@
+import { $mod as __mod, createQueryOperator } from "../../_predicates";
+const $mod = createQueryOperator(__mod);
+export {
+  $mod
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/evaluation/regex.js

@@ -0,0 +1,5 @@
+import { $regex as __regex, createQueryOperator } from "../../_predicates";
+const $regex = createQueryOperator(__regex);
+export {
+  $regex
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/evaluation/where.js

@@ -0,0 +1,13 @@
+import { assert, isFunction, truthy } from "../../../util";
+function $where(_, rhs, options) {
+  assert(
+    options.scriptEnabled,
+    "$where operator requires 'scriptEnabled' option to be true"
+  );
+  const f = rhs;
+  assert(isFunction(f), "$where only accepts a Function object");
+  return (obj) => truthy(f.call(obj), options?.useStrictMode);
+}
+export {
+  $where
+};

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

@@ -0,0 +1,6 @@
+export * from "./array";
+export * from "./bitwise";
+export * from "./comparison";
+export * from "./element";
+export * from "./evaluation";
+export * from "./logical";

package/rust-client/node_modules/mingo/dist/esm/operators/query/logical/and.js

@@ -0,0 +1,13 @@
+import { Query } from "../../../query";
+import { assert, isArray } from "../../../util";
+const $and = (_, rhs, options) => {
+  assert(
+    isArray(rhs),
+    "Invalid expression: $and expects value to be an Array."
+  );
+  const queries = rhs.map((expr) => new Query(expr, options));
+  return (obj) => queries.every((q) => q.test(obj));
+};
+export {
+  $and
+};

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

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

package/rust-client/node_modules/mingo/dist/esm/operators/query/logical/nor.js

@@ -0,0 +1,13 @@
+import { assert, isArray } from "../../../util";
+import { $or } from "./or";
+const $nor = (_, rhs, options) => {
+  assert(
+    isArray(rhs),
+    "Invalid expression. $nor expects value to be an array."
+  );
+  const f = $or("$or", rhs, options);
+  return (obj) => !f(obj);
+};
+export {
+  $nor
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/logical/not.js

@@ -0,0 +1,11 @@
+import { Query } from "../../../query";
+import { normalize } from "../../../util";
+const $not = (selector, rhs, options) => {
+  const criteria = {};
+  criteria[selector] = normalize(rhs);
+  const query = new Query(criteria, options);
+  return (obj) => !query.test(obj);
+};
+export {
+  $not
+};

package/rust-client/node_modules/mingo/dist/esm/operators/query/logical/or.js

@@ -0,0 +1,10 @@
+import { Query } from "../../../query";
+import { assert, isArray } from "../../../util";
+const $or = (_, rhs, options) => {
+  assert(isArray(rhs), "Invalid expression. $or expects value to be an Array");
+  const queries = rhs.map((expr) => new Query(expr, options));
+  return (obj) => queries.some((q) => q.test(obj));
+};
+export {
+  $or
+};

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

@@ -0,0 +1,99 @@
+import { Query } from "../../query";
+import {
+  assert,
+  cloneDeep,
+  isArray,
+  isDate,
+  isObject,
+  resolve,
+  walk
+} from "../../util";
+const clone = (mode, val) => {
+  switch (mode) {
+    case "deep":
+      return cloneDeep(val);
+    case "copy": {
+      if (isDate(val))
+        return new Date(val);
+      if (isArray(val))
+        return [...val];
+      if (isObject(val))
+        return { ...val };
+      return val;
+    }
+    default:
+      return val;
+  }
+};
+const FILTER_IDENT_RE = /^[a-z]+[a-zA-Z0-9]*$/;
+function tokenizePath(selector) {
+  if (!selector.includes(".$")) {
+    return [{ parent: selector, selector }, []];
+  }
+  const begin = selector.indexOf(".$");
+  const end = selector.indexOf("]");
+  const parent = selector.substring(0, begin);
+  const child = selector.substring(begin + 3, end);
+  assert(
+    child === "" || FILTER_IDENT_RE.test(child),
+    "The filter <identifier> must begin with a lowercase letter and contain only alphanumeric characters."
+  );
+  const rest = selector.substring(end + 2);
+  const [next, elems] = rest ? tokenizePath(rest) : [];
+  return [
+    { selector, parent, child: child || "$", next },
+    [child, ...elems || []].filter(Boolean)
+  ];
+}
+const applyUpdate = (o, n, q, f, opts) => {
+  const { parent, child: c, next } = n;
+  if (!c) {
+    let b = false;
+    const g = (u, k) => b = Boolean(f(u, k)) || b;
+    walk(o, parent, g, opts);
+    return b;
+  }
+  const t = resolve(o, parent);
+  if (!isArray(t))
+    return false;
+  return t.map((e, i) => {
+    if (q[c] && !q[c].test({ [c]: e }))
+      return false;
+    return next ? applyUpdate(e, next, q, f, opts) : f(t, i);
+  }).some(Boolean);
+};
+function walkExpression(expr, arrayFilter, options, callback) {
+  const res = [];
+  for (const [selector, val] of Object.entries(expr)) {
+    const [node, vars] = tokenizePath(selector);
+    if (!vars.length) {
+      if (callback(val, node, {}))
+        res.push(node.parent);
+    } else {
+      const conditions = {};
+      arrayFilter.forEach((o) => {
+        Object.keys(o).forEach((k) => {
+          vars.forEach((w) => {
+            if (k === w || k.startsWith(w + ".")) {
+              conditions[w] = conditions[w] || {};
+              Object.assign(conditions[w], { [k]: o[k] });
+            }
+          });
+        });
+      });
+      const queries = {};
+      for (const [k, condition] of Object.entries(conditions)) {
+        queries[k] = new Query(condition, options.queryOptions);
+      }
+      if (callback(val, node, queries))
+        res.push(node.parent);
+    }
+  }
+  return res;
+}
+export {
+  applyUpdate,
+  clone,
+  tokenizePath,
+  walkExpression
+};

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

@@ -0,0 +1,27 @@
+import { has, intersection, isObject, unique } from "../../util";
+import { applyUpdate, clone, walkExpression } from "./_internal";
+const $addToSet = (obj, expr, arrayFilters = [], options = {}) => {
+  return walkExpression(expr, arrayFilters, options, (val, node, queries) => {
+    const args = { $each: [val] };
+    if (isObject(val) && has(val, "$each")) {
+      Object.assign(args, val);
+    }
+    return applyUpdate(
+      obj,
+      node,
+      queries,
+      (o, k) => {
+        const prev = o[k] ||= [];
+        const common = intersection([prev, args.$each]);
+        if (common.length === args.$each.length)
+          return false;
+        o[k] = clone(options.cloneMode, unique(prev.concat(args.$each)));
+        return true;
+      },
+      { buildGraph: true }
+    );
+  });
+};
+export {
+  $addToSet
+};