@code0-tech/pictor 0.0.0-mvp.29 → 0.0.0-mvp.30

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

@@ -0,0 +1,128 @@
+import { jsx as c } from "react/jsx-runtime";
+import S from "react";
+import "../../_virtual/compiler-runtime.js";
+import "@radix-ui/react-checkbox";
+import "merge-props";
+import "@tabler/icons-react";
+import '../../assets/components/form/Input.style.css';/* empty css                       */
+import "../form/EmailInput.js";
+import "../form/Input.js";
+import "../form/InputSuggestion.js";
+import "../form/NumberInput.js";
+import "../form/PasswordInput.js";
+import "@radix-ui/react-one-time-password-field";
+import "@radix-ui/react-radio-group";
+import "../form/SwitchInput.js";
+import { TextInput as B } from "../form/TextInput.js";
+import { MenuItem as D } from "../menu/Menu.js";
+import { Text as b } from "../text/Text.js";
+import { DFlowSuggestionMenuFooter as T } from "../d-flow-suggestion/DFlowSuggestionMenuFooter.js";
+import { toInputSuggestions as x } from "../d-flow-suggestion/DFlowSuggestionMenu.util.js";
+import { useService as a } from "../../utils/contextStore.js";
+import { DFlowFunctionReactiveService as O } from "../d-flow-function/DFlowFunction.service.js";
+import "js-md5";
+import "../d-flow/DFlow.js";
+import { DFlowReactiveService as h } from "../d-flow/DFlow.service.js";
+import "../d-flow-data-type/rules/DFlowDataTypeRegexRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeNumberRangeRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeItemOfCollectionRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeContainsTypeRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeContainsKeyRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.js";
+import { useSuggestions as R } from "../d-flow-suggestion/DFlowSuggestion.hook.js";
+import { DFlowInputNodeBadge as j } from "./DFlowInputNodeBadge.js";
+import { DFlowInputReferenceBadge as L } from "./DFlowInputReferenceBadge.js";
+import { DFlowTypeReactiveService as $ } from "../d-flow-type/DFlowType.service.js";
+const k = (g) => {
+  const o = [];
+  let p = "", m = "", n = 0, s = "", r = !1;
+  const f = () => {
+    p && o.push(p), p = "";
+  }, d = (e) => {
+    try {
+      return JSON.parse(e);
+    } catch {
+      try {
+        return JSON.parse(e.replace(/'/g, '"').replace(/([{,]\s*)([A-Za-z_$][\w$]*)(\s*:)/g, '$1"$2"$3'));
+      } catch {
+        return {};
+      }
+    }
+  };
+  return g.split("").forEach((e) => {
+    if (n > 0) {
+      if (m += e, r) {
+        r = !1;
+        return;
+      }
+      if (e === "\\") {
+        r = !0;
+        return;
+      }
+      if (s) {
+        e === s && (s = "");
+        return;
+      }
+      if (e === '"' || e === "'") {
+        s = e;
+        return;
+      }
+      e === "{" && n++, e === "}" && n--, n === 0 && (o.push(d(m)), m = "");
+      return;
+    }
+    if (e === "{") {
+      f(), n = 1, m = "{";
+      return;
+    }
+    p += e;
+  }), f(), o;
+}, at = (g) => {
+  const {
+    flowId: o,
+    nodeId: p,
+    parameterId: m,
+    ...n
+  } = g, s = a(O), r = a(h), f = a($), d = S.useMemo(() => r.getById(o), [r, o]), e = n.suggestions || R(o, p, m), I = S.useCallback((F) => {
+    const w = String(F ?? "");
+    let u = 0;
+    const l = (t) => {
+      const i = {
+        type: "text",
+        value: t,
+        start: u,
+        end: u + t.length,
+        visualLength: t.length,
+        content: t
+      };
+      return u += t.length, i;
+    }, y = (t, i) => {
+      const N = {
+        type: "block",
+        value: i,
+        start: u,
+        end: u + JSON.stringify(i).length,
+        visualLength: 1,
+        content: t
+      };
+      return u += JSON.stringify(i).length, N;
+    };
+    return k(w).map((t) => {
+      if (typeof t != "object")
+        return l(t);
+      if (t?.__typename === "NodeFunctionIdWrapper" || t?.__typename === "NodeFunction") {
+        const i = t?.__typename === "NodeFunction" ? t : r.getNodeById(o, t.id);
+        return y(/* @__PURE__ */ c(j, { value: t, flowId: o, definition: s.getById(i?.functionDefinition.id) }), t);
+      }
+      if (t?.__typename === "ReferenceValue") {
+        const i = t.nodeFunctionId === "gid://sagittarius/NodeFunction/-1" ? f.getById(d?.type?.id) : s.getById(r.getNodeById(o, t.nodeFunctionId)?.functionDefinition?.id);
+        return y(/* @__PURE__ */ c(L, { flowId: o, definition: i, value: t }), t);
+      }
+      return t?.__typename === "LiteralValue" ? l(t.value) : l(t);
+    });
+  }, [s, r]);
+  return /* @__PURE__ */ c(B, { suggestionsEmptyState: /* @__PURE__ */ c(D, { children: /* @__PURE__ */ c(b, { children: "No suggestion found" }) }), suggestionsFooter: /* @__PURE__ */ c(T, {}), filterSuggestionsByLastToken: !0, enforceUniqueSuggestions: !0, validationUsesSyntax: !0, transformSyntax: I, suggestions: n.suggestions ? n.suggestions : x(e), ...n });
+};
+export {
+  at as DFlowInputDefault,
+  k as splitTextAndObjects
+};

package/dist/components/d-flow-input/DFlowInputLiteralBadge.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { BadgeType } from '../badge/Badge';
+import { LiteralValue } from '@code0-tech/sagittarius-graphql-types';
+export interface DFlowInputLiteralBadgeProps extends Omit<BadgeType, 'value' | 'children'> {
+    value: LiteralValue;
+}
+export declare const DFlowInputLiteralBadge: React.FC<DFlowInputLiteralBadgeProps>;

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

@@ -0,0 +1,24 @@
+import { jsx as s } from "react/jsx-runtime";
+import { c as n } from "../../_virtual/compiler-runtime.js";
+import { Badge as a } from "../badge/Badge.js";
+import { Text as f } from "../text/Text.js";
+const x = (m) => {
+  const e = n.c(9);
+  let t, r;
+  e[0] !== m ? ({
+    value: r,
+    ...t
+  } = m, e[0] = m, e[1] = t, e[2] = r) : (t = e[1], r = e[2]);
+  let i;
+  e[3] === Symbol.for("react.memo_cache_sentinel") ? (i = {
+    verticalAlign: "middle"
+  }, e[3] = i) : i = e[3];
+  const c = String(r.value);
+  let l;
+  e[4] !== c ? (l = /* @__PURE__ */ s(f, { size: "sm", children: c }), e[4] = c, e[5] = l) : l = e[5];
+  let o;
+  return e[6] !== t || e[7] !== l ? (o = /* @__PURE__ */ s(a, { style: i, color: "secondary", ...t, children: l }), e[6] = t, e[7] = l, e[8] = o) : o = e[8], o;
+};
+export {
+  x as DFlowInputLiteralBadge
+};

package/dist/components/d-flow-input/DFlowInputNodeBadge.d.ts

@@ -0,0 +1,11 @@
+import { BadgeType } from '../badge/Badge';
+import { Flow, NodeFunction, NodeFunctionIdWrapper } from '@code0-tech/sagittarius-graphql-types';
+import { default as React } from 'react';
+import { FunctionDefinitionView } from '../d-flow-function';
+import { FlowTypeView } from '../d-flow-type';
+export interface DFlowInputNodeBadgeProps extends Omit<BadgeType, 'value' | 'children'> {
+    value: NodeFunction | NodeFunctionIdWrapper;
+    flowId: Flow['id'];
+    definition?: FunctionDefinitionView | FlowTypeView;
+}
+export declare const DFlowInputNodeBadge: React.FC<DFlowInputNodeBadgeProps>;

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

@@ -0,0 +1,44 @@
+import { jsxs as B, jsx as i } from "react/jsx-runtime";
+import { Badge as T } from "../badge/Badge.js";
+import p from "react";
+import { IconBolt as N, IconNote as _ } from "@tabler/icons-react";
+import { Text as h } from "../text/Text.js";
+import { useService as n, useStore as c } from "../../utils/contextStore.js";
+import "merge-props";
+import { DFlowFunctionReactiveService as f } from "../d-flow-function/DFlowFunction.service.js";
+import { hashToColor as D } from "../d-flow/DFlow.util.js";
+import "../d-flow/DFlow.js";
+import { DFlowReactiveService as d } from "../d-flow/DFlow.service.js";
+import "../d-flow-data-type/rules/DFlowDataTypeRegexRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeNumberRangeRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeItemOfCollectionRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeContainsTypeRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeContainsKeyRule.js";
+import "../d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.js";
+import { DFlowTypeReactiveService as l } from "../d-flow-type/DFlowType.service.js";
+import { FlowTypeView as x } from "../d-flow-type/DFlowType.view.js";
+const Q = (u) => {
+  const {
+    value: e,
+    flowId: m,
+    definition: o,
+    ...a
+  } = u, y = o || n(f), g = o || c(f), s = o || n(d), v = o || c(d), w = o || n(l), S = o || c(l), t = e.__typename === "NodeFunctionIdWrapper" && e.id === "gid://sagittarius/NodeFunction/-1", r = p.useMemo(() => {
+    if (t && !o) {
+      const I = s.getById(m);
+      return w.getById(I?.type?.id);
+    }
+    return e.__typename === "NodeFunction" || o ? e : s.getNodeById(m, e.id);
+  }, [v, S]), F = p.useMemo(() => o ? o.names?.[0]?.content : t && r instanceof x ? r.names?.[0]?.content : y.getById(r?.functionDefinition?.id)?.names?.[0]?.content, [g, r]);
+  return /* @__PURE__ */ B(T, { style: {
+    verticalAlign: "middle"
+  }, color: t ? "info" : D(e.id || ""), border: !0, ...a, children: [
+    t ? /* @__PURE__ */ i(N, { size: 12 }) : /* @__PURE__ */ i(_, { size: 12 }),
+    /* @__PURE__ */ i(h, { size: "sm", style: {
+      color: "inherit"
+    }, children: String(F) })
+  ] });
+};
+export {
+  Q as DFlowInputNodeBadge
+};

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

@@ -0,0 +1,11 @@
+import { BadgeType } from '../badge/Badge';
+import { Flow, ReferenceValue } from '@code0-tech/sagittarius-graphql-types';
+import { default as React } from 'react';
+import { FunctionDefinitionView } from '../d-flow-function';
+import { FlowTypeView } from '../d-flow-type';
+export interface DFlowInputReferenceBadge extends Omit<BadgeType, 'value' | 'children'> {
+    value: ReferenceValue;
+    flowId: Flow['id'];
+    definition?: FunctionDefinitionView | FlowTypeView;
+}
+export declare const DFlowInputReferenceBadge: React.FC<DFlowInputReferenceBadge>;

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

@@ -0,0 +1,33 @@
+import { jsxs as i, jsx as r } from "react/jsx-runtime";
+import { Badge as a } from "../badge/Badge.js";
+import c from "react";
+import { Text as m } 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) => {
+  const {
+    value: e,
+    flowId: t,
+    definition: p,
+    ...d
+  } = o, l = c.useMemo(() => (console.log(e), e.nodeFunctionId && t ? /* @__PURE__ */ i(f, { align: "center", display: "inline-flex", children: [
+    /* @__PURE__ */ r(s, { definition: p, value: {
+      id: e.nodeFunctionId,
+      __typename: "NodeFunctionIdWrapper"
+    }, flowId: t }),
+    "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]);
+  return /* @__PURE__ */ i(a, { style: {
+    verticalAlign: "middle"
+  }, color: "warning", py: "0", border: !0, ...d, children: [
+    /* @__PURE__ */ r(u, { size: 12 }),
+    /* @__PURE__ */ r(m, { size: "sm", style: {
+      color: "inherit"
+    }, children: l })
+  ] });
+};
+export {
+  w as DFlowInputReferenceBadge
+};

package/dist/components/d-flow-panel/DFlowExport.js

@@ -5,13 +5,13 @@ import { useService as w, useStore as b } from "../../utils/contextStore.js";
 import "merge-props";
 import "../d-flow/DFlow.js";
 import { DFlowReactiveService as m } from "../d-flow/DFlow.service.js";
+import "js-md5";
 import "../d-flow-data-type/rules/DFlowDataTypeRegexRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeNumberRangeRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeItemOfCollectionRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeContainsTypeRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeContainsKeyRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.js";
-import "js-md5";
 import { Button as x } from "../button/Button.js";
 const F = (p) => {
   const {

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

@@ -6,13 +6,13 @@ import "../../utils/contextStore.js";
 import "react";
 import "merge-props";
 import { FLOW_EDGE_RAINBOW as p } from "../d-flow/DFlow.edges.hook.js";
+import "js-md5";
 import "../d-flow-data-type/rules/DFlowDataTypeRegexRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeNumberRangeRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeItemOfCollectionRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeContainsTypeRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeContainsKeyRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.js";
-import "js-md5";
 import '../../assets/components/d-flow-panel/DFlowMiniMap.style.css';/* empty css                        */
 const F = (c) => {
   const i = a.c(2), m = d();

package/dist/components/d-flow-panel/DFlowPanelControl.js

@@ -1,70 +1,72 @@
 import { jsx as o, jsxs as t } from "react/jsx-runtime";
 import l from "react";
-import { ButtonGroup as N } from "../button-group/ButtonGroup.js";
-import { Button as a } from "../button/Button.js";
-import { IconTrash as C, IconPlus as I } from "@tabler/icons-react";
-import { Panel as B } from "@xyflow/react";
-import { useService as m, useStore as F } from "../../utils/contextStore.js";
+import { ButtonGroup as k } from "../button-group/ButtonGroup.js";
+import { Button as s } from "../button/Button.js";
+import { IconTrash as F, IconPlus as z } from "@tabler/icons-react";
+import { Panel as P } from "@xyflow/react";
+import { useService as f, useStore as u } from "../../utils/contextStore.js";
 import "merge-props";
-import { FileTabsService as u } from "../file-tabs/FileTabs.service.js";
+import { FileTabsService as h } from "../file-tabs/FileTabs.service.js";
 import "../d-flow/DFlow.js";
-import { DFlowReactiveService as z } from "../d-flow/DFlow.service.js";
+import { DFlowReactiveService as w } from "../d-flow/DFlow.service.js";
+import "js-md5";
 import "../d-flow-data-type/rules/DFlowDataTypeRegexRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeNumberRangeRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeItemOfCollectionRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeContainsTypeRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeContainsKeyRule.js";
 import "../d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.js";
-import "js-md5";
-import { Tooltip as f, TooltipTrigger as h, TooltipPortal as v, TooltipContent as T, TooltipArrow as x } from "../tooltip/Tooltip.js";
+import { Tooltip as S, TooltipTrigger as T, TooltipPortal as v, TooltipContent as x, TooltipArrow as g } from "../tooltip/Tooltip.js";
 import { Text as d } from "../text/Text.js";
-import { Badge as S } from "../badge/Badge.js";
-import { DFlowSuggestionMenu as P } from "../d-flow-suggestion/DFlowSuggestionMenu.js";
-import { useSuggestions as _ } from "../d-flow-suggestion/DFlowSuggestion.hook.js";
-const eo = (w) => {
+import { Badge as y } from "../badge/Badge.js";
+import { DFlowSuggestionMenu as _ } from "../d-flow-suggestion/DFlowSuggestionMenu.js";
+import { useSuggestions as D } from "../d-flow-suggestion/DFlowSuggestion.hook.js";
+const ro = (N) => {
   const {
     flowId: r
-  } = w, s = m(u), p = F(u), i = m(z), [, c] = l.useTransition(), e = l.useMemo(() => p.find((n) => n.active), [p, s]), g = _(void 0, [], r, 0, [0], 0), y = l.useCallback(() => {
-    e && (c(async () => {
-      await i.deleteNodeById(e.content.props.flowId, e.content.props.node.id);
-    }), s.deleteById(e.id));
-  }, [e, i]), b = l.useCallback((n) => {
+  } = N, a = f(h), p = u(h), i = f(w), b = u(w), [, c] = l.useTransition(), e = l.useMemo(() => p.find((n) => n.active), [p, a]), I = D(r, e?.content?.props?.node?.id), B = l.useCallback(() => {
+    e && e.content.props.flowId && c(async () => {
+      i.getLinkedNodesById(r, e.content.props.node.id).forEach((m) => {
+        m.id && a.deleteById(m.id);
+      }), await i.deleteNodeById(e.content.props.flowId, e.content.props.node.id);
+    });
+  }, [e, i, b]), C = l.useCallback((n) => {
     r && n.value.__typename === "NodeFunction" && "node" in e.content.props ? c(async () => {
       await i.addNextNodeById(r, e.content.props.node.id ?? void 0, n.value);
     }) : c(async () => {
       await i.addNextNodeById(r, null, n.value);
     });
   }, [r, i, e]);
-  return /* @__PURE__ */ o(B, { position: "bottom-center", children: /* @__PURE__ */ t(N, { children: [
-    /* @__PURE__ */ t(f, { children: [
-      /* @__PURE__ */ o(h, { asChild: !0, children: /* @__PURE__ */ o(a, { color: "info", paddingSize: "xxs", variant: "none", "aria-selected": !0, children: "Execute flow" }) }),
-      /* @__PURE__ */ o(v, { children: /* @__PURE__ */ t(T, { maw: "300px", children: [
+  return /* @__PURE__ */ o(P, { position: "bottom-center", children: /* @__PURE__ */ t(k, { children: [
+    /* @__PURE__ */ t(S, { children: [
+      /* @__PURE__ */ o(T, { asChild: !0, children: /* @__PURE__ */ o(s, { color: "info", paddingSize: "xxs", variant: "none", "aria-selected": !0, children: "Execute flow" }) }),
+      /* @__PURE__ */ o(v, { children: /* @__PURE__ */ t(x, { maw: "300px", children: [
         /* @__PURE__ */ t(d, { children: [
           "To execute this flow you can call the following endpoint ",
           " ",
           " ",
           /* @__PURE__ */ o("br", {}),
-          /* @__PURE__ */ o(S, { children: /* @__PURE__ */ o(d, { children: "POST" }) }),
-          /* @__PURE__ */ o(S, { color: "info", border: !0, children: /* @__PURE__ */ o(d, { style: {
+          /* @__PURE__ */ o(y, { children: /* @__PURE__ */ o(d, { children: "POST" }) }),
+          /* @__PURE__ */ o(y, { color: "info", border: !0, children: /* @__PURE__ */ o(d, { style: {
             color: "inherit"
           }, children: "localhost:6212/72hsa13/users/get" }) })
         ] }),
-        /* @__PURE__ */ o(x, {})
+        /* @__PURE__ */ o(g, {})
       ] }) })
     ] }),
-    /* @__PURE__ */ t(f, { children: [
-      /* @__PURE__ */ o(h, { asChild: !0, children: /* @__PURE__ */ o(a, { disabled: !e, onClick: y, paddingSize: "xxs", variant: "none", color: "primary", children: /* @__PURE__ */ o(C, { size: 16 }) }) }),
-      /* @__PURE__ */ o(v, { children: /* @__PURE__ */ t(T, { children: [
+    /* @__PURE__ */ t(S, { children: [
+      /* @__PURE__ */ o(T, { asChild: !0, children: /* @__PURE__ */ o(s, { disabled: !e || !e.content.props.flowId, onClick: B, paddingSize: "xxs", variant: "none", color: "primary", children: /* @__PURE__ */ o(F, { size: 16 }) }) }),
+      /* @__PURE__ */ o(v, { children: /* @__PURE__ */ t(x, { children: [
         /* @__PURE__ */ o(d, { children: "Select a node to delete it" }),
-        /* @__PURE__ */ o(x, {})
+        /* @__PURE__ */ o(g, {})
       ] }) })
     ] }),
-    /* @__PURE__ */ o(P, { suggestions: g, onSuggestionSelect: b, triggerContent: /* @__PURE__ */ t(a, { disabled: !e, paddingSize: "xxs", variant: "none", color: "primary", children: [
-      /* @__PURE__ */ o(I, { size: 16 }),
+    /* @__PURE__ */ o(_, { suggestions: I, onSuggestionSelect: C, triggerContent: /* @__PURE__ */ t(s, { disabled: !e, paddingSize: "xxs", variant: "none", color: "primary", children: [
+      /* @__PURE__ */ o(z, { size: 16 }),
       "Next node"
     ] }) })
   ] }) });
 };
 export {
-  eo as DFlowPanelControl
+  ro as DFlowPanelControl
 };

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

@@ -0,0 +1,3 @@
+import { DFlowSuggestion } from './DFlowSuggestion.view';
+import { DataTypeIdentifier } from '@code0-tech/sagittarius-graphql-types';
+export declare const useDataTypeSuggestions: (dataTypeIdentifier?: DataTypeIdentifier) => DFlowSuggestion[];

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

@@ -0,0 +1,34 @@
+import { c as s } from "../../_virtual/compiler-runtime.js";
+import { useService as c, useStore as n } from "../../utils/contextStore.js";
+import "react";
+import "merge-props";
+import { DFlowDataTypeReactiveService as p } from "../d-flow-data-type/DFlowDataType.service.js";
+import "js-md5";
+import { DFlowSuggestionType as l } from "./DFlowSuggestion.view.js";
+const _ = (t) => {
+  const e = s.c(3), o = c(p);
+  n(p);
+  const m = t ? o?.getDataType(t) : void 0;
+  let a;
+  e: {
+    if (!m || m.variant !== "DATA_TYPE") {
+      let i;
+      e[0] === Symbol.for("react.memo_cache_sentinel") ? (i = [], e[0] = i) : i = e[0], a = i;
+      break e;
+    }
+    let r;
+    e[1] !== o ? (r = o.values().map(u), e[1] = o, e[2] = r) : r = e[2], a = r;
+  }
+  return a;
+};
+function u(t) {
+  return {
+    path: [],
+    type: l.DATA_TYPE,
+    displayText: [t.name[0]?.content],
+    value: t.json
+  };
+}
+export {
+  _ as useDataTypeSuggestions
+};

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

@@ -0,0 +1,3 @@
+import { DFlowSuggestion } from './DFlowSuggestion.view';
+import { DataTypeIdentifier } from '@code0-tech/sagittarius-graphql-types';
+export declare const useFunctionSuggestions: (dataTypeIdentifier?: DataTypeIdentifier, genericKeys?: string[]) => DFlowSuggestion[];

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

@@ -0,0 +1,50 @@
+import s from "react";
+import { useService as F, useStore as v } from "../../utils/contextStore.js";
+import "merge-props";
+import { DFlowDataTypeReactiveService as g } from "../d-flow-data-type/DFlowDataType.service.js";
+import "js-md5";
+import { DFlowSuggestionType as A } from "./DFlowSuggestion.view.js";
+import { DFlowFunctionReactiveService as S } from "../d-flow-function/DFlowFunction.service.js";
+import { replaceGenericsAndSortType as f, resolveType as d, isMatchingType as M } from "../../utils/generics.js";
+const P = (t, u = []) => {
+  const r = F(g), c = F(S), m = v(g), y = v(S), p = s.useMemo(() => t ? r?.getDataType(t) : void 0, [t, r, m]), i = s.useMemo(() => t ? f(d(t, r), u) : void 0, [t, r, m, u]);
+  return s.useMemo(() => c.values().filter((e) => {
+    if (!t || !i) return !0;
+    if (e.runtimeFunctionDefinition?.identifier == "std::control::return" && t) return !1;
+    if (p?.variant === "NODE") return !0;
+    if (!e.returnType || !e.genericKeys) return !1;
+    const o = f(d(e.returnType, r), e.genericKeys);
+    return M(i, o);
+  }).sort((e, o) => {
+    const [n, T, C] = e.runtimeFunctionDefinition.identifier.split("::"), [D, N, h] = o.runtimeFunctionDefinition.identifier.split("::"), a = n.localeCompare(D);
+    if (a !== 0) return a;
+    const l = T.localeCompare(N);
+    return l !== 0 ? l : C.localeCompare(h);
+  }).map((e) => {
+    const o = {
+      __typename: "NodeFunction",
+      id: "gid://sagittarius/NodeFunction/1",
+      functionDefinition: {
+        id: e.id,
+        runtimeFunctionDefinition: e.runtimeFunctionDefinition
+      },
+      parameters: {
+        nodes: e.parameterDefinitions?.map((n) => ({
+          id: n.id,
+          runtimeParameter: {
+            id: n.id
+          }
+        })) ?? []
+      }
+    };
+    return {
+      path: [],
+      type: A.FUNCTION,
+      displayText: [e.names[0]?.content],
+      value: o
+    };
+  }), [p, t, r, c, y, i]);
+};
+export {
+  P as useFunctionSuggestions
+};

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

@@ -0,0 +1,3 @@
+import { DFlowSuggestion } from './DFlowSuggestion.view';
+import { DataTypeIdentifier, Flow, NodeFunction } from '@code0-tech/sagittarius-graphql-types';
+export declare const useReferenceSuggestions: (flowId: Flow["id"], nodeId?: NodeFunction["id"], dataTypeIdentifier?: DataTypeIdentifier, genericKeys?: string[]) => DFlowSuggestion[];

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

@@ -0,0 +1,133 @@
+import l from "react";
+import { useService as F, useStore as N } from "../../utils/contextStore.js";
+import "merge-props";
+import { DFlowDataTypeReactiveService as h } from "../d-flow-data-type/DFlowDataType.service.js";
+import "js-md5";
+import { DFlowSuggestionType as $ } from "./DFlowSuggestion.view.js";
+import { replaceGenericsAndSortType as W, resolveType as C, isMatchingType as K, resolveGenericKeys as V, targetForGenericKey as A, replaceGenericKeysInType as Y } from "../../utils/generics.js";
+import { DFlowFunctionReactiveService as E } from "../d-flow-function/DFlowFunction.service.js";
+import "../d-flow/DFlow.js";
+import { DFlowReactiveService as x } from "../d-flow/DFlow.service.js";
+import { useReturnType as k } from "../d-flow-function/DFlowFunction.return.hook.js";
+const oe = (n, t, o, m = []) => {
+  const y = F(h), r = N(h), v = F(x), g = N(x), M = P(n), D = l.useMemo(() => t ? M?.find((i) => i.nodeFunctionId === t) : void 0, [M, t]), a = l.useMemo(() => t ? v.getNodeById(n, t)?.parameters?.nodes?.map((s) => s?.value).filter((s) => s?.__typename === "NodeFunctionIdWrapper") ?? [] : [], [n, t, v, g]), u = l.useMemo(() => o ? W(C(o, y), m) : void 0, [o, y, r, m]), T = J(n);
+  return l.useMemo(() => {
+    if (!u || !D) return [];
+    const {
+      depth: i,
+      scope: s,
+      node: d
+    } = D;
+    return T.flatMap((e) => {
+      if (e.node === null || e.node === void 0) return [];
+      if (e.depth === null || e.depth === void 0) return [];
+      if (e.scope === null || e.scope === void 0) return [];
+      const c = e.parameterIndex !== void 0 && e.inputTypeIndex !== void 0, I = c ? e.scope?.every((f, B) => s?.[B] === f) : !0;
+      if (c && !I) return [];
+      if (a.some((f) => f.id === e.nodeFunctionId)) return [];
+      if (!c && e.node >= d) return [];
+      if (e.depth > i) return [];
+      if (e.scope.some((f) => !s.includes(f))) return [];
+      const R = W(C(e.dataTypeIdentifier, y), []);
+      return K(u, R) ? [{
+        path: [],
+        type: $.REF_OBJECT,
+        displayText: [`${e.depth}-${e.scope}-${e.node || ""}-${e.referencePath?.map((f) => f.path).join(".") ?? ""}`],
+        value: e
+      }] : [];
+    });
+  }, [y, D, a, T, u]);
+}, J = (n) => {
+  const t = F(h);
+  N(h);
+  const o = F(E), m = F(x), y = N(x), r = l.useMemo(() => m.getById(n), [n, y]), v = P(n), g = l.useMemo(() => r?.nodes?.nodes?.map((a) => {
+    const u = a?.parameters?.nodes?.map((d) => d?.value) ?? [], T = o.getById(a?.functionDefinition?.id), i = k(T, u, t), s = v?.find((d) => d.nodeFunctionId === a?.id);
+    return i && s ? w(s, i, t) : {};
+  }) ?? [], [r]), M = l.useMemo(() => w({
+    node: 0,
+    depth: 0,
+    nodeFunctionId: "gid://sagittarius/NodeFunction/-1",
+    scope: [0]
+  }, {
+    dataType: r?.inputType
+  }), [r]);
+  return [...l.useMemo(() => r?.nodes?.nodes?.length ? r.nodes.nodes.flatMap((a) => {
+    const u = o.getById(a?.functionDefinition?.id);
+    if (!u) return [];
+    const T = a?.parameters?.nodes?.map((i) => i?.value).filter(Boolean) ?? [];
+    return (u.parameterDefinitions ?? []).flatMap((i, s) => {
+      const d = i?.dataTypeIdentifier;
+      if (!d) return [];
+      const e = t.getDataType(d);
+      if (!e || e.variant !== "NODE") return [];
+      const c = a?.parameters?.nodes?.find((p) => p?.id === i?.id);
+      if (!c?.value || c.value.__typename !== "NodeFunctionIdWrapper") return [];
+      const I = v?.find((p) => c?.value?.__typename === "NodeFunctionIdWrapper" && p.nodeFunctionId === c.value?.id);
+      if (!I) return [];
+      const R = e.rules?.nodes?.filter((p) => p?.variant === "INPUT_TYPES") ?? [], f = V(u, T, t), B = A(u, d), S = new Map([...f].map(([p, G]) => [B.get(p) ?? p, G]));
+      return R.flatMap((p) => (p?.config?.inputTypes ?? []).flatMap((O, j) => {
+        const b = Y(O.dataTypeIdentifier, S);
+        return b ? w({
+          ...I,
+          nodeFunctionId: a?.id,
+          parameterIndex: s,
+          inputTypeIndex: j,
+          inputTypeIdentifier: O.inputIdentifier
+        }, b, t) : [];
+      }));
+    });
+  }) : [], [r, v, o, t]), ...M, ...g].flat();
+}, w = (n, t, o) => {
+  const m = o ? o.getDataType(t) : t.dataType ?? t.genericType?.dataType;
+  return m ? [...m.rules?.nodes?.map((r) => {
+    if (r?.variant === "CONTAINS_KEY")
+      return t ? w({
+        ...n,
+        referencePath: [...n.referencePath ?? [], {
+          path: r.config.key
+        }]
+      }, r.config.dataTypeIdentifier) : void 0;
+  }).flat().filter((r) => !!r) ?? [], {
+    __typename: "ReferenceValue",
+    dataTypeIdentifier: t,
+    nodeFunctionId: n.nodeFunctionId,
+    ...n
+  }] : [];
+}, P = (n) => {
+  const t = F(h), o = F(x), m = F(E), y = N(x), r = N(E), v = N(h), g = l.useMemo(() => o.getById(n), [n, y]);
+  return l.useMemo(() => {
+    if (!t || !o || !m || !g?.startingNodeId) return;
+    let M = 0;
+    const D = () => ++M;
+    let a = 0;
+    const u = () => ++a, T = [], i = (s, d, e) => {
+      if (!s) return;
+      let c = s.__typename === "NodeFunctionIdWrapper" ? o.getNodeById(n, s.id) : s;
+      for (; c; ) {
+        const I = m.getById(c.functionDefinition?.id);
+        if (!I) break;
+        if (c.parameters && I.parameterDefinitions)
+          for (const f of I.parameterDefinitions) {
+            const B = t.getDataType(f.dataTypeIdentifier), S = c.parameters?.nodes?.find((p) => p?.id === f.id);
+            if (B?.variant === "NODE") {
+              if (S?.value && S.value.__typename === "NodeFunctionIdWrapper") {
+                const p = [...e, D()];
+                i(S.value, d + 1, p);
+              }
+            } else S?.value && S.value.__typename === "NodeFunctionIdWrapper" && i(S.value, d, e);
+          }
+        const R = u();
+        T.push({
+          node: R,
+          depth: d,
+          scope: e,
+          nodeFunctionId: c.id
+        }), c = o.getNodeById(g.id, c.nextNodeId);
+      }
+    };
+    return i(o.getNodeById(g.id, g.startingNodeId), 0, [0]), T;
+  }, [t, g, n, o, m, v, y, r]) ?? [];
+};
+export {
+  oe as useReferenceSuggestions
+};