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

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

@@ -1,3 +1,7 @@
 import { Node } from '@xyflow/react';
-import { Flow } from '@code0-tech/sagittarius-graphql-types';
-export declare const useFlowNodes: (flowId: Flow["id"]) => Node[];
+import { Flow, Namespace, NamespaceProject } from '@code0-tech/sagittarius-graphql-types';
+import { DFlowFunctionDefaultCardDataProps } from '../d-flow-function/DFlowFunctionDefaultCard';
+import { DFlowFunctionSuggestionCardDataProps } from '../d-flow-function/DFlowFunctionSuggestionCard';
+import { DFlowFunctionTriggerCardDataProps } from '../d-flow-function/DFlowFunctionTriggerCard';
+import { DFlowFunctionGroupCardDataProps } from '../d-flow-function/DFlowFunctionGroupCard';
+export declare const useFlowNodes: (flowId: Flow["id"], namespaceId?: Namespace["id"], projectId?: NamespaceProject["id"]) => Node<DFlowFunctionDefaultCardDataProps | DFlowFunctionSuggestionCardDataProps | DFlowFunctionTriggerCardDataProps | DFlowFunctionGroupCardDataProps>[];

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

@@ -1,140 +1,121 @@
-import { useService as T } 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 { D as R } from "../../DFlowDataType.service-Dz8pQUeO.js";
-import { DataTypeVariant as V } from "@code0-tech/sagittarius-graphql-types";
-const E = /* @__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 C from "react";
+import "merge-props";
+import { DFlowReactiveService as M } from "./DFlow.service.js";
+import { DFlowFunctionReactiveService as _ } from "../d-flow-function/DFlowFunction.service.js";
+import { hashToColor as O } from "./DFlow.util.js";
+import { DFlowDataTypeReactiveService as k } from "../d-flow-data-type/DFlowDataType.service.js";
+const V = /* @__PURE__ */ new Map([["std", "default"]]), j = (i, m) => {
+  if (!m || i.size === 0) return "";
+  const v = /[:._\-\/\s]+/, o = m.trim().toLowerCase();
+  let n = null, u = -1 / 0;
+  for (const [l, T] of i.entries()) {
+    const a = l.trim().toLowerCase();
+    if (o === a)
+      return T;
+    let t = 0;
+    if (o.startsWith(a)) {
+      t = 2e3 + a.length * 2;
+      const d = o.charAt(a.length);
+      (d === "" || v.test(d)) && (t += 200);
     } else {
-      const u = Math.min(d.length, n.length);
+      const d = Math.min(o.length, a.length);
       let r = 0;
-      for (; r < u && d.charCodeAt(r) === n.charCodeAt(r); )
+      for (; r < d && o.charCodeAt(r) === a.charCodeAt(r); )
         r++;
       if (r > 0) {
-        a = 1e3 + r;
-        const h = d.charAt(r), m = n.charAt(r);
-        (h === "" || f.test(h) || m === "" || f.test(m)) && (a += 50);
+        t = 1e3 + r;
+        const f = o.charAt(r), g = a.charAt(r);
+        (f === "" || v.test(f) || g === "" || v.test(g)) && (t += 50);
       }
     }
-    a > i ? (i = a, t = l) : (a === i && t !== null && l.length > t.length || a === i && t === null) && (t = l);
+    t > u ? (u = t, n = l) : (t === u && n !== null && l.length > n.length || t === u && n === null) && (n = l);
   }
-  return t !== null ? s.get(t) : "";
-}, O = (s) => {
-  const x = T(A), f = T(M), d = T(R), 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 m = 0;
-  i.push({
-    id: `${t.id}`,
-    type: "trigger",
-    position: {
-      x: 0,
-      y: 0
-    },
-    draggable: !1,
-    data: {
-      instance: t,
-      flowId: s
-    }
-  });
-  const I = (e, o = !1, B, y = 0, D = [0], c, N = v, S = n) => {
-    const p = `${e.id}-${l++}`, C = ++m;
-    i.push({
-      id: p,
-      type: K(E, e.functionDefinition?.identifier),
+  return n !== null ? i.get(n) : "";
+}, Z = (i, m, v) => {
+  const o = b(M), n = B(M), u = b(_), l = B(_), T = b(k), a = B(k), t = C.useMemo(() => o.getById(i, {
+    namespaceId: m,
+    projectId: v
+  }), [i, n]);
+  return C.useMemo(() => {
+    if (!t) return [];
+    const d = [];
+    let r = 0;
+    const f = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), A = (e, s = f) => (s.has(e) || s.set(e, u.getById(e)), s.get(e)), $ = (e, s = g) => (s.has(e) || s.set(e, T.getDataType(e)), s.get(e));
+    let R = 0;
+    const E = () => ++R;
+    let W = 0;
+    d.push({
+      id: `${t.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: t,
+        flowId: i
       }
     });
-    const k = a(e.functionDefinition?.id, N);
-    e.parameters?.forEach((g) => {
-      const F = k?.parameterDefinitions.find((b) => b.id == g.runtimeParameter?.id)?.dataTypeIdentifier;
-      if ((F ? u(F, S) : void 0)?.variant === V.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
-            }
-          }), I(g.value, !1, void 0, y + 1, w, b, N, S);
+    const I = (e, s = !1, K, p = 0, h = [0], y, S = f, N = g) => {
+      if (!e) return;
+      const D = `${e?.id}-${r++}`, L = ++W;
+      d.push({
+        id: D,
+        type: j(V, e?.functionDefinition?.identifier),
+        position: {
+          x: 0,
+          y: 0
+        },
+        draggable: !1,
+        parentId: y,
+        extent: y ? "parent" : void 0,
+        data: {
+          nodeId: e.id,
+          isParameter: s,
+          flowId: i,
+          linkingId: s ? K : void 0,
+          scope: h,
+          // scope is now a PATH (number[])
+          depth: p,
+          // structural depth (0 at root, +1 per group)
+          index: L
+          // global node level
         }
-      } else g.value && g.value instanceof $ && I(g.value, !0, p, y, D, c, N, S);
-    }), e.nextNodeId && I(t.getNodeById(e.nextNodeId), !1, void 0, y, D, c, N, S);
-  };
-  return t.startingNodeId ? I(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 z = A(e?.functionDefinition?.id, S);
+      e.parameters?.nodes?.forEach((c) => {
+        const F = z?.parameterDefinitions.find((x) => x.id == c?.runtimeParameter?.id)?.dataTypeIdentifier;
+        if ((F ? $(F, N) : void 0)?.variant === "NODE") {
+          if (c?.value && c.value.__typename === "NodeFunctionIdWrapper") {
+            const x = `${D}-group-${r++}`, w = [...h, E()];
+            d.push({
+              id: x,
+              type: "group",
+              position: {
+                x: 0,
+                y: 0
+              },
+              draggable: !1,
+              parentId: y,
+              extent: y ? "parent" : void 0,
+              data: {
+                isParameter: !0,
+                linkingId: D,
+                flowId: i,
+                depth: p + 1,
+                scope: w,
+                color: O(c.value?.id ?? "")
+              }
+            }), I(o.getNodeById(i, c.value.id), !1, void 0, p + 1, w, x, S, N);
+          }
+        } else c?.value && c.value.__typename === "NodeFunctionIdWrapper" && I(o.getNodeById(i, c.value.id), !0, D, p, h, y, S, N);
+      }), e.nextNodeId && I(o.getNodeById(t.id, e.nextNodeId), !1, void 0, p, h, y, S, N);
+    };
+    return t.startingNodeId && I(o.getNodeById(t.id, t.startingNodeId), !1, void 0, 0, [0], void 0, f, g), d;
+  }, [t, n, l, a]);
 };
 export {
-  O as useFlowNodes
+  Z as useFlowNodes
 };

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

@@ -1,10 +1,20 @@
-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, Maybe, Namespace, NamespaceProject, NamespacesProjectsFlowsCreateInput, NamespacesProjectsFlowsCreatePayload, NamespacesProjectsFlowsDeleteInput, NamespacesProjectsFlowsDeletePayload, NamespacesProjectsFlowsUpdateInput, NamespacesProjectsFlowsUpdatePayload, NodeFunction, NodeParameter, ReferenceValue, Scalars } from '@code0-tech/sagittarius-graphql-types';
+export type DFlowDependencies = {
+    namespaceId: Namespace['id'];
+    projectId: NamespaceProject['id'];
+};
+export declare abstract class DFlowReactiveService extends ReactiveArrayService<Flow, DFlowDependencies> {
+    getById(id: Flow['id'], dependencies?: DFlowDependencies): Flow | undefined;
+    protected removeParameterNode(flow: Flow, parameter: NodeParameter): void;
+    getLinkedNodesById(flowId: Flow['id'], nodeId: NodeFunction['id']): NodeFunction[];
+    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'], settingIdentifier: Maybe<Scalars['String']['output']>, 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,136 @@
-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 N } from "../../utils/reactiveArrayService.js";
+import "merge-props";
+class m extends N {
+  getById(t, i) {
+    return this.values(i).find((n) => n.id === t);
+  }
+  removeParameterNode(t, i) {
+    if (i?.value?.__typename === "NodeFunctionIdWrapper") {
+      const n = t?.nodes?.nodes?.find((e) => e?.id === i.value?.id);
+      if (n) {
+        t.nodes.nodes = t.nodes.nodes.filter((d) => d?.id !== i.value?.id);
+        let e = n.nextNodeId;
+        for (; e; ) {
+          const d = t.nodes.nodes.find((o) => o?.id === e);
+          d ? (t.nodes.nodes = t.nodes.nodes.filter((o) => o?.id !== e), e = d.nextNodeId) : e = null;
+        }
+        n.parameters?.nodes?.forEach((d) => {
+          this.removeParameterNode(t, d);
+        });
+      }
+    }
+  }
+  getLinkedNodesById(t, i) {
+    const n = this.getNodeById(t, i), e = n ? this.getLinkedNodesById(t, n.nextNodeId) : [], d = [];
+    return n?.parameters?.nodes?.forEach((o) => {
+      if (o?.value?.__typename === "NodeFunctionIdWrapper") {
+        const r = this.getNodeById(t, o.value?.id);
+        r && (d.push(r), d.push(...r ? this.getLinkedNodesById(t, r.nextNodeId) : []));
+      }
+    }), [...n ? [n] : [], ...d, ...e];
+  }
+  getNodeById(t, i) {
+    return this.getById(t)?.nodes?.nodes?.find((n) => n?.id === i);
+  }
+  getPayloadById(t) {
+    const i = this.getById(t), n = (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(n) ?? []
+          })) ?? []
+        }
+      } : {}
+    });
+    return {
+      name: i?.name,
+      type: i?.type?.id,
+      settings: i?.settings?.nodes?.map((e) => ({
+        flowSettingIdentifier: e?.flowSettingIdentifier,
+        value: e?.value
+      })),
+      nodes: i?.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: n((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: i?.startingNodeId
+    };
+  }
+  async deleteNodeById(t, i) {
+    const n = this.getById(t), e = this.getNodeById(t, i), d = n?.nodes?.nodes?.find((s) => s?.parameters?.nodes?.find((a) => a?.value?.__typename === "NodeFunctionIdWrapper" && a.value?.id === i)), o = n?.nodes?.nodes?.find((s) => s?.nextNodeId === i), r = this.values().findIndex((s) => s.id === t);
+    if (!(!n || !e)) {
+      if (n.nodes.nodes = n.nodes.nodes.filter((s) => s?.id !== i), e.parameters?.nodes?.forEach((s) => this.removeParameterNode(n, s)), o ? o.nextNodeId = e.nextNodeId : d || (n.startingNodeId = e.nextNodeId ?? void 0), d) {
+        const s = d.parameters?.nodes?.find((a) => a?.value?.__typename === "NodeFunctionIdWrapper" && a.value?.id === i);
+        s && (s.value = void 0);
+      }
+      this.set(r, n);
+    }
+  }
+  async addNextNodeById(t, i, n) {
+    const e = this.getById(t), d = this.values().findIndex((u) => u.id === t), o = i ? this.getNodeById(t, i) : void 0;
+    if (!e || i && !o) return;
+    const s = `gid://sagittarius/NodeFunction/${Math.max(0, ...e.nodes?.nodes?.map((u) => Number(u?.id?.match(/NodeFunction\/(\d+)$/)?.[1] ?? 0)) ?? [0]) + 1}`, a = {
+      ...JSON.parse(JSON.stringify(n)),
+      id: s
+    };
+    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(t, i, n) {
+    const e = this.getById(t), d = this.values().findIndex((r) => r.id === t);
+    if (!e) return;
+    const o = e.settings?.nodes?.find((r) => r?.flowSettingIdentifier === i);
+    o && (o.value = n, this.set(d, e));
+  }
+  async setParameterValue(t, i, n, e) {
+    const d = this.getById(t), o = this.values().findIndex((a) => a.id === t);
+    if (!d) return;
+    const r = this.getNodeById(t, i);
+    if (!r) return;
+    const s = r.parameters?.nodes?.find((a) => a?.id === n);
+    if (s) {
+      if (this.removeParameterNode(d, s), 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), s.value = {
+          id: `gid://sagittarius/NodeFunction/${a + 1}`,
+          __typename: "NodeFunctionIdWrapper"
+        };
+      } else
+        s.value = e;
+      this.set(o, d);
+    }
   }
 }
 export {
-  c as DFlowReactiveService
+  m as DFlowReactiveService
 };

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

@@ -0,0 +1,4 @@
+import { DataTypeIdentifier } from '@code0-tech/sagittarius-graphql-types';
+export declare const hashToColor: (s: string) => string;
+export declare const attachDataTypeIdentifiers: <T>(identifiers: DataTypeIdentifier[], input: T) => T;
+export declare const resolveDataTypeIdentifiers: (list: DataTypeIdentifier[]) => DataTypeIdentifier[];

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

@@ -0,0 +1,63 @@
+import { md5 as d } from "js-md5";
+const f = 137.50776405003785, T = (t) => {
+  const a = t.match(/\/(\d+)\s*$/);
+  return a ? Number(a[1]) : null;
+}, m = (t) => {
+  const a = T(t);
+  if (a != null)
+    return `hsl(${25 + a * f % 320}, 100%, 72%)`;
+  const n = d(d(t));
+  return `hsl(${25 + parseInt(n.slice(0, 8), 16) % 320}, 100%, 72%)`;
+}, l = (t, a) => {
+  const n = new Map(t.filter((r) => r?.id).map((r) => [r.id, r])), i = (r) => Array.isArray(r) ? r.map(i) : r && typeof r == "object" ? {
+    ...Object.fromEntries(Object.entries(r).map(([s, e]) => [s, i(e)])),
+    ...r.dataTypeIdentifierId ? {
+      dataTypeIdentifier: n.get(r.dataTypeIdentifierId) ?? null
+    } : {},
+    ...Array.isArray(r.sourceDataTypeIdentifierIds) ? {
+      sourceDataTypeIdentifiers: r.sourceDataTypeIdentifierIds.map((s) => n.get(s)).filter(Boolean)
+    } : {}
+  } : r;
+  return i(a);
+}, u = (t) => {
+  const a = new Map(t.filter((e) => e?.id).map((e) => [e.id, e])), n = /* @__PURE__ */ new Map(), i = (e) => {
+    if (!e?.id) return e;
+    if (n.has(e.id)) return n.get(e.id);
+    const o = {
+      ...e
+    };
+    if (n.set(e.id, o), e.genericType) {
+      o.genericType = {
+        ...e.genericType
+      };
+      const p = e.genericType.genericMappers;
+      Array.isArray(p) && (o.genericType.genericMappers = p.map((c) => ({
+        ...c,
+        ...Array.isArray(c.sourceDataTypeIdentifierIds) ? {
+          sourceDataTypeIdentifiers: c.sourceDataTypeIdentifierIds.map((y) => i(a.get(y) ?? null)).filter(Boolean)
+        } : {}
+      })));
+    }
+    return o;
+  }, r = t.map((e) => i(e)).filter(Boolean), s = (e) => {
+    if (!e) return e;
+    const o = e?.dataTypeIdentifiers?.nodes;
+    if (!Array.isArray(o)) return e;
+    const p = u(o), c = {
+      ...e,
+      dataTypeIdentifiers: {
+        ...e.dataTypeIdentifiers,
+        nodes: p
+      }
+    };
+    return l(p, c);
+  };
+  return r.forEach((e) => {
+    e?.dataType && (e.dataType = s(e.dataType)), e?.genericType?.dataType && (e.genericType.dataType = s(e.genericType.dataType));
+  }), r;
+};
+export {
+  l as attachDataTypeIdentifiers,
+  m as hashToColor,
+  u as resolveDataTypeIdentifiers
+};

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 n, jsxs as O, Fragment as z } from "react/jsx-runtime";
+import { c as D } from "../../_virtual/compiler-runtime.js";
+import { Position as P, getSmoothStepPath as G, BaseEdge as T, EdgeLabelRenderer as W } from "@xyflow/react";
+import { memo as q } from "react";
+import { Badge as A } from "../badge/Badge.js";
+const V = q((E) => {
+  const t = D.c(43);
+  let s, i, a, d, e, o, r, l;
+  if (t[0] !== E) {
+    const {
+      sourceX: S,
+      sourceY: j,
+      targetX: v,
+      targetY: w,
+      id: C,
+      data: F,
+      label: I,
+      style: H,
+      ...U
+    } = E;
+    e = S, o = j, r = v, l = w, i = C, s = F, a = I, d = U, t[0] = E, t[1] = s, t[2] = i, t[3] = a, t[4] = d, t[5] = e, t[6] = o, t[7] = r, t[8] = l;
+  } else
+    s = t[1], i = t[2], a = t[3], d = t[4], e = t[5], o = t[6], r = t[7], l = t[8];
+  const X = s?.type === "parameter" ? P.Left : P.Bottom, Y = s?.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 = G({
+    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 = s?.color ?? "#ffffff", y = `dflow-edge-gradient-${i}`;
+  let c, p;
+  t[16] !== x ? (c = /* @__PURE__ */ n("stop", { offset: "0", stopColor: x, stopOpacity: 0.25 }), p = /* @__PURE__ */ n("stop", { offset: "1", stopColor: x, stopOpacity: 0.75 }), 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__ */ n("defs", { children: /* @__PURE__ */ O("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})`, L = s?.type === "default" ? "3px" : "2px";
+  let m;
+  t[27] !== B || t[28] !== L ? (m = {
+    stroke: B,
+    strokeWidth: L,
+    strokeLinecap: "round"
+  }, t[27] = B, t[28] = L, t[29] = m) : m = t[29];
+  let g;
+  t[30] !== $ || t[31] !== i || t[32] !== d || t[33] !== m ? (g = /* @__PURE__ */ n(T, { id: i, path: $, ...d, style: m }), t[30] = $, t[31] = i, t[32] = d, t[33] = m, t[34] = g) : g = t[34];
+  let u;
+  t[35] !== a || t[36] !== R || t[37] !== k ? (u = a ? /* @__PURE__ */ n(W, { children: /* @__PURE__ */ n("div", { style: {
+    position: "absolute",
+    transform: `translate(-50%, -50%) translate(${R}px, ${k}px)`,
+    pointerEvents: "all",
+    zIndex: 100
+  }, children: /* @__PURE__ */ n(A, { color: "primary", border: !0, children: a }) }) }) : null, t[35] = a, t[36] = R, t[37] = k, t[38] = u) : u = t[38];
+  let b;
+  return t[39] !== u || t[40] !== f || t[41] !== g ? (b = /* @__PURE__ */ O(z, { children: [
+    f,
+    g,
+    u
+  ] }), t[39] = u, t[40] = f, t[41] = g, t[42] = b) : b = t[42], b;
+});
+export {
+  V 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';