@code0-tech/pictor 0.0.0-mvp.40 → 0.0.0-mvp.42

package/dist/components/d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.js

@@ -1,14 +1,15 @@
-import { genericMapping as I, staticImplements as A } from "./DFlowDataTypeRule.js";
-import { useDataTypeValidation as T } from "../../d-flow-validation/DDataTypeValidation.hook.js";
-import { useValueValidation as v } from "../../d-flow-validation/DValueValidation.hook.js";
-function P(r, e, t, n) {
-  var i = k(), o = e(function(s) {
-    i.initializeInstanceElements(s, a.elements);
-  }, t), a = i.decorateClass(x(o.d.map(_)), r);
-  return i.initializeClassElements(o.F, a.elements), i.runClassFinishers(o.F, a.finishers);
-}
-function k() {
-  k = function() {
+import { genericMapping as F, staticImplements as R } from "./DFlowDataTypeRule.js";
+import { useDataTypeValidation as E } from "../../d-flow-validation/DDataTypeValidation.hook.js";
+import { useValueValidation as w } from "../../d-flow-validation/DValueValidation.hook.js";
+import { useReturnType as D } from "../../d-flow-function/DFlowFunction.return.hook.js";
+function z(r, e, t, n) {
+  var i = P(), o = e(function(a) {
+    i.initializeInstanceElements(a, s.elements);
+  }, t), s = i.decorateClass(K(o.d.map(O)), r);
+  return i.initializeClassElements(o.F, s.elements), i.runClassFinishers(o.F, s.finishers);
+}
+function P() {
+  P = function() {
     return r;
   };
   var r = { elementsDefinitionOrder: [["method"], ["field"]], initializeInstanceElements: function(e, t) {
@@ -21,10 +22,10 @@ function k() {
     var n = e.prototype;
     ["method", "field"].forEach(function(i) {
       t.forEach(function(o) {
-        var a = o.placement;
-        if (o.kind === i && (a === "static" || a === "prototype")) {
-          var s = a === "static" ? e : n;
-          this.defineClassElement(s, o);
+        var s = o.placement;
+        if (o.kind === i && (s === "static" || s === "prototype")) {
+          var a = s === "static" ? e : n;
+          this.defineClassElement(a, o);
         }
       }, this);
     }, this);
@@ -37,38 +38,38 @@ function k() {
     Object.defineProperty(e, t.key, n);
   }, decorateClass: function(e, t) {
     var n = [], i = [], o = { static: [], prototype: [], own: [] };
-    if (e.forEach(function(s) {
-      this.addElementPlacement(s, o);
-    }, this), e.forEach(function(s) {
-      if (!y(s)) return n.push(s);
-      var l = this.decorateElement(s, o);
+    if (e.forEach(function(a) {
+      this.addElementPlacement(a, o);
+    }, this), e.forEach(function(a) {
+      if (!v(a)) return n.push(a);
+      var l = this.decorateElement(a, o);
       n.push(l.element), n.push.apply(n, l.extras), i.push.apply(i, l.finishers);
     }, this), !t) return { elements: n, finishers: i };
-    var a = this.decorateConstructor(n, t);
-    return i.push.apply(i, a.finishers), a.finishers = i, a;
+    var s = this.decorateConstructor(n, t);
+    return i.push.apply(i, s.finishers), s.finishers = i, s;
   }, addElementPlacement: function(e, t, n) {
     var i = t[e.placement];
     if (!n && i.indexOf(e.key) !== -1) throw new TypeError("Duplicated element (" + e.key + ")");
     i.push(e.key);
   }, decorateElement: function(e, t) {
-    for (var n = [], i = [], o = e.decorators, a = o.length - 1; a >= 0; a--) {
-      var s = t[e.placement];
-      s.splice(s.indexOf(e.key), 1);
-      var l = this.fromElementDescriptor(e), p = this.toElementFinisherExtras((0, o[a])(l) || l);
-      e = p.element, this.addElementPlacement(e, t), p.finisher && i.push(p.finisher);
-      var c = p.extras;
+    for (var n = [], i = [], o = e.decorators, s = o.length - 1; s >= 0; s--) {
+      var a = t[e.placement];
+      a.splice(a.indexOf(e.key), 1);
+      var l = this.fromElementDescriptor(e), d = this.toElementFinisherExtras((0, o[s])(l) || l);
+      e = d.element, this.addElementPlacement(e, t), d.finisher && i.push(d.finisher);
+      var c = d.extras;
       if (c) {
-        for (var d = 0; d < c.length; d++) this.addElementPlacement(c[d], t);
+        for (var p = 0; p < c.length; p++) this.addElementPlacement(c[p], t);
         n.push.apply(n, c);
       }
     }
     return { element: e, finishers: i, extras: n };
   }, decorateConstructor: function(e, t) {
     for (var n = [], i = t.length - 1; i >= 0; i--) {
-      var o = this.fromClassDescriptor(e), a = this.toClassDescriptor((0, t[i])(o) || o);
-      if (a.finisher !== void 0 && n.push(a.finisher), a.elements !== void 0) {
-        e = a.elements;
-        for (var s = 0; s < e.length - 1; s++) for (var l = s + 1; l < e.length; l++) if (e[s].key === e[l].key && e[s].placement === e[l].placement) throw new TypeError("Duplicated element (" + e[s].key + ")");
+      var o = this.fromClassDescriptor(e), s = this.toClassDescriptor((0, t[i])(o) || o);
+      if (s.finisher !== void 0 && n.push(s.finisher), s.elements !== void 0) {
+        e = s.elements;
+        for (var a = 0; a < e.length - 1; a++) for (var l = a + 1; l < e.length; l++) if (e[a].key === e[l].key && e[a].placement === e[l].placement) throw new TypeError("Duplicated element (" + e[a].key + ")");
       }
     }
     return { elements: e, finishers: n };
@@ -76,21 +77,21 @@ function k() {
     var t = { kind: e.kind, key: e.key, placement: e.placement, descriptor: e.descriptor };
     return Object.defineProperty(t, Symbol.toStringTag, { value: "Descriptor", configurable: !0 }), e.kind === "field" && (t.initializer = e.initializer), t;
   }, toElementDescriptors: function(e) {
-    if (e !== void 0) return S(e).map(function(t) {
+    if (e !== void 0) return M(e).map(function(t) {
       var n = this.toElementDescriptor(t);
       return this.disallowProperty(t, "finisher", "An element descriptor"), this.disallowProperty(t, "extras", "An element descriptor"), n;
     }, this);
   }, toElementDescriptor: function(e) {
     var t = e.kind + "";
     if (t !== "method" && t !== "field") throw new TypeError(`An element descriptor's .kind property must be either "method" or "field", but a decorator created an element descriptor with .kind "` + t + '"');
-    var n = E(e.key), i = e.placement + "";
+    var n = _(e.key), i = e.placement + "";
     if (i !== "static" && i !== "prototype" && i !== "own") throw new TypeError(`An element descriptor's .placement property must be one of "static", "prototype" or "own", but a decorator created an element descriptor with .placement "` + i + '"');
     var o = e.descriptor;
     this.disallowProperty(e, "elements", "An element descriptor");
-    var a = { kind: t, key: n, placement: i, descriptor: Object.assign({}, o) };
-    return t !== "field" ? this.disallowProperty(e, "initializer", "A method descriptor") : (this.disallowProperty(o, "get", "The property descriptor of a field descriptor"), this.disallowProperty(o, "set", "The property descriptor of a field descriptor"), this.disallowProperty(o, "value", "The property descriptor of a field descriptor"), a.initializer = e.initializer), a;
+    var s = { kind: t, key: n, placement: i, descriptor: Object.assign({}, o) };
+    return t !== "field" ? this.disallowProperty(e, "initializer", "A method descriptor") : (this.disallowProperty(o, "get", "The property descriptor of a field descriptor"), this.disallowProperty(o, "set", "The property descriptor of a field descriptor"), this.disallowProperty(o, "value", "The property descriptor of a field descriptor"), s.initializer = e.initializer), s;
   }, toElementFinisherExtras: function(e) {
-    return { element: this.toElementDescriptor(e), finisher: g(e, "finisher"), extras: this.toElementDescriptors(e.extras) };
+    return { element: this.toElementDescriptor(e), finisher: I(e, "finisher"), extras: this.toElementDescriptors(e.extras) };
   }, fromClassDescriptor: function(e) {
     var t = { kind: "class", elements: e.map(this.fromElementDescriptor, this) };
     return Object.defineProperty(t, Symbol.toStringTag, { value: "Descriptor", configurable: !0 }), t;
@@ -98,7 +99,7 @@ function k() {
     var t = e.kind + "";
     if (t !== "class") throw new TypeError(`A class descriptor's .kind property must be "class", but a decorator created a class descriptor with .kind "` + t + '"');
     this.disallowProperty(e, "key", "A class descriptor"), this.disallowProperty(e, "placement", "A class descriptor"), this.disallowProperty(e, "descriptor", "A class descriptor"), this.disallowProperty(e, "initializer", "A class descriptor"), this.disallowProperty(e, "extras", "A class descriptor");
-    var n = g(e, "finisher");
+    var n = I(e, "finisher");
     return { elements: this.toElementDescriptors(e.elements), finisher: n };
   }, runClassFinishers: function(e, t) {
     for (var n = 0; n < t.length; n++) {
@@ -114,51 +115,51 @@ function k() {
   } };
   return r;
 }
-function _(r) {
-  var e, t = E(r.key);
+function O(r) {
+  var e, t = _(r.key);
   r.kind === "method" ? e = { value: r.value, writable: !0, configurable: !0, enumerable: !1 } : r.kind === "get" ? e = { get: r.value, configurable: !0, enumerable: !1 } : r.kind === "set" ? e = { set: r.value, configurable: !0, enumerable: !1 } : r.kind === "field" && (e = { configurable: !0, writable: !0, enumerable: !0 });
   var n = { kind: r.kind === "field" ? "field" : "method", key: t, placement: r.static ? "static" : r.kind === "field" ? "own" : "prototype", descriptor: e };
   return r.decorators && (n.decorators = r.decorators), r.kind === "field" && (n.initializer = r.value), n;
 }
-function C(r, e) {
+function j(r, e) {
   r.descriptor.get !== void 0 ? e.descriptor.get = r.descriptor.get : e.descriptor.set = r.descriptor.set;
 }
-function x(r) {
-  for (var e = [], t = function(a) {
-    return a.kind === "method" && a.key === o.key && a.placement === o.placement;
+function K(r) {
+  for (var e = [], t = function(s) {
+    return s.kind === "method" && s.key === o.key && s.placement === o.placement;
   }, n = 0; n < r.length; n++) {
     var i, o = r[n];
     if (o.kind === "method" && (i = e.find(t)))
-      if (b(o.descriptor) || b(i.descriptor)) {
-        if (y(o) || y(i)) throw new ReferenceError("Duplicated methods (" + o.key + ") can't be decorated.");
+      if (T(o.descriptor) || T(i.descriptor)) {
+        if (v(o) || v(i)) throw new ReferenceError("Duplicated methods (" + o.key + ") can't be decorated.");
         i.descriptor = o.descriptor;
       } else {
-        if (y(o)) {
-          if (y(i)) throw new ReferenceError("Decorators can't be placed on different accessors with for the same property (" + o.key + ").");
+        if (v(o)) {
+          if (v(i)) throw new ReferenceError("Decorators can't be placed on different accessors with for the same property (" + o.key + ").");
           i.decorators = o.decorators;
         }
-        C(o, i);
+        j(o, i);
       }
     else e.push(o);
   }
   return e;
 }
-function y(r) {
+function v(r) {
   return r.decorators && r.decorators.length;
 }
-function b(r) {
+function T(r) {
   return r !== void 0 && !(r.value === void 0 && r.writable === void 0);
 }
-function g(r, e) {
+function I(r, e) {
   var t = r[e];
   if (t !== void 0 && typeof t != "function") throw new TypeError("Expected '" + e + "' to be a function");
   return t;
 }
-function E(r) {
-  var e = F(r, "string");
+function _(r) {
+  var e = N(r, "string");
   return typeof e == "symbol" ? e : e + "";
 }
-function F(r, e) {
+function N(r, e) {
   if (typeof r != "object" || !r) return r;
   var t = r[Symbol.toPrimitive];
   if (t !== void 0) {
@@ -168,32 +169,32 @@ function F(r, e) {
   }
   return (e === "string" ? String : Number)(r);
 }
-function S(r) {
-  return j(r) || O(r) || R(r) || z();
+function M(r) {
+  return H(r) || G(r) || B(r) || W();
 }
-function z() {
+function W() {
   throw new TypeError(`Invalid attempt to destructure non-iterable instance.
 In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
 }
-function R(r, e) {
+function B(r, e) {
   if (r) {
-    if (typeof r == "string") return w(r, e);
+    if (typeof r == "string") return A(r, e);
     var t = {}.toString.call(r).slice(8, -1);
-    return t === "Object" && r.constructor && (t = r.constructor.name), t === "Map" || t === "Set" ? Array.from(r) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? w(r, e) : void 0;
+    return t === "Object" && r.constructor && (t = r.constructor.name), t === "Map" || t === "Set" ? Array.from(r) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? A(r, e) : void 0;
   }
 }
-function w(r, e) {
+function A(r, e) {
   (e == null || e > r.length) && (e = r.length);
   for (var t = 0, n = Array(e); t < e; t++) n[t] = r[t];
   return n;
 }
-function O(r) {
+function G(r) {
   if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null) return Array.from(r);
 }
-function j(r) {
+function H(r) {
   if (Array.isArray(r)) return r;
 }
-let W = P([A()], function(r) {
+let J = z([R()], function(r) {
   class e {
     constructor() {
       r(this);
@@ -205,37 +206,38 @@ let W = P([A()], function(r) {
       kind: "method",
       static: !0,
       key: "validate",
-      value: function(n, i, o, a, s) {
-        const l = o?.get(i?.dataTypeIdentifier?.genericKey), p = o?.get(i?.dataTypeIdentifier?.genericKey)?.sourceDataTypeIdentifiers, c = o?.get(i?.dataTypeIdentifier?.genericKey)?.genericCombinationStrategies;
+      value: function(n, i, o, s, a, l) {
+        const d = o?.get(i?.dataTypeIdentifier?.genericKey), c = o?.get(i?.dataTypeIdentifier?.genericKey)?.sourceDataTypeIdentifiers, p = o?.get(i?.dataTypeIdentifier?.genericKey)?.genericCombinationStrategies;
         if (n.__typename != "NodeFunctionIdWrapper") return !1;
-        if (i?.dataTypeIdentifier?.genericKey && !l && !a?.getDataType(i.dataTypeIdentifier)) return !0;
-        const d = D(n, s);
-        if (!d || !d?.parameters?.nodes?.[0]?.value || !(a?.getDataType(i.dataTypeIdentifier) || l) || l && !a?.hasDataTypes(p) || l && (c?.length ?? 0) + 1 != p.length) return !1;
-        if (d?.parameters?.nodes?.[0]?.value?.__typename === "ReferenceValue") {
-          if (i?.dataTypeIdentifier?.genericKey && l && p) {
-            const u = p.map((f) => T(a?.getDataType(f), a?.getDataType((d?.parameters?.nodes?.[0]?.value).dataTypeIdentifier)));
-            return u.length > 1 ? u.reduce((f, m, h) => c && c[h - 1].type == "OR" ? f || m : f && m) : u[0];
+        if (i?.dataTypeIdentifier?.genericKey && !d && !a?.getDataType(i.dataTypeIdentifier)) return !0;
+        const u = C(n, s);
+        if (!u || !u?.parameters?.nodes?.[0]?.value || !(a?.getDataType(i.dataTypeIdentifier) || d) || d && !a?.hasDataTypes(c) || d && (p?.length ?? 0) + 1 != c.length) return !1;
+        if (u?.parameters?.nodes?.[0]?.value?.__typename === "ReferenceValue") {
+          const h = u?.parameters?.nodes?.[0]?.value, f = s?.nodes?.nodes?.find((m) => m?.id === h.nodeFunctionId), y = l?.getById(f?.functionDefinition?.id), b = f.parameters?.nodes?.map((m) => m?.value) ?? [];
+          if (i?.dataTypeIdentifier?.genericKey && d && c) {
+            const m = c.map((g) => E(a?.getDataType(g), a?.getDataType(D(y, b, a, l))));
+            return m.length > 1 ? m.reduce((g, k, x) => p && p[x - 1].type == "OR" ? g || k : g && k) : m[0];
           }
           if (i?.dataTypeIdentifier?.dataType)
-            return T(a?.getDataType(i.dataTypeIdentifier), a?.getDataType(d?.parameters?.nodes?.[0]?.value?.dataTypeIdentifier));
-        } else if (d?.parameters?.nodes?.[0]?.value?.__typename != "NodeFunctionIdWrapper") {
-          if (i?.dataTypeIdentifier?.genericKey && l && p) {
-            const u = p.map((f) => v(d?.parameters?.nodes?.[0]?.value, a?.getDataType(f), a, s, f.genericType.genericMappers));
-            return u.length > 1 ? u.reduce((f, m, h) => c && c[h - 1].type == "OR" ? f || m : f && m) : u[0];
+            return E(a?.getDataType(i.dataTypeIdentifier), a?.getDataType(D(y, b, a, l)));
+        } else if (u?.parameters?.nodes?.[0]?.value?.__typename != "NodeFunctionIdWrapper") {
+          if (i?.dataTypeIdentifier?.genericKey && d && c) {
+            const h = c.map((f) => w(u?.parameters?.nodes?.[0]?.value, a?.getDataType(f), a, s, f.genericType.genericMappers));
+            return h.length > 1 ? h.reduce((f, y, b) => p && p[b - 1].type == "OR" ? f || y : f && y) : h[0];
           }
-          return i?.dataTypeIdentifier?.dataType ? v(d?.parameters?.nodes?.[0]?.value, a?.getDataType(i.dataTypeIdentifier), a) : v(d?.parameters?.nodes?.[0]?.value, a?.getDataType(i.dataTypeIdentifier), a, s, I(i.dataTypeIdentifier?.genericType?.genericMappers, o));
+          return i?.dataTypeIdentifier?.dataType ? w(u?.parameters?.nodes?.[0]?.value, a?.getDataType(i.dataTypeIdentifier), a) : w(u?.parameters?.nodes?.[0]?.value, a?.getDataType(i.dataTypeIdentifier), a, s, F(i.dataTypeIdentifier?.genericType?.genericMappers, o));
         }
         return !1;
       }
     }]
   };
 });
-const D = (r, e) => {
+const C = (r, e) => {
   const t = e.nodes?.nodes?.find((n) => n?.id === r.id);
   if (t) {
     if (t?.functionDefinition?.runtimeFunctionDefinition?.identifier === "std::control::return") return t;
     if (t && t.nextNodeId) {
-      const n = D({
+      const n = C({
         id: t.nextNodeId
       }, e);
       if (n) return n;
@@ -243,6 +245,6 @@ const D = (r, e) => {
   }
 };
 export {
-  W as DFlowDataTypeReturnTypeRule,
-  D as findReturnNode
+  J as DFlowDataTypeReturnTypeRule,
+  C as findReturnNode
 };

package/dist/components/d-flow-data-type/rules/DFlowDataTypeRule.d.ts

@@ -1,7 +1,8 @@
 import { DFlowDataTypeReactiveService } from '../DFlowDataType.service';
 import { Flow, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
+import { DFlowFunctionReactiveService } from '../../d-flow-function';
 export interface DFlowDataTypeRule {
-    validate(value: NodeParameterValue, config: object, generics?: Map<string, GenericMapper>, service?: DFlowDataTypeReactiveService, flow?: Flow): boolean;
+    validate(value: NodeParameterValue, config: object, generics?: Map<string, GenericMapper>, flow?: Flow, dataTypeService?: DFlowDataTypeReactiveService, functionService?: DFlowFunctionReactiveService): boolean;
 }
 export declare const staticImplements: <T>() => <U extends T>(constructor: U) => U;
 export declare const genericMapping: (to?: GenericMapper[], from?: Map<string, GenericMapper>) => GenericMapper[] | undefined;

package/dist/components/d-flow-function/DFlowFunction.input.hook.d.ts

@@ -1,4 +1,5 @@
 import { FunctionDefinitionView } from './DFlowFunction.view';
 import { DFlowDataTypeReactiveService } from '../d-flow-data-type';
 import { DataTypeIdentifier, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
-export declare const useInputType: (type: DataTypeIdentifier, func: FunctionDefinitionView, values: NodeParameterValue[], dataTypeService: DFlowDataTypeReactiveService) => DataTypeIdentifier | null;
+import { DFlowFunctionReactiveService } from './DFlowFunction.service';
+export declare const useInputType: (type: DataTypeIdentifier, func: FunctionDefinitionView, values: NodeParameterValue[], dataTypeService: DFlowDataTypeReactiveService, functionService: DFlowFunctionReactiveService) => DataTypeIdentifier | null;

package/dist/components/d-flow-function/DFlowFunction.input.hook.js

@@ -1,8 +1,8 @@
-import { resolveGenericKeys as o, replaceGenericKeysInType as s } from "../../utils/generics.js";
-const y = (e, r, n, p) => {
-  const c = o(r, n, p);
-  return s(e, c);
+import { resolveGenericKeys as s, replaceGenericKeysInType as t } from "../../utils/generics.js";
+const i = (e, r, n, p, c) => {
+  const o = s(r, n, p, c);
+  return t(e, o);
 };
 export {
-  y as useInputType
+  i as useInputType
 };

package/dist/components/d-flow-function/DFlowFunction.return.hook.d.ts

@@ -1,4 +1,5 @@
 import { FunctionDefinitionView } from './DFlowFunction.view';
 import { DFlowDataTypeReactiveService } from '../d-flow-data-type';
 import { DataTypeIdentifier, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
-export declare const useReturnType: (func: FunctionDefinitionView, values: NodeParameterValue[], dataTypeService: DFlowDataTypeReactiveService) => DataTypeIdentifier | null;
+import { DFlowFunctionReactiveService } from './DFlowFunction.service';
+export declare const useReturnType: (func: FunctionDefinitionView, values: NodeParameterValue[], dataTypeService: DFlowDataTypeReactiveService, functionService: DFlowFunctionReactiveService) => DataTypeIdentifier | null;

package/dist/components/d-flow-function/DFlowFunction.return.hook.js

@@ -1,9 +1,9 @@
-import { resolveGenericKeys as t, replaceGenericKeysInType as y } from "../../utils/generics.js";
-const s = (e, r, n) => {
+import { resolveGenericKeys as y, replaceGenericKeysInType as o } from "../../utils/generics.js";
+const i = (e, r, n, p) => {
   if (!e?.returnType) return null;
-  const p = t(e, r, n);
-  return y(e.returnType, p);
+  const t = y(e, r, n, p);
+  return o(e.returnType, t);
 };
 export {
-  s as useReturnType
+  i as useReturnType
 };

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

@@ -14,7 +14,7 @@ import { hashToColor as s } from "../d-flow/DFlow.util.js";
 import { ScrollArea as U, ScrollAreaViewport as X, ScrollAreaScrollbar as f, ScrollAreaThumb as h } from "../scroll-area/ScrollArea.js";
 import { Spacing as g } from "../spacing/Spacing.js";
 import { Badge as c } from "../badge/Badge.js";
-import { syntaxTree as T } from "../../node_modules/@codemirror/language/dist/index.js";
+import { syntaxTree as T } from "@codemirror/language";
 import { Button as q } from "../button/Button.js";
 import { IconX as J } from "@tabler/icons-react";
 const ue = (i) => {

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

@@ -1,33 +1,33 @@
-import { jsxs as i, jsx as r } from "react/jsx-runtime";
+import { jsxs as i, jsx as n } from "react/jsx-runtime";
 import { Badge as c } from "../badge/Badge.js";
-import l from "react";
-import { Text as m } from "../text/Text.js";
+import m from "react";
+import { Text as a } from "../text/Text.js";
 import { Flex as f } from "../flex/Flex.js";
-import { DFlowInputNodeBadge as s } from "./DFlowInputNodeBadge.js";
-import { IconVariable as u } from "@tabler/icons-react";
-const w = (o) => {
+import { DFlowInputNodeBadge as u } from "./DFlowInputNodeBadge.js";
+import { IconVariable as s } from "@tabler/icons-react";
+const T = (t) => {
   const {
     value: e,
-    flowId: t,
-    definition: p,
+    flowId: r,
+    definition: o,
     ...d
-  } = o, a = l.useMemo(() => e.nodeFunctionId && t ? /* @__PURE__ */ i(f, { align: "center", display: "inline-flex", children: [
-    /* @__PURE__ */ r(s, { definition: p, value: {
+  } = t, p = m.useMemo(() => e.nodeFunctionId && r ? /* @__PURE__ */ i(f, { align: "center", display: "inline-flex", children: [
+    /* @__PURE__ */ n(u, { definition: o, value: {
       id: e.nodeFunctionId,
       __typename: "NodeFunctionIdWrapper"
-    }, flowId: t }),
+    }, flowId: r }),
     "inputTypeIdentifier" in e && e.inputTypeIdentifier ? "." + e.inputTypeIdentifier : "",
-    e.referencePath ? "." + (e.referencePath?.map((n) => n.path).join(".") ?? "") : ""
-  ] }) : `{{ ${String(e.depth)}-${String(e.scope)}-${String(e.node)}-${e.referencePath?.map((n) => n.path).join(".") ?? ""} }}`, [e]);
+    e.referencePath ? "." + (e.referencePath?.map((l) => l.path).join(".") ?? "") : ""
+  ] }) : "undefineds", [e]);
   return /* @__PURE__ */ i(c, { style: {
     verticalAlign: "middle"
   }, color: "warning", py: "0", border: !0, ...d, children: [
-    /* @__PURE__ */ r(u, { size: 12 }),
-    /* @__PURE__ */ r(m, { size: "sm", style: {
+    /* @__PURE__ */ n(s, { size: 12 }),
+    /* @__PURE__ */ n(a, { size: "sm", style: {
       color: "inherit"
-    }, children: a })
+    }, children: p })
   ] });
 };
 export {
-  w as DFlowInputReferenceBadge
+  T as DFlowInputReferenceBadge
 };

package/dist/components/d-flow-node/DFlowNode.return.hook.d.ts

@@ -0,0 +1,5 @@
+import { DataTypeIdentifier, Flow, NodeFunction } from '@code0-tech/sagittarius-graphql-types';
+import { DFlowFunctionReactiveService } from '../d-flow-function';
+import { DFlowDataTypeReactiveService } from '../d-flow-data-type';
+export declare const useReturnTypes: (flowId: Flow["id"]) => Map<NodeFunction["id"], DataTypeIdentifier | null>;
+export declare function getReturnTypesForFlow(flow: Flow, functionService: DFlowFunctionReactiveService, dataTypeService: DFlowDataTypeReactiveService): Map<NodeFunction['id'], DataTypeIdentifier | null>;

package/dist/components/d-flow-node/DFlowNode.return.hook.js

@@ -0,0 +1,27 @@
+import { resolveGenericKeys as v, replaceGenericKeysInType as S } from "../../utils/generics.js";
+import { useService as p, useStore as u } from "../../utils/contextStore.js";
+import T from "react";
+import "merge-props";
+import { DFlowFunctionReactiveService as m } from "../d-flow-function/DFlowFunction.service.js";
+import "js-md5";
+import { DFlowDataTypeReactiveService as w } from "../d-flow-data-type/DFlowDataType.service.js";
+import "../d-flow/DFlow.js";
+import { DFlowReactiveService as a } from "../d-flow/DFlow.service.js";
+const h = (t) => {
+  const r = p(a), n = u(a), c = p(m), o = u(m), e = p(w);
+  return T.useMemo(() => {
+    const i = r.getById(t);
+    return d(i, c, e);
+  }, [t, n, o, e]);
+};
+function d(t, r, n) {
+  const c = t?.nodes?.nodes, o = /* @__PURE__ */ new Map();
+  return c?.forEach((e) => {
+    const i = e?.parameters?.nodes?.map((y) => y?.value) ?? [], s = r.getById(e?.functionDefinition?.id), f = v(s, i, n, r), l = s?.returnType ? S(s.returnType, f) : null;
+    e?.id && o.set(e.id, l);
+  }), o;
+}
+export {
+  d as getReturnTypesForFlow,
+  h as useReturnTypes
+};