@code0-tech/pictor 0.0.0-mvp.2

package/dist/components/d-flow/input/DFlowInputDataType.js

@@ -0,0 +1,422 @@
+import { jsxs as R, jsx as c, Fragment as q } from "react/jsx-runtime";
+import { c as Me } from "../../../compiler-runtime-BNHg76kC.js";
+import y from "react";
+import { DataTypeRulesVariant as S, DataTypeVariant as de } from "@code0-tech/sagittarius-graphql-types";
+import { InputMessage as ke } from "../../form/InputMessage.js";
+import { TextInput as z } from "../../form/TextInput.js";
+import { Button as oe } from "../../button/Button.js";
+import { IconSettings as ge, IconTrash as Ee } from "@tabler/icons-react";
+import { Text as w } from "../../text/Text.js";
+import { Flex as X } from "../../flex/Flex.js";
+import { Badge as Ve } from "../../badge/Badge.js";
+import { InputLabel as Oe } from "../../form/InputLabel.js";
+import { useSuggestions as Be } from "../suggestion/DFlowSuggestion.hook.js";
+import { DFlowSuggestionMenuFooter as he } from "../suggestion/DFlowSuggestionMenuFooter.js";
+import { toInputSuggestions as Ke } from "../suggestion/DFlowSuggestionMenu.util.js";
+import { DFlowSuggestionType as we } from "../suggestion/DFlowSuggestion.view.js";
+import { Menu as Ae, MenuTrigger as Fe, MenuPortal as Ge } from "../../menu/Menu.js";
+import { InputSuggestionMenuContent as xe, InputSuggestionMenuContentItems as ze } from "../../form/InputSuggestion.js";
+import '../../../assets/DFlowInputDataType.css';const Ce = /* @__PURE__ */ new Set([S.ItemOfCollection, S.Regex, S.NumberRange]), Ie = "__blockingSignature", Je = [S.ContainsKey, S.ContainsType, S.ItemOfCollection, S.NumberRange, S.Regex], ue = (n) => {
+  const {
+    formValidation: e,
+    initialValue: t,
+    onDataTypeChange: p = () => {
+    },
+    blockingDataType: a
+  } = n, m = y.useMemo(() => Ne(t, a), [t, a]), [s, u] = y.useState(m), T = y.useMemo(() => J(s), [s]), l = y.useMemo(() => J(a), [a]), B = y.useMemo(() => new Map((_(s) ? s.genericMappers ?? [] : []).map((r) => [r.target ?? "", r])), [s]), I = y.useMemo(() => l?.rules?.nodes?.filter(Boolean), [l]), N = y.useCallback((r) => {
+    u((o) => {
+      if (!o) return o;
+      const i = W(o);
+      return r(i), p(i), $e(o, i), i;
+    });
+  }, []), D = y.useCallback((r, o, i) => {
+    N((b) => {
+      const h = J(b);
+      if (!h) return;
+      const M = ae(h), v = M[r];
+      if (!v) return;
+      const f = be(v, l);
+      if (f && !i?.allowBlocked) return;
+      const g = o(W(v));
+      g !== void 0 && (f && (ce(g, f), se(g, f)), M[r] = g);
+    });
+  }, [l, N]), K = y.useCallback((r) => {
+    N((o) => {
+      const i = J(o);
+      if (!i) return;
+      const b = ae(i), h = b[r];
+      h && (He(h, l) || b.splice(r, 1));
+    });
+  }, [l, N]), d = y.useCallback((r, o) => {
+    D(r, (i) => (!("dataTypeIdentifier" in i?.config) || !i?.config?.dataTypeIdentifier || (P(o) ? (i.config.dataTypeIdentifier.dataType = o, delete i.config.dataTypeIdentifier.genericType) : _(o) && (i.config.dataTypeIdentifier.genericType = o, delete i.config.dataTypeIdentifier.dataType)), i), {
+      allowBlocked: !0
+    });
+  }, [D]), V = y.useCallback((r, o, i) => {
+    N((b) => {
+      if (!_(b)) return;
+      const h = b.genericMappers ?? [], M = h.findIndex((g) => g.target === r);
+      if (M === -1) return;
+      const v = h[M], f = v?.sourceDataTypeIdentifiers ?? [];
+      f[o] && (P(i) ? (f[o].dataType = i, delete f[o].genericType) : _(i) && (f[o].genericType = i, delete f[o].dataType), v.sourceDataTypeIdentifiers = f, b.genericMappers = [...h], b.genericMappers[M] = v);
+    });
+  }, [N]);
+  return /* @__PURE__ */ R("div", { children: [
+    /* @__PURE__ */ R("div", { className: "d-flow-viewport-data-type-input", children: [
+      T?.rules?.nodes?.map((r, o) => {
+        if (!r) return null;
+        const i = I?.find((f) => fe(r, f)), b = r?.variant === "PARENT_TYPE", h = r?.config, M = (h?.dataTypeIdentifier?.dataType?.rules?.nodes?.length ?? 0) > 0 || (h?.dataTypeIdentifier?.genericType?.dataType?.rules?.nodes?.length ?? 0) > 0;
+        return !b || M ? /* @__PURE__ */ c(_e, { rule: r, blockingRule: i, genericMap: B, onRemove: () => K(o), onConfigChange: (f) => D(o, (g) => (g.config = f, g)), onHeaderKeyChange: (f) => D(o, (g) => (g.config || (g.config = {}), g.config.key = f || null, g)), onHeaderDataTypeChange: (f) => D(o, (g) => {
+          g.config || (g.config = {}), "dataTypeIdentifier" in g.config || (g.config.dataTypeIdentifier = {});
+          const k = g.config.dataTypeIdentifier;
+          return f ? (P(f) ? (k.dataType = f, delete k.genericType) : _(f) && (k.genericType = f, delete k.dataType), g) : (delete k?.dataType, delete k?.genericType, g);
+        }), onNestedChange: (f) => d(o, f), onGenericMapperChange: V }, `${r.variant}-${o}`) : null;
+      }),
+      /* @__PURE__ */ R(Ae, { children: [
+        /* @__PURE__ */ c(Fe, { asChild: !0, children: /* @__PURE__ */ R(oe, { color: "primary", children: [
+          /* @__PURE__ */ c(ge, { size: 16 }),
+          " Add new rule"
+        ] }) }),
+        /* @__PURE__ */ c(Ge, { children: /* @__PURE__ */ R(xe, { children: [
+          /* @__PURE__ */ c(ze, { onSuggestionSelect: (r) => {
+            N((o) => {
+              "rules" in o ? o?.rules?.nodes?.push(r.value) : "dataType" in o?.genericType && o?.genericType?.dataType?.rules?.nodes?.push(r.value);
+            });
+          }, suggestions: Je.filter((r) => T?.variant == de.Object ? r == S.ContainsKey : T?.variant == de.Array ? r == S.ContainsType : !(r == S.ContainsType || r == S.ContainsKey)).map((r) => ({
+            children: /* @__PURE__ */ R(q, { children: [
+              /* @__PURE__ */ c(ge, { size: 16 }),
+              /* @__PURE__ */ c(w, { children: r })
+            ] }),
+            value: {
+              variant: r,
+              config: {
+                __typename: `DataTypeRules${r[0]}Config`,
+                ...r === S.NumberRange ? {
+                  from: void 0,
+                  to: void 0,
+                  steps: void 0
+                } : {},
+                ...r === S.Regex ? {
+                  pattern: void 0
+                } : {},
+                ...r === S.ItemOfCollection ? {
+                  items: void 0
+                } : {}
+              }
+            }
+          })) }),
+          /* @__PURE__ */ c(he, {})
+        ] }) })
+      ] })
+    ] }),
+    !e?.valid && e?.notValidMessage && /* @__PURE__ */ c(ke, { children: e.notValidMessage })
+  ] });
+}, _e = (n) => {
+  const e = Me.c(56), {
+    rule: t,
+    blockingRule: p,
+    genericMap: a,
+    onRemove: m,
+    onConfigChange: s,
+    onHeaderKeyChange: u,
+    onHeaderDataTypeChange: T,
+    onNestedChange: l,
+    onGenericMapperChange: B
+  } = n, I = t?.config?.dataTypeIdentifier ?? void 0, N = !!I?.genericKey, [D, K] = y.useState(!1), d = !!p, V = t.variant, r = V ? !Ce.has(V) : !1;
+  let o;
+  e[0] !== t.config ? (o = () => ye(t?.config), e[0] = t.config, e[1] = o) : o = e[1];
+  const [i, b] = y.useState(o);
+  let h;
+  e[2] !== t.config ? (h = () => {
+    b(ye(t?.config));
+  }, e[2] = t.config, e[3] = h) : h = e[3];
+  let M;
+  e[4] !== t ? (M = [t], e[4] = t, e[5] = M) : M = e[5], y.useEffect(h, M);
+  let v;
+  e: {
+    if (!r) {
+      v = void 0;
+      break e;
+    }
+    if (!I) {
+      v = void 0;
+      break e;
+    }
+    if (I.genericKey) {
+      let C;
+      e[6] !== a || e[7] !== I.genericKey ? (C = a.get(I.genericKey), e[6] = a, e[7] = I.genericKey, e[8] = C) : C = e[8];
+      const O = C?.sourceDataTypeIdentifiers?.[0];
+      v = O?.dataType?.name?.nodes?.[0]?.content ?? O?.genericType?.dataType?.name?.nodes?.[0]?.content;
+      break e;
+    }
+    v = I.dataType?.name?.nodes?.[0]?.content ?? I.genericType?.dataType?.name?.nodes?.[0]?.content;
+  }
+  const f = v;
+  let g;
+  e[9] === Symbol.for("react.memo_cache_sentinel") ? (g = (C) => {
+    const E = C.target.value;
+    b(E);
+  }, e[9] = g) : g = e[9];
+  const k = g;
+  let $;
+  e[10] !== i || e[11] !== d || e[12] !== s || e[13] !== t.config || e[14] !== V ? ($ = (C) => {
+    if (d)
+      return;
+    const E = C?.target?.name, O = Pe(i, t.config, {
+      variant: V,
+      numberRangeKey: E
+    });
+    O && s(O);
+  }, e[10] = i, e[11] = d, e[12] = s, e[13] = t.config, e[14] = V, e[15] = $) : $ = e[15];
+  const A = $;
+  let H;
+  e[16] !== t ? (H = Te(t), e[16] = t, e[17] = H) : H = e[17];
+  const F = H;
+  let j;
+  e[18] !== p ? (j = Te(p), e[18] = p, e[19] = j) : j = e[19];
+  const Q = j;
+  let Y;
+  e[20] !== f || e[21] !== a || e[22] !== N || e[23] !== I || e[24] !== d || e[25] !== D || e[26] !== Q || e[27] !== F || e[28] !== B || e[29] !== T || e[30] !== u || e[31] !== l || e[32] !== m || e[33] !== t ? (Y = () => {
+    if (!F && !N)
+      return null;
+    const C = /* @__PURE__ */ c(pe, { rule: t, genericMap: a, isBlocked: d, dataTypeLabel: f, onClick: () => K(je), onRemove: d ? void 0 : m, onKeyChange: d ? void 0 : u, onDataTypeChange: d ? void 0 : T });
+    if (F)
+      return /* @__PURE__ */ R(q, { children: [
+        C,
+        D ? /* @__PURE__ */ c(ue, { initialValue: F, blockingDataType: Q, onDataTypeChange: l }) : null
+      ] });
+    if (I?.genericKey) {
+      const E = a.get(I.genericKey);
+      return /* @__PURE__ */ R(q, { children: [
+        C,
+        D ? E?.sourceDataTypeIdentifiers?.map((O, le) => {
+          const ie = O?.dataType ?? O?.genericType;
+          if (!ie)
+            return null;
+          const ve = d ? ie : void 0, re = I.genericKey;
+          return re ? /* @__PURE__ */ c(ue, { initialValue: ie, blockingDataType: ve, onDataTypeChange: (De) => B(re, le, De) }, `${re}-${le}`) : null;
+        }) : null
+      ] });
+    }
+    return null;
+  }, e[20] = f, e[21] = a, e[22] = N, e[23] = I, e[24] = d, e[25] = D, e[26] = Q, e[27] = F, e[28] = B, e[29] = T, e[30] = u, e[31] = l, e[32] = m, e[33] = t, e[34] = Y) : Y = e[34];
+  const Z = Y;
+  if (r && (F || N)) {
+    let C;
+    e[35] !== Z ? (C = Z(), e[35] = Z, e[36] = C) : C = e[36];
+    let E;
+    return e[37] !== C ? (E = /* @__PURE__ */ c("div", { className: "d-flow-viewport-data-type-input__rule", children: C }), e[37] = C, e[38] = E) : E = e[38], E;
+  }
+  let L;
+  e[39] === Symbol.for("react.memo_cache_sentinel") ? (L = {
+    flex: 1
+  }, e[39] = L) : L = e[39];
+  const ee = d ? void 0 : m, ne = d ? void 0 : u, te = d ? void 0 : T;
+  let G;
+  e[40] !== f || e[41] !== a || e[42] !== d || e[43] !== t || e[44] !== ee || e[45] !== ne || e[46] !== te ? (G = /* @__PURE__ */ c(pe, { rule: t, genericMap: a, isBlocked: d, dataTypeLabel: f, onRemove: ee, onKeyChange: ne, onDataTypeChange: te }), e[40] = f, e[41] = a, e[42] = d, e[43] = t, e[44] = ee, e[45] = ne, e[46] = te, e[47] = G) : G = e[47];
+  let x;
+  e[48] !== i || e[49] !== A || e[50] !== d || e[51] !== t.variant ? (x = t.variant === "REGEX" || t.variant === "ITEM_OF_COLLECTION" ? /* @__PURE__ */ c(z, { clearable: !0, left: /* @__PURE__ */ c(w, { size: "sm", children: t.variant === "REGEX" ? "Pattern" : "Items" }), leftType: "icon", defaultValue: i, onChange: k, onBlur: A, w: "100%", disabled: d }) : t.variant === "NUMBER_RANGE" ? /* @__PURE__ */ R(q, { children: [
+    /* @__PURE__ */ c(z, { clearable: !0, defaultValue: i?.from?.toString() ?? "", onChange: k, onBlur: A, w: "100%", left: /* @__PURE__ */ c(w, { size: "sm", children: "From" }), leftType: "icon", disabled: d, name: "from" }),
+    /* @__PURE__ */ c(z, { clearable: !0, defaultValue: i?.steps?.toString() ?? "", onChange: k, onBlur: A, left: /* @__PURE__ */ c(w, { size: "sm", children: "Steps" }), leftType: "icon", w: "100%", disabled: d, name: "steps" }),
+    /* @__PURE__ */ c(z, { clearable: !0, left: /* @__PURE__ */ c(w, { size: "sm", children: "To" }), leftType: "icon", defaultValue: i?.to?.toString() ?? "", onChange: k, onBlur: A, w: "100%", disabled: d, name: "to" })
+  ] }) : null, e[48] = i, e[49] = A, e[50] = d, e[51] = t.variant, e[52] = x) : x = e[52];
+  let U;
+  return e[53] !== G || e[54] !== x ? (U = /* @__PURE__ */ c("div", { className: "d-flow-viewport-data-type-input__rule", children: /* @__PURE__ */ R("div", { style: L, children: [
+    G,
+    x
+  ] }) }), e[53] = G, e[54] = x, e[55] = U) : U = e[55], U;
+}, pe = ({
+  rule: n,
+  dataTypeLabel: e,
+  onClick: t,
+  onRemove: p,
+  isBlocked: a,
+  onKeyChange: m,
+  onDataTypeChange: s,
+  genericMap: u
+}) => {
+  const T = n.variant, l = T ? !Ce.has(T) : !1, B = l ? Be({
+    dataType: {
+      id: "gid://sagittarius/DataType/878634678"
+    }
+  }, [], "", 0, [0], 1, [we.DATA_TYPE]) : [], I = n?.config?.dataTypeIdentifier?.dataType?.rules?.nodes?.length ?? n?.config?.dataTypeIdentifier?.genericType?.dataType?.rules?.nodes?.length ?? u.get(n?.config?.dataTypeIdentifier?.genericKey)?.sourceDataTypeIdentifiers?.map((i) => i?.dataType?.rules?.nodes?.length ?? i.genericType?.dataType?.rules?.nodes?.length) ?? 0, [N, D] = y.useState(() => "key" in (n?.config ?? {}) ? n?.config?.key ?? "" : ""), [K, d] = y.useState(() => e ?? "");
+  y.useEffect(() => {
+    D("key" in (n?.config ?? {}) ? n?.config?.key ?? "" : "");
+  }, [n]), y.useEffect(() => {
+    d(e ?? "");
+  }, [e]);
+  const V = y.useCallback(() => {
+    !m || a || m(N);
+  }, [a, N, m]), r = y.useCallback(() => {
+    !s || a || K.trim() === "" && s(void 0);
+  }, [K, a, s]), o = y.useCallback((i) => {
+    if (!s || a) return;
+    const b = i.value;
+    if (!b) return;
+    s(b);
+    const h = i?.ref?.displayText?.join(" ") ?? e ?? "";
+    d(h);
+  }, [e, a, s]);
+  return /* @__PURE__ */ R("div", { children: [
+    /* @__PURE__ */ R(X, { justify: "space-between", children: [
+      /* @__PURE__ */ c(Ve, { color: "info", children: n?.variant }),
+      p ? /* @__PURE__ */ c(oe, { color: "error", onClick: p, children: /* @__PURE__ */ c(Ee, { size: 16 }) }) : null
+    ] }),
+    /* @__PURE__ */ R(X, { mt: 0.7, style: {
+      flexDirection: "column",
+      gap: ".7rem"
+    }, children: [
+      l ? /* @__PURE__ */ R(X, { align: "center", style: {
+        gap: ".7rem"
+      }, children: [
+        n.variant === "CONTAINS_KEY" ? /* @__PURE__ */ c(z, { left: /* @__PURE__ */ c(w, { size: "sm", children: "Key" }), leftType: "icon", disabled: a, defaultValue: N, onChange: (i) => "value" in i.target && D(i.target.value), onBlur: V }) : null,
+        /* @__PURE__ */ c(z, { left: /* @__PURE__ */ c(w, { size: "sm", children: "DataType" }), leftType: "icon", disabled: a, suggestionsFooter: /* @__PURE__ */ c(he, {}), suggestions: Ke(B), value: K, onChange: (i) => "value" in i.target && d(i.target.value), onBlur: r, onSuggestionSelect: o })
+      ] }) : null,
+      n.variant != "REGEX" && n.variant != "ITEM_OF_COLLECTION" && n.variant != "NUMBER_RANGE" ? /* @__PURE__ */ c(Oe, { children: /* @__PURE__ */ R(X, { align: "center", style: {
+        gap: ".7rem"
+      }, children: [
+        "+",
+        I,
+        " rules included",
+        /* @__PURE__ */ c(oe, { color: "primary", onClick: t, children: "Show/Hide Rules" })
+      ] }) }) : null
+    ] })
+  ] });
+}, ye = (n) => n ? "pattern" in n || n?.__typename === "DataTypeRulesRegexConfig" ? n?.pattern ?? "" : "items" in n || n?.__typename === "DataTypeRulesItemOfCollectionConfig" ? JSON.stringify(n.items) : n : "", Pe = (n, e, t) => {
+  const {
+    variant: p,
+    numberRangeKey: a
+  } = t ?? {}, m = p === S.NumberRange, s = e ?? void 0;
+  if (m) {
+    const u = {
+      __typename: "DataTypeRulesNumberRangeConfig",
+      ...s
+    };
+    if (typeof n != "string")
+      return {
+        ...u,
+        ...n
+      };
+    if (!a)
+      return u;
+    const T = {
+      ...u
+    };
+    switch (a) {
+      case "from":
+        T.from = (() => {
+          if (n.trim() === "") return;
+          const l = Number(n);
+          return Number.isFinite(l) ? l : u.from;
+        })();
+        break;
+      case "steps":
+        T.steps = (() => {
+          if (n.trim() === "") return;
+          const l = Number(n);
+          return Number.isFinite(l) ? l : u.steps;
+        })();
+        break;
+      case "to":
+        T.to = (() => {
+          if (n.trim() === "") return;
+          const l = Number(n);
+          return Number.isFinite(l) ? l : u.to;
+        })();
+        break;
+    }
+    return T;
+  }
+  if (!s) {
+    if (typeof n != "string")
+      return n;
+    try {
+      return JSON.parse(n);
+    } catch {
+      return;
+    }
+  }
+  if (typeof n != "string")
+    return n;
+  if (s.__typename === "DataTypeRulesRegexConfig" || "pattern" in s)
+    return {
+      ...s,
+      pattern: n
+    };
+  if (s.__typename === "DataTypeRulesItemOfCollectionConfig" || "items" in s)
+    try {
+      return {
+        ...s,
+        items: JSON.parse(n)
+      };
+    } catch {
+      return s;
+    }
+  try {
+    return JSON.parse(n);
+  } catch {
+    return s;
+  }
+}, W = (n) => n == null ? n : JSON.parse(JSON.stringify(n)), me = (n) => {
+  if (n)
+    return JSON.stringify(n);
+}, Te = (n) => {
+  if (n?.config?.dataTypeIdentifier)
+    return n?.config?.dataTypeIdentifier?.dataType ?? n?.config?.dataTypeIdentifier?.genericType ?? void 0;
+}, $e = (n, e) => me(n) === me(e), He = (n, e) => !n || !e?.rules?.nodes || !Se(n) ? !1 : !!be(n, e), be = (n, e) => !n || !e?.rules?.nodes ? void 0 : e.rules.nodes?.filter(Boolean).find((p) => fe(n, p)), P = (n) => n != null && n.rules !== void 0, _ = (n) => n != null && typeof n == "object" && "genericMappers" in n, J = (n) => {
+  if (n)
+    return P(n) ? n : n.dataType ?? void 0;
+}, ae = (n) => (n.rules ? n.rules.nodes || (n.rules.nodes = []) : n.rules = {
+  nodes: []
+}, n.rules.nodes), Ne = (n, e) => {
+  if (!n && !e) return;
+  const t = W(n ?? e), p = J(t), a = J(e);
+  if (!p || !a)
+    return t;
+  const m = ae(p);
+  return a.rules?.nodes?.filter(Boolean)?.forEach((u) => {
+    if (!u) return;
+    const T = m.findIndex((l) => fe(l, u));
+    if (T === -1) {
+      const l = W(u);
+      ce(l, u), m.push(l), se(l, u);
+    } else {
+      const l = m[T];
+      ce(l, u), se(l, u);
+    }
+  }), t;
+}, se = (n, e) => {
+  const t = n?.config?.dataTypeIdentifier, p = e?.config?.dataTypeIdentifier;
+  if (!t || !p) return;
+  const a = t.dataType ?? t.genericType, m = p.dataType ?? p.genericType;
+  if (!a || !m) return;
+  const s = Ne(a, m);
+  s && (P(s) ? t.dataType = s : t.genericType = s);
+}, fe = (n, e) => {
+  if (!n || !e) return !1;
+  const t = Se(n), p = Re(e);
+  return t && p ? t === p : n.id && e.id ? n.id === e.id : JSON.stringify({
+    variant: n.variant,
+    config: n.config
+  }) === JSON.stringify({
+    variant: e.variant,
+    config: e.config
+  });
+}, Se = (n) => {
+  if (n)
+    return n?.[Ie];
+}, Re = (n) => {
+  if (n)
+    return n.id ? `id:${n.id}` : `config:${JSON.stringify({
+      variant: n.variant,
+      config: n.config
+    })}`;
+}, ce = (n, e) => {
+  const t = Re(e);
+  t && (n[Ie] = t);
+};
+function je(n) {
+  return !n;
+}
+export {
+  ue as DFlowInputDataType
+};

