@platforma-sdk/model 1.2.22 → 1.2.23

package/dist/index.mjs

@@ -0,0 +1,697 @@
+var D = Object.defineProperty;
+var V = (e, t, n) => t in e ? D(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var l = (e, t, n) => V(e, typeof t != "symbol" ? t + "" : t, n);
+import { isPColumn as O, mapPObjectData as w, mapValueInVOE as x, mapPTableDef as I } from "@milaboratories/pl-model-common";
+export * from "@milaboratories/pl-model-common";
+class B extends Error {
+  constructor(t, n) {
+    super(`${t.length}${n ? "+" : ""} errors, first error: ` + t[0]), this.errors = t, this.moreErrors = n;
+  }
+}
+function L(e) {
+  if (!e.ok) throw new B(e.errors, e.moreErrors);
+  return e.value;
+}
+function T(e) {
+  return new Proxy(e, {
+    get(t, n) {
+      return L(t[n]);
+    }
+  });
+}
+function i(e) {
+  return typeof e == "string" || typeof e == "number" || typeof e == "boolean" || e === null ? p(e) : e;
+}
+function g(e) {
+  return { type: "GetFromCtx", variable: e };
+}
+function K(e) {
+  return {
+    type: "Isolate",
+    cfg: e
+  };
+}
+const W = g("$args"), z = g("$it"), U = g("$prod"), q = g("$staging"), Q = g("$ui");
+function p(e) {
+  return { type: "Immediate", value: e };
+}
+function C(e) {
+  const t = {};
+  for (const [n, r] of Object.entries(e)) t[n] = i(r);
+  return {
+    type: "MakeObject",
+    template: t
+  };
+}
+function X(...e) {
+  const t = [];
+  for (const n of e) t.push(i(n));
+  return {
+    type: "MakeArray",
+    template: t
+  };
+}
+function h(e, t) {
+  return {
+    type: "GetJsonField",
+    source: i(e),
+    field: i(t)
+  };
+}
+function Y(e, t, n = "$it") {
+  return {
+    type: "MapRecordValues",
+    source: e,
+    mapping: t,
+    itVar: n
+  };
+}
+function Z(e, t, n = "$it") {
+  return {
+    type: "MapArrayValues",
+    source: e,
+    mapping: t,
+    itVar: n
+  };
+}
+function tt(e) {
+  return {
+    type: "Flatten",
+    source: e
+  };
+}
+function et(e) {
+  return {
+    type: "IsEmpty",
+    arg: e
+  };
+}
+function nt(e) {
+  return {
+    type: "Not",
+    operand: e
+  };
+}
+function rt(e, t) {
+  return {
+    type: "And",
+    operand1: e,
+    operand2: t
+  };
+}
+function st(e, t) {
+  return {
+    type: "Or",
+    operand1: e,
+    operand2: t
+  };
+}
+function it(e, t) {
+  return {
+    type: "GetResourceField",
+    source: i(e),
+    field: i(t)
+  };
+}
+function ot() {
+  return function(e) {
+    return {
+      type: "GetResourceValueAsJson",
+      source: i(e)
+    };
+  };
+}
+function at(e, t, n = "$it") {
+  return {
+    type: "MapResourceFields",
+    source: e,
+    mapping: t,
+    itVar: n
+  };
+}
+function ut(e) {
+  return {
+    type: "GetBlobContent",
+    source: i(e)
+  };
+}
+function lt(e) {
+  return {
+    type: "GetBlobContentAsString",
+    source: i(e)
+  };
+}
+function ct() {
+  return function(e) {
+    return {
+      type: "GetBlobContentAsJson",
+      source: i(e)
+    };
+  };
+}
+function dt(e) {
+  return {
+    type: "GetDownloadedBlobContent",
+    source: i(e)
+  };
+}
+function gt(e) {
+  return {
+    type: "GetOnDemandBlobContent",
+    source: i(e)
+  };
+}
+function pt(e) {
+  return {
+    type: "GetImportProgress",
+    source: i(e)
+  };
+}
+function ht(e, t) {
+  return {
+    type: "GetLastLogs",
+    source: i(e),
+    lines: t
+  };
+}
+function ft(e, t) {
+  return {
+    type: "GetProgressLog",
+    source: i(e),
+    patternToSearch: t
+  };
+}
+function mt(e) {
+  return {
+    type: "GetLogHandle",
+    source: i(e)
+  };
+}
+function E() {
+  return typeof getPlatforma < "u" || typeof platforma < "u";
+}
+function k(e) {
+  if (typeof getPlatforma == "function") return getPlatforma(e);
+  if (typeof platforma < "u") return platforma;
+  throw new Error("Can't get platforma instance.");
+}
+function j() {
+  if (typeof cfgRenderCtx < "u") return cfgRenderCtx;
+}
+function s() {
+  if (typeof cfgRenderCtx < "u") return cfgRenderCtx;
+  throw new Error("Not in config rendering context");
+}
+function f(e, t) {
+  const n = j();
+  if (n === void 0) return !1;
+  if (e in n.callbackRegistry) throw new Error(`Callback with key ${e} already registered.`);
+  return n.callbackRegistry[e] = t, !0;
+}
+const m = /* @__PURE__ */ new Map();
+function J(e, t) {
+  e in s().callbackRegistry || (s().callbackRegistry[e] = (n) => {
+    for (const r of m.get(e))
+      r(n);
+  }, m.set(e, [])), m.get(e).push(t);
+}
+class a {
+  constructor(t, n = (r) => r) {
+    l(this, "isResolved", !1);
+    l(this, "resolvedValue");
+    this.handle = t, this.postProcess = n, J(t, (r) => {
+      this.resolvedValue = n(r), this.isResolved = !0;
+    });
+  }
+  map(t) {
+    return new a(this.handle, (n) => t(this.postProcess(n)));
+  }
+  mapDefined(t) {
+    return new a(this.handle, (n) => {
+      const r = this.postProcess(n);
+      return r ? t(r) : void 0;
+    });
+  }
+  toJSON() {
+    return this.isResolved ? this.resolvedValue : { __awaited_futures__: [this.handle] };
+  }
+}
+function b(e) {
+  return e === void 0 ? void 0 : new d(e);
+}
+class d {
+  constructor(t) {
+    this.handle = t;
+  }
+  resolve(...t) {
+    return this.resolveWithCommon({}, ...t);
+  }
+  resolveWithCommon(t, ...n) {
+    return b(s().resolveWithCommon(this.handle, t, ...n));
+  }
+  get resourceType() {
+    return s().getResourceType(this.handle);
+  }
+  getInputsLocked() {
+    return s().getInputsLocked(this.handle);
+  }
+  getOutputsLocked() {
+    return s().getOutputsLocked(this.handle);
+  }
+  getIsReadyOrError() {
+    return s().getIsReadyOrError(this.handle);
+  }
+  getIsFinal() {
+    return s().getIsFinal(this.handle);
+  }
+  getError() {
+    return b(s().getError(this.handle));
+  }
+  listInputFields() {
+    return s().listInputFields(this.handle);
+  }
+  listOutputFields() {
+    return s().listOutputFields(this.handle);
+  }
+  listDynamicFields() {
+    return s().listDynamicFields(this.handle);
+  }
+  getKeyValueBase64(t) {
+    return s().getKeyValueBase64(this.handle, t);
+  }
+  getKeyValueAsString(t) {
+    return s().getKeyValueAsString(this.handle, t);
+  }
+  getKeyValueAsJson(t) {
+    const n = this.getKeyValueAsString(t);
+    if (n == null) throw new Error("Resource has no content.");
+    return JSON.parse(n);
+  }
+  getDataBase64() {
+    return s().getDataBase64(this.handle);
+  }
+  getDataAsString() {
+    return s().getDataAsString(this.handle);
+  }
+  getDataAsJson() {
+    const t = this.getDataAsString();
+    if (t == null) throw new Error("Resource has no content.");
+    return JSON.parse(t);
+  }
+  /**
+   *
+   */
+  getPColumns(t = !1, n = "") {
+    const r = this.parsePObjectCollection(t, n);
+    return r === void 0 ? void 0 : Object.entries(r).map(([, c]) => {
+      if (!O(c)) throw new Error(`not a PColumn (kind = ${c.spec.kind})`);
+      return c;
+    });
+  }
+  /**
+   *
+   */
+  parsePObjectCollection(t = !1, n = "") {
+    const r = s().parsePObjectCollection(
+      this.handle,
+      t,
+      n
+    );
+    if (r === void 0) return;
+    const o = {};
+    for (const [c, R] of Object.entries(r))
+      o[c] = w(R, (v) => new d(v));
+    return o;
+  }
+  getFileContentAsBase64() {
+    return new a(s().getBlobContentAsBase64(this.handle));
+  }
+  getFileContentAsString() {
+    return new a(s().getBlobContentAsString(this.handle));
+  }
+  getFileContentAsJson() {
+    return new a(
+      s().getBlobContentAsString(this.handle)
+    ).mapDefined((t) => JSON.parse(t));
+  }
+  /**
+   * @deprecated use getFileContentAsBase64
+   */
+  getBlobContentAsBase64() {
+    return this.getFileContentAsBase64();
+  }
+  /**
+   * @deprecated use getFileContentAsString
+   */
+  getBlobContentAsString() {
+    return this.getFileContentAsString();
+  }
+  /**
+   * @returns downloaded file handle
+   */
+  getFileHandle() {
+    return new a(s().getDownloadedBlobContentHandle(this.handle));
+  }
+  /**
+   * @deprecated use getFileHandle
+   */
+  getDownloadedBlobHandle() {
+    return this.getFileHandle();
+  }
+  /**
+   * @returns downloaded file handle
+   */
+  getRemoteFileHandle() {
+    return new a(s().getOnDemandBlobContentHandle(this.handle));
+  }
+  /**
+   * @deprecated use getRemoteFileHandle
+   */
+  getOnDemandBlobHandle() {
+    return this.getRemoteFileHandle();
+  }
+  getImportProgress() {
+    return new a(s().getImportProgress(this.handle));
+  }
+  getLastLogs(t) {
+    return new a(s().getLastLogs(this.handle, t));
+  }
+  getProgressLog(t) {
+    return new a(s().getProgressLog(this.handle, t));
+  }
+  getLogHandle() {
+    return new a(s().getLogHandle(this.handle));
+  }
+}
+const _ = "staging", F = "main";
+function P(e) {
+  return typeof e == "object" && e !== null && "__awaited_futures__" in e;
+}
+function A(e, t, n) {
+  if (t.has(n)) return;
+  if (t.add(n), typeof n === "object")
+    if (P(n)) n.__awaited_futures__.forEach((o) => e.add(o));
+    else if (Array.isArray(n))
+      for (const o of n) A(e, t, o);
+    else
+      for (const [, o] of Object.entries(n))
+        o !== n && A(e, t, o);
+}
+function H(e) {
+  const t = /* @__PURE__ */ new Set();
+  return A(t, /* @__PURE__ */ new Set(), e), t;
+}
+const yt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  MainAccessorName: F,
+  StagingAccessorName: _,
+  getAllFutureAwaits: H,
+  isFutureAwait: P
+}, Symbol.toStringTag, { value: "Module" }));
+class G {
+  constructor() {
+    l(this, "ctx", s());
+  }
+  calculateOptions(t) {
+    return this.ctx.calculateOptions(t);
+  }
+  getDataFromResultPool() {
+    const t = this.ctx.getDataFromResultPool();
+    return {
+      isComplete: t.isComplete,
+      entries: t.entries.map((n) => ({
+        ref: n.ref,
+        obj: {
+          ...n.obj,
+          data: new d(n.obj.data)
+        }
+      }))
+    };
+  }
+  getDataWithErrorsFromResultPool() {
+    const t = this.ctx.getDataWithErrorsFromResultPool();
+    return {
+      isComplete: t.isComplete,
+      entries: t.entries.map((n) => ({
+        ref: n.ref,
+        obj: {
+          ...n.obj,
+          data: x(n.obj.data, (r) => new d(r))
+        }
+      }))
+    };
+  }
+  getSpecsFromResultPool() {
+    return this.ctx.getSpecsFromResultPool();
+  }
+}
+class y {
+  constructor() {
+    l(this, "ctx");
+    l(this, "args");
+    l(this, "uiState");
+    l(this, "resultPool", new G());
+    this.ctx = s(), this.args = JSON.parse(this.ctx.args), this.uiState = this.ctx.uiState !== void 0 ? JSON.parse(this.ctx.uiState) : void 0;
+  }
+  getNamedAccessor(t) {
+    const n = this.ctx.getAccessorHandleByName(t);
+    return n ? new d(n) : void 0;
+  }
+  get prerun() {
+    return this.getNamedAccessor(_);
+  }
+  /**
+   * @deprecated use prerun
+   */
+  get precalc() {
+    return this.prerun;
+  }
+  /**
+   * @deprecated use prerun
+   */
+  get stagingOutput() {
+    return this.precalc;
+  }
+  get outputs() {
+    return this.getNamedAccessor(F);
+  }
+  /**
+   * @deprecated use outputs
+   */
+  get mainOutput() {
+    return this.outputs;
+  }
+  createPFrame(t) {
+    return this.ctx.createPFrame(t.map((n) => w(n, (r) => r.handle)));
+  }
+  createPTable(t) {
+    var n;
+    return "columns" in t ? n = {
+      src: {
+        type: "inner",
+        entries: t.columns.map((r) => ({ type: "column", column: r }))
+      },
+      filters: t.filters ?? [],
+      sorting: t.sorting ?? []
+    } : n = t, this.ctx.createPTable(I(n, (r) => w(r, (o) => o.handle)));
+  }
+  getBlockLabel(t) {
+    return this.ctx.getBlockLabel(t);
+  }
+}
+const S = "1.2.23";
+function wt(e) {
+  return typeof e == "string";
+}
+function At(e) {
+  if (e.inputsValid !== void 0) return e;
+  {
+    if (e.canRun === void 0)
+      throw new Error(`Malformed config, SDK version ${e.sdkVersion}`);
+    const t = { ...e, inputsValid: e.canRun };
+    return delete t.canRun, t;
+  }
+}
+class u {
+  constructor(t, n, r, o, c) {
+    this._renderingMode = t, this._initialArgs = n, this._outputs = r, this._inputsValid = o, this._sections = c;
+  }
+  /** Initiates configuration builder */
+  static create(t) {
+    return new u(
+      t,
+      void 0,
+      {},
+      p(!0),
+      p([])
+    );
+  }
+  output(t, n) {
+    if (typeof n == "function") {
+      const r = `output#${t}`;
+      return f(r, () => n(new y())), new u(
+        this._renderingMode,
+        this._initialArgs,
+        {
+          ...this._outputs,
+          [t]: r
+        },
+        this._inputsValid,
+        this._sections
+      );
+    } else
+      return new u(
+        this._renderingMode,
+        this._initialArgs,
+        {
+          ...this._outputs,
+          [t]: n
+        },
+        this._inputsValid,
+        this._sections
+      );
+  }
+  /** @deprecated */
+  canRun(t) {
+    return this.inputsValid(t);
+  }
+  inputsValid(t) {
+    return typeof t == "function" ? (f("inputsValid", () => t(new y())), new u(
+      this._renderingMode,
+      this._initialArgs,
+      this._outputs,
+      "inputsValid",
+      this._sections
+    )) : new u(
+      this._renderingMode,
+      this._initialArgs,
+      this._outputs,
+      t,
+      this._sections
+    );
+  }
+  sections(t) {
+    return Array.isArray(t) ? this.sections(p(t)) : typeof t == "function" ? (f("sections", () => t(new y())), new u(
+      this._renderingMode,
+      this._initialArgs,
+      this._outputs,
+      this._inputsValid,
+      "sections"
+    )) : new u(
+      this._renderingMode,
+      this._initialArgs,
+      this._outputs,
+      this._inputsValid,
+      t
+    );
+  }
+  /** Sets initial args for the block, this value must be specified. */
+  initialArgs(t) {
+    return new u(
+      this._renderingMode,
+      t,
+      this._outputs,
+      this._inputsValid,
+      this._sections
+    );
+  }
+  /** Renders all provided block settings into a pre-configured platforma API
+   * instance, that can be used in frontend to interact with block state, and
+   * other features provided by the platforma to the block. */
+  done() {
+    if (this._initialArgs === void 0) throw new Error("Initial arguments not set.");
+    const t = {
+      sdkVersion: S,
+      renderingMode: this._renderingMode,
+      initialArgs: this._initialArgs,
+      inputsValid: this._inputsValid,
+      sections: this._sections,
+      outputs: this._outputs
+    };
+    return E() ? k(t) : { config: t };
+  }
+}
+class bt {
+  constructor(t) {
+    this.handle = t;
+  }
+  async findColumns(t) {
+    return await platforma.pFrameDriver.findColumns(this.handle, t);
+  }
+  async getColumnSpec(t) {
+    return await platforma.pFrameDriver.getColumnSpec(this.handle, t);
+  }
+  async listColumns() {
+    return await platforma.pFrameDriver.listColumns(this.handle);
+  }
+  async calculateTableData(t) {
+    return await platforma.pFrameDriver.calculateTableData(this.handle, t);
+  }
+  async getUniqueValues(t) {
+    return await platforma.pFrameDriver.getUniqueValues(this.handle, t);
+  }
+}
+function N(e) {
+  return C({
+    __isRef: !0,
+    blockId: h(e, "blockId"),
+    name: h(e, "name")
+  });
+}
+function Ct(e) {
+  return C({
+    ref: N(h(e, "ref")),
+    label: h(e, "label")
+  });
+}
+const _t = {
+  sdkVersion: S
+};
+export {
+  W as Args,
+  u as BlockModel,
+  _t as CurrentSdkInfo,
+  a as FutureRef,
+  z as It,
+  yt as JsRenderInternal,
+  U as MainOutputs,
+  B as OutputError,
+  bt as PFrameImpl,
+  y as RenderCtx,
+  G as ResultPool,
+  q as StagingOutputs,
+  d as TreeNodeAccessor,
+  Q as UiState,
+  rt as and,
+  tt as flatten,
+  Ct as fromPlOption,
+  N as fromPlRef,
+  ut as getBlobContent,
+  ct as getBlobContentAsJson,
+  lt as getBlobContentAsString,
+  dt as getDownloadedBlobContent,
+  g as getFromCfg,
+  p as getImmediate,
+  pt as getImportProgress,
+  h as getJsonField,
+  ht as getLastLogs,
+  mt as getLogHandle,
+  gt as getOnDemandBlobContent,
+  ft as getProgressLog,
+  it as getResourceField,
+  ot as getResourceValueAsJson,
+  et as isEmpty,
+  wt as isFunctionHandle,
+  K as isolate,
+  X as makeArray,
+  C as makeObject,
+  Z as mapArrayValues,
+  Y as mapRecordValues,
+  at as mapResourceFields,
+  At as normalizeBlockConfig,
+  nt as not,
+  st as or,
+  L as readOutput,
+  T as wrapOutputs
+};
+//# sourceMappingURL=index.mjs.map