@milaboratories/pframes-rs-node 1.0.18 → 1.0.20

package/export_dist/index.mjs

@@ -1,211 +1,577 @@
-var l = Object.defineProperty;
-var c = (o, r, e) => r in o ? l(o, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[r] = e;
-var n = (o, r, e) => c(o, typeof r != "symbol" ? r + "" : r, e);
-import { createRequire as m } from "node:module";
-import { dirname as u, resolve as h } from "node:path";
-import { fileURLToPath as f } from "node:url";
-import S from "@mapbox/node-pre-gyp";
-const s = import.meta.url, d = u(f(s)), p = m(s), { find: w } = S, a = p(
-  w(h(d, "../package.json"))
+var y = Object.defineProperty;
+var S = (c, e, t) => e in c ? y(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var p = (c, e, t) => S(c, typeof e != "symbol" ? e + "" : e, t);
+import { ulid as n } from "ulid";
+import { createRequire as q } from "node:module";
+import d, { dirname as D, resolve as b } from "node:path";
+import { fileURLToPath as T } from "node:url";
+import F from "@mapbox/node-pre-gyp";
+import h from "node:fs";
+import { Readable as g, Writable as P } from "node:stream";
+const $ = import.meta.url, C = D(T($)), j = q($), { find: E } = F, l = j(
+  E(b(C, "../package.json"))
 );
-let y = class {
-  constructor(r) {
-    n(this, "frame");
+async function w(c) {
+  try {
+    return await h.promises.access(c), !0;
+  } catch {
+    return !1;
+  }
+}
+async function M(c) {
+  await w(c) || await h.promises.mkdir(c, { recursive: !0 });
+}
+async function J(c, e) {
+  const t = `${c}.tmp`;
+  await w(t) && await h.promises.rm(t, { recursive: !0 });
+  const r = typeof e == "string" ? Buffer.from(e, "utf8") : e, o = g.from(r), s = h.createWriteStream(t, { flags: "wx" });
+  await g.toWeb(o).pipeTo(P.toWeb(s)), await h.promises.rename(t, c);
+}
+async function a(c, e, t) {
+  if (process.env.MI_DUMP_PFRAMES_RS)
     try {
-      this.frame = a.pFrameCreate(r);
-    } catch (e) {
-      throw new Error(
-        `PFrame creation failed, logger: ${r == null ? void 0 : r.toString()}, error:
-${e.toString()}`
+      const r = d.join(
+        process.env.MI_DUMP_PFRAMES_RS,
+        ...c.slice(0, -1)
       );
+      await M(r);
+      const o = d.join(process.env.MI_DUMP_PFRAMES_RS, ...c), s = ArrayBuffer.isView(e) ? e : JSON.stringify(e);
+      await J(o, s);
+    } catch (r) {
+      t == null || t("warn", `error while dumping PFrames data: ${r}`);
     }
-  }
-  addColumnSpec(r, e) {
+}
+let N = class {
+  constructor(e) {
+    p(this, "id", n());
+    p(this, "frame");
+    this.logger = e, a(
+      [`${this.id}`, `${this.id}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "create"
+      },
+      this.logger
+    );
     try {
-      return a.pFrameAddColumnSpec(this.frame, r, e);
+      this.frame = l.pFrameCreate(e);
     } catch (t) {
       throw new Error(
-        `PFrame addColumnSpec request failed, columnId: ${JSON.stringify(r)}, columnSpec: ${JSON.stringify(e)}, error:
+        `PFrame creation failed, logger: ${e == null ? void 0 : e.toString()}, error:
 ${t.toString()}`
       );
     }
   }
-  setDataSource(r) {
+  addColumnSpec(e, t) {
+    const r = n();
+    a(
+      [`${this.id}`, `${r}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "addColumnSpec",
+        requestData: {
+          columnId: e,
+          columnSpec: t
+        }
+      },
+      this.logger
+    ), a(
+      [`${this.id}`, "data", `${e}.spec`],
+      {
+        ...t
+      },
+      this.logger
+    );
     try {
-      return a.pFrameSetDataSource(this.frame, r);
-    } catch (e) {
+      return l.pFrameAddColumnSpec(this.frame, e, t);
+    } catch (o) {
       throw new Error(
-        `PFrame setDataSource request failed, dataSource: ${r.toString()}, error:
-${e.toString()}`
+        `PFrame addColumnSpec request failed, columnId: ${JSON.stringify(e)}, columnSpec: ${JSON.stringify(t)}, error:
+${o.toString()}`
       );
     }
   }
-  setColumnData(r, e) {
+  setDataSource(e) {
+    const t = n();
+    a(
+      [`${this.id}`, `${t}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "setDataSource"
+      },
+      this.logger
+    );
+    let r = {
+      preloadBlob: async (o) => {
+        var m;
+        const s = n();
+        a(
+          [`${this.id}`, `${s}.json`],
+          {
+            timeStamp: Date.now(),
+            requestType: "preloadBlob",
+            requestData: {
+              blobIds: o
+            }
+          },
+          this.logger
+        );
+        const i = performance.now();
+        try {
+          return e.preloadBlob(o);
+        } finally {
+          const u = performance.now();
+          (m = this.logger) == null || m.call(
+            this,
+            "info",
+            `PFrame preloaded ${o.length} blobs, took ${Math.round(u - i)}ms`
+          );
+        }
+      },
+      resolveBlobContent: async (o) => {
+        const s = n();
+        a(
+          [`${this.id}`, `${s}.json`],
+          {
+            timeStamp: Date.now(),
+            requestType: "resolveBlobContent",
+            requestData: {
+              blobId: o
+            }
+          },
+          this.logger
+        );
+        const i = await e.resolveBlobContent(o);
+        return a([`${this.id}`, "data", `${o}`], i, this.logger), i;
+      }
+    };
     try {
-      return a.pFrameSetColumnData(this.frame, r, e);
-    } catch (t) {
+      return l.pFrameSetDataSource(this.frame, r);
+    } catch (o) {
       throw new Error(
-        `PFrame setColumnData request failed, columnId: ${JSON.stringify(r)}, dataInfo: ${JSON.stringify(e)}, error:
-${t.toString()}`
+        `PFrame setDataSource request failed, dataSource: ${e.toString()}, error:
+${o.toString()}`
+      );
+    }
+  }
+  setColumnData(e, t) {
+    const r = n();
+    a(
+      [`${this.id}`, `${r}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "setColumnData",
+        requestData: {
+          columnId: e,
+          dataInfo: t
+        }
+      },
+      this.logger
+    ), a(
+      [`${this.id}`, "data", `${e}.datainfo`],
+      {
+        ...t
+      },
+      this.logger
+    );
+    try {
+      return l.pFrameSetColumnData(this.frame, e, t);
+    } catch (o) {
+      throw new Error(
+        `PFrame setColumnData request failed, columnId: ${JSON.stringify(e)}, dataInfo: ${JSON.stringify(t)}, error:
+${o.toString()}`
       );
     }
   }
   dispose() {
+    const e = n();
+    a(
+      [`${this.id}`, `${e}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "dispose"
+      },
+      this.logger
+    );
     try {
-      a.pFrameDispose(this.frame);
-    } catch (r) {
+      l.pFrameDispose(this.frame);
+    } catch (t) {
       throw new Error(
         `PFrame dispose request failed, error:
-${r.toString()}`
+${t.toString()}`
       );
     }
   }
   [Symbol.dispose]() {
     this.dispose();
   }
-  async findColumns(r) {
+  async findColumns(e) {
+    var o;
+    const t = n();
+    a(
+      [`${this.id}`, `${t}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "findColumns",
+        requestData: e
+      },
+      this.logger
+    );
+    const r = performance.now();
     try {
-      return await a.pFrameFindColumns(this.frame, r);
-    } catch (e) {
+      return await l.pFrameFindColumns(this.frame, e);
+    } catch (s) {
       throw new Error(
-        `PFrame findColumns request failed, request: ${JSON.stringify(r)}, error:
-${e.toString()}`
+        `PFrame findColumns request failed, request: ${JSON.stringify(e)}, error:
+${s.toString()}`
+      );
+    } finally {
+      const s = performance.now();
+      (o = this.logger) == null || o.call(
+        this,
+        "info",
+        `PFrame findColumns request took ${Math.round(s - r)}ms`
       );
     }
   }
-  async deleteColumn(r) {
+  async deleteColumn(e) {
+    var o;
+    const t = n();
+    a(
+      [`${this.id}`, `${t}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "deleteColumn",
+        requestData: e
+      },
+      this.logger
+    );
+    const r = performance.now();
     try {
-      return await a.pFrameDeleteColumn(this.frame, r);
-    } catch (e) {
+      return await l.pFrameDeleteColumn(this.frame, e);
+    } catch (s) {
       throw new Error(
-        `PFrame deleteColumn request failed, request: ${JSON.stringify(r)}, error:
-${e.toString()}`
+        `PFrame deleteColumn request failed, request: ${JSON.stringify(e)}, error:
+${s.toString()}`
+      );
+    } finally {
+      const s = performance.now();
+      (o = this.logger) == null || o.call(
+        this,
+        "info",
+        `PFrame deleteColumn request took ${Math.round(s - r)}ms`
       );
     }
   }
-  async getColumnSpec(r) {
+  async getColumnSpec(e) {
+    var o;
+    const t = n();
+    a(
+      [`${this.id}`, `${t}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "getColumnSpec",
+        requestData: {
+          columnId: e
+        }
+      },
+      this.logger
+    );
+    const r = performance.now();
     try {
-      return await a.pFrameGetColumnSpec(this.frame, r);
-    } catch (e) {
+      return await l.pFrameGetColumnSpec(this.frame, e);
+    } catch (s) {
       throw new Error(
-        `PFrame getColumnSpec request failed, columnId: ${JSON.stringify(r)}, error:
-${e.toString()}`
+        `PFrame getColumnSpec request failed, columnId: ${JSON.stringify(e)}, error:
+${s.toString()}`
+      );
+    } finally {
+      const s = performance.now();
+      (o = this.logger) == null || o.call(
+        this,
+        "info",
+        `PFrame getColumnSpec request took ${Math.round(s - r)}ms`
       );
     }
   }
   async listColumns() {
+    var r;
+    const e = n();
+    a(
+      [`${this.id}`, `${e}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "listColumns"
+      },
+      this.logger
+    );
+    const t = performance.now();
     try {
-      return await a.pFrameListColumns(this.frame);
-    } catch (r) {
+      return await l.pFrameListColumns(this.frame);
+    } catch (o) {
       throw new Error(
         `PFrame listColumns request failed, error:
-${r.toString()}`
+${o.toString()}`
+      );
+    } finally {
+      const o = performance.now();
+      (r = this.logger) == null || r.call(
+        this,
+        "info",
+        `PFrame listColumns request took ${Math.round(o - t)}ms`
       );
     }
   }
-  async createTable(r, e) {
+  async createTable(e, t) {
+    var i;
+    const r = n(), o = {
+      timeStamp: Date.now(),
+      requestType: "createTable",
+      requestData: e
+    };
+    a([`${this.id}`, `${r}.json`], o, this.logger), a(
+      [`${this.id}`, `${r}`, `${r}.json`],
+      o,
+      this.logger
+    );
+    const s = performance.now();
     try {
-      const t = await a.pFrameCreateTable(
+      const m = await l.pFrameCreateTable(
         this.frame,
-        r,
-        e
+        e,
+        t
       );
-      return new i(t);
-    } catch (t) {
+      return new f(this, r, m);
+    } catch (m) {
       throw new Error(
-        `PFrame createTable request failed, request: ${JSON.stringify(r)}, error:
-${t.toString()}`
+        `PFrame createTable request failed, request: ${JSON.stringify(e)}, error:
+${m.toString()}`
+      );
+    } finally {
+      const m = performance.now();
+      (i = this.logger) == null || i.call(
+        this,
+        "info",
+        `PFrame createTable request took ${Math.round(m - s)}ms`
       );
     }
   }
-  async getUniqueValues(r, e) {
+  async getUniqueValues(e, t) {
+    var s;
+    const r = n();
+    a(
+      [`${this.id}`, `${r}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "getUniqueValues",
+        requestData: e
+      },
+      this.logger
+    );
+    const o = performance.now();
     try {
-      return await a.pFrameGetUniqueValues(
+      return await l.pFrameGetUniqueValues(
         this.frame,
-        r,
-        e
+        e,
+        t
       );
-    } catch (t) {
+    } catch (i) {
       throw new Error(
-        `PFrame getUniqueValues request failed, request: ${JSON.stringify(r)}, error:
-${t.toString()}`
+        `PFrame getUniqueValues request failed, request: ${JSON.stringify(e)}, error:
+${i.toString()}`
+      );
+    } finally {
+      const i = performance.now();
+      (s = this.logger) == null || s.call(
+        this,
+        "info",
+        `PFrame getUniqueValues request took ${Math.round(i - o)}ms`
       );
     }
   }
 };
-class i {
-  constructor(r) {
-    this.table = r;
+class f {
+  constructor(e, t, r) {
+    this.frame = e, this.id = t, this.table = r;
   }
   getShape() {
+    const e = n();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${e}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "getShape"
+      },
+      this.frame.logger
+    );
     try {
-      return a.pTableGetShape(this.table);
-    } catch (r) {
+      return l.pTableGetShape(this.table);
+    } catch (t) {
       throw new Error(
         `PTable getShape request failed, error:
-${r.toString()}`
+${t.toString()}`
       );
     }
   }
   getSpec() {
+    const e = n();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${e}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "getSpec"
+      },
+      this.frame.logger
+    );
     try {
-      return a.pTableGetSpec(this.table);
-    } catch (r) {
+      return l.pTableGetSpec(this.table);
+    } catch (t) {
       throw new Error(
         `PTable getSpec request failed, error:
-${r.toString()}`
+${t.toString()}`
       );
     }
   }
-  getColumnIndices(r) {
+  getColumnIndices(e) {
+    const t = n();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${t}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "getColumnIndices",
+        requestData: {
+          columnIds: e
+        }
+      },
+      this.frame.logger
+    );
     try {
-      return a.pTableGetColumnIndices(this.table, r);
-    } catch (e) {
+      return l.pTableGetColumnIndices(this.table, e);
+    } catch (r) {
       throw new Error(
-        `PTable getColumnIndices request failed, columnIds: ${JSON.stringify(r)}, error:
-${e.toString()}`
+        `PTable getColumnIndices request failed, columnIds: ${JSON.stringify(e)}, error:
+${r.toString()}`
       );
     }
   }
-  async getData(r, e) {
+  async getData(e, t) {
+    var s, i;
+    const r = n();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${r}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "getData",
+        requestData: {
+          columnIndices: e,
+          range: t ?? null
+        }
+      },
+      this.frame.logger
+    );
+    const o = performance.now();
     try {
-      return a.pTableGetData(this.table, r, e);
-    } catch (t) {
+      return await l.pTableGetData(this.table, e, t);
+    } catch (m) {
       throw new Error(
-        `PTable getData request failed, columnIndices: ${JSON.stringify(r)}, range: ${e ? JSON.stringify(e) : void 0}, error:
-${t.toString()}`
+        `PTable getData request failed, columnIndices: ${JSON.stringify(e)}, range: ${t ? JSON.stringify(t) : void 0}, error:
+${m.toString()}`
+      );
+    } finally {
+      const m = performance.now();
+      (i = (s = this.frame).logger) == null || i.call(
+        s,
+        "info",
+        `PTable getData request took ${Math.round(m - o)}ms`
       );
     }
   }
-  async filter(r, e) {
+  async filter(e, t) {
+    var i, m;
+    const r = n(), o = {
+      timeStamp: Date.now(),
+      table: this.id,
+      requestType: "filter",
+      requestData: e
+    };
+    a(
+      [`${this.frame.id}`, `${r}.json`],
+      o,
+      this.frame.logger
+    ), a(
+      [`${this.frame.id}`, `${r}`, `${r}.json`],
+      o,
+      this.frame.logger
+    );
+    const s = performance.now();
     try {
-      const t = await a.pTableFilter(this.table, r, e);
-      return new i(t);
-    } catch (t) {
+      const u = await l.pTableFilter(this.table, e, t);
+      return new f(this.frame, r, u);
+    } catch (u) {
       throw new Error(
-        `PTable filter request failed, request: ${JSON.stringify(r)}, error:
-${t.toString()}`
+        `PTable filter request failed, request: ${JSON.stringify(e)}, error:
+${u.toString()}`
+      );
+    } finally {
+      const u = performance.now();
+      (m = (i = this.frame).logger) == null || m.call(
+        i,
+        "info",
+        `PTable filter request took ${Math.round(u - s)}ms`
       );
     }
   }
-  async sort(r, e) {
+  async sort(e, t) {
+    var i, m;
+    const r = n(), o = {
+      timeStamp: Date.now(),
+      table: this.id,
+      requestType: "sort",
+      requestData: e
+    };
+    a(
+      [`${this.frame.id}`, `${r}.json`],
+      o,
+      this.frame.logger
+    ), a(
+      [`${this.frame.id}`, `${r}`, `${r}.json`],
+      o,
+      this.frame.logger
+    );
+    const s = performance.now();
     try {
-      const t = await a.pTableSort(this.table, r, e);
-      return new i(t);
-    } catch (t) {
+      const u = await l.pTableSort(this.table, e, t);
+      return new f(this.frame, r, u);
+    } catch (u) {
       throw new Error(
-        `PTable sort request failed, request: ${JSON.stringify(r)}, error:
-${t.toString()}`
+        `PTable sort request failed, request: ${JSON.stringify(e)}, error:
+${u.toString()}`
+      );
+    } finally {
+      const u = performance.now();
+      (m = (i = this.frame).logger) == null || m.call(
+        i,
+        "info",
+        `PTable sort request took ${Math.round(u - s)}ms`
       );
     }
   }
   dispose() {
+    const e = n();
+    a(
+      [`${this.frame.id}`, `${this.id}`, `${e}.json`],
+      {
+        timeStamp: Date.now(),
+        requestType: "dispose"
+      },
+      this.frame.logger
+    );
     try {
-      a.pTableDispose(this.table);
-    } catch (r) {
+      l.pTableDispose(this.table);
+    } catch (t) {
       throw new Error(
         `PTable dispose request failed, error:
-${r.toString()}`
+${t.toString()}`
       );
     }
   }
@@ -213,8 +579,8 @@ ${r.toString()}`
     this.dispose();
   }
 }
-const P = y;
+const _ = N;
 export {
-  P as PFrame
+  _ as PFrame
 };
 //# sourceMappingURL=index.mjs.map