package/dist/components/d-flow/minimap/DFlowMiniMap.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const DFlowMiniMap: React.FC;

package/dist/components/d-flow/minimap/DFlowMiniMap.js

@@ -0,0 +1,21 @@
+import { jsx as l } from "react/jsx-runtime";
+import { c as m } from "../../../compiler-runtime-BNHg76kC.js";
+import { useNodes as h, MiniMap as s } from "@xyflow/react";
+import { FLOW_EDGE_RAINBOW as d } from "../DFlow.edges.hook.js";
+import '../../../assets/DFlowMiniMap.css';const w = (c) => {
+  const e = m.c(2), o = h();
+  let i;
+  return e[0] !== o ? (i = /* @__PURE__ */ l(s, { offsetScale: 0, pannable: !0, zoomable: !0, className: "d-flow-viewport-mini-map", nodeComponent: (t) => {
+    const r = o.find((n) => n.id === t.id);
+    if (!r || r.type == "suggestion")
+      return null;
+    if (r.type == "group") {
+      const n = r.data?.depth ?? 0, a = d[n % d.length];
+      return /* @__PURE__ */ l("rect", { width: t.width, height: t.height, rx: 50, ry: 50, fill: a, fillOpacity: 0.05, stroke: a, strokeWidth: 2, "stroke-dasharray": "20", className: "d-flow-viewport-mini-map__group", x: t.x, y: t.y });
+    }
+    return /* @__PURE__ */ l("rect", { width: t.width, height: t.height, x: t.x, rx: 25, ry: 25, fill: "rgb(28.2, 25.5, 43.5)", y: t.y });
+  } }), e[0] = o, e[1] = i) : i = e[1], i;
+};
+export {
+  w as DFlowMiniMap
+};

