@milaboratories/pl-middle-layer 1.37.76 → 1.37.77

package/dist/index.mjs

@@ -5299,24 +5299,24 @@ class Vc {
 }
 class Uc {
   constructor(e, t) {
-    this.table = e, this.abortController = t;
+    this.pTable = e, this.abortController = t;
   }
   get disposeSignal() {
     return this.abortController.signal;
   }
   [Symbol.dispose]() {
-    this.abortController.abort(), this.table.then((e) => e.dispose());
+    this.abortController.abort(), this.pTable.dispose();
   }
 }
 class Dr {
   constructor(e, t, r) {
     k(this, "pFrames");
     k(this, "pTables");
-    k(this, "concurrencyLimiter");
-    k(this, "getDataLimiter");
+    k(this, "frameConcurrencyLimiter");
+    k(this, "tableConcurrencyLimiter");
     this.blobDriver = e, this.logger = t, this.spillPath = r;
     const n = new Gr(1);
-    this.concurrencyLimiter = n, this.getDataLimiter = new Gr(1), this.pFrames = new class extends tn {
+    this.frameConcurrencyLimiter = n, this.tableConcurrencyLimiter = new Gr(1), this.pFrames = new class extends tn {
       constructor(o, i, l) {
         super(), this.blobDriver = o, this.logger = i, this.spillPath = l;
       }
@@ -5337,22 +5337,17 @@ class Dr {
         ne().logPFrameRequests && t.info(
           `PTable creation (pTableHandle = ${this.calculateParamsKey(o)}): ${JSON.stringify(o, Te)}`
         );
-        const l = this.pFrames.getByKey(i), c = new AbortController(), a = AbortSignal.any(
-          [o.signal, c.signal, l.disposeSignal].filter((d) => !!d)
-        ), u = n.run(async () => {
-          const d = await l.pFrame.createTable({
-            src: Be(o.def.src),
-            filters: cr(o.def.filters)
-          }, a);
-          let p = d;
-          if (o.def.sorting.length > 0)
-            try {
-              p = await d.sort(o.def.sorting, a);
-            } finally {
-              d.dispose();
-            }
-          return p;
+        const l = this.pFrames.getByKey(i), c = new AbortController(), a = l.pFrame.createTable({
+          src: Be(o.def.src),
+          filters: cr(o.def.filters)
         });
+        let u = a;
+        if (o.def.sorting.length > 0)
+          try {
+            u = a.sort(o.def.sorting);
+          } finally {
+            a.dispose();
+          }
         return new Uc(u, c);
       }
       calculateParamsKey(o) {
@@ -5379,14 +5374,14 @@ class Dr {
     ), n = this.pFrames.acquire(r);
     return t.addOnDestroy(n.unref), n.key;
   }
-  createPTable(e, t, r) {
-    const n = this.createPFrame(oo(e.src), t), o = lr(e, (l) => l.id), i = this.pTables.acquire({ def: o, pFrameHandle: n, signal: r });
+  createPTable(e, t) {
+    const r = this.createPFrame(oo(e.src), t), n = lr(e, (i) => i.id), o = this.pTables.acquire({ def: n, pFrameHandle: r });
     return ne().logPFrameRequests && this.logger.info(
-      `Create PTable call (pFrameHandle = ${n}; pTableHandle = ${JSON.stringify(i)}): ${JSON.stringify(
-        lr(e, (l) => l.spec),
+      `Create PTable call (pFrameHandle = ${r}; pTableHandle = ${JSON.stringify(o)}): ${JSON.stringify(
+        lr(e, (i) => i.spec),
         Te
       )}`
-    ), t.addOnDestroy(i.unref), i.key;
+    ), t.addOnDestroy(o.unref), o.key;
   }
   //
   // PFrame istance methods
@@ -5419,20 +5414,23 @@ class Dr {
   async calculateTableData(e, t, r, n) {
     return ne().logPFrameRequests && this.logger.info(
       `Call calculateTableData, handle = ${e}, request = ${JSON.stringify(t, Te)}`
-    ), await this.concurrencyLimiter.run(async () => {
-      const o = this.pFrames.getByKey(e), i = AbortSignal.any([n, o.disposeSignal].filter((a) => !!a)), l = await o.pFrame.createTable({
+    ), await this.frameConcurrencyLimiter.run(async () => {
+      const o = this.pFrames.getByKey(e), i = AbortSignal.any([n, o.disposeSignal].filter((a) => !!a)), l = o.pFrame.createTable({
         src: Be(t.src),
         filters: cr(t.filters)
-      }, i);
+      });
       let c = l;
       if (t.sorting.length > 0)
         try {
-          c = await l.sort(t.sorting, i);
+          c = l.sort(t.sorting);
         } finally {
           l.dispose();
         }
       try {
-        const a = c.getSpec(), u = await c.getData([...a.keys()], r, i);
+        const a = c.getSpec(), u = await c.getData([...a.keys()], {
+          range: r,
+          signal: i
+        });
         return a.map((d, p) => ({
           spec: d,
           data: u[p]
@@ -5445,27 +5443,35 @@ class Dr {
   async getUniqueValues(e, t, r) {
     return ne().logPFrameRequests && this.logger.info(
       `Call getUniqueValues, handle = ${e}, request = ${JSON.stringify(t, Te)}`
-    ), await this.concurrencyLimiter.run(async () => {
+    ), await this.frameConcurrencyLimiter.run(async () => {
       const n = this.pFrames.getByKey(e), o = AbortSignal.any([r, n.disposeSignal].filter((i) => !!i));
       return await n.pFrame.getUniqueValues({
         ...t,
         filters: cr(t.filters)
-      }, o);
+      }, {
+        signal: o
+      });
     });
   }
   //
   // PTable istance methods
   //
-  async getShape(e) {
-    return (await this.pTables.getByKey(e).table).getShape();
+  getSpec(e) {
+    const t = this.pTables.getByKey(e).pTable;
+    return Promise.resolve(t.getSpec());
   }
-  async getSpec(e) {
-    return (await this.pTables.getByKey(e).table).getSpec();
+  async getShape(e, t) {
+    return await this.tableConcurrencyLimiter.run(async () => await this.pTables.getByKey(e).pTable.getShape({
+      signal: t
+    }));
   }
   async getData(e, t, r, n) {
-    return await this.getDataLimiter.run(async () => {
-      const o = this.pTables.getByKey(e), i = await o.table, l = AbortSignal.any([n, o.disposeSignal].filter((c) => !!c));
-      return await i.getData(t, r, l);
+    return await this.tableConcurrencyLimiter.run(async () => {
+      const o = this.pTables.getByKey(e), i = AbortSignal.any([n, o.disposeSignal].filter((l) => !!l));
+      return await o.pTable.getData(t, {
+        range: r,
+        signal: i
+      });
     });
   }
 }