@code0-tech/pictor 0.0.0-mvp.26 → 0.0.0-mvp.27

package/dist/components/d-flow/DFlow.nodes.hook.js

@@ -1,139 +1,117 @@
-import { useService as F } from "../../utils/contextStore.js";
-import { DFlowReactiveService as A } from "./DFlow.service.js";
-import { NodeFunctionView as $ } from "./DFlow.view.js";
-import { DFlowFunctionReactiveService as M } from "./function/DFlowFunction.service.js";
-import { DFlowDataTypeReactiveService as E } from "./data-type/DFlowDataType.service.js";
-const R = /* @__PURE__ */ new Map([["std", "default"]]), K = (s, x) => {
-  if (!x || s.size === 0) return "";
-  const f = /[:._\-\/\s]+/, d = x.trim().toLowerCase();
-  let t = null, i = -1 / 0;
-  for (const [l, v] of s.entries()) {
-    const n = l.trim().toLowerCase();
-    if (d === n)
-      return v;
-    let a = 0;
-    if (d.startsWith(n)) {
-      a = 2e3 + n.length * 2;
-      const u = d.charAt(n.length);
-      (u === "" || f.test(u)) && (a += 200);
+import { useService as b, useStore as B } from "../../utils/contextStore.js";
+import w from "react";
+import "merge-props";
+import { DFlowReactiveService as M } from "./DFlow.service.js";
+import { DFlowFunctionReactiveService as C } from "../d-flow-function/DFlowFunction.service.js";
+import { DFlowDataTypeReactiveService as _ } from "../d-flow-data-type/DFlowDataType.service.js";
+import { md5 as H } from "js-md5";
+const J = /* @__PURE__ */ new Map([["std", "default"]]), V = (i, d) => {
+  if (!d || i.size === 0) return "";
+  const g = /[:._\-\/\s]+/, c = d.trim().toLowerCase();
+  let s = null, y = -1 / 0;
+  for (const [f, r] of i.entries()) {
+    const t = f.trim().toLowerCase();
+    if (c === t)
+      return r;
+    let o = 0;
+    if (c.startsWith(t)) {
+      o = 2e3 + t.length * 2;
+      const l = c.charAt(t.length);
+      (l === "" || g.test(l)) && (o += 200);
     } else {
-      const u = Math.min(d.length, n.length);
-      let r = 0;
-      for (; r < u && d.charCodeAt(r) === n.charCodeAt(r); )
-        r++;
-      if (r > 0) {
-        a = 1e3 + r;
-        const h = d.charAt(r), I = n.charAt(r);
-        (h === "" || f.test(h) || I === "" || f.test(I)) && (a += 50);
+      const l = Math.min(c.length, t.length);
+      let n = 0;
+      for (; n < l && c.charCodeAt(n) === t.charCodeAt(n); )
+        n++;
+      if (n > 0) {
+        o = 1e3 + n;
+        const h = c.charAt(n), I = t.charAt(n);
+        (h === "" || g.test(h) || I === "" || g.test(I)) && (o += 50);
       }
     }
-    a > i ? (i = a, t = l) : (a === i && t !== null && l.length > t.length || a === i && t === null) && (t = l);
+    o > y ? (y = o, s = f) : (o === y && s !== null && f.length > s.length || o === y && s === null) && (s = f);
   }
-  return t !== null ? s.get(t) : "";
-}, q = (s) => {
-  const x = F(A), f = F(M), d = F(E), t = x.getById(s);
-  if (!t) return [];
-  const i = [];
-  let l = 0;
-  const v = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), a = (e, o = v) => (o.has(e) || o.set(e, f.getById(e)), o.get(e)), u = (e, o = n) => (o.has(e) || o.set(e, d.getDataType(e)), o.get(e));
-  let r = 0;
-  const h = () => ++r;
-  let I = 0;
-  i.push({
-    id: `${t.id}`,
-    type: "trigger",
-    position: {
-      x: 0,
-      y: 0
-    },
-    draggable: !1,
-    data: {
-      instance: t,
-      flowId: s
-    }
-  });
-  const m = (e, o = !1, B, y = 0, D = [0], c, N = v, S = n) => {
-    const p = `${e.id}-${l++}`, C = ++I;
-    i.push({
-      id: p,
-      type: K(R, e.functionDefinition?.identifier),
+  return s !== null ? i.get(s) : "";
+}, ee = (i) => {
+  const d = b(M), g = B(M), c = b(C), s = B(C), y = b(_), f = B(_), r = w.useMemo(() => d.getById(i), [i, g]);
+  return w.useMemo(() => {
+    if (!r) return [];
+    const t = [];
+    let o = 0;
+    const l = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), h = (e, a = l) => (a.has(e) || a.set(e, c.getById(e)), a.get(e)), I = (e, a = n) => (a.has(e) || a.set(e, y.getDataType(e)), a.get(e));
+    let k = 0;
+    const A = () => ++k;
+    let R = 0;
+    t.push({
+      id: `${r.id}`,
+      type: "trigger",
       position: {
         x: 0,
         y: 0
       },
       draggable: !1,
-      parentId: c,
-      extent: c ? "parent" : void 0,
       data: {
-        instance: e,
-        isParameter: o,
-        flowId: s,
-        linkingId: o ? B : void 0,
-        scope: D,
-        // scope is now a PATH (number[])
-        depth: y,
-        // structural depth (0 at root, +1 per group)
-        index: C
-        // global node level
-      }
-    }), !e.nextNodeId && !o && i.push({
-      id: `${p}-suggestion`,
-      type: "suggestion",
-      position: {
-        x: 0,
-        y: 0
-      },
-      draggable: !1,
-      extent: c ? "parent" : void 0,
-      parentId: c,
-      data: {
-        flowId: s,
-        parentFunction: e
+        instance: r,
+        flowId: i
       }
     });
-    const k = a(e.functionDefinition?.id, N);
-    e.parameters?.forEach((g) => {
-      const T = k?.parameterDefinitions.find((b) => b.id == g.runtimeParameter?.id)?.dataTypeIdentifier;
-      if ((T ? u(T, S) : void 0)?.variant === "NODE") {
-        if (g.value && g.value instanceof $) {
-          const b = `${p}-group-${l++}`, w = [...D, h()];
-          i.push({
-            id: b,
-            type: "group",
-            position: {
-              x: 0,
-              y: 0
-            },
-            draggable: !1,
-            parentId: c,
-            extent: c ? "parent" : void 0,
-            data: {
-              isParameter: !0,
-              linkingId: p,
-              flowId: s,
-              depth: y + 1,
-              scope: w
-            }
-          }), m(g.value, !1, void 0, y + 1, w, b, N, S);
+    const S = (e, a = !1, E, v = 0, N = [0], p, D = l, x = n) => {
+      const m = `${e.id}-${o++}`, W = ++R;
+      t.push({
+        id: m,
+        type: V(J, e.functionDefinition?.identifier),
+        position: {
+          x: 0,
+          y: 0
+        },
+        draggable: !1,
+        parentId: p,
+        extent: p ? "parent" : void 0,
+        data: {
+          nodeId: e.id,
+          isParameter: a,
+          flowId: i,
+          linkingId: a ? E : void 0,
+          scope: N,
+          // scope is now a PATH (number[])
+          depth: v,
+          // structural depth (0 at root, +1 per group)
+          index: W
+          // global node level
         }
-      } else g.value && g.value instanceof $ && m(g.value, !0, p, y, D, c, N, S);
-    }), e.nextNodeId && m(t.getNodeById(e.nextNodeId), !1, void 0, y, D, c, N, S);
-  };
-  return t.startingNodeId ? m(t.getNodeById(t.startingNodeId), !1, void 0, 0, [0], void 0, v, n) : i.push({
-    id: `${t.id}-suggestion`,
-    type: "suggestion",
-    position: {
-      x: 0,
-      y: 0
-    },
-    draggable: !1,
-    extent: void 0,
-    data: {
-      flowId: s,
-      parentFunction: void 0
-    }
-  }), i;
+      });
+      const K = h(e.functionDefinition?.id, D);
+      e.parameters?.nodes?.forEach((u) => {
+        const F = K?.parameterDefinitions.find((T) => T.id == u?.runtimeParameter?.id)?.dataTypeIdentifier;
+        if ((F ? I(F, x) : void 0)?.variant === "NODE") {
+          if (u?.value && u.value.__typename === "NodeFunctionIdWrapper") {
+            const T = `${m}-group-${o++}`, $ = [...N, A()], L = H(`${m}-param-${JSON.stringify(u)}`), O = (z) => parseInt(z.slice(0, 8), 16) % 360;
+            t.push({
+              id: T,
+              type: "group",
+              position: {
+                x: 0,
+                y: 0
+              },
+              draggable: !1,
+              parentId: p,
+              extent: p ? "parent" : void 0,
+              data: {
+                isParameter: !0,
+                linkingId: m,
+                flowId: i,
+                depth: v + 1,
+                scope: $,
+                color: `hsl(${O(L)}, 100%, 72%)`
+              }
+            }), S(d.getNodeById(i, u.value.id), !1, void 0, v + 1, $, T, D, x);
+          }
+        } else u?.value && u.value.__typename === "NodeFunctionIdWrapper" && S(d.getNodeById(i, u.value.id), !0, m, v, N, p, D, x);
+      }), e.nextNodeId && S(d.getNodeById(r.id, e.nextNodeId), !1, void 0, v, N, p, D, x);
+    };
+    return r.startingNodeId && S(d.getNodeById(r.id, r.startingNodeId), !1, void 0, 0, [0], void 0, l, n), t;
+  }, [r, g, s, f]);
 };
 export {
-  q as useFlowNodes
+  ee as useFlowNodes
 };

package/dist/components/d-flow/DFlow.service.d.ts

@@ -1,10 +1,15 @@
-import { FlowView } from './DFlow.view';
-import { ReactiveArrayService } from '../../utils/reactiveArrayService';
-import { Flow, NamespacesProjectsFlowsCreateInput, NamespacesProjectsFlowsCreatePayload, NamespacesProjectsFlowsDeleteInput, NamespacesProjectsFlowsDeletePayload } from '@code0-tech/sagittarius-graphql-types';
-export declare abstract class DFlowReactiveService extends ReactiveArrayService<FlowView> {
-    getById(id: Flow['id']): FlowView | undefined;
-    /** Creates a new flow. */
+import { ReactiveArrayService } from '../../utils';
+import { Flow, FlowInput, FlowSetting, LiteralValue, NamespacesProjectsFlowsCreateInput, NamespacesProjectsFlowsCreatePayload, NamespacesProjectsFlowsDeleteInput, NamespacesProjectsFlowsDeletePayload, NamespacesProjectsFlowsUpdateInput, NamespacesProjectsFlowsUpdatePayload, NodeFunction, NodeParameter, ReferenceValue } from '@code0-tech/sagittarius-graphql-types';
+export declare abstract class DFlowReactiveService extends ReactiveArrayService<Flow> {
+    getById(id: Flow['id']): Flow | undefined;
+    protected removeParameterNode(flow: Flow, parameter: NodeParameter): void;
+    getNodeById(flowId: Flow['id'], nodeId: NodeFunction['id']): NodeFunction | undefined;
+    getPayloadById(flowId: Flow['id']): FlowInput | undefined;
+    deleteNodeById(flowId: Flow['id'], nodeId: NodeFunction['id']): Promise<void>;
+    addNextNodeById(flowId: Flow['id'], parentNodeId: NodeFunction['id'] | null, nextNode: NodeFunction): Promise<void>;
+    setSettingValue(flowId: Flow['id'], settingId: FlowSetting['id'], value: FlowSetting['value']): Promise<void>;
+    setParameterValue(flowId: Flow['id'], nodeId: NodeFunction['id'], parameterId: NodeParameter['id'], value?: LiteralValue | ReferenceValue | NodeFunction): Promise<void>;
     abstract flowCreate(payload: NamespacesProjectsFlowsCreateInput): Promise<NamespacesProjectsFlowsCreatePayload | undefined>;
-    /** Deletes a namespace project. */
     abstract flowDelete(payload: NamespacesProjectsFlowsDeleteInput): Promise<NamespacesProjectsFlowsDeletePayload | undefined>;
+    abstract flowUpdate(payload: NamespacesProjectsFlowsUpdateInput): Promise<NamespacesProjectsFlowsUpdatePayload | undefined>;
 }

package/dist/components/d-flow/DFlow.service.js

@@ -1,11 +1,121 @@
-import { ReactiveArrayService as i } from "../../utils/reactiveArrayService.js";
-class c extends i {
-  //TODO: inject UI error handler for toasts
-  //inject: namespaceId and projectId because the runtimes query needs it
-  getById(e) {
-    return this.values().find((r) => r.id === e);
+import "../../utils/contextStore.js";
+import "react";
+import { ReactiveArrayService as I } from "../../utils/reactiveArrayService.js";
+import "merge-props";
+class m extends I {
+  getById(n) {
+    return this.values().find((t) => t.id === n);
+  }
+  removeParameterNode(n, t) {
+    if (t?.value?.__typename === "NodeFunctionIdWrapper") {
+      const i = n?.nodes?.nodes?.find((e) => e?.id === t.value?.id);
+      if (i) {
+        n.nodes.nodes = n.nodes.nodes.filter((d) => d?.id !== t.value?.id);
+        let e = i.nextNodeId;
+        for (; e; ) {
+          const d = n.nodes.nodes.find((o) => o?.id === e);
+          d ? (n.nodes.nodes = n.nodes.nodes.filter((o) => o?.id !== e), e = d.nextNodeId) : e = null;
+        }
+        i.parameters?.nodes?.forEach((d) => {
+          this.removeParameterNode(n, d);
+        });
+      }
+    }
+  }
+  getNodeById(n, t) {
+    return this.getById(n)?.nodes?.nodes?.find((i) => i?.id === t);
+  }
+  getPayloadById(n) {
+    const t = this.getById(n), i = (e) => ({
+      ...e?.dataType ? {
+        dataTypeId: e?.dataType?.id
+      } : {},
+      ...e?.genericKey ? {
+        genericKey: e?.genericKey
+      } : {},
+      ...e?.genericType ? {
+        genericType: {
+          dataTypeId: e?.genericType?.dataType?.id,
+          genericMappers: e?.genericType?.genericMappers?.map((d) => ({
+            target: d.target,
+            sourceDataTypeIdentifiers: d.sourceDataTypeIdentifiers?.map(i) ?? []
+          })) ?? []
+        }
+      } : {}
+    });
+    return {
+      name: t?.name,
+      type: t?.type?.id,
+      settings: t?.settings?.nodes?.map((e) => ({
+        flowSettingIdentifier: e?.flowSettingIdentifier,
+        value: e?.value
+      })),
+      nodes: t?.nodes?.nodes?.map((e) => ({
+        id: e?.id,
+        nextNodeId: e?.nextNodeId,
+        parameters: e?.parameters?.nodes?.map((d) => ({
+          runtimeParameterDefinitionId: d?.runtimeParameter?.id,
+          value: d?.value?.__typename === "NodeFunctionIdWrapper" ? {
+            nodeFunctionId: d.value.id
+          } : d?.value?.__typename === "LiteralValue" ? {
+            literalValue: d.value.value
+          } : {
+            referenceValue: {
+              dataTypeIdentifier: i((d?.value).dataTypeIdentifier),
+              depth: (d?.value).depth,
+              node: (d?.value).node,
+              nodeFunctionId: (d?.value).nodeFunctionId,
+              referencePath: (d?.value).referencePath,
+              scope: (d?.value).scope
+            }
+          }
+        })) ?? [],
+        runtimeFunctionId: e?.functionDefinition?.runtimeFunctionDefinition?.id
+      })) ?? [],
+      startingNodeId: t?.startingNodeId
+    };
+  }
+  async deleteNodeById(n, t) {
+    const i = this.getById(n), e = this.getNodeById(n, t), d = i?.nodes?.nodes?.find((s) => s?.nextNodeId === t), o = this.values().findIndex((s) => s.id === n);
+    !i || !e || (i.nodes.nodes = i.nodes.nodes.filter((s) => s?.id !== t), e.parameters?.nodes?.forEach((s) => this.removeParameterNode(i, s)), d ? d.nextNodeId = e.nextNodeId : i.startingNodeId = e.nextNodeId ?? void 0, this.set(o, i));
+  }
+  async addNextNodeById(n, t, i) {
+    const e = this.getById(n), d = this.values().findIndex((u) => u.id === n), o = t ? this.getNodeById(n, t) : void 0;
+    if (!e || t && !o) return;
+    const r = `gid://sagittarius/NodeFunction/${Math.max(0, ...e.nodes?.nodes?.map((u) => Number(u?.id?.match(/NodeFunction\/(\d+)$/)?.[1] ?? 0)) ?? [0]) + 1}`, a = {
+      ...i,
+      id: r
+    };
+    o && o.nextNodeId ? a.nextNodeId = o.nextNodeId : !o && e.startingNodeId && (a.nextNodeId = e.startingNodeId), e.nodes?.nodes?.push(a), o ? o.nextNodeId = a.id : e.startingNodeId = a.id, this.set(d, e);
+  }
+  async setSettingValue(n, t, i) {
+    const e = this.getById(n), d = this.values().findIndex((s) => s.id === n);
+    if (!e) return;
+    const o = e.settings?.nodes?.find((s) => s?.id === t);
+    o && (o.value = i, this.set(d, e));
+  }
+  async setParameterValue(n, t, i, e) {
+    const d = this.getById(n), o = this.values().findIndex((a) => a.id === n);
+    if (!d) return;
+    const s = this.getNodeById(n, t);
+    if (!s) return;
+    const r = s.parameters?.nodes?.find((a) => a?.id === i);
+    if (r) {
+      if (this.removeParameterNode(d, r), e?.__typename === "NodeFunction") {
+        const a = Math.max(0, ...d.nodes?.nodes?.map((c) => Number(c?.id?.match(/NodeFunction\/(\d+)$/)?.[1] ?? 0)) ?? [0]), u = {
+          ...e,
+          id: `gid://sagittarius/NodeFunction/${a + 1}`
+        };
+        d.nodes?.nodes?.push(u), r.value = {
+          id: `gid://sagittarius/NodeFunction/${a + 1}`,
+          __typename: "NodeFunctionIdWrapper"
+        };
+      } else
+        r.value = e;
+      this.set(o, d);
+    }
   }
 }
 export {
-  c as DFlowReactiveService
+  m as DFlowReactiveService
 };

package/dist/components/d-flow/{edge/DFlowEdge.d.ts → DFlowEdge.d.ts}

@@ -1,10 +1,12 @@
-import { Code0Component } from '../../../utils/types';
+import { Code0Component } from '../../utils';
 import { Edge, EdgeProps } from '@xyflow/react';
 import { default as React } from 'react';
+import { Flow, NodeFunction } from '@code0-tech/sagittarius-graphql-types';
 export interface DFlowEdgeDataProps extends Code0Component<HTMLDivElement> {
     color?: string;
-    isParameter?: boolean;
-    isSuggestion?: boolean;
+    type: 'parameter' | 'suggestion' | 'group' | 'default';
+    parentNodeId?: NodeFunction['id'] | null;
+    flowId: Flow['id'];
 }
 export type DFlowEdgeProps = EdgeProps<Edge<DFlowEdgeDataProps>>;
 export declare const DFlowEdge: React.FC<DFlowEdgeProps>;

package/dist/components/d-flow/DFlowEdge.js

@@ -0,0 +1,69 @@
+import { jsx as a, jsxs as L, Fragment as U } from "react/jsx-runtime";
+import { c as z } from "../../_virtual/compiler-runtime.js";
+import { Position as P, getSmoothStepPath as D, BaseEdge as G, EdgeLabelRenderer as T } from "@xyflow/react";
+import { memo as W } from "react";
+import { Badge as q } from "../badge/Badge.js";
+const Q = W((E) => {
+  const t = z.c(42);
+  let n, s, i, d, e, o, r, l;
+  if (t[0] !== E) {
+    const {
+      sourceX: O,
+      sourceY: S,
+      targetX: j,
+      targetY: v,
+      id: w,
+      data: C,
+      label: F,
+      style: A,
+      ...I
+    } = E;
+    e = O, o = S, r = j, l = v, s = w, n = C, i = F, d = I, t[0] = E, t[1] = n, t[2] = s, t[3] = i, t[4] = d, t[5] = e, t[6] = o, t[7] = r, t[8] = l;
+  } else
+    n = t[1], s = t[2], i = t[3], d = t[4], e = t[5], o = t[6], r = t[7], l = t[8];
+  const X = n?.type === "parameter" ? P.Left : P.Bottom, Y = n?.type === "parameter" ? P.Right : P.Top;
+  let h;
+  t[9] !== e || t[10] !== o || t[11] !== X || t[12] !== Y || t[13] !== r || t[14] !== l ? (h = D({
+    sourceX: e,
+    sourceY: o,
+    sourcePosition: X,
+    targetX: r,
+    targetY: l,
+    targetPosition: Y,
+    borderRadius: 16,
+    stepPosition: 0.5
+  }), t[9] = e, t[10] = o, t[11] = X, t[12] = Y, t[13] = r, t[14] = l, t[15] = h) : h = t[15];
+  const [$, R, k] = h, x = n?.color ?? "#ffffff", y = `dflow-edge-gradient-${s}`;
+  let c, p;
+  t[16] !== x ? (c = /* @__PURE__ */ a("stop", { offset: "0", stopColor: x, stopOpacity: 0.75 }), p = /* @__PURE__ */ a("stop", { offset: "1", stopColor: x, stopOpacity: 0.25 }), t[16] = x, t[17] = c, t[18] = p) : (c = t[17], p = t[18]);
+  let f;
+  t[19] !== y || t[20] !== e || t[21] !== o || t[22] !== c || t[23] !== p || t[24] !== r || t[25] !== l ? (f = /* @__PURE__ */ a("defs", { children: /* @__PURE__ */ L("linearGradient", { id: y, x1: e, y1: o, x2: r, y2: l, gradientUnits: "userSpaceOnUse", children: [
+    c,
+    p
+  ] }) }), t[19] = y, t[20] = e, t[21] = o, t[22] = c, t[23] = p, t[24] = r, t[25] = l, t[26] = f) : f = t[26];
+  const B = `url(#${y})`;
+  let m;
+  t[27] !== B ? (m = {
+    stroke: B,
+    strokeWidth: "2px",
+    strokeLinecap: "round"
+  }, t[27] = B, t[28] = m) : m = t[28];
+  let g;
+  t[29] !== $ || t[30] !== s || t[31] !== d || t[32] !== m ? (g = /* @__PURE__ */ a(G, { id: s, path: $, ...d, style: m }), t[29] = $, t[30] = s, t[31] = d, t[32] = m, t[33] = g) : g = t[33];
+  let u;
+  t[34] !== i || t[35] !== R || t[36] !== k ? (u = i ? /* @__PURE__ */ a(T, { children: /* @__PURE__ */ a("div", { style: {
+    position: "absolute",
+    transform: `translate(-50%, -50%) translate(${R}px, ${k}px)`,
+    pointerEvents: "all",
+    zIndex: 100
+  }, children: /* @__PURE__ */ a(q, { color: "primary", border: !0, children: i }) }) }) : null, t[34] = i, t[35] = R, t[36] = k, t[37] = u) : u = t[37];
+  let b;
+  return t[38] !== f || t[39] !== g || t[40] !== u ? (b = /* @__PURE__ */ L(U, { children: [
+    f,
+    g,
+    u
+  ] }), t[38] = f, t[39] = g, t[40] = u, t[41] = b) : b = t[41], b;
+});
+export {
+  Q as DFlowEdge
+};

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

@@ -1,13 +1,4 @@
-export * from './DFlow.view';
+export * from './DFlow';
 export * from './DFlow.service';
 export * from './DFlow.edges.hook';
 export * from './DFlow.nodes.hook';
-export * from './DFlow';
-export * from './control/index';
-export * from './data-type/index';
-export * from './folder/index';
-export * from './function/index';
-export * from './minimap/index';
-export * from './suggestion/index';
-export * from './type/index';
-export * from './validation/index';

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

@@ -1,46 +1,11 @@
-import { FlowSettingView as r, FlowView as t, NodeFunctionView as i, NodeParameterView as w } from "./DFlow.view.js";
-import { DFlowReactiveService as l } from "./DFlow.service.js";
-import { FLOW_EDGE_RAINBOW as m, useFlowEdges as f } from "./DFlow.edges.hook.js";
-import { useFlowNodes as a } from "./DFlow.nodes.hook.js";
-import { DFlow as x } from "./DFlow.js";
-import { DFlowControl as u } from "./control/DFlowControl.js";
-import { DFlowDataTypeReactiveService as V } from "./data-type/DFlowDataType.service.js";
-import { DataTypeView as s } from "./data-type/DFlowDataType.view.js";
-import { DFlowFolder as g, DFlowFolderGroup as R, DFlowFolderItem as y } from "./folder/DFlowFolder.js";
-import { DFlowFunctionReactiveService as N } from "./function/DFlowFunction.service.js";
-import { FunctionDefinitionView as G, ParameterDefinitionView as I } from "./function/DFlowFunction.view.js";
-import { DFlowMiniMap as O } from "./minimap/DFlowMiniMap.js";
-import { DFlowReactiveSuggestionService as W } from "./suggestion/DFlowSuggestion.service.js";
-import { DFlowSuggestion as A, DFlowSuggestionType as B } from "./suggestion/DFlowSuggestion.view.js";
-import { DFlowTypeReactiveService as L } from "./type/DFlowType.service.js";
-import { FlowTypeView as h } from "./type/DFlowType.view.js";
-import { useDFlowValidations as k } from "./validation/DFlowValidation.hook.js";
-import { DFlowValidation as z } from "./validation/DFlowValidation.js";
+import { DFlow as r } from "./DFlow.js";
+import { DFlowReactiveService as F } from "./DFlow.service.js";
+import { FLOW_EDGE_RAINBOW as l, useFlowEdges as m } from "./DFlow.edges.hook.js";
+import { useFlowNodes as s } from "./DFlow.nodes.hook.js";
 export {
-  x as DFlow,
-  u as DFlowControl,
-  V as DFlowDataTypeReactiveService,
-  g as DFlowFolder,
-  R as DFlowFolderGroup,
-  y as DFlowFolderItem,
-  N as DFlowFunctionReactiveService,
-  O as DFlowMiniMap,
-  l as DFlowReactiveService,
-  W as DFlowReactiveSuggestionService,
-  A as DFlowSuggestion,
-  B as DFlowSuggestionType,
-  L as DFlowTypeReactiveService,
-  z as DFlowValidation,
-  s as DataTypeView,
-  m as FLOW_EDGE_RAINBOW,
-  r as FlowSettingView,
-  h as FlowTypeView,
-  t as FlowView,
-  G as FunctionDefinitionView,
-  i as NodeFunctionView,
-  w as NodeParameterView,
-  I as ParameterDefinitionView,
-  k as useDFlowValidations,
-  f as useFlowEdges,
-  a as useFlowNodes
+  r as DFlow,
+  F as DFlowReactiveService,
+  l as FLOW_EDGE_RAINBOW,
+  m as useFlowEdges,
+  s as useFlowNodes
 };

package/dist/components/d-flow-data-type/DFlowDataType.service.d.ts

@@ -0,0 +1,9 @@
+import { ReactiveArrayService } from '../../utils';
+import { DataTypeView } from './DFlowDataType.view';
+import { DataTypeIdentifier, Flow, Maybe, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
+export declare abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<DataTypeView> {
+    getDataType(type: DataTypeIdentifier): DataTypeView | undefined;
+    getDataTypeFromValue(value: NodeParameterValue, flow?: Flow): DataTypeView | undefined;
+    getTypeFromValue(value: NodeParameterValue, flow?: Flow): Maybe<DataTypeIdentifier> | undefined;
+    hasDataTypes(types: DataTypeIdentifier[]): boolean;
+}

package/dist/components/{d-flow/data-type → d-flow-data-type}/DFlowDataType.service.js

@@ -1,8 +1,10 @@
-import { ReactiveArrayService as s } from "../../../utils/reactiveArrayService.js";
-import { resolveType as y } from "../../../utils/generics.js";
-import { useValidateValue as f } from "./DFlowDataType.validation.value.js";
-class l extends s {
-  //TODO: remove string because of sagittarius types update
+import "../../utils/contextStore.js";
+import "react";
+import { ReactiveArrayService as s } from "../../utils/reactiveArrayService.js";
+import "merge-props";
+import { resolveType as y } from "../../utils/generics.js";
+import { useValueValidation as f } from "../d-flow-validation/DValueValidation.hook.js";
+class D extends s {
   getDataType(e) {
     if (!e || e.genericKey) return;
     const i = e.dataType?.identifier ?? e.genericType?.dataType?.identifier, t = e.dataType?.id ?? e.genericType?.dataType?.id;
@@ -32,7 +34,7 @@ class l extends s {
         }
       });
     }
-    const t = this.values().filter((r) => r.identifier === "OBJECT" || e.__typename === "NodeFunction" && (r.variant != "NODE" || !i) ? !1 : f(e, r, i));
+    const t = this.values().filter((r) => r.identifier === "OBJECT" || e.__typename === "NodeFunctionIdWrapper" && (r.variant != "NODE" || !i) ? !1 : f(e, r, this, i));
     return t[t.length - 1];
   }
   getTypeFromValue(e, i) {
@@ -45,7 +47,7 @@ class l extends s {
       }
     };
     const r = t.genericKeys.map((a) => {
-      const n = t.rules?.nodes?.find((d) => "dataTypeIdentifier" in (d?.config ?? {}) && d?.config?.dataTypeIdentifier?.genericKey == a || "inputTypes" in (d?.config ?? {}) && d.config.inputTypes?.some((p) => p.dataTypeIdentifier?.genericKey == a));
+      const n = t.rules?.nodes?.find((d) => "dataTypeIdentifier" in (d?.config ?? {}) && d?.config?.dataTypeIdentifier?.genericKey == a || "inputTypes" in (d?.config ?? {}) && d.config.inputTypes?.some((T) => T.dataTypeIdentifier?.genericKey == a));
       return n && n.variant == "CONTAINS_TYPE" && "value" in e && e?.value && t.variant === "ARRAY" ? {
         sourceDataTypeIdentifiers: [this.getTypeFromValue({
           __typename: "LiteralValue",
@@ -68,7 +70,7 @@ class l extends s {
         }],
         target: a
       } : null;
-    }).filter((a) => !!a), T = r.length > 0 ? {
+    }).filter((a) => !!a), p = r.length > 0 ? {
       genericType: {
         dataType: {
           id: t.id
@@ -80,12 +82,12 @@ class l extends s {
         id: t.id
       }
     };
-    return y(T, this);
+    return y(p, this);
   }
   hasDataTypes(e) {
     return e.every((i) => this.values().find((t) => t.id === (i.genericType?.dataType?.id ?? i.dataType?.id)));
   }
 }
 export {
-  l as DFlowDataTypeReactiveService
+  D as DFlowDataTypeReactiveService
 };