@valkey/valkey-glide-darwin-arm64 1.3.1 → 1.3.3-rc0

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

@@ -1,142 +0,0 @@
-import {
-  ComputeOptions,
-  computeValue,
-  getOperator
-} from "../../core";
-import {
-  assert,
-  ensureArray,
-  filterMissing,
-  has,
-  isArray,
-  isBoolean,
-  isEmpty,
-  isNumber,
-  isObject,
-  isOperator,
-  isString,
-  merge,
-  removeValue,
-  resolve,
-  resolveGraph,
-  setValue
-} from "../../util";
-const $project = (collection, expr, options) => {
-  if (isEmpty(expr)) return collection;
-  validateExpression(expr, options);
-  return collection.map(createHandler(expr, ComputeOptions.init(options)));
-};
-function createHandler(expr, options, isRoot = true) {
-  const idKey = options.idKey;
-  const expressionKeys = Object.keys(expr);
-  const excludedKeys = new Array();
-  const includedKeys = new Array();
-  const handlers = {};
-  for (const key of expressionKeys) {
-    const subExpr = expr[key];
-    if (isNumber(subExpr) || isBoolean(subExpr)) {
-      if (subExpr) {
-        includedKeys.push(key);
-      } else {
-        excludedKeys.push(key);
-      }
-    } else if (isArray(subExpr)) {
-      handlers[key] = (o) => subExpr.map((v) => computeValue(o, v, null, options.update(o)) ?? null);
-    } else if (isObject(subExpr)) {
-      const subExprKeys = Object.keys(subExpr);
-      const operator = subExprKeys.length == 1 ? subExprKeys[0] : "";
-      const projectFn = getOperator(
-        "projection",
-        operator,
-        options
-      );
-      if (projectFn) {
-        const foundSlice = operator === "$slice";
-        if (foundSlice && !ensureArray(subExpr[operator]).every(isNumber)) {
-          handlers[key] = (o) => computeValue(o, subExpr, key, options.update(o));
-        } else {
-          handlers[key] = (o) => projectFn(o, subExpr[operator], key, options.update(o));
-        }
-      } else if (isOperator(operator)) {
-        handlers[key] = (o) => computeValue(o, subExpr[operator], operator, options);
-      } else {
-        validateExpression(subExpr, options);
-        handlers[key] = (o) => {
-          if (!has(o, key)) return computeValue(o, subExpr, null, options);
-          if (isRoot) options.update(o);
-          const target = resolve(o, key);
-          const fn = createHandler(subExpr, options, false);
-          if (isArray(target)) return target.map(fn);
-          if (isObject(target)) return fn(target);
-          return fn(o);
-        };
-      }
-    } else {
-      handlers[key] = isString(subExpr) && subExpr[0] === "$" ? (o) => computeValue(o, subExpr, key, options) : (_) => subExpr;
-    }
-  }
-  const handlerKeys = Object.keys(handlers);
-  const idKeyExcluded = excludedKeys.includes(idKey);
-  const idKeyOnlyExcluded = isRoot && idKeyExcluded && excludedKeys.length === 1 && !includedKeys.length && !handlerKeys.length;
-  if (idKeyOnlyExcluded) {
-    return (o) => {
-      const newObj = { ...o };
-      delete newObj[idKey];
-      return newObj;
-    };
-  }
-  const idKeyImplicit = isRoot && !idKeyExcluded && !includedKeys.includes(idKey);
-  const opts = {
-    preserveMissing: true
-  };
-  return (o) => {
-    const newObj = {};
-    if (excludedKeys.length && !includedKeys.length) {
-      merge(newObj, o);
-      for (const k of excludedKeys) {
-        removeValue(newObj, k, { descendArray: true });
-      }
-    }
-    for (const k of includedKeys) {
-      const pathObj = resolveGraph(o, k, opts) ?? {};
-      merge(newObj, pathObj);
-    }
-    if (includedKeys.length) filterMissing(newObj);
-    for (const k of handlerKeys) {
-      const value = handlers[k](o);
-      if (value === void 0) {
-        removeValue(newObj, k, { descendArray: true });
-      } else {
-        setValue(newObj, k, value);
-      }
-    }
-    if (idKeyImplicit && has(o, idKey)) {
-      newObj[idKey] = resolve(o, idKey);
-    }
-    return newObj;
-  };
-}
-function validateExpression(expr, options) {
-  let exclusions = false;
-  let inclusions = false;
-  for (const [k, v] of Object.entries(expr)) {
-    assert(!k.startsWith("$"), "Field names may not start with '$'.");
-    assert(
-      !k.endsWith(".$"),
-      "Positional projection operator '$' is not supported."
-    );
-    if (k === options?.idKey) continue;
-    if (v === 0 || v === false) {
-      exclusions = true;
-    } else if (v === 1 || v === true) {
-      inclusions = true;
-    }
-    assert(
-      !(exclusions && inclusions),
-      "Projection cannot have a mix of inclusion and exclusion."
-    );
-  }
-}
-export {
-  $project
-};

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

