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

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
+};

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

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

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

@@ -0,0 +1,24 @@
+import { useService as f, useStore as p } from "../../utils/contextStore.js";
+import o from "react";
+import "merge-props";
+import { DFlowFunctionReactiveService as g } from "../d-flow-function/DFlowFunction.service.js";
+import "js-md5";
+import "../d-flow/DFlow.js";
+import { DFlowReactiveService as a } 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 { useValueSuggestions as M } from "./DFlowValueSuggestions.hook.js";
+import { useReferenceSuggestions as R } from "./DFlowReferenceSuggestions.hook.js";
+import { useFunctionSuggestions as T } from "./DFlowFunctionSuggestions.hook.js";
+import { useDataTypeSuggestions as B } from "./DFlowDataTypeSuggestions.hook.js";
+const J = (e, t, n) => {
+  const c = f(g), u = f(a), S = p(g), D = p(a), r = o.useMemo(() => u.getNodeById(e, t), [e, u, D, t]), s = o.useMemo(() => r?.functionDefinition?.id ? c.getById(r.functionDefinition.id) : void 0, [S, c, r?.functionDefinition?.id]), i = o.useMemo(() => s?.parameterDefinitions?.find((F) => F.id === n), [s?.parameterDefinitions, n])?.dataTypeIdentifier, m = s?.genericKeys ?? [], v = M(i), y = B(i), d = R(e, t, i, m), l = T(i, m);
+  return o.useMemo(() => [...v, ...y, ...d, ...l].sort(), [e, t, n]);
+};
+export {
+  J as useSuggestions
+};

package/dist/components/d-flow-suggestion/DFlowSuggestion.view.d.ts

@@ -0,0 +1,14 @@
+import { LiteralValue, NodeFunction, ReferenceValue } from '@code0-tech/sagittarius-graphql-types';
+export declare enum DFlowSuggestionType {
+    REF_OBJECT = 0,
+    VALUE = 1,
+    FUNCTION = 2,
+    FUNCTION_COMBINATION = 3,
+    DATA_TYPE = 4
+}
+export interface DFlowSuggestion {
+    displayText: string[];
+    path: number[];
+    value: LiteralValue | ReferenceValue | NodeFunction;
+    type: DFlowSuggestionType;
+}

package/dist/components/d-flow-suggestion/DFlowSuggestion.view.js

@@ -0,0 +1,4 @@
+var O = /* @__PURE__ */ ((N) => (N[N.REF_OBJECT = 0] = "REF_OBJECT", N[N.VALUE = 1] = "VALUE", N[N.FUNCTION = 2] = "FUNCTION", N[N.FUNCTION_COMBINATION = 3] = "FUNCTION_COMBINATION", N[N.DATA_TYPE = 4] = "DATA_TYPE", N))(O || {});
+export {
+  O as DFlowSuggestionType
+};

package/dist/components/d-flow-suggestion/DFlowSuggestionMenu.js

