@event-driven-io/emmett 0.38.4 → 0.38.6

package/dist/index.cjs

@@ -199,24 +199,117 @@ var arrayUtils = {
 };
 
 // src/utils/deepEquals.ts
-var deepEquals = (left, right) => {
-  if (isEquatable(left)) {
-    return left.equals(right);
+var isPrimitive = (value) => {
+  const type = typeof value;
+  return value === null || value === void 0 || type === "boolean" || type === "number" || type === "string" || type === "symbol" || type === "bigint";
+};
+var compareArrays = (left, right) => {
+  if (left.length !== right.length) {
+    return false;
   }
-  if (Array.isArray(left)) {
-    return Array.isArray(right) && left.length === right.length && left.every((val, index) => deepEquals(val, right[index]));
+  for (let i = 0; i < left.length; i++) {
+    const leftHas = i in left;
+    const rightHas = i in right;
+    if (leftHas !== rightHas) return false;
+    if (leftHas && !deepEquals(left[i], right[i])) return false;
   }
-  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
-    return left === right;
+  return true;
+};
+var compareDates = (left, right) => {
+  return left.getTime() === right.getTime();
+};
+var compareRegExps = (left, right) => {
+  return left.toString() === right.toString();
+};
+var compareErrors = (left, right) => {
+  if (left.message !== right.message || left.name !== right.name) {
+    return false;
+  }
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) return false;
+  const rightKeySet = new Set(rightKeys);
+  for (const key of leftKeys) {
+    if (!rightKeySet.has(key)) return false;
+    if (!deepEquals(left[key], right[key])) return false;
+  }
+  return true;
+};
+var compareMaps = (left, right) => {
+  if (left.size !== right.size) return false;
+  for (const [key, value] of left) {
+    if (isPrimitive(key)) {
+      if (!right.has(key) || !deepEquals(value, right.get(key))) {
+        return false;
+      }
+    } else {
+      let found = false;
+      for (const [rightKey, rightValue] of right) {
+        if (deepEquals(key, rightKey) && deepEquals(value, rightValue)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
   }
-  if (Array.isArray(right)) return false;
+  return true;
+};
+var compareSets = (left, right) => {
+  if (left.size !== right.size) return false;
+  for (const leftItem of left) {
+    if (isPrimitive(leftItem)) {
+      if (!right.has(leftItem)) return false;
+    } else {
+      let found = false;
+      for (const rightItem of right) {
+        if (deepEquals(leftItem, rightItem)) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) return false;
+    }
+  }
+  return true;
+};
+var compareArrayBuffers = (left, right) => {
+  if (left.byteLength !== right.byteLength) return false;
+  const leftView = new Uint8Array(left);
+  const rightView = new Uint8Array(right);
+  for (let i = 0; i < leftView.length; i++) {
+    if (leftView[i] !== rightView[i]) return false;
+  }
+  return true;
+};
+var compareTypedArrays = (left, right) => {
+  if (left.constructor !== right.constructor) return false;
+  if (left.byteLength !== right.byteLength) return false;
+  const leftArray = new Uint8Array(
+    left.buffer,
+    left.byteOffset,
+    left.byteLength
+  );
+  const rightArray = new Uint8Array(
+    right.buffer,
+    right.byteOffset,
+    right.byteLength
+  );
+  for (let i = 0; i < leftArray.length; i++) {
+    if (leftArray[i] !== rightArray[i]) return false;
+  }
+  return true;
+};
+var compareObjects = (left, right) => {
   const keys1 = Object.keys(left);
   const keys2 = Object.keys(right);
-  if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key)))
+  if (keys1.length !== keys2.length) {
     return false;
-  for (const key in left) {
-    if (left[key] instanceof Function && right[key] instanceof Function)
+  }
+  for (const key of keys1) {
+    if (left[key] instanceof Function && right[key] instanceof Function) {
       continue;
+    }
     const isEqual = deepEquals(left[key], right[key]);
     if (!isEqual) {
       return false;
@@ -224,8 +317,88 @@ var deepEquals = (left, right) => {
   }
   return true;
 };
+var getType = (value) => {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const primitiveType = typeof value;
+  if (primitiveType !== "object") return primitiveType;
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Boolean) return "boxed-boolean";
+  if (value instanceof Number) return "boxed-number";
+  if (value instanceof String) return "boxed-string";
+  if (value instanceof Date) return "date";
+  if (value instanceof RegExp) return "regexp";
+  if (value instanceof Error) return "error";
+  if (value instanceof Map) return "map";
+  if (value instanceof Set) return "set";
+  if (value instanceof ArrayBuffer) return "arraybuffer";
+  if (value instanceof DataView) return "dataview";
+  if (value instanceof WeakMap) return "weakmap";
+  if (value instanceof WeakSet) return "weakset";
+  if (ArrayBuffer.isView(value)) return "typedarray";
+  return "object";
+};
+var deepEquals = (left, right) => {
+  if (left === right) return true;
+  if (isEquatable(left)) {
+    return left.equals(right);
+  }
+  const leftType = getType(left);
+  const rightType = getType(right);
+  if (leftType !== rightType) return false;
+  switch (leftType) {
+    case "null":
+    case "undefined":
+    case "boolean":
+    case "number":
+    case "bigint":
+    case "string":
+    case "symbol":
+    case "function":
+      return left === right;
+    case "array":
+      return compareArrays(left, right);
+    case "date":
+      return compareDates(left, right);
+    case "regexp":
+      return compareRegExps(left, right);
+    case "error":
+      return compareErrors(left, right);
+    case "map":
+      return compareMaps(
+        left,
+        right
+      );
+    case "set":
+      return compareSets(left, right);
+    case "arraybuffer":
+      return compareArrayBuffers(left, right);
+    case "dataview":
+    case "weakmap":
+    case "weakset":
+      return false;
+    case "typedarray":
+      return compareTypedArrays(
+        left,
+        right
+      );
+    case "boxed-boolean":
+      return left.valueOf() === right.valueOf();
+    case "boxed-number":
+      return left.valueOf() === right.valueOf();
+    case "boxed-string":
+      return left.valueOf() === right.valueOf();
+    case "object":
+      return compareObjects(
+        left,
+        right
+      );
+    default:
+      return false;
+  }
+};
 var isEquatable = (left) => {
-  return left && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
+  return left !== null && left !== void 0 && typeof left === "object" && "equals" in left && typeof left["equals"] === "function";
 };
 
 // src/utils/iterators.ts
@@ -1602,6 +1775,7 @@ var CommandHandler = (options) => async (store, id, handle, handleOptions) => as
         evolve,
         initialState,
         read: {
+          ...handleOptions ? handleOptions : {},
           // expected stream version is passed to fail fast
           // if stream is in the wrong state
           expectedStreamVersion: _nullishCoalesce(_optionalChain([handleOptions, 'optionalAccess', _87 => _87.expectedStreamVersion]), () => ( NO_CONCURRENCY_CHECK))