@mark1russell7/collections 0.9.5 → 0.9.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/collections",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "Collections with no dependencies: lists, maps, queues, a summary tree, channels, lazy operations and dependency graphs.",
   "keywords": [
     "collections",

package/src/behaviors/synchronized.ts

@@ -277,8 +277,12 @@ export function readWriteLock<C extends object>(): Middleware<C> {
       "forEach",
       "getOrDefault",
       "getOrUndefined",
+      "descendingIterator",
     ]);
 
+    // The reads that give an iterator. The lock copies the elements before it releases the read (C32).
+    const ITERATOR_READS = new Set(["keys", "values", "entries", "descendingIterator"]);
+
     return new Proxy(next, {
       get(target, prop, receiver) {
         const value = Reflect.get(target, prop, receiver);
@@ -287,15 +291,28 @@ export function readWriteLock<C extends object>(): Middleware<C> {
           return value;
         }
 
-        const isReadMethod = typeof prop === "string" && READ_METHODS.has(prop);
+        // A method with a symbol key, for example Symbol.iterator, stays synchronous, so `for of` works (C32).
+        // The loop reads at once with no lock, as a plain method of synchronized().
+        if (typeof prop === "symbol") {
+          return function (this: unknown, ...args: unknown[]) {
+            return (value as Function).apply(target, args);
+          };
+        }
+
+        const isReadMethod = READ_METHODS.has(prop);
+        const isIteratorRead = ITERATOR_READS.has(prop);
 
         return async function (this: any, ...args: any[]) {
           if (isReadMethod) {
             // Acquire read lock
             await acquireRead();
             try {
-              const result = (value as Function).apply(target, args);
-              return result instanceof Promise ? await result : result;
+              const raw = (value as Function).apply(target, args);
+              const result = raw instanceof Promise ? await raw : raw;
+              // Before C32, the iteration started after the release of the read, so a write could change the elements.
+              return isIteratorRead && result != null && typeof result[Symbol.iterator] === "function"
+                ? Array.from(result as Iterable<unknown>)[Symbol.iterator]()
+                : result;
             } finally {
               releaseRead();
             }

package/src/utils/defaults.ts

@@ -368,25 +368,29 @@ export const hashBy = <T>(accessor: (value: T) => any): Hash<T> => {
 // Default Comparison
 // ============================================================================
 
+/** This function gives the place of `null` and `undefined` in the order of `defaultCompare`: `null`, then `undefined`, then each other value. */
+const nullishRank = (value: unknown): number => (value === null ? 0 : value === undefined ? 1 : 2);
+
 /**
- * Natural ordering comparison for primitives.
- * Numbers, strings, booleans, dates are compared naturally.
+ * This comparator gives the natural order of primitives.
+ * - `null` comes first, then `undefined`, then each other value.
+ * - Numbers and dates compare as `numberCompare` and `dateCompare` compare them.
+ * - Strings compare by `localeCompare`, and `false` comes before `true`.
+ * - Two values of different types compare by their text, with `String`.
  */
 export const defaultCompare: Compare<any> = (a, b) => {
   if (a === b) return 0;
-  if (a === null || a === undefined) return -1;
-  if (b === null || b === undefined) return 1;
+  const nullish = nullishRank(a) - nullishRank(b);
+  if (nullish !== 0) return nullish;
 
   // Handle dates
   if (a instanceof Date && b instanceof Date) {
-    return a.getTime() - b.getTime();
+    return dateCompare(a, b);
   }
 
   // Handle numbers
   if (typeof a === "number" && typeof b === "number") {
-    if (Number.isNaN(a)) return Number.isNaN(b) ? 0 : -1;
-    if (Number.isNaN(b)) return 1;
-    return a - b;
+    return numberCompare(a, b);
   }
 
   // Handle strings
@@ -404,12 +408,14 @@ export const defaultCompare: Compare<any> = (a, b) => {
 };
 
 /**
- * Numeric comparison (for numbers).
+ * This comparator gives the order of numbers by value. It gives -1, 0 or 1.
+ * - `NaN` comes first, and two `NaN` values give 0.
+ * - Two equal infinities give 0, and 0 equals -0.
  */
 export const numberCompare: Compare<number> = (a, b) => {
   if (Number.isNaN(a)) return Number.isNaN(b) ? 0 : -1;
   if (Number.isNaN(b)) return 1;
-  return a - b;
+  return a < b ? -1 : a > b ? 1 : 0;
 };
 
 /**
@@ -424,10 +430,10 @@ export const stringCompareIgnoreCase: Compare<string> = (a, b) =>
   a.toLowerCase().localeCompare(b.toLowerCase());
 
 /**
- * Date comparison.
+ * This comparator gives the order of dates by time, with `numberCompare`. An invalid date has the time `NaN`, so it comes
+ * first, and two invalid dates give 0.
  */
-export const dateCompare: Compare<Date> = (a, b) =>
-  a.getTime() - b.getTime();
+export const dateCompare: Compare<Date> = (a, b) => numberCompare(a.getTime(), b.getTime());
 
 /**
  * Boolean comparison (false < true).