@milaboratories/pframes-rs-node 1.0.40 → 1.0.41

package/export_dist/index.mjs

@@ -1,53 +1,128 @@
-var D = Object.defineProperty;
-var b = (d, t, e) => t in d ? D(d, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : d[t] = e;
-var g = (d, t, e) => b(d, typeof t != "symbol" ? t + "" : t, e);
+var C = Object.defineProperty;
+var F = (i, e, t) => e in i ? C(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var S = (i, e, t) => F(i, typeof e != "symbol" ? e + "" : e, t);
 import f from "humanize-duration";
 import { ulid as h } from "ulid";
-import { createRequire as P } from "node:module";
-import w, { dirname as T, resolve as F } from "node:path";
-import { fileURLToPath as C } from "node:url";
-import j from "@mapbox/node-pre-gyp";
-import l from "node:fs";
-import { Readable as y, Writable as E } from "node:stream";
-const S = import.meta.url, M = T(C(S)), I = P(S), { find: J } = j, m = I(
-  J(F(M, "../package.json"))
+import { createRequire as I } from "node:module";
+import D, { dirname as j, resolve as E } from "node:path";
+import { fileURLToPath as M } from "node:url";
+import J from "@mapbox/node-pre-gyp";
+import { createHash as N } from "node:crypto";
+import g from "node:fs";
+import { Readable as b, Writable as O } from "node:stream";
+const T = import.meta.url, U = j(M(T)), R = I(T), { find: k } = J, u = R(
+  k(E(U, "../package.json"))
 );
-async function q(d) {
+async function P(i) {
   try {
-    return await l.promises.access(d), !0;
+    return await g.promises.access(i), !0;
   } catch {
     return !1;
   }
 }
-async function N(d) {
-  await q(d) || await l.promises.mkdir(d, { recursive: !0 });
+async function v(i) {
+  await P(i) || await g.promises.mkdir(i, { recursive: !0 });
 }
-async function O(d, t) {
-  const e = `${d}.tmp`;
-  await q(e) && await l.promises.rm(e, { recursive: !0 });
-  const r = typeof t == "string" ? Buffer.from(t, "utf8") : t, i = y.from(r), o = l.createWriteStream(e, { flags: "wx" });
-  await y.toWeb(i).pipeTo(E.toWeb(o)), await l.promises.rename(e, d);
+async function A(i, e) {
+  const t = `${i}.tmp`;
+  await P(t) && await g.promises.rm(t, { recursive: !0 });
+  const r = typeof e == "string" ? Buffer.from(e, "utf8") : e, o = b.from(r), s = g.createWriteStream(t, { flags: "wx" });
+  await b.toWeb(o).pipeTo(O.toWeb(s)), await g.promises.rename(t, i);
 }
-async function s(d, t, e) {
+function l(i) {
+  return N("sha256").update(i).digest("hex");
+}
+function y(i) {
+  return i.type === "column" ? {
+    ...i,
+    id: l(i.id)
+  } : i;
+}
+function q(i) {
+  return {
+    ...i,
+    column: y(i.column)
+  };
+}
+function x(i) {
+  return {
+    ...i,
+    columnId: l(i.columnId),
+    filters: i.filters.map(q)
+  };
+}
+function B(i) {
+  return {
+    ...i,
+    column: y(i.column)
+  };
+}
+function p(i) {
+  const e = i.type;
+  switch (e) {
+    case "column":
+      return {
+        ...i,
+        columnId: l(i.columnId)
+      };
+    case "slicedColumn":
+      return {
+        ...i,
+        columnId: l(i.columnId),
+        newId: l(i.newId)
+      };
+    case "inlineColumn":
+      return {
+        ...i,
+        newId: l(i.newId)
+      };
+    case "inner":
+      return {
+        ...i,
+        entries: i.entries.map(p)
+      };
+    case "full":
+      return {
+        ...i,
+        entries: i.entries.map(p)
+      };
+    case "outer":
+      return {
+        ...i,
+        primary: p(i.primary),
+        secondary: i.secondary.map(p)
+      };
+    default:
+      throw new Error(`Unsupported join entry type: ${e}`);
+  }
+}
+function V(i) {
+  return {
+    ...i,
+    src: p(i.src),
+    filters: i.filters.map(q)
+  };
+}
+async function a(i, e, t) {
   if (process.env.MI_DUMP_PFRAMES_RS)
     try {
-      const r = d.map((a) => encodeURIComponent(a)), i = w.join(
+      const r = i.map((n) => encodeURIComponent(n)), o = D.join(
         process.env.MI_DUMP_PFRAMES_RS,
         ...r.slice(0, -1)
       );
-      await N(i);
-      const o = w.join(process.env.MI_DUMP_PFRAMES_RS, ...r), n = ArrayBuffer.isView(t) ? t : JSON.stringify(t);
-      await O(o, n);
+      await v(o);
+      const s = D.join(process.env.MI_DUMP_PFRAMES_RS, ...r), m = ArrayBuffer.isView(e) ? e : JSON.stringify(e, null, 2);
+      await A(s, m);
     } catch (r) {
-      e == null || e("warn", `error while dumping PFrames data: ${r}`);
+      t == null || t("warn", `error while dumping PFrames data: ${r}`);
     }
 }
-let U = class {
-  constructor(t, e) {
-    g(this, "id", h());
-    g(this, "frame");
+let _ = class {
+  constructor(e, t) {
+    S(this, "id", h());
+    S(this, "frame");
     var r;
-    this.logger = e, s(
+    this.logger = t, a(
       [`${this.id}`, `${this.id}.json`],
       {
         timeStamp: Date.now(),
@@ -56,50 +131,50 @@ let U = class {
       this.logger
     );
     try {
-      this.frame = m.pFrameCreate(t, e), (r = this.logger) == null || r.call(this, "info", `PFrame ${this.id} created`);
-    } catch (i) {
+      this.frame = u.pFrameCreate(e, t), (r = this.logger) == null || r.call(this, "info", `PFrame ${this.id} created`);
+    } catch (o) {
       throw new Error(
-        `PFrame ${this.id} creation failed, logger: ${e == null ? void 0 : e.toString()}, error:
-${i.toString()}`
+        `PFrame ${this.id} creation failed, logger: ${t == null ? void 0 : t.toString()}, error:
+${o.toString()}`
       );
     }
   }
   static async pprofDump() {
-    return m.pprofDump();
+    return u.pprofDump();
   }
-  addColumnSpec(t, e) {
+  addColumnSpec(e, t) {
     const r = h();
-    s(
+    a(
       [`${this.id}`, `${r}.json`],
       {
         timeStamp: Date.now(),
         requestType: "addColumnSpec",
         requestData: {
-          columnId: t,
-          columnSpec: e
+          columnId: l(e),
+          columnSpec: t
         }
       },
       this.logger
-    ), s(
-      [`${this.id}`, "data", `${t}.spec`],
+    ), a(
+      [`${this.id}`, "data", `${l(e)}.spec`],
       {
-        ...e
+        ...t
       },
       this.logger
     );
     try {
-      return m.pFrameAddColumnSpec(this.frame, t, e);
-    } catch (i) {
+      return u.pFrameAddColumnSpec(this.frame, e, t);
+    } catch (o) {
       throw new Error(
-        `PFrame ${this.id} addColumnSpec request ${r} failed, columnId: ${JSON.stringify(t)}, columnSpec: ${JSON.stringify(e)}, error:
-${i.toString()}`
+        `PFrame ${this.id} addColumnSpec request ${r} failed, columnId: ${JSON.stringify(e)}, columnSpec: ${JSON.stringify(t)}, error:
+${o.toString()}`
       );
     }
   }
-  setDataSource(t) {
-    const e = h();
-    s(
-      [`${this.id}`, `${e}.json`],
+  setDataSource(e) {
+    const t = h();
+    a(
+      [`${this.id}`, `${t}.json`],
       {
         timeStamp: Date.now(),
         requestType: "setDataSource"
@@ -107,93 +182,93 @@ ${i.toString()}`
       this.logger
     );
     let r = {
-      preloadBlob: async (i) => {
-        var a;
-        const o = h();
-        s(
-          [`${this.id}`, `${o}.json`],
+      preloadBlob: async (o) => {
+        var n;
+        const s = h();
+        a(
+          [`${this.id}`, `${s}.json`],
           {
             timeStamp: Date.now(),
             requestType: "preloadBlob",
             requestData: {
-              blobIds: i
+              blobIds: o
             }
           },
           this.logger
         );
-        const n = performance.now();
+        const m = performance.now();
         try {
-          return t.preloadBlob(i);
+          return e.preloadBlob(o);
         } finally {
           const c = performance.now();
-          (a = this.logger) == null || a.call(
+          (n = this.logger) == null || n.call(
             this,
             "info",
-            `PFrame ${this.id} preloaded ${i.length} blobs ${JSON.stringify(i)}, took ${f(Math.round(c - n))}`
+            `PFrame ${this.id} preloaded ${o.length} blobs ${JSON.stringify(o)}, took ${f(Math.round(c - m))}`
           );
         }
       },
-      resolveBlobContent: async (i) => {
-        var a;
-        const o = h();
-        s(
-          [`${this.id}`, `${o}.json`],
+      resolveBlobContent: async (o) => {
+        var n;
+        const s = h();
+        a(
+          [`${this.id}`, `${s}.json`],
           {
             timeStamp: Date.now(),
             requestType: "resolveBlobContent",
             requestData: {
-              blobId: i
+              blobId: o
             }
           },
           this.logger
         );
-        const n = await t.resolveBlobContent(i);
-        return (a = this.logger) == null || a.call(this, "info", `PFrame ${this.id} resolved blob ${i}`), s([`${this.id}`, "data", `${i}`], n, this.logger), n;
+        const m = await e.resolveBlobContent(o);
+        return (n = this.logger) == null || n.call(this, "info", `PFrame ${this.id} resolved blob ${o}`), a([`${this.id}`, "data", `${o}`], m, this.logger), m;
       }
     };
     try {
-      return m.pFrameSetDataSource(this.frame, r);
-    } catch (i) {
+      return u.pFrameSetDataSource(this.frame, r);
+    } catch (o) {
       throw new Error(
-        `PFrame ${this.id} setDataSource request ${e} failed, dataSource: ${t.toString()}, error:
-${i.toString()}`
+        `PFrame ${this.id} setDataSource request ${t} failed, dataSource: ${e.toString()}, error:
+${o.toString()}`
       );
     }
   }
-  setColumnData(t, e) {
+  setColumnData(e, t) {
     const r = h();
-    s(
+    a(
       [`${this.id}`, `${r}.json`],
       {
         timeStamp: Date.now(),
         requestType: "setColumnData",
         requestData: {
-          columnId: t,
-          dataInfo: e
+          columnId: l(e),
+          dataInfo: t
         }
       },
       this.logger
-    ), s(
-      [`${this.id}`, "data", `${t}.datainfo`],
+    ), a(
+      [`${this.id}`, "data", `${l(e)}.datainfo`],
       {
-        ...e
+        ...t
       },
       this.logger
     );
     try {
-      return m.pFrameSetColumnData(this.frame, t, e);
-    } catch (i) {
+      return u.pFrameSetColumnData(this.frame, e, t);
+    } catch (o) {
       throw new Error(
-        `PFrame ${this.id} setColumnData request ${r} failed, columnId: ${JSON.stringify(t)}, dataInfo: ${JSON.stringify(e)}, error:
-${i.toString()}`
+        `PFrame ${this.id} setColumnData request ${r} failed, columnId: ${JSON.stringify(e)}, dataInfo: ${JSON.stringify(t)}, error:
+${o.toString()}`
       );
     }
   }
   dispose() {
-    var e;
-    const t = h();
-    s(
-      [`${this.id}`, `${t}.json`],
+    var t;
+    const e = h();
+    a(
+      [`${this.id}`, `${e}.json`],
       {
         timeStamp: Date.now(),
         requestType: "dispose"
@@ -201,10 +276,10 @@ ${i.toString()}`
       this.logger
     );
     try {
-      m.pFrameDispose(this.frame), (e = this.logger) == null || e.call(this, "info", `PFrame ${this.id} disposed`);
+      u.pFrameDispose(this.frame), (t = this.logger) == null || t.call(this, "info", `PFrame ${this.id} disposed`);
     } catch (r) {
       throw new Error(
-        `PFrame ${this.id} dispose request ${t} failed, error:
+        `PFrame ${this.id} dispose request ${e} failed, error:
 ${r.toString()}`
       );
     }
@@ -212,211 +287,211 @@ ${r.toString()}`
   [Symbol.dispose]() {
     this.dispose();
   }
-  async findColumns(t) {
-    var i;
-    const e = h();
-    s(
-      [`${this.id}`, `${e}.json`],
+  async findColumns(e) {
+    var o;
+    const t = h();
+    a(
+      [`${this.id}`, `${t}.json`],
       {
         timeStamp: Date.now(),
         requestType: "findColumns",
-        requestData: t
+        requestData: e
       },
       this.logger
     );
     const r = performance.now();
     try {
-      return await m.pFrameFindColumns(this.frame, t);
-    } catch (o) {
+      return await u.pFrameFindColumns(this.frame, e);
+    } catch (s) {
       throw new Error(
-        `PFrame ${this.id} findColumns request ${e} failed, request: ${JSON.stringify(t)}, error:
-${o.toString()}`
+        `PFrame ${this.id} findColumns request ${t} failed, request: ${JSON.stringify(e)}, error:
+${s.toString()}`
       );
     } finally {
-      const o = performance.now();
-      (i = this.logger) == null || i.call(
+      const s = performance.now();
+      (o = this.logger) == null || o.call(
         this,
         "info",
-        `PFrame ${this.id} findColumns request ${e} took ${f(Math.round(o - r))}`
+        `PFrame ${this.id} findColumns request ${t} took ${f(Math.round(s - r))}`
       );
     }
   }
-  async deleteColumn(t) {
-    var i;
-    const e = h();
-    s(
-      [`${this.id}`, `${e}.json`],
+  async deleteColumn(e) {
+    var o;
+    const t = h();
+    a(
+      [`${this.id}`, `${t}.json`],
       {
         timeStamp: Date.now(),
         requestType: "deleteColumn",
-        requestData: t
+        requestData: e
       },
       this.logger
     );
     const r = performance.now();
     try {
-      return await m.pFrameDeleteColumn(this.frame, t);
-    } catch (o) {
+      return await u.pFrameDeleteColumn(this.frame, e);
+    } catch (s) {
       throw new Error(
-        `PFrame ${this.id} deleteColumn request ${e} failed, request: ${JSON.stringify(t)}, error:
-${o.toString()}`
+        `PFrame ${this.id} deleteColumn request ${t} failed, request: ${JSON.stringify(e)}, error:
+${s.toString()}`
       );
     } finally {
-      const o = performance.now();
-      (i = this.logger) == null || i.call(
+      const s = performance.now();
+      (o = this.logger) == null || o.call(
         this,
         "info",
-        `PFrame ${this.id} deleteColumn request ${e} took ${f(Math.round(o - r))}`
+        `PFrame ${this.id} deleteColumn request ${t} took ${f(Math.round(s - r))}`
       );
     }
   }
-  async getColumnSpec(t) {
-    var i;
-    const e = h();
-    s(
-      [`${this.id}`, `${e}.json`],
+  async getColumnSpec(e) {
+    var o;
+    const t = h();
+    a(
+      [`${this.id}`, `${t}.json`],
       {
         timeStamp: Date.now(),
         requestType: "getColumnSpec",
         requestData: {
-          columnId: t
+          columnId: l(e)
         }
       },
       this.logger
     );
     const r = performance.now();
     try {
-      return await m.pFrameGetColumnSpec(this.frame, t);
-    } catch (o) {
+      return await u.pFrameGetColumnSpec(this.frame, e);
+    } catch (s) {
       throw new Error(
-        `PFrame ${this.id} getColumnSpec request ${e} failed, columnId: ${JSON.stringify(t)}, error:
-${o.toString()}`
+        `PFrame ${this.id} getColumnSpec request ${t} failed, columnId: ${JSON.stringify(e)}, error:
+${s.toString()}`
       );
     } finally {
-      const o = performance.now();
-      (i = this.logger) == null || i.call(
+      const s = performance.now();
+      (o = this.logger) == null || o.call(
         this,
         "info",
-        `PFrame ${this.id} getColumnSpec request ${e} took ${f(Math.round(o - r))}`
+        `PFrame ${this.id} getColumnSpec request ${t} took ${f(Math.round(s - r))}`
       );
     }
   }
   async listColumns() {
     var r;
-    const t = h();
-    s(
-      [`${this.id}`, `${t}.json`],
+    const e = h();
+    a(
+      [`${this.id}`, `${e}.json`],
       {
         timeStamp: Date.now(),
         requestType: "listColumns"
       },
       this.logger
     );
-    const e = performance.now();
+    const t = performance.now();
     try {
-      return await m.pFrameListColumns(this.frame);
-    } catch (i) {
+      return await u.pFrameListColumns(this.frame);
+    } catch (o) {
       throw new Error(
-        `PFrame ${this.id} listColumns request ${t} failed, error:
-${i.toString()}`
+        `PFrame ${this.id} listColumns request ${e} failed, error:
+${o.toString()}`
       );
     } finally {
-      const i = performance.now();
+      const o = performance.now();
       (r = this.logger) == null || r.call(
         this,
         "info",
-        `PFrame ${this.id} listColumns request ${t} took ${f(Math.round(i - e))}`
+        `PFrame ${this.id} listColumns request ${e} took ${f(Math.round(o - t))}`
       );
     }
   }
-  async createTable(t, e) {
-    var n, a;
-    const r = h(), i = {
+  async createTable(e, t) {
+    var m, n;
+    const r = h(), o = {
       timeStamp: Date.now(),
       requestType: "createTable",
-      requestData: t
+      requestData: V(e)
     };
-    s([`${this.id}`, `${r}.json`], i, this.logger), s(
+    a([`${this.id}`, `${r}.json`], o, this.logger), a(
       [`${this.id}`, `${r}`, `${r}.json`],
-      i,
+      o,
       this.logger
-    ), (n = this.logger) == null || n.call(
+    ), (m = this.logger) == null || m.call(
       this,
       "info",
       `PFrame ${this.id} createTable request ${r} started`
     );
-    const o = performance.now();
+    const s = performance.now();
     try {
-      e == null || e.throwIfAborted();
-      const c = await m.pFrameCreateTable(
+      t == null || t.throwIfAborted();
+      const c = await u.pFrameCreateTable(
         this.frame,
         r,
-        t,
-        e
+        e,
+        t
       );
-      return new p(this, r, c);
+      return new w(this, r, c);
     } catch (c) {
       throw new Error(
-        `PFrame ${this.id} createTable request ${r} failed, request: ${JSON.stringify(t)}, error:
+        `PFrame ${this.id} createTable request ${r} failed, request: ${JSON.stringify(e)}, error:
 ${c.toString()}`
       );
     } finally {
       const c = performance.now();
-      (a = this.logger) == null || a.call(
+      (n = this.logger) == null || n.call(
         this,
         "info",
-        `PFrame ${this.id} createTable request ${r} finished, took ${f(Math.round(c - o))}`
+        `PFrame ${this.id} createTable request ${r} finished, took ${f(Math.round(c - s))}`
       );
     }
   }
-  async getUniqueValues(t, e) {
-    var o, n;
+  async getUniqueValues(e, t) {
+    var s, m;
     const r = h();
-    s(
+    a(
       [`${this.id}`, `${r}.json`],
       {
         timeStamp: Date.now(),
         requestType: "getUniqueValues",
-        requestData: t
+        requestData: x(e)
       },
       this.logger
-    ), (o = this.logger) == null || o.call(
+    ), (s = this.logger) == null || s.call(
       this,
       "info",
       `PFrame ${this.id} getUniqueValues request ${r} started`
     );
-    const i = performance.now();
+    const o = performance.now();
     try {
-      return e == null || e.throwIfAborted(), await m.pFrameGetUniqueValues(
+      return t == null || t.throwIfAborted(), await u.pFrameGetUniqueValues(
         this.frame,
         r,
-        t,
-        e
+        e,
+        t
       );
-    } catch (a) {
+    } catch (n) {
       throw new Error(
-        `PFrame ${this.id} getUniqueValues request ${r} failed, request: ${JSON.stringify(t)}, error:
-${a.toString()}`
+        `PFrame ${this.id} getUniqueValues request ${r} failed, request: ${JSON.stringify(e)}, error:
+${n.toString()}`
       );
     } finally {
-      const a = performance.now();
-      (n = this.logger) == null || n.call(
+      const n = performance.now();
+      (m = this.logger) == null || m.call(
         this,
         "info",
-        `PFrame ${this.id} getUniqueValues request ${r} finished, took ${f(Math.round(a - i))}`
+        `PFrame ${this.id} getUniqueValues request ${r} finished, took ${f(Math.round(n - o))}`
       );
     }
   }
 };
-class p {
-  constructor(t, e, r) {
-    var i, o;
-    this.frame = t, this.id = e, this.table = r, (o = (i = this.frame).logger) == null || o.call(i, "info", `PTable ${this.id} created`);
+class w {
+  constructor(e, t, r) {
+    var o, s;
+    this.frame = e, this.id = t, this.table = r, (s = (o = this.frame).logger) == null || s.call(o, "info", `PTable ${this.id} created`);
   }
   getShape() {
-    const t = h();
-    s(
-      [`${this.frame.id}`, `${this.id}`, `${t}.json`],
+    const e = h();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${e}.json`],
       {
         timeStamp: Date.now(),
         requestType: "getShape"
@@ -424,18 +499,18 @@ class p {
       this.frame.logger
     );
     try {
-      return m.pTableGetShape(this.table);
-    } catch (e) {
+      return u.pTableGetShape(this.table);
+    } catch (t) {
       throw new Error(
-        `PTable ${this.id} getShape request ${t} failed, error:
-${e.toString()}`
+        `PTable ${this.id} getShape request ${e} failed, error:
+${t.toString()}`
       );
     }
   }
   getSpec() {
-    const t = h();
-    s(
-      [`${this.frame.id}`, `${this.id}`, `${t}.json`],
+    const e = h();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${e}.json`],
       {
         timeStamp: Date.now(),
         requestType: "getSpec"
@@ -443,173 +518,175 @@ ${e.toString()}`
       this.frame.logger
     );
     try {
-      return m.pTableGetSpec(this.table);
-    } catch (e) {
+      return u.pTableGetSpec(this.table);
+    } catch (t) {
       throw new Error(
-        `PTable ${this.id} getSpec request ${t} failed, error:
-${e.toString()}`
+        `PTable ${this.id} getSpec request ${e} failed, error:
+${t.toString()}`
       );
     }
   }
-  getColumnIndices(t) {
-    const e = h();
-    s(
-      [`${this.frame.id}`, `${this.id}`, `${e}.json`],
+  getColumnIndices(e) {
+    const t = h();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${t}.json`],
       {
         timeStamp: Date.now(),
         requestType: "getColumnIndices",
         requestData: {
-          columnIds: t
+          columnIds: e.map(y)
         }
       },
       this.frame.logger
     );
     try {
-      return m.pTableGetColumnIndices(this.table, t);
+      return u.pTableGetColumnIndices(this.table, e);
     } catch (r) {
       throw new Error(
-        `PTable ${this.id} getColumnIndices request ${e} failed, columnIds: ${JSON.stringify(t)}, error:
+        `PTable ${this.id} getColumnIndices request ${t} failed, columnIds: ${JSON.stringify(e)}, error:
 ${r.toString()}`
       );
     }
   }
-  async getData(t, e, r) {
-    var n, a, c, u;
-    const i = h();
-    s(
-      [`${this.frame.id}`, `${this.id}`, `${i}.json`],
+  async getData(e, t, r) {
+    var m, n, c, $;
+    const o = h();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${o}.json`],
       {
         timeStamp: Date.now(),
         requestType: "getData",
         requestData: {
-          columnIndices: t,
-          range: e ?? null
+          columnIndices: e,
+          range: t ?? null
         }
       },
       this.frame.logger
-    ), (a = (n = this.frame).logger) == null || a.call(
-      n,
+    ), (n = (m = this.frame).logger) == null || n.call(
+      m,
       "info",
-      `PTable ${this.id} getData request ${i} started`
+      `PTable ${this.id} getData request ${o} started`
     );
-    const o = performance.now();
+    const s = performance.now();
     try {
-      return r == null || r.throwIfAborted(), await m.pTableGetData(
+      return r == null || r.throwIfAborted(), await u.pTableGetData(
         this.table,
-        i,
-        t,
+        o,
         e,
+        t,
         r
       );
-    } catch ($) {
+    } catch (d) {
       throw new Error(
-        `PTable ${this.id} getData request ${i} failed, columnIndices: ${JSON.stringify(t)}, range: ${e ? JSON.stringify(e) : void 0}, error:
-${$.toString()}`
+        `PTable ${this.id} getData request ${o} failed, columnIndices: ${JSON.stringify(e)}, range: ${t ? JSON.stringify(t) : void 0}, error:
+${d.toString()}`
       );
     } finally {
-      const $ = performance.now();
-      (u = (c = this.frame).logger) == null || u.call(
+      const d = performance.now();
+      ($ = (c = this.frame).logger) == null || $.call(
         c,
         "info",
-        `PTable ${this.id} getData request ${i} finished, took ${f(Math.round($ - o))}`
+        `PTable ${this.id} getData request ${o} finished, took ${f(Math.round(d - s))}`
       );
     }
   }
-  async filter(t, e) {
-    var n, a, c, u;
-    const r = h(), i = {
+  async filter(e, t) {
+    var m, n, c, $;
+    const r = h(), o = {
       timeStamp: Date.now(),
       table: this.id,
       requestType: "filter",
-      requestData: t
+      requestData: {
+        filters: e.map(q)
+      }
     };
-    s(
+    a(
       [`${this.frame.id}`, `${r}.json`],
-      i,
+      o,
       this.frame.logger
-    ), s(
+    ), a(
       [`${this.frame.id}`, `${r}`, `${r}.json`],
-      i,
+      o,
       this.frame.logger
-    ), (a = (n = this.frame).logger) == null || a.call(
-      n,
+    ), (n = (m = this.frame).logger) == null || n.call(
+      m,
       "info",
       `PTable ${this.id} filter request ${r} started`
     );
-    const o = performance.now();
+    const s = performance.now();
     try {
-      e == null || e.throwIfAborted();
-      const $ = await m.pTableFilter(
+      t == null || t.throwIfAborted();
+      const d = await u.pTableFilter(
         this.table,
         r,
-        t,
-        e
+        e,
+        t
       );
-      return new p(this.frame, r, $);
-    } catch ($) {
+      return new w(this.frame, r, d);
+    } catch (d) {
       throw new Error(
-        `PTable ${this.id} filter request ${r} failed, request: ${JSON.stringify(t)}, error:
-${$.toString()}`
+        `PTable ${this.id} filter request ${r} failed, request: ${JSON.stringify(e)}, error:
+${d.toString()}`
       );
     } finally {
-      const $ = performance.now();
-      (u = (c = this.frame).logger) == null || u.call(
+      const d = performance.now();
+      ($ = (c = this.frame).logger) == null || $.call(
         c,
         "info",
-        `PTable ${this.id} filter request ${r} finished, took ${f(Math.round($ - o))}`
+        `PTable ${this.id} filter request ${r} finished, took ${f(Math.round(d - s))}`
       );
     }
   }
-  async sort(t, e) {
-    var n, a, c, u;
-    const r = h(), i = {
+  async sort(e, t) {
+    var m, n, c, $;
+    const r = h(), o = {
       timeStamp: Date.now(),
       table: this.id,
       requestType: "sort",
-      requestData: t
+      requestData: e.map(B)
     };
-    s(
+    a(
       [`${this.frame.id}`, `${r}.json`],
-      i,
+      o,
       this.frame.logger
-    ), s(
+    ), a(
       [`${this.frame.id}`, `${r}`, `${r}.json`],
-      i,
+      o,
       this.frame.logger
-    ), (a = (n = this.frame).logger) == null || a.call(
-      n,
+    ), (n = (m = this.frame).logger) == null || n.call(
+      m,
       "info",
       `PTable ${this.id} sort request ${r} started`
     );
-    const o = performance.now();
+    const s = performance.now();
     try {
-      e == null || e.throwIfAborted();
-      const $ = await m.pTableSort(
+      t == null || t.throwIfAborted();
+      const d = await u.pTableSort(
         this.table,
         r,
-        t,
-        e
+        e,
+        t
       );
-      return new p(this.frame, r, $);
-    } catch ($) {
+      return new w(this.frame, r, d);
+    } catch (d) {
       throw new Error(
-        `PTable ${this.id} sort request ${r} failed, request: ${JSON.stringify(t)}, error:
-${$.toString()}`
+        `PTable ${this.id} sort request ${r} failed, request: ${JSON.stringify(e)}, error:
+${d.toString()}`
       );
     } finally {
-      const $ = performance.now();
-      (u = (c = this.frame).logger) == null || u.call(
+      const d = performance.now();
+      ($ = (c = this.frame).logger) == null || $.call(
         c,
         "info",
-        `PTable ${this.id} sort request ${r} finished, took ${f(Math.round($ - o))}`
+        `PTable ${this.id} sort request ${r} finished, took ${f(Math.round(d - s))}`
       );
     }
   }
   dispose() {
-    var e, r;
-    const t = h();
-    s(
-      [`${this.frame.id}`, `${this.id}`, `${t}.json`],
+    var t, r;
+    const e = h();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${e}.json`],
       {
         timeStamp: Date.now(),
         requestType: "dispose"
@@ -617,11 +694,11 @@ ${$.toString()}`
       this.frame.logger
     );
     try {
-      m.pTableDispose(this.table), (r = (e = this.frame).logger) == null || r.call(e, "info", `PTable ${this.id} disposed`);
-    } catch (i) {
+      u.pTableDispose(this.table), (r = (t = this.frame).logger) == null || r.call(t, "info", `PTable ${this.id} disposed`);
+    } catch (o) {
       throw new Error(
-        `PTable ${this.id} dispose request ${t} failed, error:
-${i.toString()}`
+        `PTable ${this.id} dispose request ${e} failed, error:
+${o.toString()}`
       );
     }
   }
@@ -629,8 +706,8 @@ ${i.toString()}`
     this.dispose();
   }
 }
-const L = U;
+const te = _;
 export {
-  L as PFrame
+  te as PFrame
 };
 //# sourceMappingURL=index.mjs.map