@@ -0,0 +1,72 @@
+import { jsx as r, jsxs as F } from "react/jsx-runtime";
+import { c as k } from "../../_virtual/compiler-runtime.js";
+import { MenuTrigger as v, MenuSeparator as C, MenuPortal as A, Menu as E } from "../menu/Menu.js";
+import y from "react";
+import { DFlowSuggestionMenuFooter as B } from "./DFlowSuggestionMenuFooter.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 { InputSuggestionMenuContentItems as L, InputSuggestionMenuContent as P } from "../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 "../form/TextInput.js";
+import { toInputSuggestions as U } from "./DFlowSuggestionMenu.util.js";
+import { DFlowSuggestionMenuSearchBar as $ } from "./DFlowSuggestionMenuSearchBar.js";
+const le = (R) => {
+  const e = k.c(25), {
+    suggestions: f,
+    triggerContent: M,
+    onSuggestionSelect: I
+  } = R;
+  let c;
+  e[0] !== f ? (c = f === void 0 ? [] : f, e[0] = f, e[1] = c) : c = e[1];
+  const t = c, D = I === void 0 ? q : I, _ = y.useRef(null), [w, x] = y.useState(t);
+  let g, p;
+  e[2] !== t ? (g = () => {
+    x(t);
+  }, p = [t], e[2] = t, e[3] = g, e[4] = p) : (g = e[3], p = e[4]), y.useEffect(g, p);
+  let i;
+  e[5] !== M ? (i = /* @__PURE__ */ r(v, { asChild: !0, children: M }), e[5] = M, e[6] = i) : i = e[6];
+  let s;
+  e[7] !== t ? (s = /* @__PURE__ */ r($, { onType: (o) => {
+    o.key === "ArrowDown" ? (o.preventDefault(), _.current?.focusFirstItem()) : o.key === "ArrowUp" && (o.preventDefault(), _.current?.focusLastItem());
+    const T = o.target.value;
+    return x(t.filter((b) => b.displayText.some((j) => j.includes(T)))), o.preventDefault(), !1;
+  } }), e[7] = t, e[8] = s) : s = e[8];
+  let a;
+  e[9] === Symbol.for("react.memo_cache_sentinel") ? (a = /* @__PURE__ */ r(C, {}), e[9] = a) : a = e[9];
+  let n;
+  e[10] !== w ? (n = U(w), e[10] = w, e[11] = n) : n = e[11];
+  let l;
+  e[12] !== D ? (l = (o) => {
+    D(o.valueData);
+  }, e[12] = D, e[13] = l) : l = e[13];
+  let u;
+  e[14] !== n || e[15] !== l ? (u = /* @__PURE__ */ r(L, { ref: _, suggestions: n, onSuggestionSelect: l }), e[14] = n, e[15] = l, e[16] = u) : u = e[16];
+  let S, d;
+  e[17] === Symbol.for("react.memo_cache_sentinel") ? (S = /* @__PURE__ */ r(C, {}), d = /* @__PURE__ */ r(B, {}), e[17] = S, e[18] = d) : (S = e[17], d = e[18]);
+  let m;
+  e[19] !== u || e[20] !== s ? (m = /* @__PURE__ */ r(A, { children: /* @__PURE__ */ F(P, { align: "center", children: [
+    s,
+    a,
+    u,
+    S,
+    d
+  ] }) }), e[19] = u, e[20] = s, e[21] = m) : m = e[21];
+  let h;
+  return e[22] !== m || e[23] !== i ? (h = /* @__PURE__ */ F(E, { children: [
+    i,
+    m
+  ] }), e[22] = m, e[23] = i, e[24] = h) : h = e[24], h;
+};
+function q() {
+}
+export {
+  le as DFlowSuggestionMenu
+};

package/dist/components/{d-flow/suggestion → d-flow-suggestion}/DFlowSuggestionMenu.util.d.ts

@@ -1,3 +1,3 @@
 import { DFlowSuggestion } from './DFlowSuggestion.view';
-import { InputSuggestion } from '../../form/InputSuggestion';
+import { InputSuggestion } from '../form';
 export declare const toInputSuggestions: (suggestions: DFlowSuggestion[]) => InputSuggestion[];

package/dist/components/{d-flow/suggestion → d-flow-suggestion}/DFlowSuggestionMenu.util.js

@@ -1,23 +1,23 @@
 import { jsx as o, jsxs as T, Fragment as d } from "react/jsx-runtime";
 import { DFlowSuggestionType as e } from "./DFlowSuggestion.view.js";
