@vuu-ui/vuu-data-remote 0.8.22-debug → 0.8.23-debug

package/esm/index.js

@@ -163,31 +163,31 @@ var getCookieValue = (name) => {
 };
 
 // ../vuu-utils/src/range-utils.ts
-function getFullRange({ from, to }, bufferSize = 0, rowCount = Number.MAX_SAFE_INTEGER) {
-  if (bufferSize === 0) {
-    if (rowCount < from) {
+function getFullRange({ from, to }, bufferSize = 0, totalRowCount = Number.MAX_SAFE_INTEGER) {
+  if (from === 0 && to === 0) {
+    return { from, to };
+  } else if (bufferSize === 0) {
+    if (totalRowCount < from) {
       return { from: 0, to: 0 };
     } else {
-      return { from, to: Math.min(to, rowCount) };
+      return { from, to: Math.min(to, totalRowCount) };
     }
   } else if (from === 0) {
-    return { from, to: Math.min(to + bufferSize, rowCount) };
+    return { from, to: Math.min(to + bufferSize, totalRowCount) };
   } else {
-    const rangeSize = to - from;
-    const buff = Math.round(bufferSize / 2);
-    const shortfallBefore = from - buff < 0;
-    const shortFallAfter = rowCount - (to + buff) < 0;
-    if (shortfallBefore && shortFallAfter) {
-      return { from: 0, to: rowCount };
+    const shortfallBefore = from - bufferSize < 0;
+    const shortfallAfter = totalRowCount - (to + bufferSize) < 0;
+    if (shortfallBefore && shortfallAfter) {
+      return { from: 0, to: totalRowCount };
     } else if (shortfallBefore) {
-      return { from: 0, to: rangeSize + bufferSize };
-    } else if (shortFallAfter) {
+      return { from: 0, to: to + bufferSize };
+    } else if (shortfallAfter) {
       return {
-        from: Math.max(0, rowCount - (rangeSize + bufferSize)),
-        to: rowCount
+        from: Math.max(0, from - bufferSize),
+        to: totalRowCount
       };
     } else {
-      return { from: from - buff, to: to + buff };
+      return { from: from - bufferSize, to: to + bufferSize };
     }
   }
 }
@@ -293,54 +293,67 @@ var RangeMonitor = class {
 };
 
 // ../vuu-utils/src/keyset.ts
+var EMPTY = [];
 var KeySet = class {
   constructor(range) {
     this.keys = /* @__PURE__ */ new Map();
-    this.free = [];
     this.nextKeyValue = 0;
-    this.reset(range);
+    this.range = range;
+    this.init(range);
   }
-  next() {
-    if (this.free.length > 0) {
-      return this.free.shift();
+  next(free = EMPTY) {
+    if (free.length > 0) {
+      return free.shift();
     } else {
       return this.nextKeyValue++;
     }
   }
-  reset({ from, to }) {
+  init({ from, to }) {
+    this.keys.clear();
+    this.nextKeyValue = 0;
+    for (let rowIndex = from; rowIndex < to; rowIndex++) {
+      const nextKeyValue = this.next();
+      this.keys.set(rowIndex, nextKeyValue);
+    }
+    return true;
+  }
+  reset(range) {
+    const { from, to } = range;
+    const newSize = to - from;
+    const currentSize = this.range.to - this.range.from;
+    this.range = range;
+    if (currentSize > newSize) {
+      return this.init(range);
+    }
+    const freeKeys = [];
     this.keys.forEach((keyValue, rowIndex) => {
       if (rowIndex < from || rowIndex >= to) {
-        this.free.push(keyValue);
+        freeKeys.push(keyValue);
         this.keys.delete(rowIndex);
       }
     });
-    const size = to - from;
-    if (this.keys.size + this.free.length > size) {
-      this.free.length = Math.max(0, size - this.keys.size);
-    }
     for (let rowIndex = from; rowIndex < to; rowIndex++) {
       if (!this.keys.has(rowIndex)) {
-        const nextKeyValue = this.next();
+        const nextKeyValue = this.next(freeKeys);
         this.keys.set(rowIndex, nextKeyValue);
       }
     }
-    if (this.nextKeyValue > this.keys.size) {
-      this.nextKeyValue = this.keys.size;
-    }
+    return false;
   }
   keyFor(rowIndex) {
     const key = this.keys.get(rowIndex);
     if (key === void 0) {
       console.log(\`key not found
         keys: \${this.toDebugString()}
-        free : \${this.free.join(",")}  
       \`);
       throw Error(\`KeySet, no key found for rowIndex \${rowIndex}\`);
     }
     return key;
   }
   toDebugString() {
-    return Array.from(this.keys.entries()).map(([k, v]) => \`\${k}=>\${v}\`).join(",");
+    return \`\${this.keys.size} keys
+\${Array.from(this.keys.entries()).sort(([key1], [key2]) => key1 - key2).map(([k, v]) => \`\${k}=>\${v}\`).join(",")}]
+\`;
   }
 };
 
@@ -876,8 +889,9 @@ var Viewport = class {
     filterSpec: filter,
     range,
     sort,
-    groupBy
-  }, tableSchema) {
+    groupBy,
+    table
+  }, baseTableSchema) {
     this.serverViewportId = viewPortId;
     this.status = "subscribed";
     this.aggregations = aggregations;
@@ -885,6 +899,13 @@ var Viewport = class {
     this.groupBy = groupBy;
     this.isTree = groupBy && groupBy.length > 0;
     this.dataWindow.setRange(range.from, range.to);
+    const tableSchema = table === baseTableSchema.table.table ? baseTableSchema : {
+      ...baseTableSchema,
+      table: {
+        ...baseTableSchema.table,
+        session: table
+      }
+    };
     return {
       aggregations,
       type: "subscribed",
@@ -2338,7 +2359,7 @@ async function connect(connectionString, protocol, callback, retryLimitDisconnec
   };
   return makeConnection(connectionString, protocol, callback);
 }
-async function reconnect(connection) {
+async function reconnect(_) {
   throw Error("connection broken");
 }
 async function makeConnection(url, protocol, callback, connection) {