lib0 0.2.44 → 0.2.47

package/dist/test.js

@@ -862,6 +862,8 @@
    */
   const flatten = arr => arr.reduce((acc, val) => acc.concat(val), []);
 
+  const isArray = Array.isArray;
+
   /**
    * Utility functions for working with EcmaScript objects.
    *
@@ -4304,10 +4306,23 @@
     compareArrays(flatten(arr), [1, 2, 3, 4]);
   };
 
+  /**
+   * @param {t.TestCase} tc
+   */
+  const testIsArray = tc => {
+    assert(isArray([]));
+    assert(isArray([1]));
+    assert(isArray(Array.from(new Set([3]))));
+    assert(!isArray(1));
+    assert(!isArray(0));
+    assert(!isArray(''));
+  };
+
   var array = /*#__PURE__*/Object.freeze({
     __proto__: null,
     testAppend: testAppend,
-    testflatten: testflatten
+    testflatten: testflatten,
+    testIsArray: testIsArray
   });
 
   const testLogging = () => {
@@ -7369,13 +7384,9 @@
    * @return {Entry<K, V> | undefined}
    */
   const getNode = (cache, key) => {
-    const now = removeStale(cache);
-    const q = cache._q;
+    removeStale(cache);
     const n = cache._map.get(key);
     if (n) {
-      removeNode(q, n);
-      pushEnd(q, n);
-      n.created = now;
       return n
     }
   };
@@ -7392,6 +7403,23 @@
     return n && !(n.val instanceof Promise) ? n.val : undefined
   };
 
+  /**
+   * @template K, V
+   *
+   * @param {Cache<K, V>} cache
+   * @param {K} key
+   */
+  const refreshTimeout = (cache, key) => {
+    const now = getUnixTime();
+    const q = cache._q;
+    const n = cache._map.get(key);
+    if (n) {
+      removeNode(q, n);
+      pushEnd(q, n);
+      n.created = now;
+    }
+  };
+
   /**
    * Works well in conjunktion with setIfUndefined which has an async init function.
    * Using getAsync & setIfUndefined ensures that the init function is only called once.
@@ -7407,22 +7435,35 @@
     return n ? n.val : undefined
   };
 
+  /**
+   * @template K, V
+   *
+   * @param {Cache<K, V>} cache
+   * @param {K} key
+   */
+  const remove = (cache, key) => {
+    const n = cache._map.get(key);
+    if (n) {
+      removeNode(cache._q, n);
+      cache._map.delete(key);
+      return n.val && !(n.val instanceof Promise) ? n.val : undefined
+    }
+  };
+
   /**
    * @template K, V
    *
    * @param {Cache<K, V>} cache
    * @param {K} key
    * @param {function():Promise<V>} init
+   * @param {boolean} removeNull Optional argument that automatically removes values that resolve to null/undefined from the cache.
    * @return {Promise<V> | V}
    */
-  const setIfUndefined = (cache, key, init) => {
-    const now = removeStale(cache);
+  const setIfUndefined = (cache, key, init, removeNull = false) => {
+    removeStale(cache);
     const q = cache._q;
     const n = cache._map.get(key);
     if (n) {
-      removeNode(q, n);
-      pushEnd(q, n);
-      n.created = now;
       return n.val
     } else {
       const p = init();
@@ -7433,6 +7474,9 @@
         if (p === node.val) {
           node.val = v;
         }
+        if (removeNull && v == null) {
+          remove(cache, key);
+        }
       });
       return p
     }
@@ -7476,11 +7520,13 @@
 
     // write new values and check later if the creation-timestamp was updated
     set(c, 'a', '11');
-    await setIfUndefined(c, 'b', () => resolveWith('22')); // this shouldn't override, but update the timestamp
+    set(c, 'b', '22');
 
     await wait(5); // keys should be updated and not timed out. Hence the creation time should be updated
     assert(get(c, 'a') === '11');
-    assert(get(c, 'b') === '2');
+    assert(get(c, 'b') === '22');
+    set(c, 'a', '11');
+    set(c, 'b', '22');
     // timestamps should be updated
     assert(aTimestamp1 !== m.get('a').created);
     assert(bTimestamp1 !== m.get('b').created);
@@ -7499,6 +7545,26 @@
     await xp;
     // we override the Entry.val property in cache when p resolves. However, we must prevent that when the value is overriden before p is resolved.
     assert(get(c, 'a') === 'y');
+
+    // test that we can remove properties
+    remove(c, 'a');
+    remove(c, 'does not exist'); // remove a non-existent property to achieve full test-coverage
+    assert(get(c, 'a') === undefined);
+
+    // test that the optional property in setifUndefined works
+    const yp = setIfUndefined(c, 'a', () => resolveWith(null), true);
+    assert(await yp === null);
+    assert(get(c, 'a') === undefined);
+
+    // check manual updating of timeout
+    set(c, 'a', '3');
+    const ts1 = m.get('a').created;
+    await wait(30);
+    refreshTimeout(c, 'a');
+    const ts2 = m.get('a').created;
+    assert(ts1 !== ts2);
+    refreshTimeout(c, 'x'); // for full test coverage
+    assert(m.get('x') == null);
   };
 
   var cache = /*#__PURE__*/Object.freeze({