lib0 0.2.45 → 0.2.48

package/dist/test.cjs

@@ -863,6 +863,8 @@ const equalFlat$1 = (a, b) => a.length === b.length && every$1(a, (item, index)
  */
 const flatten = arr => arr.reduce((acc, val) => acc.concat(val), []);
 
+const isArray = Array.isArray;
+
 /**
  * Utility functions for working with EcmaScript objects.
  *
@@ -2322,7 +2324,7 @@ const writeAny = (encoder, data) => {
       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);
@@ -4279,10 +4281,23 @@ const testflatten = tc => {
   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 = () => {
@@ -5047,6 +5062,18 @@ const testStringDecoder = tc => {
   }
 };
 
+/**
+ * @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,
@@ -5077,7 +5104,8 @@ var encoding = /*#__PURE__*/Object.freeze({
   testIntDiffRleEncoder: testIntDiffRleEncoder,
   testIntEncoders: testIntEncoders,
   testIntDiffEncoder: testIntDiffEncoder,
-  testStringDecoder: testStringDecoder
+  testStringDecoder: testStringDecoder,
+  testLargeNumberAnyEncoding: testLargeNumberAnyEncoding
 });
 
 /**
@@ -7344,13 +7372,9 @@ const set = (cache, key, value) => {
  * @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
   }
 };
@@ -7367,6 +7391,23 @@ const get = (cache, key) => {
   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,13 +7448,10 @@ const remove = (cache, key) => {
  * @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();
@@ -7470,11 +7508,13 @@ const testCache = async tc => {
 
   // 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);
@@ -7503,6 +7543,16 @@ const testCache = async tc => {
   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({