@@ -1,10 +0,0 @@
-import { ComputeOptions, redact } from "../../core";
-const $redact = (collection, expr, options) => {
-  const copts = ComputeOptions.init(options);
-  return collection.map(
-    (obj) => redact(obj, expr, copts.update(obj))
-  );
-};
-export {
-  $redact
-};

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

@@ -1,12 +0,0 @@
-import { computeValue } from "../../core";
-import { assert, isObject } from "../../util";
-const $replaceRoot = (collection, expr, options) => {
-  return collection.map((obj) => {
-    obj = computeValue(obj, expr.newRoot, null, options);
-    assert(isObject(obj), "$replaceRoot expression must return an object");
-    return obj;
-  });
-};
-export {
-  $replaceRoot
-};

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

@@ -1,12 +0,0 @@
-import { computeValue } from "../../core";
-import { assert, isObject } from "../../util";
-const $replaceWith = (collection, expr, options) => {
-  return collection.map((obj) => {
-    obj = computeValue(obj, expr, null, options);
-    assert(isObject(obj), "$replaceWith expression must return an object");
-    return obj;
-  });
-};
-export {
-  $replaceWith
-};

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

@@ -1,14 +0,0 @@
-const $sample = (collection, expr, _options) => {
-  return collection.transform((xs) => {
-    const len = xs.length;
-    let i = -1;
-    return () => {
-      if (++i === expr.size) return { done: true };
-      const n = Math.floor(Math.random() * len);
-      return { value: xs[n], done: false };
-    };
-  });
-};
-export {
-  $sample
-};

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

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

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

