lib0 0.2.45 → 0.2.48

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.
    *
@@ -2347,7 +2349,7 @@
         writeVarString(encoder, data);
         break
       case 'number':
-        if (isInteger(data) && data <= BITS31) {
+        if (isInteger(data) && abs(data) <= BITS31) {
           // TYPE 125: INTEGER
           write(encoder, 125);
           writeVarInt(encoder, data);
@@ -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 = () => {
@@ -5072,6 +5087,18 @@
     }
   };
 
+  /**
+   * @param {t.TestCase} tc
+   */
+  const testLargeNumberAnyEncoding = tc => {
+    const encoder = createEncoder();
+    const num = -2.2062063918362897e+50;
+    writeAny(encoder, num);
+    const decoder = createDecoder(toUint8Array(encoder));
+    const readNum = readAny(decoder);
+    assert(readNum === num);
+  };
+
   var encoding = /*#__PURE__*/Object.freeze({
     __proto__: null,
     testGolangBinaryEncodingCompatibility: testGolangBinaryEncodingCompatibility,
@@ -5102,7 +5129,8 @@
     testIntDiffRleEncoder: testIntDiffRleEncoder,
     testIntEncoders: testIntEncoders,
     testIntDiffEncoder: testIntDiffEncoder,
-    testStringDecoder: testStringDecoder
+    testStringDecoder: testStringDecoder,
+    testLargeNumberAnyEncoding: testLargeNumberAnyEncoding
   });
 
   /**
@@ -7369,13 +7397,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 +7416,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.
@@ -7432,13 +7473,10 @@
    * @return {Promise<V> | V}
    */
   const setIfUndefined = (cache, key, init, removeNull = false) => {
-    const now = removeStale(cache);
+    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();
@@ -7495,11 +7533,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);
@@ -7528,6 +7568,16 @@
     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({