@tanstack/db/dist/cjs/utils/comparison.cjs

A reactive client store for building super fast apps on sync

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const utils = require("../utils.cjs");
const runtimeReferenceIdentity = require("../query/runtime-reference-identity.cjs");
const errorMessage = require("../error-message.cjs");
function isUnorderable(value) {
  return typeof value === `number` && Number.isNaN(value) || value instanceof Date && Number.isNaN(value.getTime());
}
const ascComparator = (a, b, opts) => {
  const { nulls } = opts;
  if (a == null && b == null) return 0;
  if (a == null) return nulls === `first` ? -1 : 1;
  if (b == null) return nulls === `first` ? 1 : -1;
  const aUnordered = isUnorderable(a);
  const bUnordered = isUnorderable(b);
  if (aUnordered && bUnordered) return 0;
  if (aUnordered) return 1;
  if (bUnordered) return -1;
  if (typeof a === `string` && typeof b === `string`) {
    if (opts.stringSort === `custom`) {
      return opts.compare(a, b);
    }
    if (opts.stringSort === `locale`) {
      return a.localeCompare(b, opts.locale, opts.localeOptions);
    }
  }
  if (Array.isArray(a) && Array.isArray(b)) {
    for (let i = 0; i < Math.min(a.length, b.length); i++) {
      const result = ascComparator(a[i], b[i], opts);
      if (result !== 0) {
        return result;
      }
    }
    return a.length - b.length;
  }
  if (a instanceof Date && b instanceof Date) {
    return a.getTime() - b.getTime();
  }
  if (utils.isTemporal(a) && utils.isTemporal(b)) {
    return compareTemporalValues(a, b);
  }
  const aIsSymbol = typeof a === `symbol`;
  const bIsSymbol = typeof b === `symbol`;
  if (aIsSymbol && bIsSymbol) {
    if (a === b) return 0;
    return runtimeReferenceIdentity.getRuntimeReferenceIdentity(a)[2] - runtimeReferenceIdentity.getRuntimeReferenceIdentity(b)[2];
  }
  if (aIsSymbol) return 1;
  if (bIsSymbol) return -1;
  const aIsObject = typeof a === `object`;
  const bIsObject = typeof b === `object`;
  if (aIsObject || bIsObject) {
    if (aIsObject && bIsObject) {
      const aId = runtimeReferenceIdentity.getRuntimeReferenceIdentity(a)[2];
      const bId = runtimeReferenceIdentity.getRuntimeReferenceIdentity(b)[2];
      return aId - bId;
    }
    if (aIsObject) return 1;
    if (bIsObject) return -1;
  }
  if (a < b) return -1;
  if (a > b) return 1;
  return 0;
};
const descComparator = (a, b, opts) => {
  return a == null || b == null ? ascComparator(a, b, opts) : ascComparator(b, a, opts);
};
function indexObjectKind(value) {
  if (isUint8Array(value)) return `Binary`;
  if (utils.isTemporal(value)) {
    const tag = value[Symbol.toStringTag];
    const fields = value;
    return tag === `Temporal.Duration` && (fields.years || fields.months || fields.weeks) ? `Temporal.Duration.calendar` : tag;
  }
  if (Array.isArray(value)) return `Array`;
  return `Object`;
}
function makeComparator(opts, scope = `values`) {
  const compare = opts.direction === `asc` ? ascComparator : descComparator;
  if (scope !== `index`) return (a, b) => compare(a, b, opts);
  const direction = opts.direction === `asc` ? 1 : -1;
  return (a, b) => {
    if (a != null && b != null) {
      if (a instanceof Date) a = a.getTime();
      if (b instanceof Date) b = b.getTime();
      const aType = typeof a;
      const bType = typeof b;
      if (aType !== bType) return (aType < bType ? -1 : 1) * direction;
      if (aType === `object`) {
        const aKind = indexObjectKind(a);
        const bKind = indexObjectKind(b);
        if (aKind !== bKind) return (aKind < bKind ? -1 : 1) * direction;
        if (aKind === `Binary` || aKind === `Temporal.Duration.calendar` || aKind === `Temporal.PlainMonthDay`) {
          const left = normalizeValue(a);
          const right = normalizeValue(b);
          return (left < right ? -1 : left > right ? 1 : 0) * direction;
        }
      }
    }
    return compare(a, b, opts);
  };
}
function makeCheckedComparator(compareFn) {
  return (a, b) => {
    const result = compareFn(a, b);
    if (typeof result !== `number` || Number.isNaN(result))
      throw new TypeError(
        errorMessage.devBuild() && process.env.NODE_ENV !== `production` ? `Index comparator must return a number, but returned ${String(result)}` : errorMessage.codedMessage(166, { result })
      );
    return result;
  };
}
const defaultComparator = makeComparator({
  direction: `asc`,
  nulls: `first`,
  stringSort: `locale`
});
function isUint8Array(value) {
  return value instanceof Uint8Array || typeof Buffer !== `undefined` && value instanceof Buffer;
}
function areUint8ArraysEqual(a, b) {
  if (a.byteLength !== b.byteLength) {
    return false;
  }
  for (let i = 0; i < a.byteLength; i++) {
    if (a[i] !== b[i]) {
      return false;
    }
  }
  return true;
}
const NORMALIZED_KEY_PREFIX = `\0tanstack-db:`;
function normalizedKey(kind, value) {
  return `${NORMALIZED_KEY_PREFIX}${kind}:${value}`;
}
const binaryKeys = /* @__PURE__ */ new WeakMap();
function normalizeBinary(value) {
  const cached = binaryKeys.get(value);
  if (cached) return cached;
  let bytes;
  if (value.byteLength <= 8192) {
    bytes = String.fromCharCode.apply(null, value);
  } else {
    const chunks = [];
    for (let index = 0; index < value.byteLength; index += 8192) {
      chunks.push(
        String.fromCharCode.apply(
          null,
          value.subarray(index, index + 8192)
        )
      );
    }
    bytes = chunks.join(``);
  }
  const key = normalizedKey(`binary`, bytes);
  binaryKeys.set(value, key);
  return key;
}
function normalizeValue(value) {
  if (typeof value === `string`) {
    return value.startsWith(NORMALIZED_KEY_PREFIX) ? normalizedKey(`string`, value) : value;
  }
  if (typeof value !== `object` || value === null) {
    return value;
  }
  if (value instanceof Date) {
    return value.getTime();
  }
  if (utils.isTemporal(value)) {
    const tag = value[Symbol.toStringTag];
    if (tag === "Temporal.Duration") {
      const fields = value;
      return normalizedKey(
        tag,
        utils.durationFields.map((field) => fields[field]).join(",")
      );
    }
    return normalizedKey(tag, value.toString());
  }
  if (isUint8Array(value)) {
    return normalizeBinary(value);
  }
  return value;
}
function areSameValueZeroEqual(a, b) {
  return a === b || Number.isNaN(a) && Number.isNaN(b);
}
function compareTemporalValues(a, b) {
  const aTag = a[Symbol.toStringTag];
  const bTag = b[Symbol.toStringTag];
  if (aTag !== bTag) {
    throw new TypeError(
      errorMessage.devBuild() && process.env.NODE_ENV !== `production` ? `Cannot order Temporal values of different types: ${aTag} vs ${bTag}` : errorMessage.codedMessage(167, { aTag, bTag })
    );
  }
  const compare = a.constructor.compare;
  if (typeof compare !== `function`) {
    throw new TypeError(
      errorMessage.devBuild() && process.env.NODE_ENV !== `production` ? `${aTag} has no defined ordering` : errorMessage.codedMessage(168, { aTag })
    );
  }
  return compare(a, b);
}
function compareValues(a, b) {
  if (utils.isTemporal(a) && utils.isTemporal(b)) {
    return compareTemporalValues(a, b);
  }
  return a < b ? -1 : a > b ? 1 : 0;
}
function areValuesEqual(a, b) {
  if (a === b) {
    return true;
  }
  if (isUint8Array(a) && isUint8Array(b)) {
    return areUint8ArraysEqual(a, b);
  }
  return false;
}
exports.areSameValueZeroEqual = areSameValueZeroEqual;
exports.areValuesEqual = areValuesEqual;
exports.ascComparator = ascComparator;
exports.compareTemporalValues = compareTemporalValues;
exports.compareValues = compareValues;
exports.defaultComparator = defaultComparator;
exports.descComparator = descComparator;
exports.indexObjectKind = indexObjectKind;
exports.isUint8Array = isUint8Array;
exports.isUnorderable = isUnorderable;
exports.makeCheckedComparator = makeCheckedComparator;
exports.makeComparator = makeComparator;
exports.normalizeValue = normalizeValue;
//# sourceMappingURL=comparison.cjs.map