package/dist/components/d-flow/minimap/index.d.ts

@@ -0,0 +1 @@
+export * from './DFlowMiniMap';

package/dist/components/d-flow/minimap/index.js

@@ -0,0 +1,4 @@
+import { DFlowMiniMap as p } from "./DFlowMiniMap.js";
+export {
+  p as DFlowMiniMap
+};

package/dist/components/d-flow/suggestion/DFlowSuggestion.hook.d.ts

@@ -0,0 +1,33 @@
+import { DFlowSuggestion, DFlowSuggestionType } from './DFlowSuggestion.view';
+import { DataTypeIdentifier, Flow, ReferenceValue } from '@code0-tech/sagittarius-graphql-types';
+export declare const useSuggestions: (type: DataTypeIdentifier | undefined, genericKeys: string[] | undefined, flowId: Flow["id"], depth?: number, scope?: number[], node?: number, suggestionTypes?: DFlowSuggestionType[]) => DFlowSuggestion[];
+/**
+ * React hook that produces a stable MD5 hash for a given Type, deeply resolving:
+ * - All type aliases (via DFlowDataTypeReactiveService) at any level of nesting
+ * - All occurrences of any provided generic_keys (can be any string) as "GENERIC"
+ * - All generic_mapper/type fields, rules/config.type fields, and parent fields, recursively
+ * - All object keys sorted for stable, order-independent hashing
+ *
+ * This ensures semantically equivalent types—regardless of alias, generic key naming, or structural nesting—
+ * always produce the same hash, making this suitable for caching, deduplication, and fast comparison.
+ *
+ * @param type          The Type to hash (either a string or a GenericType object)
+ * @param generic_keys  (optional) Array of string keys that should be normalized as generics (can be any string)
+ * @returns             MD5 hash string if type/service available, otherwise undefined
+ */
+export declare const useTypeHash: (type: DataTypeIdentifier, generic_keys?: string[]) => string | undefined;
+/**
+ * Walks the flow starting at its startingNode (depth-first, left-to-right) and collects
+ * all RefObjects (variables/outputs) with contextual metadata:
+ *  - depth: nesting level (root 0; +1 per NODE-parameter sub-block)
+ *  - scope: PATH of scope ids as number[], e.g. [0], [0,1], [0,2], [0,2,3] ...
+ *           (root is [0]; each NODE-parameter group appends a new unique id)
+ *  - node:  GLOBAL visit index across the entire flow (1-based, strictly increasing)
+ *
+ * Notes:
+ *  - A NODE-typed parameter opens a new group/lane: depth+1 and scopePath+[newId].
+ *  - Functions passed as non-NODE parameters are traversed in the SAME depth/scopePath.
+ *  - The `node` id is incremented globally for every visited node and shared by all
+ *    RefObjects (inputs from rules and the return value) produced by that node.
+ */
+export declare const useRefObjects: (flowId: Flow["id"]) => Array<ReferenceValue>;

