@milaboratories/pl-model-common 1.10.1 → 1.10.2

package/dist/index.mjs

@@ -1,60 +1,60 @@
-import { z as s } from "zod";
-function R(t) {
+import { z as a } from "zod";
+function Z(t) {
   return t !== void 0 && t.startsWith("log+live://log/");
 }
-function f(t) {
+function b(t) {
   throw new Error("Unexpected object: " + t);
 }
-const p = "upload://upload/", l = "index://index/";
-function b(t) {
-  return t.startsWith(p);
+const w = "upload://upload/", h = "index://index/";
+function E(t) {
+  return t.startsWith(w);
 }
-function y(t) {
-  return t.startsWith(l);
+function I(t) {
+  return t.startsWith(h);
 }
-function g(t) {
-  if (y(t)) {
-    const n = t.slice(l.length);
+function C(t) {
+  if (I(t)) {
+    const n = t.slice(h.length);
     return JSON.parse(decodeURIComponent(n)).path;
-  } else if (b(t)) {
-    const n = t.slice(p.length);
+  } else if (E(t)) {
+    const n = t.slice(w.length);
     return JSON.parse(decodeURIComponent(n)).localPath;
   }
-  f(t);
+  b(t);
 }
-function w(t) {
+function V(t) {
   return t.replace(/^.*[\\/]/, "");
 }
-function O(t) {
-  return w(g(t));
+function z(t) {
+  return V(C(t));
 }
-const N = -2147483648, d = -9007199254740991n, h = NaN, P = NaN, x = null, E = null;
-function a(t, n) {
+const F = -2147483648, g = -9007199254740991n, x = NaN, R = NaN, U = null, k = null;
+function d(t, n) {
   switch (n) {
     case "Int":
-      return t === N;
+      return t === F;
     case "Long":
-      return t === Number(d) || t === d;
+      return t === Number(g) || t === g;
     case "Float":
-      return t === h;
+      return t === x;
     case "Double":
-      return t === P;
+      return t === R;
     case "String":
-      return t === x;
+      return t === U;
     case "Bytes":
-      return t === E;
+      return t === k;
     default:
       throw Error(`unsupported data type: ${n}`);
   }
 }
-function _(t) {
-  if (!V(t)) throw new Error(`Expected not-NA PValue, got ${t}`);
+function q(t) {
+  if (!B(t)) throw new Error(`Expected not-NA PValue, got ${t}`);
   return t;
 }
-function V(t, n) {
+function B(t, n) {
   if (!n)
     return typeof t == "string" || typeof t == "number" && isFinite(t) || typeof t == "bigint";
-  if (a(t, n)) return !1;
+  if (d(t, n)) return !1;
   switch (n) {
     case "Int":
       return typeof t == "number";
@@ -72,10 +72,10 @@ function V(t, n) {
       throw Error(`unsupported data type: ${n}`);
   }
 }
-function I(t, n) {
+function S(t, n) {
   if (!n)
     return t === null || typeof t == "string" || typeof t == "number" || typeof t == "bigint";
-  if (a(t, n)) return !0;
+  if (d(t, n)) return !0;
   switch (n) {
     case "Int":
       return typeof t == "number";
@@ -93,14 +93,14 @@ function I(t, n) {
       throw Error(`unsupported data type: ${n}`);
   }
 }
-function j(t) {
+function v(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 A(t, n) {
+function D(t, n) {
   if (t === null || typeof t == "string" || typeof t == "number" || typeof t == "bigint") {
-    if (n && !a(t, n) && !I(t, n))
+    if (n && !d(t, n) && !S(t, n))
       throw new Error(`Unexpected value type, got ${typeof t}, expected ${n}`);
     return t;
   }
@@ -111,12 +111,12 @@ function A(t, n) {
   }
   throw new Error(`Unsupported type ${typeof t} (value ${t}).`);
 }
-function H(t) {
+function tt(t) {
   if (t = $(t), t === null) throw new Error("Value is null");
   return t;
 }
 function $(t) {
-  if (t = A(t), t === null) return null;
+  if (t = D(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})`);
@@ -126,16 +126,20 @@ function $(t) {
     return Number(t);
   throw new Error(`Unexpected value type: ${typeof t}`);
 }
-function k(t, n) {
-  const r = Math.floor(n / 8), e = 1 << 7 - n % 8;
-  return (t[r] & e) > 0;
+function L(t, n) {
+  const e = Math.floor(n / 8), r = 1 << 7 - n % 8;
+  return (t[e] & r) > 0;
+}
+const O = { type: "absent" }, H = null;
+function nt(t) {
+  return typeof t == "object" && t !== null && t.type === "absent";
 }
-const F = { type: "absent" }, C = null;
-function J(t, n) {
-  if (k(t.absent, n)) return F;
-  const r = t.data[n], e = t.type;
-  if (a(r, e)) return C;
-  switch (e) {
+function et(t, n, e = {}) {
+  if (L(t.absent, n))
+    return e.absent === void 0 ? O : e.absent;
+  const r = t.data[n], o = t.type;
+  if (d(r, o)) return e.na === void 0 ? H : e.na;
+  switch (o) {
     case "Int":
       return r;
     case "Long":
@@ -149,30 +153,30 @@ function J(t, n) {
     case "Bytes":
       throw Error("Bytes not yet supported");
     default:
-      throw Error(`unsupported data type: ${e}`);
+      throw Error(`unsupported data type: ${o}`);
   }
 }
-function S(t) {
-  const { type: n, name: r, domain: e } = t;
-  return { type: n, name: r, ...e && { domain: e } };
+function J(t) {
+  const { type: n, name: e, domain: r } = t;
+  return { type: n, name: e, ...r && { domain: r } };
 }
-function W(t) {
-  return t.map(S);
+function rt(t) {
+  return t.map(J);
 }
-function B(t, n) {
+function _(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;
+  for (const e in n)
+    if (t[e] !== n[e]) return !1;
   return !0;
 }
-function z(t, n) {
-  return t.name === n.name && B(t.domain, n.domain);
+function ot(t, n) {
+  return t.name === n.name && _(t.domain, n.domain);
 }
-function M(t, n) {
-  return { ...t, src: u(t.src, n) };
+function it(t, n) {
+  return { ...t, src: f(t.src, n) };
 }
-function u(t, n) {
+function f(t, n) {
   switch (t.type) {
     case "column":
       return {
@@ -183,148 +187,204 @@ function u(t, n) {
     case "full":
       return {
         type: t.type,
-        entries: t.entries.map((r) => u(r, n))
+        entries: t.entries.map((e) => f(e, n))
       };
     case "outer":
       return {
         type: "outer",
-        primary: u(t.primary, n),
-        secondary: t.secondary.map((r) => u(r, n))
+        primary: f(t.primary, n),
+        secondary: t.secondary.map((e) => f(e, n))
       };
     default:
-      f(t);
+      b(t);
   }
 }
-const q = { href: "/" }, G = s.object({
-  __isRef: s.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
-  blockId: s.string().describe("Upstream block id"),
-  name: s.string().describe("Name of the output provided to the upstream block's output context")
+const st = { href: "/" }, ut = 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")
 }).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 K(t, n) {
+function at(t, n) {
   return t.blockId === n.blockId && t.name === n.name;
 }
-function o(t) {
+function i(t) {
   return t.kind === "PColumn";
 }
-function U(t) {
-  return o(t.spec);
+function W(t) {
+  return i(t.spec);
 }
-function Q(t) {
-  return o(t.obj);
+function ct(t) {
+  return i(t.obj);
 }
-function X(t) {
-  return o(t.obj.spec);
+function ft(t) {
+  return i(t.obj.spec);
 }
-function Y(t) {
-  if (!U(t)) throw new Error(`not a PColumn (kind = ${t.spec.kind})`);
+function dt(t) {
+  if (!W(t)) throw new Error(`not a PColumn (kind = ${t.spec.kind})`);
   return t;
 }
-function Z(t, n) {
+function lt(t, n) {
   return t === void 0 ? void 0 : {
     ...t,
     data: n(t.data)
   };
 }
-function T(t) {
-  const n = /* @__PURE__ */ new Map(), r = (e) => {
-    switch (e.type) {
+function pt(t) {
+  const n = /* @__PURE__ */ new Map(), e = (r) => {
+    switch (r.type) {
       case "column":
-        n.set(e.column.id, e.column);
+        n.set(r.column.id, r.column);
         return;
       case "full":
       case "inner":
-        for (const i of e.entries) r(i);
+        for (const o of r.entries) e(o);
         return;
       case "outer":
-        r(e.primary);
-        for (const i of e.secondary) r(i);
+        e(r.primary);
+        for (const o of r.secondary) e(o);
         return;
       default:
-        f(e);
+        b(r);
     }
   };
-  return r(t), [...n.values()];
+  return e(t), [...n.values()];
 }
-function D(t) {
+function j(t) {
   throw new Error("Unexpected object: " + t);
 }
-function c(t, n) {
+function m(t, n) {
   switch (t.type) {
     case "and":
-      for (const r of t.operands)
-        if (!c(r, n)) return !1;
+      for (const e of t.operands)
+        if (!m(e, n)) return !1;
       return !0;
     case "or":
-      for (const r of t.operands)
-        if (c(r, n)) return !0;
+      for (const e of t.operands)
+        if (m(e, n)) return !0;
       return !1;
     case "not":
-      return !c(t.operand, n);
+      return !m(t.operand, n);
     case "name":
-      return o(n) && n.name === t.name;
+      return i(n) && n.name === t.name;
     case "name_pattern":
-      return o(n) && !!n.name.match(t.pattern);
+      return i(n) && !!n.name.match(t.pattern);
     case "annotation":
-      return o(n) && n.annotations !== void 0 && n.annotations[t.annotation] === t.value;
+      return i(n) && n.annotations !== void 0 && n.annotations[t.annotation] === t.value;
     case "annotation_pattern":
-      return o(n) && n.annotations !== void 0 && n.annotations[t.annotation] !== void 0 && !!n.annotations[t.annotation].match(t.pattern);
+      return i(n) && n.annotations !== void 0 && n.annotations[t.annotation] !== void 0 && !!n.annotations[t.annotation].match(t.pattern);
     case "has_axes":
-      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(
-            ([i, m]) => e.domain[i] === m
+      return i(n) && t.axes.every(
+        (e) => n.axesSpec.some(
+          (r) => (e.type === void 0 || e.type === r.type) && (e.name === void 0 || e.name === r.name) && (e.domain === void 0 || Object.keys(e.domain).length === 0 || r.domain !== void 0 && Object.entries(e.domain).every(
+            ([o, l]) => r.domain[o] === l
           ))
         )
       );
     default:
-      D(t);
+      j(t);
   }
 }
-function v(t, n) {
+function mt(t, n) {
   return t.ok ? { ok: !0, value: n(t.value) } : t;
 }
+function M(t) {
+  if (t instanceof Int8Array || t instanceof Uint8Array || t instanceof Uint8ClampedArray)
+    return new DataView(t.buffer, t.byteOffset, t.byteLength);
+  if (t instanceof ArrayBuffer) return new DataView(t);
+  throw new TypeError(
+    "Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray"
+  );
+}
+const K = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", X = "0123456789ABCDEFGHIJKLMNOPQRSTUV", G = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function P(t, n, e) {
+  e = e || {};
+  let r, o;
+  switch (n) {
+    case "RFC3548":
+    case "RFC4648":
+      r = K, o = !0;
+      break;
+    case "RFC4648-HEX":
+      r = X, o = !0;
+      break;
+    case "Crockford":
+      r = G, o = !1;
+      break;
+    default:
+      throw new Error("Unknown base32 variant: " + n);
+  }
+  const l = e.padding !== void 0 ? e.padding : o, y = M(t);
+  let s = 0, c = 0, u = "";
+  for (let p = 0; p < y.byteLength; p++)
+    for (c = c << 8 | y.getUint8(p), s += 8; s >= 5; )
+      u += r[c >>> s - 5 & 31], s -= 5;
+  if (s > 0 && (u += r[c << 5 - s & 31]), l)
+    for (; u.length % 8 !== 0; )
+      u += "=";
+  return u;
+}
+const N = 15, Q = 24, A = a.string().length(Q).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+function bt() {
+  const t = new Uint8Array(N);
+  return crypto.getRandomValues(t), A.parse(P(t, "RFC4648"));
+}
+function T(t) {
+  if (t.length !== N) throw new Error(`Wrong number of bytes: ${t.length}`);
+  return A.parse(P(t, "RFC4648"));
+}
+async function yt(t) {
+  const n = new TextEncoder(), e = await crypto.subtle.digest("SHA-256", n.encode(t));
+  return T(new Uint8Array(e.slice(0, 15)));
+}
 export {
-  q as DefaultNavigationState,
-  C as PTableNA,
-  F as PTableNull,
-  E as PValueBytesNA,
-  P as PValueDoubleNA,
-  h as PValueFloatNA,
-  N as PValueIntNA,
-  d as PValueLongNA,
-  x as PValueStringNA,
-  G as PlRef,
-  _ as ensureNotNAPValue,
-  Y as ensurePColumn,
-  c as executePSpecPredicate,
-  T as extractAllColumns,
-  W as getAxesId,
-  S as getAxisId,
-  O as getFileNameFromHandle,
-  g as getFilePathFromHandle,
-  y as isImportFileHandleIndex,
-  b as isImportFileHandleUpload,
-  R as isLiveLog,
-  V as isNotNAPValue,
-  U as isPColumn,
-  X as isPColumnResult,
-  o as isPColumnSpec,
-  Q as isPColumnSpecResult,
-  I as isPValue,
-  k as isValueAbsent,
-  a as isValueNA,
-  u as mapJoinEntry,
-  Z as mapPObjectData,
-  M as mapPTableDef,
-  v as mapValueInVOE,
-  z as matchAxisId,
-  J as pTableValue,
-  H as pValueToStringOrNumber,
+  st as DefaultNavigationState,
+  O as PTableAbsent,
+  H as PTableNA,
+  k as PValueBytesNA,
+  R as PValueDoubleNA,
+  x as PValueFloatNA,
+  F as PValueIntNA,
+  g as PValueLongNA,
+  U as PValueStringNA,
+  A as PlId,
+  N as PlIdBytes,
+  Q as PlIdLength,
+  ut as PlRef,
+  yt as digestPlId,
+  q as ensureNotNAPValue,
+  dt as ensurePColumn,
+  m as executePSpecPredicate,
+  pt as extractAllColumns,
+  rt as getAxesId,
+  J as getAxisId,
+  z as getFileNameFromHandle,
+  C as getFilePathFromHandle,
+  I as isImportFileHandleIndex,
+  E as isImportFileHandleUpload,
+  Z as isLiveLog,
+  B as isNotNAPValue,
+  W as isPColumn,
+  ft as isPColumnResult,
+  i as isPColumnSpec,
+  ct as isPColumnSpecResult,
+  nt as isPTableAbsent,
+  S as isPValue,
+  L as isValueAbsent,
+  d as isValueNA,
+  f as mapJoinEntry,
+  lt as mapPObjectData,
+  it as mapPTableDef,
+  mt as mapValueInVOE,
+  ot as matchAxisId,
+  et as pTableValue,
+  tt as pValueToStringOrNumber,
   $ as pValueToStringOrNumberOrNull,
-  K as plRefsEqual,
-  A as safeConvertToPValue,
-  j as toJsonSafePValue
+  T as plId,
+  at as plRefsEqual,
+  D as safeConvertToPValue,
+  v as toJsonSafePValue,
+  bt as uniquePlId
 };
 //# sourceMappingURL=index.mjs.map