@milaboratories/uikit 2.3.0 → 2.3.1

package/dist/lib/model/common/dist/index.js

@@ -1,51 +1,552 @@
-import t from "../../../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.js";
-t.object({
+import u from "../../../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.js";
+import y from "../../../../_virtual/canonicalize.js";
+var A = Object.defineProperty, O = (e, t, n) => t in e ? A(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, m = (e, t, n) => O(e, typeof t != "symbol" ? t + "" : t, n);
+u.object({
   /** Included left border. */
-  from: t.number(),
+  from: u.number(),
   /** Excluded right border. */
-  to: t.number()
+  to: u.number()
 });
-function i(e) {
+function g(e) {
   throw new Error("Unexpected object: " + e);
 }
-const n = "upload://upload/", o = "index://index/";
-function c(e) {
-  return e.startsWith(n);
+const P = "upload://upload/", k = "index://index/";
+function I(e) {
+  return e.startsWith(P);
 }
-function s(e) {
-  return e.startsWith(o);
+function S(e) {
+  return e.startsWith(k);
 }
-function l(e) {
-  if (s(e)) {
-    const r = e.slice(o.length);
-    return JSON.parse(decodeURIComponent(r)).path;
-  } else if (c(e)) {
-    const r = e.slice(n.length);
-    return JSON.parse(decodeURIComponent(r)).localPath;
+function J(e) {
+  if (S(e)) {
+    const t = e.slice(k.length);
+    return JSON.parse(decodeURIComponent(t)).path;
+  } else if (I(e)) {
+    const t = e.slice(P.length);
+    return JSON.parse(decodeURIComponent(t)).localPath;
   }
-  i(e);
+  g(e);
 }
-function a(e) {
+function j(e) {
   return e.replace(/^.*[\\/]/, "");
 }
-function p(e) {
-  return a(l(e));
+function M(e) {
+  return j(J(e));
 }
-t.object({
-  __isRef: t.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
-  blockId: t.string().describe("Upstream block id"),
-  name: t.string().describe("Name of the output provided to the upstream block's output context"),
-  requireEnrichments: t.literal(!0).optional().describe("True if current block that stores this reference in its args, may need enrichments for the references value originating from the blocks in between current and referenced block")
+function _(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = e;
+  if (!("type" in t))
+    return !1;
+  switch (t.type) {
+    case "Json":
+      return typeof t.keyLength == "number" && t.data !== void 0 && typeof t.data == "object";
+    case "JsonPartitioned":
+      return typeof t.partitionKeyLength == "number" && t.parts !== void 0 && typeof t.parts == "object";
+    case "BinaryPartitioned":
+      return typeof t.partitionKeyLength == "number" && t.parts !== void 0 && typeof t.parts == "object";
+    default:
+      return !1;
+  }
+}
+function U(e, t) {
+  if (e !== void 0)
+    switch (e.type) {
+      case "Json":
+        return e;
+      case "JsonPartitioned": {
+        const n = {};
+        for (const [r, o] of Object.entries(e.parts))
+          n[r] = t(o);
+        return {
+          ...e,
+          parts: n
+        };
+      }
+      case "BinaryPartitioned": {
+        const n = {};
+        for (const [r, o] of Object.entries(e.parts))
+          n[r] = {
+            index: t(o.index),
+            values: t(o.values)
+          };
+        return {
+          ...e,
+          parts: n
+        };
+      }
+    }
+}
+function E(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = e;
+  if (!("type" in t))
+    return !1;
+  switch (t.type) {
+    case "Json":
+      return typeof t.keyLength == "number" && Array.isArray(t.data);
+    case "JsonPartitioned":
+      return typeof t.partitionKeyLength == "number" && Array.isArray(t.parts);
+    case "BinaryPartitioned":
+      return typeof t.partitionKeyLength == "number" && Array.isArray(t.parts);
+    default:
+      return !1;
+  }
+}
+function H(e) {
+  return E(e) ? e.type === "JsonPartitioned" || e.type === "BinaryPartitioned" : !1;
+}
+function q(e) {
+  switch (e.type) {
+    case "Json": {
+      const t = Object.entries(e.data).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
+      return {
+        type: "Json",
+        keyLength: e.keyLength,
+        data: t
+      };
+    }
+    case "JsonPartitioned": {
+      const t = Object.entries(e.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
+      return {
+        type: "JsonPartitioned",
+        partitionKeyLength: e.partitionKeyLength,
+        parts: t
+      };
+    }
+    case "BinaryPartitioned": {
+      const t = Object.entries(e.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }));
+      return {
+        type: "BinaryPartitioned",
+        partitionKeyLength: e.partitionKeyLength,
+        parts: t
+      };
+    }
+  }
+}
+function V(e) {
+  switch (e.type) {
+    case "Json": {
+      const t = {};
+      for (const n of e.data)
+        t[JSON.stringify(n.key)] = n.value;
+      return {
+        type: "Json",
+        keyLength: e.keyLength,
+        data: t
+      };
+    }
+    case "JsonPartitioned": {
+      const t = {};
+      for (const n of e.parts)
+        t[JSON.stringify(n.key)] = n.value;
+      return {
+        type: "JsonPartitioned",
+        partitionKeyLength: e.partitionKeyLength,
+        parts: t
+      };
+    }
+    case "BinaryPartitioned": {
+      const t = {};
+      for (const n of e.parts)
+        t[JSON.stringify(n.key)] = n.value;
+      return {
+        type: "BinaryPartitioned",
+        partitionKeyLength: e.partitionKeyLength,
+        parts: t
+      };
+    }
+  }
+}
+function d(e) {
+  const { type: t, name: n, domain: r } = e, o = { type: t, name: n };
+  return r && Object.entries(r).length > 0 && Object.assign(o, { domain: r }), o;
+}
+function C(e) {
+  return e.map(d);
+}
+function W(e) {
+  return y(d(e));
+}
+function L(e, t) {
+  if (e === void 0) return t === void 0;
+  if (t === void 0) return !0;
+  for (const n in t)
+    if (e[n] !== t[n]) return !1;
+  return !0;
+}
+function $(e, t) {
+  return e.name === t.name && L(e.domain, t.domain);
+}
+function z(e, t) {
+  return { ...e, src: p(e.src, t) };
+}
+function p(e, t) {
+  switch (e.type) {
+    case "column":
+      return {
+        type: "column",
+        column: t(e.column)
+      };
+    case "slicedColumn":
+      return {
+        type: "slicedColumn",
+        column: t(e.column),
+        newId: e.newId,
+        axisFilters: e.axisFilters
+      };
+    case "inlineColumn":
+      return e;
+    case "inner":
+    case "full":
+      return {
+        type: e.type,
+        entries: e.entries.map((n) => p(n, t))
+      };
+    case "outer":
+      return {
+        type: "outer",
+        primary: p(e.primary, t),
+        secondary: e.secondary.map((n) => p(n, t))
+      };
+    default:
+      g(e);
+  }
+}
+function N(e) {
+  return y(e);
+}
+function x(e) {
+  return y(d(e));
+}
+function b(e, t) {
+  return JSON.stringify([e, t]);
+}
+class Y {
+  /**
+   * Creates a new anchor context from a set of anchor column specifications
+   * @param anchors Record of anchor column specifications indexed by anchor ID
+   */
+  constructor(t) {
+    m(this, "domains", /* @__PURE__ */ new Map()), m(this, "axes", /* @__PURE__ */ new Map()), m(this, "domainPacks", []), m(this, "domainPackToAnchor", /* @__PURE__ */ new Map()), this.anchors = t;
+    const n = Object.entries(t);
+    n.sort((r, o) => r[0].localeCompare(o[0]));
+    for (const [r, o] of n) {
+      for (let i = 0; i < o.axesSpec.length; i++) {
+        const a = o.axesSpec[i], s = x(a);
+        this.axes.set(s, { anchor: r, idx: i });
+      }
+      if (o.domain !== void 0) {
+        const i = Object.entries(o.domain);
+        i.sort((a, s) => a[0].localeCompare(s[0])), this.domainPackToAnchor.set(JSON.stringify(i), r), this.domainPacks.push(i.map(([a]) => a));
+        for (const [a, s] of i) {
+          const c = b(a, s);
+          this.domains.set(c, r);
+        }
+      }
+    }
+  }
+  /**
+   * Implementation of derive method
+   */
+  derive(t, n) {
+    const r = {
+      name: t.name,
+      axes: []
+    };
+    let o;
+    if (t.domain !== void 0)
+      e:
+        for (const a of this.domainPacks) {
+          const s = [];
+          for (const f of a) {
+            const l = t.domain[f];
+            if (l !== void 0)
+              s.push([f, l]);
+            else
+              break e;
+          }
+          const c = this.domainPackToAnchor.get(JSON.stringify(s));
+          if (c !== void 0) {
+            r.domainAnchor = c, o = new Set(a);
+            break;
+          }
+        }
+    for (const [a, s] of Object.entries(t.domain ?? {})) {
+      if (o !== void 0 && o.has(a))
+        continue;
+      const c = b(a, s), f = this.domains.get(c);
+      r.domain ?? (r.domain = {}), r.domain[a] = f ? { anchor: f } : s;
+    }
+    if (r.axes = t.axesSpec.map((a) => {
+      const s = x(a), c = this.axes.get(s);
+      return c === void 0 ? d(a) : c;
+    }), !n || n.length === 0)
+      return r;
+    const i = [];
+    for (const a of n) {
+      const [s, c] = a;
+      if (typeof s == "number") {
+        if (s < 0 || s >= t.axesSpec.length)
+          throw new Error(`Axis index ${s} is out of bounds (0-${t.axesSpec.length - 1})`);
+        i.push([s, c]);
+      } else {
+        const f = t.axesSpec.findIndex((l) => l.name === s);
+        if (f === -1)
+          throw new Error(`Axis with name "${s}" not found in the column specification`);
+        i.push([f, c]);
+      }
+    }
+    return i.sort((a, s) => a[0] - s[0]), {
+      source: r,
+      axisFilters: i
+    };
+  }
+  /**
+   * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column
+   * @param spec Column specification to anchor
+   * @param axisFilters Optional axis filters to apply to the column
+   * @returns A canonicalized string representation of the anchored column identifier
+   */
+  deriveS(t, n) {
+    return N(this.derive(t, n));
+  }
+}
+function Z(e, t, n) {
+  const r = { ...t }, o = (n == null ? void 0 : n.ignoreMissingDomains) ?? !1;
+  if (r.domainAnchor !== void 0) {
+    const i = e[r.domainAnchor];
+    if (!i)
+      throw new Error(`Anchor "${r.domainAnchor}" not found`);
+    const a = i.domain || {};
+    r.domain = { ...a, ...r.domain }, delete r.domainAnchor;
+  }
+  if (r.domain) {
+    const i = {};
+    for (const [a, s] of Object.entries(r.domain))
+      if (typeof s == "string")
+        i[a] = s;
+      else {
+        const c = e[s.anchor];
+        if (!c)
+          throw new Error(`Anchor "${s.anchor}" not found for domain key "${a}"`);
+        if (!c.domain || c.domain[a] === void 0) {
+          if (!o)
+            throw new Error(`Domain key "${a}" not found in anchor "${s.anchor}"`);
+          continue;
+        }
+        i[a] = c.domain[a];
+      }
+    r.domain = i;
+  }
+  return r.axes && (r.axes = r.axes.map((i) => K(e, i))), r;
+}
+function K(e, t) {
+  if (!D(t))
+    return t;
+  const n = t.anchor, r = e[n];
+  if (!r)
+    throw new Error(`Anchor "${n}" not found for axis reference`);
+  if ("idx" in t) {
+    if (t.idx < 0 || t.idx >= r.axesSpec.length)
+      throw new Error(`Axis index ${t.idx} out of bounds for anchor "${n}"`);
+    return r.axesSpec[t.idx];
+  } else if ("name" in t) {
+    const o = r.axesSpec.filter((i) => i.name === t.name);
+    if (o.length > 1)
+      throw new Error(`Multiple axes with name "${t.name}" found in anchor "${n}"`);
+    if (o.length === 0)
+      throw new Error(`Axis with name "${t.name}" not found in anchor "${n}"`);
+    return o[0];
+  } else if ("id" in t) {
+    const o = r.axesSpec.filter((i) => $(t.id, d(i)));
+    if (o.length > 1)
+      throw new Error(`Multiple matching axes found for matcher in anchor "${n}"`);
+    if (o.length === 0)
+      throw new Error(`No matching axis found for matcher in anchor "${n}"`);
+    return o[0];
+  }
+  throw new Error("Unsupported axis reference type");
+}
+function D(e) {
+  return typeof e == "object" && "anchor" in e;
+}
+function h(e) {
+  return e.kind === "PColumn";
+}
+function R(e) {
+  return h(e.spec);
+}
+function G(e) {
+  if (!R(e)) throw new Error(`not a PColumn (kind = ${e.spec.kind})`);
+  return e;
+}
+function Q(e, t) {
+  return e === void 0 ? void 0 : {
+    ...e,
+    data: t(e.data)
+  };
+}
+function X(e) {
+  const t = /* @__PURE__ */ new Map(), n = (r) => {
+    switch (r.type) {
+      case "column":
+        t.set(r.column.id, r.column);
+        return;
+      case "slicedColumn":
+        t.set(r.column.id, r.column);
+        return;
+      case "inlineColumn":
+        return;
+      case "full":
+      case "inner":
+        for (const o of r.entries) n(o);
+        return;
+      case "outer":
+        n(r.primary);
+        for (const o of r.secondary) n(o);
+        return;
+      default:
+        g(r);
+    }
+  };
+  return n(e), [...t.values()];
+}
+function v(e, t) {
+  if (e.name !== void 0 && e.name !== t.name)
+    return !1;
+  if (e.type !== void 0) {
+    if (Array.isArray(e.type)) {
+      if (!e.type.includes(t.type))
+        return !1;
+    } else if (e.type !== t.type)
+      return !1;
+  }
+  if (e.domain !== void 0) {
+    const n = t.domain || {};
+    for (const [r, o] of Object.entries(e.domain))
+      if (n[r] !== o)
+        return !1;
+  }
+  return !0;
+}
+function w(e, t) {
+  if (t.name !== void 0 && e.name !== t.name || t.namePattern !== void 0 && !new RegExp(t.namePattern).test(e.name))
+    return !1;
+  if (t.type !== void 0) {
+    if (Array.isArray(t.type)) {
+      if (!t.type.includes(e.valueType))
+        return !1;
+    } else if (t.type !== e.valueType)
+      return !1;
+  }
+  if (t.domain !== void 0) {
+    const n = e.domain || {};
+    for (const [r, o] of Object.entries(t.domain))
+      if (n[r] !== o)
+        return !1;
+  }
+  if (t.axes !== void 0) {
+    const n = e.axesSpec.map(d);
+    if (t.partialAxesMatch) {
+      for (const r of t.axes)
+        if (!n.some((o) => v(r, o)))
+          return !1;
+    } else {
+      if (n.length !== t.axes.length)
+        return !1;
+      for (let r = 0; r < t.axes.length; r++)
+        if (!v(t.axes[r], n[r]))
+          return !1;
+    }
+  }
+  if (t.annotations !== void 0) {
+    const n = e.annotations || {};
+    for (const [r, o] of Object.entries(t.annotations))
+      if (n[r] !== o)
+        return !1;
+  }
+  if (t.annotationPatterns !== void 0) {
+    const n = e.annotations || {};
+    for (const [r, o] of Object.entries(t.annotationPatterns)) {
+      const i = n[r];
+      if (i === void 0 || !new RegExp(o).test(i))
+        return !1;
+    }
+  }
+  return !0;
+}
+function ee(e) {
+  return Array.isArray(e) ? (t) => e.some((n) => h(t) && w(t, n)) : (t) => h(t) && w(t, e);
+}
+function te(e) {
+  const t = {
+    kind: e.kind,
+    name: e.name
+  };
+  return e.domain !== void 0 && (t.domain = e.domain), h(e) && (t.axesSpec = C(e.axesSpec)), y(t);
+}
+u.object({
+  __isRef: u.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
+  blockId: u.string().describe("Upstream block id"),
+  name: u.string().describe("Name of the output provided to the upstream block's output context"),
+  requireEnrichments: u.literal(!0).optional().describe("True if current block that stores this reference in its args, may need enrichments for the references value originating from the blocks in between current and referenced block")
 }).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."
 ).readonly();
-const d = 24;
-t.string().length(d).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+function ne(e) {
+  return typeof e == "object" && e !== null && "__isRef" in e && e.__isRef === !0 && "blockId" in e && "name" in e;
+}
+function re(e, t = !0) {
+  if (t)
+    return {
+      ...e,
+      requireEnrichments: !0
+    };
+  {
+    const { requireEnrichments: n, ...r } = e;
+    return r;
+  }
+}
+function oe(e, t) {
+  return e.ok ? { ok: !0, value: t(e.value) } : e;
+}
+const T = 24;
+u.string().length(T).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
 export {
-  d as PlIdLength,
-  p as getFileNameFromHandle,
-  l as getFilePathFromHandle,
-  s as isImportFileHandleIndex,
-  c as isImportFileHandleUpload
+  Y as AnchoredIdDeriver,
+  T as PlIdLength,
+  W as canonicalizeAxisId,
+  q as dataInfoToEntries,
+  te as deriveNativeId,
+  G as ensurePColumn,
+  V as entriesToDataInfo,
+  X as extractAllColumns,
+  C as getAxesId,
+  d as getAxisId,
+  M as getFileNameFromHandle,
+  J as getFilePathFromHandle,
+  _ as isDataInfo,
+  E as isDataInfoEntries,
+  S as isImportFileHandleIndex,
+  I as isImportFileHandleUpload,
+  R as isPColumn,
+  h as isPColumnSpec,
+  H as isPartitionedDataInfoEntries,
+  ne as isPlRef,
+  U as mapDataInfo,
+  p as mapJoinEntry,
+  Q as mapPObjectData,
+  z as mapPTableDef,
+  oe as mapValueInVOE,
+  v as matchAxis,
+  $ as matchAxisId,
+  w as matchPColumn,
+  Z as resolveAnchors,
+  ee as selectorsToPredicate,
+  N as stringifyColumnId,
+  re as withEnrichments
 };
 //# sourceMappingURL=index.js.map