package/dist/components/d-flow/suggestion/DFlowSuggestion.hook.js

@@ -0,0 +1,151 @@
+import { c as J } from "../../../compiler-runtime-BNHg76kC.js";
+import { useService as I } from "../../../utils/contextStore.js";
+import { DFlowReactiveSuggestionService as G } from "./DFlowSuggestion.service.js";
+import { D as b } from "../../../DFlowDataType.service-Dz8pQUeO.js";
+import { md5 as H } from "js-md5";
+import { DFlowSuggestionType as f, DFlowSuggestion as h } from "./DFlowSuggestion.view.js";
+import { DFlowFunctionReactiveService as L } from "../function/DFlowFunction.service.js";
+import { replaceGenericsAndSortType as R, resolveType as O, isMatchingType as x } from "../../../utils/generics.js";
+import { NodeFunctionView as E } from "../DFlow.view.js";
+import { DFlowReactiveService as $ } from "../DFlow.service.js";
+import { useReturnType as M } from "../function/DFlowFunction.return.hook.js";
+import { useInputType as Y } from "../function/DFlowFunction.input.hook.js";
+import { DataTypeRulesVariant as _, DataTypeVariant as w } from "@code0-tech/sagittarius-graphql-types";
+const se = (i, p, s, g = 0, u = [0], T = 1, v = [f.REF_OBJECT, f.VALUE, f.FUNCTION, f.FUNCTION_COMBINATION, f.DATA_TYPE]) => {
+  const m = I(G), y = I(b), A = I($), F = I(L), N = A.getById(s), l = i ? y?.getDataType(i) : void 0;
+  if (!m || !y) return [];
+  const o = i ? K(i) : void 0, r = i ? R(O(i, y), p) : void 0, a = [];
+  return m.getSuggestionsByHash(o || "").length <= 0 && (o && l && v.includes(f.VALUE) && l.rules?.nodes?.forEach((n) => {
+    if (n?.variant === _.ItemOfCollection)
+      n.config.items?.forEach((e) => {
+        const t = new h(o, [], {
+          __typename: "LiteralValue",
+          value: e
+        }, f.VALUE, [e.toString()]);
+        m.add(t), a.push(t);
+      });
+    else if (n?.variant === _.NumberRange) {
+      const e = n.config, t = new h(o, [], {
+        __typename: "LiteralValue",
+        value: e.from
+      }, f.VALUE, [e.from?.toString() ?? ""]);
+      m.add(t), a.push(t);
+    }
+  }), o && l && l.variant === w.DataType && v.includes(f.DATA_TYPE) && y.values().forEach((n) => {
+    const e = new h(o, [], n.json, f.DATA_TYPE, [n.name?.nodes[0]?.content]);
+    m.add(e), a.push(e);
+  }), v.includes(f.FUNCTION_COMBINATION) && F.values().filter((e) => {
+    if (!i || !r || !o) return !0;
+    if (e.runtimeFunctionDefinition?.identifier == "RETURN" && i) return !1;
+    if (l?.variant === w.Node) return !0;
+    if (!e.returnType || !e.genericKeys) return !1;
+    const t = R(O(e.returnType, y), e.genericKeys);
+    return x(r, t);
+  }).sort((e, t) => {
+    const [c, d, B] = e.runtimeFunctionDefinition.identifier.split("::"), [S, V, D] = t.runtimeFunctionDefinition.identifier.split("::"), U = c.localeCompare(S);
+    if (U !== 0) return U;
+    const j = d.localeCompare(V);
+    return j !== 0 ? j : B.localeCompare(D);
+  }).forEach((e) => {
+    const t = {
+      __typename: "NodeFunction",
+      //TODO: generate unique id
+      id: `gid://sagittarius/NodeFunction/${(N?.nodes?.length ?? 0) + 1}`,
+      functionDefinition: {
+        id: e.id,
+        runtimeFunctionDefinition: e.runtimeFunctionDefinition
+      },
+      parameters: {
+        nodes: e.parameterDefinitions?.map((d) => ({
+          id: d.id,
+          runtimeParameter: {
+            id: d.id
+          }
+        })) ?? []
+      }
+    }, c = new h(o || "", [], t, f.FUNCTION, [e.names?.nodes[0]?.content]);
+    a.push(c);
+  })), v.includes(f.REF_OBJECT) && (i ? P(s) : []).forEach((e) => {
+    if ((e?.node ?? 0) >= T || (e?.depth ?? 0) > g || (e?.scope ?? []).some((d) => !u.includes(d)) || !r) return;
+    const t = R(O(e.dataTypeIdentifier, y), []);
+    if (!x(r, t)) return;
+    const c = new h(o || "", [], e, f.REF_OBJECT, [`${e.depth}-${e.scope}-${e.node || ""}`]);
+    a.push(c);
+  }), [...a, ...m.getSuggestionsByHash(o || "")].sort();
+}, K = (i, p) => {
+  const s = J.c(4), g = I(b);
+  if (!i || !g)
+    return;
+  let u;
+  if (s[0] !== g || s[1] !== p || s[2] !== i) {
+    const T = O(i, g), v = R(T, p), m = JSON.stringify(v);
+    u = H(m), s[0] = g, s[1] = p, s[2] = i, s[3] = u;
+  } else
+    u = s[3];
+  return u;
+}, P = (i) => {
+  const p = I(b), s = I($), g = I(L), u = [];
+  if (!p || !s || !g) return u;
+  const T = s.values().find((N) => N.id === i);
+  if (!T?.startingNodeId) return u;
+  let v = 0;
+  const m = () => ++v;
+  let y = 0;
+  const A = () => ++y, F = (N, l, o) => {
+    if (!N) return;
+    let r = N;
+    for (; r; ) {
+      const a = g.getById(r.functionDefinition?.id);
+      if (!a) break;
+      const C = A();
+      if (r.parameters && a.parameterDefinitions)
+        for (const n of a.parameterDefinitions) {
+          const e = p.getDataType(n.dataTypeIdentifier);
+          if (!e || e.variant === w.Node) continue;
+          const t = e.rules?.nodes?.filter((c) => c?.variant === _.InputType) ?? [];
+          if (t.length) {
+            const d = r.parameters.find((S) => S.id === n.id)?.value, B = d !== void 0 ? d instanceof E ? [d.json()] : [d] : [];
+            for (const S of t) {
+              const V = S?.config, D = Y(V.dataTypeIdentifier, a, B, p);
+              D && u.push({
+                __typename: "ReferenceValue",
+                dataTypeIdentifier: D,
+                depth: l,
+                scope: o,
+                node: C
+              });
+            }
+          }
+        }
+      {
+        const n = r.parameters?.map((t) => t.value).filter((t) => t !== void 0) ?? [], e = M(a, n.map((t) => t instanceof E ? t.json() : t), p);
+        e && u.push({
+          __typename: "ReferenceValue",
+          dataTypeIdentifier: e,
+          depth: l,
+          scope: o,
+          node: C
+        });
+      }
+      if (r.parameters && a.parameterDefinitions)
+        for (const n of a.parameterDefinitions)
+          if (p.getDataType(n.dataTypeIdentifier)?.variant === w.Node) {
+            const t = r.parameters.find((c) => c.id === n.id);
+            if (t?.value && t.value instanceof E) {
+              const c = t.value, d = [...o, m()];
+              F(c, l + 1, d);
+            }
+          } else {
+            const t = r.parameters.find((c) => c.id === n.id);
+            t?.value && t.value instanceof E && F(t.value, l, o);
+          }
+      r = T.getNodeById(r.nextNodeId);
+    }
+  };
+  return F(T.getNodeById(T.startingNodeId), 0, [0]), u;
+};
+export {
+  P as useRefObjects,
+  se as useSuggestions,
+  K as useTypeHash
+};

package/dist/components/d-flow/suggestion/DFlowSuggestion.service.d.ts

@@ -0,0 +1,5 @@
+import { ReactiveArrayService } from '../../../utils/reactiveArrayService';
+import { DFlowSuggestion } from './DFlowSuggestion.view';
+export declare abstract class DFlowReactiveSuggestionService extends ReactiveArrayService<DFlowSuggestion> {
+    getSuggestionsByHash(hash: string): DFlowSuggestion[];
+}

package/dist/components/d-flow/suggestion/DFlowSuggestion.service.js

@@ -0,0 +1,18 @@
+import { ReactiveArrayService as s } from "../../../utils/reactiveArrayService.js";
+class l extends s {
+  //get all suggestions with matching hash
+  getSuggestionsByHash(a) {
+    const t = /* @__PURE__ */ new Set();
+    return this.values().filter((e) => e.hash === a).filter((e) => {
+      const r = JSON.stringify({
+        path: e.path,
+        value: e.value,
+        type: e.type
+      });
+      return t.has(r) ? !1 : (t.add(r), !0);
+    });
+  }
+}
+export {
+  l as DFlowReactiveSuggestionService
+};