@code0-tech/pictor 0.0.0-mvp.10

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

@@ -0,0 +1,422 @@
+import { jsxs as S, jsx as c, Fragment as j } from "react/jsx-runtime";
+import { c as be } from "../../../_virtual/compiler-runtime.js";
+import y from "react";
+import { InputMessage as Me } from "../../form/InputMessage.js";
+import '../../../assets/components/d-flow/input/DFlowInputDataType.style.css';/* empty css                              */
+import { TextInput as F } from "../../form/TextInput.js";
+import { Button as re } from "../../button/Button.js";
+import { IconSettings as le, IconTrash as Oe } from "@tabler/icons-react";
+import { Text as A } from "../../text/Text.js";
+import { Flex as X } from "../../flex/Flex.js";
+import { Badge as ve } from "../../badge/Badge.js";
+import { InputLabel as De } from "../../form/InputLabel.js";
+import { useSuggestions as ke } from "../suggestion/DFlowSuggestion.hook.js";
+import { DFlowSuggestionMenuFooter as me } from "../suggestion/DFlowSuggestionMenuFooter.js";
+import { toInputSuggestions as Be } from "../suggestion/DFlowSuggestionMenu.util.js";
+import { DFlowSuggestionType as Ve } from "../suggestion/DFlowSuggestion.view.js";
+import { Menu as Ae, MenuTrigger as _e, MenuPortal as Ke } from "../../menu/Menu.js";
+import { InputSuggestionMenuContent as we, InputSuggestionMenuContentItems as Ge } from "../../form/InputSuggestion.js";
+const Te = /* @__PURE__ */ new Set(["ITEM_OF_COLLECTION", "REGEX", "NUMBER_RANGE"]), he = "__blockingSignature", Fe = ["CONTAINS_KEY", "CONTAINS_TYPE", "ITEM_OF_COLLECTION", "NUMBER_RANGE", "REGEX"], de = (n) => {
+  const {
+    formValidation: e,
+    initialValue: t,
+    onDataTypeChange: p = () => {
+    },
+    blockingDataType: s
+  } = n, m = y.useMemo(() => Ie(t, s), [t, s]), [a, u] = y.useState(m), T = y.useMemo(() => Y(a), [a]), l = y.useMemo(() => Y(s), [s]), B = y.useMemo(() => new Map((J(a) ? a.genericMappers ?? [] : []).map((r) => [r.target ?? "", r])), [a]), I = y.useMemo(() => l?.rules?.nodes?.filter(Boolean), [l]), E = y.useCallback((r) => {
+    u((o) => {
+      if (!o) return o;
+      const i = q(o);
+      return r(i), p(i), Le(o, i), i;
+    });
+  }, []), b = y.useCallback((r, o, i) => {
+    E((N) => {
+      const h = Y(N);
+      if (!h) return;
+      const M = oe(h), R = M[r];
+      if (!R) return;
+      const f = Ce(R, l);
+      if (f && !i?.allowBlocked) return;
+      const g = o(q(R));
+      g !== void 0 && (f && (ae(g, f), se(g, f)), M[r] = g);
+    });
+  }, [l, E]), V = y.useCallback((r) => {
+    E((o) => {
+      const i = Y(o);
+      if (!i) return;
+      const N = oe(i), h = N[r];
+      h && (Pe(h, l) || N.splice(r, 1));
+    });
+  }, [l, E]), d = y.useCallback((r, o) => {
+    b(r, (i) => (!("dataTypeIdentifier" in i?.config) || !i?.config?.dataTypeIdentifier || (L(o) ? (i.config.dataTypeIdentifier.dataType = o, delete i.config.dataTypeIdentifier.genericType) : J(o) && (i.config.dataTypeIdentifier.genericType = o, delete i.config.dataTypeIdentifier.dataType)), i), {
+      allowBlocked: !0
+    });
+  }, [b]), D = y.useCallback((r, o, i) => {
+    E((N) => {
+      if (!J(N)) return;
+      const h = N.genericMappers ?? [], M = h.findIndex((g) => g.target === r);
+      if (M === -1) return;
+      const R = h[M], f = R?.sourceDataTypeIdentifiers ?? [];
+      f[o] && (L(i) ? (f[o].dataType = i, delete f[o].genericType) : J(i) && (f[o].genericType = i, delete f[o].dataType), R.sourceDataTypeIdentifiers = f, N.genericMappers = [...h], N.genericMappers[M] = R);
+    });
+  }, [E]);
+  return /* @__PURE__ */ S("div", { children: [
+    /* @__PURE__ */ S("div", { className: "d-flow-viewport-data-type-input", children: [
+      T?.rules?.nodes?.map((r, o) => {
+        if (!r) return null;
+        const i = I?.find((f) => ce(r, f)), N = 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 !N || M ? /* @__PURE__ */ c(Ye, { rule: r, blockingRule: i, genericMap: B, onRemove: () => V(o), onConfigChange: (f) => b(o, (g) => (g.config = f, g)), onHeaderKeyChange: (f) => b(o, (g) => (g.config || (g.config = {}), g.config.key = f || null, g)), onHeaderDataTypeChange: (f) => b(o, (g) => {
+          g.config || (g.config = {}), "dataTypeIdentifier" in g.config || (g.config.dataTypeIdentifier = {});
+          const O = g.config.dataTypeIdentifier;
+          return f ? (L(f) ? (O.dataType = f, delete O.genericType) : J(f) && (O.genericType = f, delete O.dataType), g) : (delete O?.dataType, delete O?.genericType, g);
+        }), onNestedChange: (f) => d(o, f), onGenericMapperChange: D }, `${r.variant}-${o}`) : null;
+      }),
+      /* @__PURE__ */ S(Ae, { children: [
+        /* @__PURE__ */ c(_e, { asChild: !0, children: /* @__PURE__ */ S(re, { color: "primary", children: [
+          /* @__PURE__ */ c(le, { size: 16 }),
+          " Add new rule"
+        ] }) }),
+        /* @__PURE__ */ c(Ke, { children: /* @__PURE__ */ S(we, { children: [
+          /* @__PURE__ */ c(Ge, { onSuggestionSelect: (r) => {
+            E((o) => {
+              "rules" in o ? o?.rules?.nodes?.push(r.value) : "dataType" in o?.genericType && o?.genericType?.dataType?.rules?.nodes?.push(r.value);
+            });
+          }, suggestions: Fe.filter((r) => T?.variant == "OBJECT" ? r == "CONTAINS_KEY" : T?.variant == "ARRAY" ? r == "CONTAINS_TYPE" : !(r == "CONTAINS_TYPE" || r == "CONTAINS_KEY")).map((r) => ({
+            children: /* @__PURE__ */ S(j, { children: [
+              /* @__PURE__ */ c(le, { size: 16 }),
+              /* @__PURE__ */ c(A, { children: r })
+            ] }),
+            value: {
+              variant: r,
+              config: {
+                __typename: `DataTypeRules${r[0]}Config`,
+                ...r === "NUMBER_RANGE" ? {
+                  from: void 0,
+                  to: void 0,
+                  steps: void 0
+                } : {},
+                ...r === "REGEX" ? {
+                  pattern: void 0
+                } : {},
+                ...r === "ITEM_OF_COLLECTION" ? {
+                  items: void 0
+                } : {}
+              }
+            }
+          })) }),
+          /* @__PURE__ */ c(me, {})
+        ] }) })
+      ] })
+    ] }),
+    !e?.valid && e?.notValidMessage && /* @__PURE__ */ c(Me, { children: e.notValidMessage })
+  ] });
+}, Ye = (n) => {
+  const e = be.c(56), {
+    rule: t,
+    blockingRule: p,
+    genericMap: s,
+    onRemove: m,
+    onConfigChange: a,
+    onHeaderKeyChange: u,
+    onHeaderDataTypeChange: T,
+    onNestedChange: l,
+    onGenericMapperChange: B
+  } = n, I = t?.config?.dataTypeIdentifier ?? void 0, E = !!I?.genericKey, [b, V] = y.useState(!1), d = !!p, D = t.variant, r = D ? !Te.has(D) : !1;
+  let o;
+  e[0] !== t.config ? (o = () => ue(t?.config), e[0] = t.config, e[1] = o) : o = e[1];
+  const [i, N] = y.useState(o);
+  let h;
+  e[2] !== t.config ? (h = () => {
+    N(ue(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 R;
+  e: {
+    if (!r) {
+      R = void 0;
+      break e;
+    }
+    if (!I) {
+      R = void 0;
+      break e;
+    }
+    if (I.genericKey) {
+      let C;
+      e[6] !== s || e[7] !== I.genericKey ? (C = s.get(I.genericKey), e[6] = s, e[7] = I.genericKey, e[8] = C) : C = e[8];
+      const k = C?.sourceDataTypeIdentifiers?.[0];
+      R = k?.dataType?.name?.nodes?.[0]?.content ?? k?.genericType?.dataType?.name?.nodes?.[0]?.content;
+      break e;
+    }
+    R = I.dataType?.name?.nodes?.[0]?.content ?? I.genericType?.dataType?.name?.nodes?.[0]?.content;
+  }
+  const f = R;
+  let g;
+  e[9] === Symbol.for("react.memo_cache_sentinel") ? (g = (C) => {
+    const v = C.target.value;
+    N(v);
+  }, e[9] = g) : g = e[9];
+  const O = g;
+  let P;
+  e[10] !== i || e[11] !== d || e[12] !== a || e[13] !== t.config || e[14] !== D ? (P = (C) => {
+    if (d)
+      return;
+    const v = C?.target?.name, k = Je(i, t.config, {
+      variant: D,
+      numberRangeKey: v
+    });
+    k && a(k);
+  }, e[10] = i, e[11] = d, e[12] = a, e[13] = t.config, e[14] = D, e[15] = P) : P = e[15];
+  const _ = P;
+  let z;
+  e[16] !== t ? (z = ye(t), e[16] = t, e[17] = z) : z = e[17];
+  const K = z;
+  let U;
+  e[18] !== p ? (U = ye(p), e[18] = p, e[19] = U) : U = e[19];
+  const W = U;
+  let $;
+  e[20] !== f || e[21] !== s || e[22] !== E || e[23] !== I || e[24] !== d || e[25] !== b || e[26] !== W || e[27] !== K || e[28] !== B || e[29] !== T || e[30] !== u || e[31] !== l || e[32] !== m || e[33] !== t ? ($ = () => {
+    if (!K && !E)
+      return null;
+    const C = /* @__PURE__ */ c(ge, { rule: t, genericMap: s, isBlocked: d, dataTypeLabel: f, onClick: () => V(ze), onRemove: d ? void 0 : m, onKeyChange: d ? void 0 : u, onDataTypeChange: d ? void 0 : T });
+    if (K)
+      return /* @__PURE__ */ S(j, { children: [
+        C,
+        b ? /* @__PURE__ */ c(de, { initialValue: K, blockingDataType: W, onDataTypeChange: l }) : null
+      ] });
+    if (I?.genericKey) {
+      const v = s.get(I.genericKey);
+      return /* @__PURE__ */ S(j, { children: [
+        C,
+        b ? v?.sourceDataTypeIdentifiers?.map((k, fe) => {
+          const te = k?.dataType ?? k?.genericType;
+          if (!te)
+            return null;
+          const Se = d ? te : void 0, ie = I.genericKey;
+          return ie ? /* @__PURE__ */ c(de, { initialValue: te, blockingDataType: Se, onDataTypeChange: (Re) => B(ie, fe, Re) }, `${ie}-${fe}`) : null;
+        }) : null
+      ] });
+    }
+    return null;
+  }, e[20] = f, e[21] = s, e[22] = E, e[23] = I, e[24] = d, e[25] = b, e[26] = W, e[27] = K, e[28] = B, e[29] = T, e[30] = u, e[31] = l, e[32] = m, e[33] = t, e[34] = $) : $ = e[34];
+  const Q = $;
+  if (r && (K || E)) {
+    let C;
+    e[35] !== Q ? (C = Q(), e[35] = Q, e[36] = C) : C = e[36];
+    let v;
+    return e[37] !== C ? (v = /* @__PURE__ */ c("div", { className: "d-flow-viewport-data-type-input__rule", children: C }), e[37] = C, e[38] = v) : v = e[38], v;
+  }
+  let x;
+  e[39] === Symbol.for("react.memo_cache_sentinel") ? (x = {
+    flex: 1
+  }, e[39] = x) : x = e[39];
+  const Z = d ? void 0 : m, ee = d ? void 0 : u, ne = d ? void 0 : T;
+  let w;
+  e[40] !== f || e[41] !== s || e[42] !== d || e[43] !== t || e[44] !== Z || e[45] !== ee || e[46] !== ne ? (w = /* @__PURE__ */ c(ge, { rule: t, genericMap: s, isBlocked: d, dataTypeLabel: f, onRemove: Z, onKeyChange: ee, onDataTypeChange: ne }), e[40] = f, e[41] = s, e[42] = d, e[43] = t, e[44] = Z, e[45] = ee, e[46] = ne, e[47] = w) : w = e[47];
+  let G;
+  e[48] !== i || e[49] !== _ || e[50] !== d || e[51] !== t.variant ? (G = t.variant === "REGEX" || t.variant === "ITEM_OF_COLLECTION" ? /* @__PURE__ */ c(F, { clearable: !0, left: /* @__PURE__ */ c(A, { size: "sm", children: t.variant === "REGEX" ? "Pattern" : "Items" }), leftType: "icon", defaultValue: i, onChange: O, onBlur: _, w: "100%", disabled: d }) : t.variant === "NUMBER_RANGE" ? /* @__PURE__ */ S(j, { children: [
+    /* @__PURE__ */ c(F, { clearable: !0, defaultValue: i?.from?.toString() ?? "", onChange: O, onBlur: _, w: "100%", left: /* @__PURE__ */ c(A, { size: "sm", children: "From" }), leftType: "icon", disabled: d, name: "from" }),
+    /* @__PURE__ */ c(F, { clearable: !0, defaultValue: i?.steps?.toString() ?? "", onChange: O, onBlur: _, left: /* @__PURE__ */ c(A, { size: "sm", children: "Steps" }), leftType: "icon", w: "100%", disabled: d, name: "steps" }),
+    /* @__PURE__ */ c(F, { clearable: !0, left: /* @__PURE__ */ c(A, { size: "sm", children: "To" }), leftType: "icon", defaultValue: i?.to?.toString() ?? "", onChange: O, onBlur: _, w: "100%", disabled: d, name: "to" })
+  ] }) : null, e[48] = i, e[49] = _, e[50] = d, e[51] = t.variant, e[52] = G) : G = e[52];
+  let H;
+  return e[53] !== w || e[54] !== G ? (H = /* @__PURE__ */ c("div", { className: "d-flow-viewport-data-type-input__rule", children: /* @__PURE__ */ S("div", { style: x, children: [
+    w,
+    G
+  ] }) }), e[53] = w, e[54] = G, e[55] = H) : H = e[55], H;
+}, ge = ({
+  rule: n,
+  dataTypeLabel: e,
+  onClick: t,
+  onRemove: p,
+  isBlocked: s,
+  onKeyChange: m,
+  onDataTypeChange: a,
+  genericMap: u
+}) => {
+  const T = n.variant, l = T ? !Te.has(T) : !1, B = l ? ke({
+    dataType: {
+      id: "gid://sagittarius/DataType/878634678"
+    }
+  }, [], "", 0, [0], 1, [Ve.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, [E, b] = y.useState(() => "key" in (n?.config ?? {}) ? n?.config?.key ?? "" : ""), [V, d] = y.useState(() => e ?? "");
+  y.useEffect(() => {
+    b("key" in (n?.config ?? {}) ? n?.config?.key ?? "" : "");
+  }, [n]), y.useEffect(() => {
+    d(e ?? "");
+  }, [e]);
+  const D = y.useCallback(() => {
+    !m || s || m(E);
+  }, [s, E, m]), r = y.useCallback(() => {
+    !a || s || V.trim() === "" && a(void 0);
+  }, [V, s, a]), o = y.useCallback((i) => {
+    if (!a || s) return;
+    const N = i.value;
+    if (!N) return;
+    a(N);
+    const h = i?.ref?.displayText?.join(" ") ?? e ?? "";
+    d(h);
+  }, [e, s, a]);
+  return /* @__PURE__ */ S("div", { children: [
+    /* @__PURE__ */ S(X, { justify: "space-between", children: [
+      /* @__PURE__ */ c(ve, { color: "info", children: n?.variant }),
+      p ? /* @__PURE__ */ c(re, { color: "error", onClick: p, children: /* @__PURE__ */ c(Oe, { size: 16 }) }) : null
+    ] }),
+    /* @__PURE__ */ S(X, { mt: 0.7, style: {
+      flexDirection: "column",
+      gap: ".7rem"
+    }, children: [
+      l ? /* @__PURE__ */ S(X, { align: "center", style: {
+        gap: ".7rem"
+      }, children: [
+        n.variant === "CONTAINS_KEY" ? /* @__PURE__ */ c(F, { left: /* @__PURE__ */ c(A, { size: "sm", children: "Key" }), leftType: "icon", disabled: s, defaultValue: E, onChange: (i) => "value" in i.target && b(i.target.value), onBlur: D }) : null,
+        /* @__PURE__ */ c(F, { left: /* @__PURE__ */ c(A, { size: "sm", children: "DataType" }), leftType: "icon", disabled: s, suggestionsFooter: /* @__PURE__ */ c(me, {}), suggestions: Be(B), value: V, 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(De, { children: /* @__PURE__ */ S(X, { align: "center", style: {
+        gap: ".7rem"
+      }, children: [
+        "+",
+        I,
+        " rules included",
+        /* @__PURE__ */ c(re, { color: "primary", onClick: t, children: "Show/Hide Rules" })
+      ] }) }) : null
+    ] })
+  ] });
+}, ue = (n) => n ? "pattern" in n || n?.__typename === "DataTypeRulesRegexConfig" ? n?.pattern ?? "" : "items" in n || n?.__typename === "DataTypeRulesItemOfCollectionConfig" ? JSON.stringify(n.items) : n : "", Je = (n, e, t) => {
+  const {
+    variant: p,
+    numberRangeKey: s
+  } = t ?? {}, m = p === "NUMBER_RANGE", a = e ?? void 0;
+  if (m) {
+    const u = {
+      __typename: "DataTypeRulesNumberRangeConfig",
+      ...a
+    };
+    if (typeof n != "string")
+      return {
+        ...u,
+        ...n
+      };
+    if (!s)
+      return u;
+    const T = {
+      ...u
+    };
+    switch (s) {
+      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 (!a) {
+    if (typeof n != "string")
+      return n;
+    try {
+      return JSON.parse(n);
+    } catch {
+      return;
+    }
+  }
+  if (typeof n != "string")
+    return n;
+  if (a.__typename === "DataTypeRulesRegexConfig" || "pattern" in a)
+    return {
+      ...a,
+      pattern: n
+    };
+  if (a.__typename === "DataTypeRulesItemOfCollectionConfig" || "items" in a)
+    try {
+      return {
+        ...a,
+        items: JSON.parse(n)
+      };
+    } catch {
+      return a;
+    }
+  try {
+    return JSON.parse(n);
+  } catch {
+    return a;
+  }
+}, q = (n) => n == null ? n : JSON.parse(JSON.stringify(n)), pe = (n) => {
+  if (n)
+    return JSON.stringify(n);
+}, ye = (n) => {
+  if (n?.config?.dataTypeIdentifier)
+    return n?.config?.dataTypeIdentifier?.dataType ?? n?.config?.dataTypeIdentifier?.genericType ?? void 0;
+}, Le = (n, e) => pe(n) === pe(e), Pe = (n, e) => !n || !e?.rules?.nodes || !Ne(n) ? !1 : !!Ce(n, e), Ce = (n, e) => !n || !e?.rules?.nodes ? void 0 : e.rules.nodes?.filter(Boolean).find((p) => ce(n, p)), L = (n) => n != null && n.rules !== void 0, J = (n) => n != null && typeof n == "object" && "genericMappers" in n, Y = (n) => {
+  if (n)
+    return L(n) ? n : n.dataType ?? void 0;
+}, oe = (n) => (n.rules ? n.rules.nodes || (n.rules.nodes = []) : n.rules = {
+  nodes: []
+}, n.rules.nodes), Ie = (n, e) => {
+  if (!n && !e) return;
+  const t = q(n ?? e), p = Y(t), s = Y(e);
+  if (!p || !s)
+    return t;
+  const m = oe(p);
+  return s.rules?.nodes?.filter(Boolean)?.forEach((u) => {
+    if (!u) return;
+    const T = m.findIndex((l) => ce(l, u));
+    if (T === -1) {
+      const l = q(u);
+      ae(l, u), m.push(l), se(l, u);
+    } else {
+      const l = m[T];
+      ae(l, u), se(l, u);
+    }
+  }), t;
+}, se = (n, e) => {
+  const t = n?.config?.dataTypeIdentifier, p = e?.config?.dataTypeIdentifier;
+  if (!t || !p) return;
+  const s = t.dataType ?? t.genericType, m = p.dataType ?? p.genericType;
+  if (!s || !m) return;
+  const a = Ie(s, m);
+  a && (L(a) ? t.dataType = a : t.genericType = a);
+}, ce = (n, e) => {
+  if (!n || !e) return !1;
+  const t = Ne(n), p = Ee(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
+  });
+}, Ne = (n) => {
+  if (n)
+    return n?.[he];
+}, Ee = (n) => {
+  if (n)
+    return n.id ? `id:${n.id}` : `config:${JSON.stringify({
+      variant: n.variant,
+      config: n.config
+    })}`;
+}, ae = (n, e) => {
+  const t = Ee(e);
+  t && (n[he] = t);
+};
+function ze(n) {
+  return !n;
+}
+export {
+  de 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,22 @@
+import { jsx as l } from "react/jsx-runtime";
+import { c as d } from "../../../_virtual/compiler-runtime.js";
+import { useNodes as h, MiniMap as s } from "@xyflow/react";
+import { FLOW_EDGE_RAINBOW as m } from "../DFlow.edges.hook.js";
+import '../../../assets/components/d-flow/minimap/DFlowMiniMap.style.css';/* empty css                        */
+const w = (c) => {
+  const e = d.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 = m[n % m.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,150 @@
+import { c as x } from "../../../_virtual/compiler-runtime.js";
+import { useService as y } from "../../../utils/contextStore.js";
+import { DFlowReactiveSuggestionService as M } from "./DFlowSuggestion.service.js";
+import { DFlowDataTypeReactiveService as B } from "../data-type/DFlowDataType.service.js";
+import { md5 as P } from "js-md5";
+import { DFlowSuggestionType as f, DFlowSuggestion as S } from "./DFlowSuggestion.view.js";
+import { DFlowFunctionReactiveService as j } from "../function/DFlowFunction.service.js";
+import { replaceGenericsAndSortType as O, resolveType as A, isMatchingType as b } from "../../../utils/generics.js";
+import { NodeFunctionView as D } from "../DFlow.view.js";
+import { DFlowReactiveService as L } from "../DFlow.service.js";
+import { useReturnType as Y } from "../function/DFlowFunction.return.hook.js";
+import { useInputType as $ } from "../function/DFlowFunction.input.hook.js";
+const ie = (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 = y(M), I = y(B), R = y(L), E = y(j), N = R.getById(s), l = i ? I?.getDataType(i) : void 0;
+  if (!m || !I) return [];
+  const o = i ? G(i) : void 0, r = i ? O(A(i, I), p) : void 0, a = [];
+  return m.getSuggestionsByHash(o || "").length <= 0 && (o && l && v.includes(f.VALUE) && l.rules?.nodes?.forEach((n) => {
+    if (n?.variant === "ITEM_OF_COLLECTION")
+      n.config.items?.forEach((e) => {
+        const t = new S(o, [], {
+          __typename: "LiteralValue",
+          value: e
+        }, f.VALUE, [e.toString()]);
+        m.add(t), a.push(t);
+      });
+    else if (n?.variant === "NUMBER_RANGE") {
+      const e = n.config, t = new S(o, [], {
+        __typename: "LiteralValue",
+        value: e.from
+      }, f.VALUE, [e.from?.toString() ?? ""]);
+      m.add(t), a.push(t);
+    }
+  }), o && l && l.variant === "DATA_TYPE" && v.includes(f.DATA_TYPE) && I.values().forEach((n) => {
+    const e = new S(o, [], n.json, f.DATA_TYPE, [n.name?.nodes[0]?.content]);
+    m.add(e), a.push(e);
+  }), v.includes(f.FUNCTION_COMBINATION) && E.values().filter((e) => {
+    if (!i || !r || !o) return !0;
+    if (e.runtimeFunctionDefinition?.identifier == "RETURN" && i) return !1;
+    if (l?.variant === "NODE") return !0;
+    if (!e.returnType || !e.genericKeys) return !1;
+    const t = O(A(e.returnType, I), e.genericKeys);
+    return b(r, t);
+  }).sort((e, t) => {
+    const [c, d, _] = e.runtimeFunctionDefinition.identifier.split("::"), [F, C, h] = t.runtimeFunctionDefinition.identifier.split("::"), U = c.localeCompare(F);
+    if (U !== 0) return U;
+    const V = d.localeCompare(C);
+    return V !== 0 ? V : _.localeCompare(h);
+  }).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 S(o || "", [], t, f.FUNCTION, [e.names?.nodes[0]?.content]);
+    a.push(c);
+  })), v.includes(f.REF_OBJECT) && (i ? J(s) : []).forEach((e) => {
+    if ((e?.node ?? 0) >= T || (e?.depth ?? 0) > g || (e?.scope ?? []).some((d) => !u.includes(d)) || !r) return;
+    const t = O(A(e.dataTypeIdentifier, I), []);
+    if (!b(r, t)) return;
+    const c = new S(o || "", [], e, f.REF_OBJECT, [`${e.depth}-${e.scope}-${e.node || ""}`]);
+    a.push(c);
+  }), [...a, ...m.getSuggestionsByHash(o || "")].sort();
+}, G = (i, p) => {
+  const s = x.c(4), g = y(B);
+  if (!i || !g)
+    return;
+  let u;
+  if (s[0] !== g || s[1] !== p || s[2] !== i) {
+    const T = A(i, g), v = O(T, p), m = JSON.stringify(v);
+    u = P(m), s[0] = g, s[1] = p, s[2] = i, s[3] = u;
+  } else
+    u = s[3];
+  return u;
+}, J = (i) => {
+  const p = y(B), s = y(L), g = y(j), 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 I = 0;
+  const R = () => ++I, E = (N, l, o) => {
+    if (!N) return;
+    let r = N;
+    for (; r; ) {
+      const a = g.getById(r.functionDefinition?.id);
+      if (!a) break;
+      const w = R();
+      if (r.parameters && a.parameterDefinitions)
+        for (const n of a.parameterDefinitions) {
+          const e = p.getDataType(n.dataTypeIdentifier);
+          if (!e || e.variant === "NODE") continue;
+          const t = e.rules?.nodes?.filter((c) => c?.variant === "INPUT_TYPE") ?? [];
+          if (t.length) {
+            const d = r.parameters.find((F) => F.id === n.id)?.value, _ = d !== void 0 ? d instanceof D ? [d.json()] : [d] : [];
+            for (const F of t) {
+              const C = F?.config, h = $(C.dataTypeIdentifier, a, _, p);
+              h && u.push({
+                __typename: "ReferenceValue",
+                dataTypeIdentifier: h,
+                depth: l,
+                scope: o,
+                node: w
+              });
+            }
+          }
+        }
+      {
+        const n = r.parameters?.map((t) => t.value).filter((t) => t !== void 0) ?? [], e = Y(a, n.map((t) => t instanceof D ? t.json() : t), p);
+        e && u.push({
+          __typename: "ReferenceValue",
+          dataTypeIdentifier: e,
+          depth: l,
+          scope: o,
+          node: w
+        });
+      }
+      if (r.parameters && a.parameterDefinitions)
+        for (const n of a.parameterDefinitions)
+          if (p.getDataType(n.dataTypeIdentifier)?.variant === "NODE") {
+            const t = r.parameters.find((c) => c.id === n.id);
+            if (t?.value && t.value instanceof D) {
+              const c = t.value, d = [...o, m()];
+              E(c, l + 1, d);
+            }
+          } else {
+            const t = r.parameters.find((c) => c.id === n.id);
+            t?.value && t.value instanceof D && E(t.value, l, o);
+          }
+      r = T.getNodeById(r.nextNodeId);
+    }
+  };
+  return E(T.getNodeById(T.startingNodeId), 0, [0]), u;
+};
+export {
+  J as useRefObjects,
+  ie as useSuggestions,
+  G 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
+};