-import { IconCircleDot as c, IconCirclesRelation as I, IconFileFunctionFilled as p } from "@tabler/icons-react";
-import { Text as N } from "../../text/Text.js";
-const O = (a) => {
+import { IconCircleDot as c, IconCirclesRelation as s, IconFileFunctionFilled as a } from "@tabler/icons-react";
+import { Text as u } from "../text/Text.js";
+const D = (p) => {
   const f = {
     [e.VALUE]: "Values",
     [e.REF_OBJECT]: "Variables",
     [e.DATA_TYPE]: "Datatypes"
   };
-  return a.map((i) => {
+  return p.map((i) => {
     const m = {
-      [e.FUNCTION]: /* @__PURE__ */ o(p, { color: "#70ffb2", size: 16 }),
-      [e.FUNCTION_COMBINATION]: /* @__PURE__ */ o(p, { color: "#70ffb2", size: 16 }),
-      [e.REF_OBJECT]: /* @__PURE__ */ o(I, { color: "#FFBE0B", size: 16 }),
+      [e.FUNCTION]: /* @__PURE__ */ o(a, { color: "#70ffb2", size: 16 }),
+      [e.FUNCTION_COMBINATION]: /* @__PURE__ */ o(a, { color: "#70ffb2", size: 16 }),
+      [e.REF_OBJECT]: /* @__PURE__ */ o(s, { color: "#FFBE0B", size: 16 }),
       [e.VALUE]: /* @__PURE__ */ o(c, { color: "#D90429", size: 16 }),
       [e.DATA_TYPE]: /* @__PURE__ */ o(c, { color: "#D90429", size: 16 })
     }, F = /* @__PURE__ */ T(d, { children: [
       m[i.type],
-      /* @__PURE__ */ o("div", { children: /* @__PURE__ */ o(N, { display: "flex", style: {
+      /* @__PURE__ */ o("div", { children: /* @__PURE__ */ o(u, { display: "flex", style: {
         gap: ".5rem"
       }, children: i.displayText.map((t, r) => /* @__PURE__ */ o("span", { children: t }, r)) }) })
     ] });
@@ -31,12 +31,13 @@ const O = (a) => {
     }
     return {
       children: F,
-      ref: i,
+      insertMode: "replace",
+      valueData: i,
       value: i.value,
-      groupLabel: n
+      groupBy: n
     };
   });
 };
 export {
-  O as toInputSuggestions
+  D as toInputSuggestions
 };

package/dist/components/{d-flow/suggestion → d-flow-suggestion}/DFlowSuggestionMenuFooter.js

@@ -1,10 +1,10 @@
 import { jsxs as t, jsx as r } from "react/jsx-runtime";
-import { c as y } from "../../../compiler-runtime-BNHg76kC.js";
-import { MenuLabel as p } from "../../menu/Menu.js";
+import { c as y } from "../../_virtual/compiler-runtime.js";
+import { MenuLabel as p } from "../menu/Menu.js";
 import { IconCornerDownLeft as d, IconBulb as g, IconFileFunctionFilled as _, IconArrowsShuffle as b, IconCirclesRelation as u, IconCircleDot as x } from "@tabler/icons-react";
-import { Text as f } from "../../text/Text.js";
-import { Flex as i } from "../../flex/Flex.js";
-import { TooltipTrigger as F, Tooltip as I, TooltipPortal as z, TooltipContent as S } from "../../tooltip/Tooltip.js";
+import { Text as f } from "../text/Text.js";
+import { Flex as i } from "../flex/Flex.js";
+import { TooltipTrigger as F, Tooltip as I, TooltipPortal as z, TooltipContent as S } from "../tooltip/Tooltip.js";
 const O = () => {
   const e = y.c(8);
   let l;

package/dist/components/{d-flow/suggestion → d-flow-suggestion}/DFlowSuggestionMenuSearchBar.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { Code0Component } from '../../../utils/types';
+import { Code0Component } from '../../utils';
 export interface DFlowSuggestionMenuSearchBarProps extends Code0Component<HTMLDivElement> {
     onType: (event: React.KeyboardEvent<HTMLInputElement>) => void;
 }

package/dist/components/{d-flow/suggestion → d-flow-suggestion}/DFlowSuggestionMenuSearchBar.js

@@ -1,5 +1,5 @@
 import { jsx as n } from "react/jsx-runtime";
-import { c as m } from "../../../compiler-runtime-BNHg76kC.js";
+import { c as m } from "../../_virtual/compiler-runtime.js";
 import { DFlowSuggestionSearchInput as i } from "./DFlowSuggestionSearchInput.js";
 import { IconSearch as s } from "@tabler/icons-react";
 const p = (c) => {

package/dist/components/{d-flow/suggestion → d-flow-suggestion}/DFlowSuggestionSearchInput.d.ts

@@ -1,4 +1,4 @@
-import { InputProps } from '../../form/Input';
+import { InputProps } from '../form';
 import { default as React } from 'react';
 interface DFlowSuggestionSearchInputProps extends Omit<InputProps<string | null>, "wrapperComponent" | "type"> {
     clearable?: boolean;

package/dist/components/d-flow-suggestion/DFlowSuggestionSearchInput.js

@@ -0,0 +1,35 @@
+import { jsx as o } from "react/jsx-runtime";
+import "../../_virtual/compiler-runtime.js";
+import i from "react";
+import "@radix-ui/react-checkbox";
+import "merge-props";
+import { IconX as s } from "@tabler/icons-react";
+import '../../assets/components/d-flow-suggestion/DFlowSuggestionSearchInput.style.css';import '../../assets/components/form/Input.style.css';/* empty css                       */
+import "../form/EmailInput.js";
+import { Input as c } from "../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 "../form/TextInput.js";
+import { Button as l } from "../button/Button.js";
+/* empty css                                      */
+import { clearInputElement as u } from "../form/Input.utils.js";
+const D = i.forwardRef((p, t) => {
+  t = t || i.useRef(null);
+  const {
+    clearable: m = !1,
+    right: e,
+    ...n
+  } = p, a = () => {
+    u(t.current);
+  }, r = [e];
+  return m && r.push(/* @__PURE__ */ o(l, { variant: "none", onClick: a, children: /* @__PURE__ */ o(s, { size: 13 }) })), /* @__PURE__ */ o(c, { wrapperComponent: {
+    className: "d-flow-suggestion-search-input"
+  }, right: r, type: "text", ref: t, ...n });
+});
+export {
+  D as DFlowSuggestionSearchInput
+};

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

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

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

@@ -0,0 +1,44 @@
+import n from "react";
+import { useService as f, useStore as c } from "../../utils/contextStore.js";
+import "merge-props";
+import { DFlowDataTypeReactiveService as p } from "../d-flow-data-type/DFlowDataType.service.js";
+import "js-md5";
+import { DFlowSuggestionType as u } from "./DFlowSuggestion.view.js";
+const E = (r) => {
+  const s = f(p), m = c(p), i = n.useMemo(() => r ? s?.getDataType(r) : void 0, [r, s, m]);
+  return n.useMemo(() => {
+    if (!i) return [];
+    const a = [];
+    return i.rules?.nodes?.forEach((e) => {
+      if (e?.variant === "ITEM_OF_COLLECTION")
+        e.config.items?.forEach((t) => {
+          a.push({
+            path: [],
+            type: u.VALUE,
+            displayText: [t.toString()],
+            value: {
+              __typename: "LiteralValue",
+              value: t
+            }
+          });
+        });
+      else if (e?.variant === "NUMBER_RANGE") {
+        const t = e.config;
+        if (t.from === null || t.from === void 0 || t.to === null || t.to === void 0) return;
+        for (let o = t.from; o <= t.to; o += t.steps ?? 1)
+          a.push({
+            path: [],
+            type: u.VALUE,
+            displayText: [o.toString() ?? ""],
+            value: {
+              __typename: "LiteralValue",
+              value: String(o)
+            }
+          });
+      }
+    }), a;
+  }, [i]);
+};
+export {
+  E as useValueSuggestions
+};

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

@@ -0,0 +1 @@
+export * from './DFlowSuggestion.view';

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

@@ -0,0 +1,4 @@
+import { DFlowSuggestionType as g } from "./DFlowSuggestion.view.js";
+export {
+  g as DFlowSuggestionType
+};

package/dist/components/d-flow-type/DFlowType.service.d.ts

@@ -0,0 +1,11 @@
+import { ReactiveArrayService } from '../../utils';
+import { FlowTypeView } from './DFlowType.view';
+import { FlowType, Namespace, NamespaceProject, Runtime } from '@code0-tech/sagittarius-graphql-types';
+export type DFlowTypeDependencies = {
+    namespaceId: Namespace['id'];
+    projectId: NamespaceProject['id'];
+    runtimeId: Runtime['id'];
+};
+export declare abstract class DFlowTypeReactiveService extends ReactiveArrayService<FlowTypeView, DFlowTypeDependencies> {
+    getById(id: FlowType['id'], dependencies?: DFlowTypeDependencies): FlowTypeView | undefined;
+}

package/dist/components/d-flow-type/DFlowType.service.js

@@ -0,0 +1,12 @@
+import "../../utils/contextStore.js";
+import "react";
+import { ReactiveArrayService as t } from "../../utils/reactiveArrayService.js";
+import "merge-props";
+class s extends t {
+  getById(e, r) {
+    return this.values(r).find((i) => i.id === e);
+  }
+}
+export {
+  s as DFlowTypeReactiveService
+};

package/dist/components/{d-flow/type → d-flow-type}/DFlowType.view.d.ts

@@ -1,9 +1,13 @@
-import { DataType, FlowType, FlowTypeSetting, Maybe, Scalars, TranslationConnection } from '@code0-tech/sagittarius-graphql-types';
+import { DataType, FlowType, FlowTypeSetting, Maybe, Scalars, Translation } from '@code0-tech/sagittarius-graphql-types';
 export declare class FlowTypeView {
+    /** Name of the function */
+    private readonly _aliases?;
     /** Time when this FlowType was created */
     private readonly _createdAt?;
     /** Descriptions of the flow type */
     private readonly _descriptions?;
+    /** Display message of the function */
+    private readonly _displayMessages?;
     /** Editable status of the flow type */
     private readonly _editable?;
     /** Flow type settings of the flow type */
@@ -21,14 +25,16 @@ export declare class FlowTypeView {
     /** Time when this FlowType was last updated */
     private readonly _updatedAt?;
     constructor(flowType: FlowType);
+    get aliases(): Maybe<Array<Translation>> | undefined;
     get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
-    get descriptions(): Maybe<TranslationConnection> | undefined;
+    get descriptions(): Maybe<Array<Translation>> | undefined;
+    get displayMessages(): Maybe<Array<Translation>> | undefined;
     get editable(): Maybe<Scalars["Boolean"]["output"]> | undefined;
     get flowTypeSettings(): Maybe<Array<FlowTypeSetting>> | undefined;
-    get id(): Maybe<Scalars["TypesFlowTypeID"]["output"]> | undefined;
+    get id(): Maybe<Scalars["FlowTypeID"]["output"]> | undefined;
     get identifier(): Maybe<Scalars["String"]["output"]> | undefined;
     get inputType(): Maybe<DataType> | undefined;
-    get names(): Maybe<TranslationConnection> | undefined;
+    get names(): Maybe<Array<Translation>> | undefined;
     get returnType(): Maybe<DataType> | undefined;
     get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
     json(): FlowType;

package/dist/components/d-flow-type/DFlowType.view.js

@@ -0,0 +1,85 @@
+import "../../utils/contextStore.js";
+import "react";
+import "merge-props";
+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 { DataTypeView as n } from "../d-flow-data-type/DFlowDataType.view.js";
+function e(i, t, s) {
+  return (t = d(t)) in i ? Object.defineProperty(i, t, { value: s, enumerable: !0, configurable: !0, writable: !0 }) : i[t] = s, i;
+}
+function d(i) {
+  var t = p(i, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function p(i, t) {
+  if (typeof i != "object" || !i) return i;
+  var s = i[Symbol.toPrimitive];
+  if (s !== void 0) {
+    var r = s.call(i, t);
+    if (typeof r != "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(i);
+}
+class v {
+  constructor(t) {
+    e(this, "_aliases", void 0), e(this, "_createdAt", void 0), e(this, "_descriptions", void 0), e(this, "_displayMessages", void 0), e(this, "_editable", void 0), e(this, "_flowTypeSettings", void 0), e(this, "_id", void 0), e(this, "_identifier", void 0), e(this, "_inputType", void 0), e(this, "_names", void 0), e(this, "_returnType", void 0), e(this, "_updatedAt", void 0), this._aliases = t.aliases, this._createdAt = t.createdAt, this._descriptions = t.descriptions, this._displayMessages = t.displayMessages, this._editable = t.editable, this._flowTypeSettings = t.flowTypeSettings, this._id = t.id, this._identifier = t.identifier, this._inputType = t.inputType ? new n(t.inputType).json : void 0, this._names = t.names, this._returnType = t.returnType ? new n(t.returnType).json : void 0, this._updatedAt = t.updatedAt, console.log(JSON.stringify(this.inputType)), console.log(this.inputType);
+  }
+  get aliases() {
+    return this._aliases;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get descriptions() {
+    return this._descriptions;
+  }
+  get displayMessages() {
+    return this._displayMessages;
+  }
+  get editable() {
+    return this._editable;
+  }
+  get flowTypeSettings() {
+    return this._flowTypeSettings;
+  }
+  get id() {
+    return this._id;
+  }
+  get identifier() {
+    return this._identifier;
+  }
+  get inputType() {
+    return this._inputType;
+  }
+  get names() {
+    return this._names;
+  }
+  get returnType() {
+    return this._returnType;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  json() {
+    return {
+      createdAt: this._createdAt,
+      descriptions: this._descriptions,
+      editable: this._editable,
+      flowTypeSettings: this._flowTypeSettings,
+      id: this._id,
+      identifier: this._identifier,
+      inputType: this._inputType,
+      names: this._names,
+      returnType: this._returnType,
+      updatedAt: this._updatedAt
+    };
+  }
+}
+export {
+  v as FlowTypeView
+};