@@ -1,191 +0,0 @@
-import {
-  getOperator,
-  initOptions
-} from "../../core";
-import { concat, Lazy } from "../../lazy";
-import { assert, isNumber, isOperator, isString } from "../../util";
-import { $function } from "../expression/custom/function";
-import { $dateAdd } from "../expression/date/dateAdd";
-import { isUnbounded } from "./_internal";
-import { $addFields } from "./addFields";
-import { $group } from "./group";
-import { $sort } from "./sort";
-const SORT_REQUIRED_OPS = /* @__PURE__ */ new Set([
-  "$denseRank",
-  "$documentNumber",
-  "$first",
-  "$last",
-  "$linearFill",
-  "$rank",
-  "$shift"
-]);
-const WINDOW_UNBOUNDED_OPS = /* @__PURE__ */ new Set([
-  "$denseRank",
-  "$expMovingAvg",
-  "$linearFill",
-  "$locf",
-  "$rank",
-  "$shift"
-]);
-const $setWindowFields = (collection, expr, options) => {
-  options = initOptions(options);
-  options.context.addExpressionOps({ $function });
-  for (const outputExpr of Object.values(expr.output)) {
-    const keys = Object.keys(outputExpr);
-    const op = keys.find(isOperator);
-    assert(
-      !!getOperator("window", op, options) || !!getOperator("accumulator", op, options),
-      `'${op}' is not a valid window operator`
-    );
-    assert(
-      keys.length > 0 && keys.length <= 2 && (keys.length == 1 || keys.includes("window")),
-      "'output' option should have a single window operator."
-    );
-    if (outputExpr?.window) {
-      const { documents, range } = outputExpr.window;
-      assert(
-        !!documents && !range || !documents && !!range || !documents && !range,
-        "'window' option supports only one of 'documents' or 'range'."
-      );
-    }
-  }
-  if (expr.sortBy) {
-    collection = $sort(collection, expr.sortBy, options);
-  }
-  collection = $group(
-    collection,
-    {
-      _id: expr.partitionBy,
-      items: { $push: "$$CURRENT" }
-    },
-    options
-  );
-  return collection.transform((partitions) => {
-    const iterators = [];
-    const outputConfig = [];
-    for (const [field, outputExpr] of Object.entries(expr.output)) {
-      const op = Object.keys(outputExpr).find(isOperator);
-      const config = {
-        operatorName: op,
-        func: {
-          left: getOperator("accumulator", op, options),
-          right: getOperator("window", op, options)
-        },
-        args: outputExpr[op],
-        field,
-        window: outputExpr.window
-      };
-      assert(
-        !!expr.sortBy || !(SORT_REQUIRED_OPS.has(op) || !config.window),
-        `${SORT_REQUIRED_OPS.has(op) ? `'${op}'` : "bounded window operation"} requires a sortBy.`
-      );
-      assert(
-        !config.window || !WINDOW_UNBOUNDED_OPS.has(op),
-        `${op} does not accept a 'window' field.`
-      );
-      outputConfig.push(config);
-    }
-    partitions.forEach((group) => {
-      const items = group.items;
-      let iterator = Lazy(items);
-      const windowResultMap = {};
-      for (const config of outputConfig) {
-        const { func, args, field, window } = config;
-        const makeResultFunc = (getItemsFn) => {
-          let index = -1;
-          return (obj) => {
-            ++index;
-            if (func.left) {
-              return func.left(getItemsFn(obj, index), args, options);
-            } else if (func.right) {
-              return func.right(
-                obj,
-                getItemsFn(obj, index),
-                {
-                  parentExpr: expr,
-                  inputExpr: args,
-                  documentNumber: index + 1,
-                  field
-                },
-                // must use raw options only since it operates over a collection.
-                options
-              );
-            }
-          };
-        };
-        if (window) {
-          const { documents, range, unit } = window;
-          const boundary = documents || range;
-          if (!isUnbounded(window)) {
-            const [begin, end] = boundary;
-            const toBeginIndex = (currentIndex) => {
-              if (begin == "current") return currentIndex;
-              if (begin == "unbounded") return 0;
-              return Math.max(begin + currentIndex, 0);
-            };
-            const toEndIndex = (currentIndex) => {
-              if (end == "current") return currentIndex + 1;
-              if (end == "unbounded") return items.length;
-              return end + currentIndex + 1;
-            };
-            const getItems = (current, index) => {
-              if (!!documents || boundary.every(isString)) {
-                return items.slice(toBeginIndex(index), toEndIndex(index));
-              }
-              const sortKey = Object.keys(expr.sortBy)[0];
-              let lower;
-              let upper;
-              if (unit) {
-                const getTime = (amount) => {
-                  return $dateAdd(
-                    current,
-                    {
-                      startDate: new Date(current[sortKey]),
-                      unit,
-                      amount
-                    },
-                    options
-                  ).getTime();
-                };
-                lower = isNumber(begin) ? getTime(begin) : -Infinity;
-                upper = isNumber(end) ? getTime(end) : Infinity;
-              } else {
-                const currentValue = current[sortKey];
-                lower = isNumber(begin) ? currentValue + begin : -Infinity;
-                upper = isNumber(end) ? currentValue + end : Infinity;
-              }
-              let array = items;
-              if (begin == "current") array = items.slice(index);
-              if (end == "current") array = items.slice(0, index + 1);
-              return array.filter((o) => {
-                const n = +o[sortKey];
-                return n >= lower && n <= upper;
-              });
-            };
-            windowResultMap[field] = makeResultFunc(getItems);
-          }
-        }
-        if (!windowResultMap[field]) {
-          windowResultMap[field] = makeResultFunc((_) => items);
-        }
-        iterator = $addFields(
-          iterator,
-          {
-            [field]: {
-              $function: {
-                body: (obj) => windowResultMap[field](obj),
-                args: ["$$CURRENT"]
-              }
-            }
-          },
-          options
-        );
-      }
-      iterators.push(iterator);
-    });
-    return concat(...iterators);
-  });
-};
-export {
-  $setWindowFields
-};

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

@@ -1,6 +0,0 @@
-const $skip = (collection, expr, _options) => {
-  return collection.drop(expr);
-};
-export {
-  $skip
-};

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

@@ -1,67 +0,0 @@
-import {
-  assert,
-  compare,
-  groupBy,
-  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();
-      let i = 0;
-      for (const k of sortedKeys) for (const v of groups.get(k)) coll[i++] = v;
-      assert(i == coll.length, "bug: counter must match collection size.");
-    }
-    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

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

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

@@ -1,14 +0,0 @@
-import { Aggregator } from "../../aggregator";
-import { concat, 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 concat(...iterators);
-};
-export {
-  $unionWith
-};

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

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

@@ -1,54 +0,0 @@
-import { Iterator, Lazy } from "../../lazy";
-import {
-  isArray,
-  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 (isArray(value)) {
-        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

@@ -1,18 +0,0 @@
-import { Query } from "../../query";
-import { assert, isArray, resolve } from "../../util";
-const $elemMatch = (obj, expr, field, options) => {
-  const arr = resolve(obj, field);
-  const query = new Query(expr, options);
-  assert(isArray(arr), "$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

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

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

@@ -1,15 +0,0 @@
-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,
-    isArray(expr) ? [xs, ...exprAsArray] : [xs, expr],
-    options
-  );
-};
-export {
-  $slice
-};

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

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

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

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

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

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

@@ -1,18 +0,0 @@
-import { isArray } from "../../../util";
-import { createQueryOperator } from "../../_predicates";
-const createBitwiseOperator = (predicate) => {
-  return createQueryOperator(
-    (value, mask, _options) => {
-      let b = 0;
-      if (isArray(mask)) {
-        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

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

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

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