@milaboratories/pl-model-common 1.7.0 → 1.8.1

package/dist/index.mjs

@@ -1,198 +1,284 @@
-import { z as a } from "zod";
-function V(n) {
-  return n !== void 0 && n.startsWith("log+live://log/");
-}
-function c(n) {
-  throw new Error("Unexpected object: " + n);
-}
-const l = "upload://upload/", d = "index://index/";
-function p(n) {
-  return n.startsWith(l);
-}
-function P(n) {
-  return n.startsWith(d);
-}
-function k(n) {
-  if (P(n)) {
-    const t = n.slice(d.length);
-    return JSON.parse(decodeURIComponent(t)).path;
-  } else if (p(n)) {
-    const t = n.slice(l.length);
-    return JSON.parse(decodeURIComponent(t)).localPath;
+import { z as i } from "zod";
+function B(t) {
+  return t !== void 0 && t.startsWith("log+live://log/");
+}
+function c(t) {
+  throw new Error("Unexpected object: " + t);
+}
+const d = "upload://upload/", m = "index://index/";
+function y(t) {
+  return t.startsWith(d);
+}
+function b(t) {
+  return t.startsWith(m);
+}
+function g(t) {
+  if (b(t)) {
+    const n = t.slice(m.length);
+    return JSON.parse(decodeURIComponent(n)).path;
+  } else if (y(t)) {
+    const n = t.slice(d.length);
+    return JSON.parse(decodeURIComponent(n)).localPath;
+  }
+  c(t);
+}
+function w(t) {
+  return t.replace(/^.*[\\/]/, "");
+}
+function D(t) {
+  return w(g(t));
+}
+const N = -2147483648, a = -9007199254740991n, P = NaN, h = NaN, x = null, E = null;
+function f(t, n) {
+  switch (n) {
+    case "Int":
+      return t === N;
+    case "Long":
+      return t === Number(a) || t === a;
+    case "Float":
+      return t === P;
+    case "Double":
+      return t === h;
+    case "String":
+      return t === x;
+    case "Bytes":
+      return t === E;
+    default:
+      throw Error(`unsupported data type: ${n}`);
   }
-  c(n);
 }
-function N(n) {
-  return n.replace(/^.*[\\/]/, "");
+function R(t) {
+  if (!V(t)) throw new Error(`Expected not-NA PValue, got ${t}`);
+  return t;
 }
-function F(n) {
-  return N(k(n));
+function V(t, n) {
+  if (!n)
+    return typeof t == "string" || typeof t == "number" && isFinite(t) || typeof t == "bigint";
+  if (f(t, n)) return !1;
+  switch (n) {
+    case "Int":
+      return typeof t == "number";
+    case "Long":
+      return typeof t == "number" || typeof t == "bigint";
+    case "Float":
+      return typeof t == "number";
+    case "Double":
+      return typeof t == "number";
+    case "String":
+      return typeof t == "string";
+    case "Bytes":
+      throw Error("Bytes not yet supported");
+    default:
+      throw Error(`unsupported data type: ${n}`);
+  }
 }
-const b = -2147483648, s = -9007199254740991n, h = NaN, v = NaN, y = null, I = null;
-function R(n, t) {
-  switch (t) {
+function I(t, n) {
+  if (!n)
+    return t === null || typeof t == "string" || typeof t == "number" || typeof t == "bigint";
+  if (f(t, n)) return !0;
+  switch (n) {
     case "Int":
-      return n === b;
+      return typeof t == "number";
     case "Long":
-      return n === Number(s) || n === s;
+      return typeof t == "number" || typeof t == "bigint";
     case "Float":
-      return n === h;
+      return typeof t == "number";
     case "Double":
-      return n === v;
+      return typeof t == "number";
     case "String":
-      return n === y;
+      return typeof t == "string";
     case "Bytes":
-      return n === I;
+      throw Error("Bytes not yet supported");
     default:
-      throw Error(`unsupported data type: ${t}`);
+      throw Error(`unsupported data type: ${n}`);
+  }
+}
+function L(t) {
+  if (t === null || typeof t == "string" || typeof t == "number") return t;
+  if (typeof t == "bigint") return { bigint: t.toString() };
+  throw new Error(`Type ${typeof t} (value ${t}) not yet supported.`);
+}
+function $(t, n) {
+  if (t === null || typeof t == "string" || typeof t == "number" || typeof t == "bigint") {
+    if (n && !f(t, n) && !I(t, n))
+      throw new Error(`Unexpected value type, got ${typeof t}, expected ${n}`);
+    return t;
+  }
+  if (typeof t == "object" && t !== null && "bigint" in t && typeof t.bigint == "string") {
+    if (n && n !== "Long")
+      throw new Error(`Unexpected value type, got serialized bigint, expected ${n}`);
+    return BigInt(t.bigint);
+  }
+  throw new Error(`Unsupported type ${typeof t} (value ${t}).`);
+}
+function O(t) {
+  if (t = k(t), t === null) throw new Error("Value is null");
+  return t;
+}
+function k(t) {
+  if (t = $(t), t === null) return null;
+  if (typeof t == "string") return t;
+  if (typeof t == "number") {
+    if (!isFinite(t)) throw new Error(`Value is not finite (${t})`);
+    return t;
   }
+  if (typeof t == "bigint")
+    return Number(t);
+  throw new Error(`Unexpected value type: ${typeof t}`);
 }
-function E(n, t) {
-  const e = Math.floor(t / 8), o = 1 << 7 - t % 8;
-  return (n[e] & o) > 0;
+function _(t, n) {
+  const r = Math.floor(n / 8), e = 1 << 7 - n % 8;
+  return (t[r] & e) > 0;
 }
-function g(n) {
-  const { type: t, name: e, domain: o } = n;
-  return { type: t, name: e, ...o && { domain: o } };
+function A(t) {
+  const { type: n, name: r, domain: e } = t;
+  return { type: n, name: r, ...e && { domain: e } };
 }
-function U(n) {
-  return n.map(g);
+function j(t) {
+  return t.map(A);
 }
-function x(n, t) {
-  if (n === void 0) return t === void 0;
-  if (t === void 0) return !0;
-  for (const e in t)
-    if (n[e] !== t[e]) return !1;
+function F(t, n) {
+  if (t === void 0) return n === void 0;
+  if (n === void 0) return !0;
+  for (const r in n)
+    if (t[r] !== n[r]) return !1;
   return !0;
 }
-function _(n, t) {
-  return n.name === t.name && x(n.domain, t.domain);
+function H(t, n) {
+  return t.name === n.name && F(t.domain, n.domain);
 }
-function D(n, t) {
-  return { ...n, src: i(n.src, t) };
+function J(t, n) {
+  return { ...t, src: s(t.src, n) };
 }
-function i(n, t) {
-  switch (n.type) {
+function s(t, n) {
+  switch (t.type) {
     case "column":
       return {
         type: "column",
-        column: t(n.column)
+        column: n(t.column)
       };
     case "inner":
     case "full":
       return {
-        type: n.type,
-        entries: n.entries.map((e) => i(e, t))
+        type: t.type,
+        entries: t.entries.map((r) => s(r, n))
       };
     case "outer":
       return {
         type: "outer",
-        primary: i(n.primary, t),
-        secondary: n.secondary.map((e) => i(e, t))
+        primary: s(t.primary, n),
+        secondary: t.secondary.map((r) => s(r, n))
       };
     default:
-      c(n);
+      c(t);
   }
 }
-const S = { href: "/" }, j = a.object({
-  __isRef: a.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
-  blockId: a.string().describe("Upstream block id"),
-  name: a.string().describe("Name of the output provided to the upstream block's output context")
+const W = { href: "/" }, z = i.object({
+  __isRef: i.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
+  blockId: i.string().describe("Upstream block id"),
+  name: i.string().describe("Name of the output provided to the upstream block's output context")
 }).describe(
   "Universal reference type, allowing to set block connections. It is crucial that {@link __isRef} is present and equal to true, internal logic relies on this marker to build block dependency trees."
 ).strict().readonly();
-function B(n, t) {
-  return n.blockId === t.blockId && n.name === t.name;
+function M(t, n) {
+  return t.blockId === n.blockId && t.name === n.name;
 }
-function r(n) {
-  return n.kind === "PColumn";
+function o(t) {
+  return t.kind === "PColumn";
 }
-function w(n) {
-  return r(n.spec);
+function S(t) {
+  return o(t.spec);
 }
-function H(n) {
-  return r(n.obj);
+function q(t) {
+  return o(t.obj);
 }
-function L(n) {
-  return r(n.obj.spec);
+function G(t) {
+  return o(t.obj.spec);
 }
-function O(n) {
-  if (!w(n)) throw new Error(`not a PColumn (kind = ${n.spec.kind})`);
-  return n;
+function K(t) {
+  if (!S(t)) throw new Error(`not a PColumn (kind = ${t.spec.kind})`);
+  return t;
 }
-function J(n, t) {
-  return n === void 0 ? void 0 : {
-    ...n,
-    data: t(n.data)
+function Q(t, n) {
+  return t === void 0 ? void 0 : {
+    ...t,
+    data: n(t.data)
   };
 }
-function A(n) {
-  throw new Error("Unexpected object: " + n);
+function C(t) {
+  throw new Error("Unexpected object: " + t);
 }
-function u(n, t) {
-  switch (n.type) {
+function u(t, n) {
+  switch (t.type) {
     case "and":
-      for (const e of n.operands)
-        if (!u(e, t)) return !1;
+      for (const r of t.operands)
+        if (!u(r, n)) return !1;
       return !0;
     case "or":
-      for (const e of n.operands)
-        if (u(e, t)) return !0;
+      for (const r of t.operands)
+        if (u(r, n)) return !0;
       return !1;
     case "not":
-      return !u(n.operand, t);
+      return !u(t.operand, n);
     case "name":
-      return r(t) && t.name === n.name;
+      return o(n) && n.name === t.name;
     case "name_pattern":
-      return r(t) && !!t.name.match(n.pattern);
+      return o(n) && !!n.name.match(t.pattern);
     case "annotation":
-      return r(t) && t.annotations !== void 0 && t.annotations[n.annotation] === n.value;
+      return o(n) && n.annotations !== void 0 && n.annotations[t.annotation] === t.value;
     case "annotation_pattern":
-      return r(t) && t.annotations !== void 0 && t.annotations[n.annotation] !== void 0 && !!t.annotations[n.annotation].match(n.pattern);
+      return o(n) && n.annotations !== void 0 && n.annotations[t.annotation] !== void 0 && !!n.annotations[t.annotation].match(t.pattern);
     case "has_axes":
-      return r(t) && n.axes.every(
-        (e) => t.axesSpec.some(
-          (o) => (e.type === void 0 || e.type === o.type) && (e.name === void 0 || e.name === o.name) && (e.domain === void 0 || Object.keys(e.domain).length === 0 || o.domain !== void 0 && Object.entries(e.domain).every(
-            ([m, f]) => o.domain[m] === f
+      return o(n) && t.axes.every(
+        (r) => n.axesSpec.some(
+          (e) => (r.type === void 0 || r.type === e.type) && (r.name === void 0 || r.name === e.name) && (r.domain === void 0 || Object.keys(r.domain).length === 0 || e.domain !== void 0 && Object.entries(r.domain).every(
+            ([p, l]) => e.domain[p] === l
           ))
         )
       );
     default:
-      A(n);
+      C(t);
   }
 }
-function W(n, t) {
-  return n.ok ? { ok: !0, value: t(n.value) } : n;
+function X(t, n) {
+  return t.ok ? { ok: !0, value: n(t.value) } : t;
 }
 export {
-  S as DefaultNavigationState,
-  I as PValueBytesNA,
-  v as PValueDoubleNA,
-  h as PValueFloatNA,
-  b as PValueIntNA,
-  s as PValueLongNA,
-  y as PValueStringNA,
-  j as PlRef,
-  O as ensurePColumn,
+  W as DefaultNavigationState,
+  E as PValueBytesNA,
+  h as PValueDoubleNA,
+  P as PValueFloatNA,
+  N as PValueIntNA,
+  a as PValueLongNA,
+  x as PValueStringNA,
+  z as PlRef,
+  R as ensureNotNAPValue,
+  K as ensurePColumn,
   u as executePSpecPredicate,
-  U as getAxesId,
-  g as getAxisId,
-  F as getFileNameFromHandle,
-  k as getFilePathFromHandle,
-  P as isImportFileHandleIndex,
-  p as isImportFileHandleUpload,
-  V as isLiveLog,
-  w as isPColumn,
-  L as isPColumnResult,
-  r as isPColumnSpec,
-  H as isPColumnSpecResult,
-  E as isValueAbsent,
-  R as isValueNA,
-  i as mapJoinEntry,
-  J as mapPObjectData,
-  D as mapPTableDef,
-  W as mapValueInVOE,
-  _ as matchAxisId,
-  B as plRefsEqual
+  j as getAxesId,
+  A as getAxisId,
+  D as getFileNameFromHandle,
+  g as getFilePathFromHandle,
+  b as isImportFileHandleIndex,
+  y as isImportFileHandleUpload,
+  B as isLiveLog,
+  V as isNotNAPValue,
+  S as isPColumn,
+  G as isPColumnResult,
+  o as isPColumnSpec,
+  q as isPColumnSpecResult,
+  I as isPValue,
+  _ as isValueAbsent,
+  f as isValueNA,
+  s as mapJoinEntry,
+  Q as mapPObjectData,
+  J as mapPTableDef,
+  X as mapValueInVOE,
+  H as matchAxisId,
+  O as pValueToStringOrNumber,
+  k as pValueToStringOrNumberOrNull,
+  M as plRefsEqual,
+  $ as safeConvertToPValue,
+  L as toJsonSafePValue
 };
 //# sourceMappingURL=index.mjs.map