@code0-tech/pictor 0.0.0-mvp.10

package/dist/components/d-flow/folder/DFlowFolder.js

@@ -0,0 +1,119 @@
+import { jsxs as g, Fragment as O, jsx as s } from "react/jsx-runtime";
+import { c as N } from "../../../_virtual/compiler-runtime.js";
+import '../../../assets/components/d-flow/folder/DFlowFolder.style.css';/* empty css                       */
+import S from "react";
+import { mergeCode0Props as D } from "../../../utils/utils.js";
+import { IconChevronDown as $, IconChevronRight as x, IconFolder as A } from "@tabler/icons-react";
+import { useService as I, useStore as k } from "../../../utils/contextStore.js";
+import { DFlowReactiveService as b } from "../DFlow.service.js";
+import { ScrollArea as z, ScrollAreaViewport as R, ScrollAreaScrollbar as j, ScrollAreaThumb as M } from "../../scroll-area/ScrollArea.js";
+const U = (f) => {
+  const {
+    flowId: e
+  } = f, a = I(b), m = k(b), h = (n) => n.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean), d = S.useMemo(() => (a.values?.() ?? []).filter((l) => !!l?.name), [m]), p = S.useMemo(() => {
+    const n = d.find((l) => l.id === e);
+    return n?.name ? h(n.name) : [];
+  }, [d, e]), u = S.useMemo(() => {
+    const n = {
+      name: "",
+      path: "",
+      children: {}
+    };
+    for (const l of d) {
+      const i = h(l.name);
+      if (i.length === 0) continue;
+      let o = n, t = "";
+      for (let c = 0; c < i.length; c++) {
+        const r = i[c];
+        t = t ? `${t}/${r}` : r, c === i.length - 1 ? o.children[r] ? o.children[r].flow = l : o.children[r] = {
+          name: r,
+          path: t,
+          children: {},
+          flow: l
+        } : (o.children[r] || (o.children[r] = {
+          name: r,
+          path: t,
+          children: {}
+        }), o = o.children[r]);
+      }
+    }
+    return n;
+  }, [d]), v = S.useCallback((n) => n ? n.split("/").filter(Boolean).every((i, o) => p[o] === i) : !1, [p]), _ = S.useCallback((n) => {
+    const l = Object.values(n), i = l.filter((t) => !t.flow), o = l.filter((t) => !!t.flow);
+    return i.sort((t, c) => t.name.localeCompare(c.name)), o.sort((t, c) => t.name.localeCompare(c.name)), /* @__PURE__ */ g(O, { children: [
+      i.map((t) => /* @__PURE__ */ s(P, { name: t.name, defaultOpen: v(t.path), children: _(t.children) }, t.path)),
+      o.map((t) => /* @__PURE__ */ s(y, { name: t.name, active: t.flow.id === e, "data-flow-id": t.flow.id ?? void 0, title: t.flow.name ?? void 0 }, t.flow.id ?? t.path))
+    ] });
+  }, [e, v]);
+  return /* @__PURE__ */ g(z, { h: "100%", children: [
+    /* @__PURE__ */ s(R, { children: /* @__PURE__ */ s("div", { className: "d-folder__root", children: _(u.children) }) }),
+    /* @__PURE__ */ s(j, { orientation: "vertical", children: /* @__PURE__ */ s(M, {}) })
+  ] });
+}, P = (f) => {
+  const e = N.c(22), {
+    name: a,
+    defaultOpen: m,
+    children: h,
+    ...d
+  } = f, p = m === void 0 ? !1 : m, [u, v] = S.useState(p);
+  let _;
+  e[0] !== v ? (_ = () => v(B), e[0] = v, e[1] = _) : _ = e[1];
+  const n = D("d-folder", d);
+  let l;
+  e[2] !== v ? (l = () => v(E), e[2] = v, e[3] = l) : l = e[3];
+  let i;
+  e[4] !== u ? (i = u ? /* @__PURE__ */ s($, { size: 12 }) : /* @__PURE__ */ s(x, { size: 12 }), e[4] = u, e[5] = i) : i = e[5];
+  let o;
+  e[6] !== l || e[7] !== i ? (o = /* @__PURE__ */ s("span", { onClick: l, className: "d-folder__status", children: i }), e[6] = l, e[7] = i, e[8] = o) : o = e[8];
+  let t;
+  e[9] === Symbol.for("react.memo_cache_sentinel") ? (t = /* @__PURE__ */ s("span", { className: "d-folder__icon", children: /* @__PURE__ */ s(A, { size: 12 }) }), e[9] = t) : t = e[9];
+  let c;
+  e[10] !== a ? (c = /* @__PURE__ */ s("span", { className: "d-folder__name", children: a }), e[10] = a, e[11] = c) : c = e[11];
+  let r;
+  e[12] !== _ || e[13] !== n || e[14] !== o || e[15] !== c ? (r = /* @__PURE__ */ g("div", { onDoubleClick: _, ...n, children: [
+    o,
+    t,
+    c
+  ] }), e[12] = _, e[13] = n, e[14] = o, e[15] = c, e[16] = r) : r = e[16];
+  const F = u ? h : null;
+  let w;
+  e[17] !== F ? (w = /* @__PURE__ */ s("div", { className: "d-folder__content", children: F }), e[17] = F, e[18] = w) : w = e[18];
+  let C;
+  return e[19] !== w || e[20] !== r ? (C = /* @__PURE__ */ g("div", { children: [
+    r,
+    w
+  ] }), e[19] = w, e[20] = r, e[21] = C) : C = e[21], C;
+}, y = (f) => {
+  const e = N.c(12);
+  let a, m, h;
+  if (e[0] !== f) {
+    const {
+      name: v,
+      icon: _,
+      active: n,
+      ...l
+    } = f;
+    m = v, a = _, h = D(`d-folder__item ${n ? "d-folder__item--active" : ""}`, l), e[0] = f, e[1] = a, e[2] = m, e[3] = h;
+  } else
+    a = e[1], m = e[2], h = e[3];
+  let d;
+  e[4] !== a ? (d = a ? /* @__PURE__ */ s("span", { className: "d-folder__item-icon", children: a }) : null, e[4] = a, e[5] = d) : d = e[5];
+  let p;
+  e[6] !== m ? (p = /* @__PURE__ */ s("span", { className: "d-folder__item-name", children: m }), e[6] = m, e[7] = p) : p = e[7];
+  let u;
+  return e[8] !== h || e[9] !== d || e[10] !== p ? (u = /* @__PURE__ */ g("div", { ...h, children: [
+    d,
+    p
+  ] }), e[8] = h, e[9] = d, e[10] = p, e[11] = u) : u = e[11], u;
+};
+function B(f) {
+  return !f;
+}
+function E(f) {
+  return !f;
+}
+export {
+  U as DFlowFolder,
+  P as DFlowFolderGroup,
+  y as DFlowFolderItem
+};

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

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

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

@@ -0,0 +1,6 @@
+import { DFlowFolder as r, DFlowFolderGroup as F, DFlowFolderItem as e } from "./DFlowFolder.js";
+export {
+  r as DFlowFolder,
+  F as DFlowFolderGroup,
+  e as DFlowFolderItem
+};

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { DFlowDataTypeReactiveService as n } from "../data-type/DFlowDataType.service.js";
+import { resolveGenericKeys as p, replaceGenericKeysInType as i } from "../../../utils/generics.js";
+import { useService as s } from "../../../utils/contextStore.js";
+const c = (e, o, r) => {
+  if (r = r ?? s(n), !e.returnType) return null;
+  const t = p(e, o, r);
+  return i(e.returnType, t);
+};
+export {
+  c as useReturnType
+};

package/dist/components/d-flow/function/DFlowFunction.service.d.ts

@@ -0,0 +1,6 @@
+import { ReactiveArrayService } from '../../../utils/reactiveArrayService';
+import { FunctionDefinitionView } from './DFlowFunction.view';
+import { FunctionDefinition } from '@code0-tech/sagittarius-graphql-types';
+export declare abstract class DFlowFunctionReactiveService extends ReactiveArrayService<FunctionDefinitionView> {
+    getById(id: FunctionDefinition['id']): FunctionDefinitionView | undefined;
+}

package/dist/components/d-flow/function/DFlowFunction.service.js

@@ -0,0 +1,9 @@
+import { ReactiveArrayService as r } from "../../../utils/reactiveArrayService.js";
+class a extends r {
+  getById(e) {
+    return this.values().find((i) => i.id === e);
+  }
+}
+export {
+  a as DFlowFunctionReactiveService
+};

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

@@ -0,0 +1,10 @@
+import { FunctionDefinitionView } from './DFlowFunction.view';
+import { DFlowDataTypeReactiveService } from '../data-type/DFlowDataType.service';
+import { ValidationResult } from '../../../utils/inspection';
+import { NodeParameterValue, Scalars } from '@code0-tech/sagittarius-graphql-types';
+/**
+ * Validates function parameter values against a function definition, resolving all generics.
+ * For each parameter, determines if the provided value is a valid match for the parameter's (possibly generic) type.
+ * Returns an array of ValidationResults (errors for each parameter, null entry for valid).
+ */
+export declare const useFunctionValidation: (func: FunctionDefinitionView, values: NodeParameterValue[], dataTypeService: DFlowDataTypeReactiveService, flowId: Scalars["FlowID"]["output"]) => ValidationResult[] | null;

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

@@ -0,0 +1,74 @@
+import { DataTypeView as m } from "../data-type/DFlowDataType.view.js";
+import { InspectionSeverity as G } from "../../../utils/inspection.js";
+import { resolveGenericKeys as N, replaceGenericKeysInDataTypeObject as g, replaceGenericKeysInType as D } from "../../../utils/generics.js";
+import { useReturnType as I } from "./DFlowFunction.return.hook.js";
+import { useService as V } from "../../../utils/contextStore.js";
+import { DFlowFunctionReactiveService as E } from "./DFlowFunction.service.js";
+import { useValidateDataType as T } from "../data-type/DFlowDataType.validation.type.js";
+import { useValidateValue as l } from "../data-type/DFlowDataType.validation.value.js";
+import { DFlowReactiveService as M } from "../DFlow.service.js";
+const q = (f, d, a, h) => {
+  const R = V(E), y = V(M).getById(h), u = N(f, d, a, y), w = f.parameterDefinitions ?? [], v = f.genericKeys ?? [], r = [];
+  return w.forEach((s, F) => {
+    const n = d[F];
+    if (!n) return;
+    const p = s.dataTypeIdentifier, e = a.getDataType(p), _ = n.__typename === "NodeFunction" && e?.variant != "NODE" ? I(R.getById(n.functionDefinition?.id), n.parameters?.nodes?.map((o) => o?.value)) : a.getTypeFromValue(n, y), t = a.getDataType(_), K = e && p?.genericType || p?.genericKey && v.includes(p.genericKey);
+    let i = !0;
+    if (K) {
+      if (_?.genericType && e) {
+        if (n.__typename === "ReferenceValue" || n.__typename === "NodeFunction") {
+          const o = new m(g(e.json, u)), j = new m(g(t?.json, u));
+          i = T(o, j), i || r.push(c(s.id, e, t));
+        } else {
+          const o = D(p, u);
+          i = l(n, e, y, o?.genericType?.genericMappers), i || r.push(c(s.id, e, t));
+        }
+        return;
+      }
+      if (p?.genericKey && v.includes(p?.genericKey)) {
+        if (n.__typename != "ReferenceValue") {
+          const o = D(p, u);
+          i = l(n, a.getDataType(o), y, o.genericType?.genericMappers), i || r.push(c(s.id, e, t));
+        }
+        return;
+      }
+      if (t && e && t.json && e.json) {
+        if (n.__typename === "ReferenceValue" || n.__typename === "NodeFunction") {
+          const o = new m(g(e.json, u));
+          i = T(o, t), i || r.push(c(s.id, e, t));
+        } else {
+          const o = D(p, u);
+          i = l(n, a.getDataType(o), y, o.genericType?.genericMappers), i || r.push(c(s.id, e, t));
+        }
+        return;
+      }
+    }
+    if (e) {
+      if (_?.genericType && e) {
+        if (n.__typename === "ReferenceValue" || n.__typename === "NodeFunction") {
+          const o = new m(g(t?.json, u));
+          i = T(e, o), i || r.push(c(s.id, e, t));
+        } else
+          i = l(n, e), i || r.push(c(s.id, e, t));
+        return;
+      }
+      if (t) {
+        (n.__typename === "ReferenceValue" || n.__typename === "NodeFunction") && e.variant !== "NODE" ? (i = T(e, t), i || r.push(c(s.id, e, t))) : (i = l(n, e), i || r.push(c(s.id, e, t)));
+        return;
+      }
+    }
+    r.push(c(s.id, e, t));
+  }), r.length > 0 ? r : null;
+}, c = (f, d, a) => ({
+  parameterId: f,
+  type: G.ERROR,
+  message: {
+    nodes: [{
+      code: "en-US",
+      content: `Argument of type ${a?.name?.nodes[0]?.content} is not assignable to parameter of type ${d?.name?.nodes[0]?.content}`
+    }]
+  }
+});
+export {
+  q as useFunctionValidation
+};

package/dist/components/d-flow/function/DFlowFunction.view.d.ts

@@ -0,0 +1,66 @@
+import { DataTypeIdentifier, FunctionDefinition, Maybe, ParameterDefinition, RuntimeFunctionDefinition, Scalars, TranslationConnection } from '@code0-tech/sagittarius-graphql-types';
+export declare class FunctionDefinitionView {
+    /** Time when this FunctionDefinition was created */
+    private readonly _createdAt?;
+    /** Deprecation message of the function */
+    private readonly _deprecationMessages?;
+    /** Description of the function */
+    private readonly _descriptions?;
+    /** Documentation of the function */
+    private readonly _documentations?;
+    /** Generic keys of the function */
+    private readonly _genericKeys?;
+    /** Global ID of this FunctionDefinition */
+    private readonly _id?;
+    /** Name of the function */
+    private readonly _names?;
+    /** Parameters of the function */
+    private readonly _parameterDefinitions?;
+    /** Return type of the function */
+    private readonly _returnType?;
+    /** Runtime function definition */
+    private readonly _runtimeFunctionDefinition?;
+    /** Indicates if the function can throw an error */
+    private readonly _throwsError?;
+    /** Time when this FunctionDefinition was last updated */
+    private readonly _updatedAt?;
+    constructor(object: FunctionDefinition);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get deprecationMessages(): Maybe<TranslationConnection> | undefined;
+    get descriptions(): Maybe<TranslationConnection> | undefined;
+    get documentations(): Maybe<TranslationConnection> | undefined;
+    get genericKeys(): Maybe<Array<Scalars["String"]["output"]>> | undefined;
+    get id(): Maybe<Scalars["FunctionDefinitionID"]["output"]> | undefined;
+    get names(): Maybe<TranslationConnection> | undefined;
+    get parameterDefinitions(): Maybe<ParameterDefinitionView[]> | undefined;
+    get returnType(): Maybe<DataTypeIdentifier> | undefined;
+    get runtimeFunctionDefinition(): Maybe<RuntimeFunctionDefinition> | undefined;
+    get throwsError(): Maybe<Scalars["Boolean"]["output"]> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    json(): FunctionDefinition;
+}
+export declare class ParameterDefinitionView {
+    /** Time when this ParameterDefinition was created */
+    private readonly _createdAt?;
+    /** Data type of the parameter */
+    private readonly _dataTypeIdentifier?;
+    /** Description of the parameter */
+    private readonly _descriptions?;
+    /** Documentation of the parameter */
+    private readonly _documentations?;
+    /** Global ID of this ParameterDefinition */
+    private readonly _id?;
+    /** Name of the parameter */
+    private readonly _names?;
+    /** Time when this ParameterDefinition was last updated */
+    private readonly _updatedAt?;
+    constructor(object: ParameterDefinition);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get dataTypeIdentifier(): Maybe<DataTypeIdentifier> | undefined;
+    get descriptions(): Maybe<TranslationConnection> | undefined;
+    get documentations(): Maybe<TranslationConnection> | undefined;
+    get id(): Maybe<Scalars["ParameterDefinitionID"]["output"]> | undefined;
+    get names(): Maybe<TranslationConnection> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    json(): ParameterDefinition;
+}

package/dist/components/d-flow/function/DFlowFunction.view.js

@@ -0,0 +1,117 @@
+function i(e, t, r) {
+  return (t = s(t)) in e ? Object.defineProperty(e, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = r, e;
+}
+function s(e) {
+  var t = d(e, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function d(e, t) {
+  if (typeof e != "object" || !e) return e;
+  var r = e[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var n = r.call(e, t);
+    if (typeof n != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+class a {
+  constructor(t) {
+    i(this, "_createdAt", void 0), i(this, "_deprecationMessages", void 0), i(this, "_descriptions", void 0), i(this, "_documentations", void 0), i(this, "_genericKeys", void 0), i(this, "_id", void 0), i(this, "_names", void 0), i(this, "_parameterDefinitions", void 0), i(this, "_returnType", void 0), i(this, "_runtimeFunctionDefinition", void 0), i(this, "_throwsError", void 0), i(this, "_updatedAt", void 0), this._createdAt = t.createdAt, this._deprecationMessages = t.deprecationMessages, this._descriptions = t.descriptions, this._documentations = t.documentations, this._genericKeys = t.genericKeys, this._id = t.id, this._names = t.names, this._parameterDefinitions = t.parameterDefinitions?.nodes?.map((r) => new o(r)) ?? void 0, this._returnType = t.returnType, this._runtimeFunctionDefinition = t.runtimeFunctionDefinition, this._throwsError = t.throwsError, this._updatedAt = t.updatedAt;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get deprecationMessages() {
+    return this._deprecationMessages;
+  }
+  get descriptions() {
+    return this._descriptions;
+  }
+  get documentations() {
+    return this._documentations;
+  }
+  get genericKeys() {
+    return this._genericKeys;
+  }
+  get id() {
+    return this._id;
+  }
+  get names() {
+    return this._names;
+  }
+  get parameterDefinitions() {
+    return this._parameterDefinitions;
+  }
+  get returnType() {
+    return this._returnType;
+  }
+  get runtimeFunctionDefinition() {
+    return this._runtimeFunctionDefinition;
+  }
+  get throwsError() {
+    return this._throwsError;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  json() {
+    return {
+      createdAt: this._createdAt,
+      deprecationMessages: this._deprecationMessages,
+      descriptions: this._descriptions,
+      documentations: this._documentations,
+      genericKeys: this._genericKeys,
+      id: this._id,
+      names: this._names,
+      parameterDefinitions: this._parameterDefinitions ? {
+        nodes: this._parameterDefinitions.map((t) => t.json())
+      } : void 0,
+      returnType: this._returnType,
+      runtimeFunctionDefinition: this._runtimeFunctionDefinition,
+      throwsError: this._throwsError,
+      updatedAt: this._updatedAt
+    };
+  }
+}
+class o {
+  constructor(t) {
+    i(this, "_createdAt", void 0), i(this, "_dataTypeIdentifier", void 0), i(this, "_descriptions", void 0), i(this, "_documentations", void 0), i(this, "_id", void 0), i(this, "_names", void 0), i(this, "_updatedAt", void 0), this._createdAt = t.createdAt, this._dataTypeIdentifier = t.dataTypeIdentifier, this._descriptions = t.descriptions, this._documentations = t.documentations, this._id = t.id, this._names = t.names, this._updatedAt = t.updatedAt;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get dataTypeIdentifier() {
+    return this._dataTypeIdentifier;
+  }
+  get descriptions() {
+    return this._descriptions;
+  }
+  get documentations() {
+    return this._documentations;
+  }
+  get id() {
+    return this._id;
+  }
+  get names() {
+    return this._names;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  json() {
+    return {
+      createdAt: this._createdAt,
+      dataTypeIdentifier: this._dataTypeIdentifier,
+      descriptions: this._descriptions,
+      documentations: this._documentations,
+      id: this._id,
+      names: this._names,
+      updatedAt: this._updatedAt
+    };
+  }
+}
+export {
+  a as FunctionDefinitionView,
+  o as ParameterDefinitionView
+};

package/dist/components/d-flow/function/DFlowFunctionDefaultCard.d.ts

@@ -0,0 +1,15 @@
+import { Code0Component } from '../../../utils/types';
+import { Node, NodeProps } from '@xyflow/react';
+import { NodeFunctionView } from '../DFlow.view';
+import { default as React } from 'react';
+import { Scalars } from '@code0-tech/sagittarius-graphql-types';
+export interface DFlowFunctionDefaultCardDataProps extends Omit<Code0Component<HTMLDivElement>, "scope"> {
+    instance: NodeFunctionView;
+    flowId: Scalars["FlowID"]["output"];
+    isParameter: boolean;
+    depth: number;
+    scope: number[];
+    index: number;
+}
+export type DFlowFunctionDefaultCardProps = NodeProps<Node<DFlowFunctionDefaultCardDataProps>>;
+export declare const DFlowFunctionDefaultCard: React.FC<DFlowFunctionDefaultCardProps>;

package/dist/components/d-flow/function/DFlowFunctionDefaultCard.js

@@ -0,0 +1,158 @@
+import { jsxs as o, jsx as t } from "react/jsx-runtime";
+import { useStore as h, useReactFlow as j, useStoreApi as B, Handle as I, Position as u } from "@xyflow/react";
+import { NodeFunctionView as b } from "../DFlow.view.js";
+import { memo as G } from "react";
+import { Card as H } from "../../card/Card.js";
+import '../../../assets/components/d-flow/function/DFlowFunctionDefaultCard.style.css';/* empty css                                    */
+import S from "../../card/CardSection.js";
+import { Flex as s } from "../../flex/Flex.js";
+import { IconFileLambdaFilled as V, IconDots as W, IconTrash as k, IconCopy as $, IconLayoutNavbarCollapseFilled as X, IconExclamationCircle as Y, IconAlertTriangle as q, IconMessageExclamation as J, IconArrowRightCircle as K } from "@tabler/icons-react";
+import { Text as T } from "../../text/Text.js";
+import { Button as D } from "../../button/Button.js";
+import { Menu as Q, MenuTrigger as U, MenuPortal as Z, MenuContent as ee, MenuLabel as te, MenuItem as x } from "../../menu/Menu.js";
+import { Badge as R } from "../../badge/Badge.js";
+import { useService as g } from "../../../utils/contextStore.js";
+import { DFlowFunctionReactiveService as ie } from "./DFlowFunction.service.js";
+import { useFunctionValidation as ne } from "./DFlowFunction.vaildation.hook.js";
+import { DFlowDataTypeReactiveService as oe } from "../data-type/DFlowDataType.service.js";
+import { InspectionSeverity as c } from "../../../utils/inspection.js";
+import { DFlowReactiveService as re } from "../DFlow.service.js";
+import { DFlowSuggestionMenu as ae } from "../suggestion/DFlowSuggestionMenu.js";
+import { useSuggestions as le } from "../suggestion/DFlowSuggestion.hook.js";
+import { FileTabsService as de } from "../../file-tabs/FileTabs.service.js";
+import { DFlowTabDefault as se } from "../tab/DFlowTabDefault.js";
+const Me = G((d) => {
+  const {
+    data: i,
+    id: m
+  } = d, N = h((e) => e.width), F = h((e) => e.height), A = j(), _ = B(), v = g(de), C = g(re), z = g(ie), w = g(oe), f = z.getById(i.instance.functionDefinition?.id), r = ne(f, i.instance.parameters.map((e) => e.value instanceof b ? e.value.json() : e.value), w, d.data.flowId), M = h((e) => e.edges), E = d.width ?? 0, L = d.height ?? 0;
+  i.instance.parameters?.forEach((e) => {
+    const a = f?.parameterDefinitions.find((n) => n.id == e?.id);
+    e.validationResults = r ? r.filter((n) => n.parameterId === a?.id) : [];
+  });
+  function P(e) {
+    return M.some((a) => a.target === m && a.targetHandle === `param-${e}`);
+  }
+  const O = h((e) => {
+    const a = e.nodes.filter((l) => l.parentId === d.parentId);
+    let n;
+    return a.forEach((l) => {
+      const y = l.data?.index ?? 1 / 0, p = n?.data?.index ?? 1 / 0;
+      (!n || y < p) && (n = l);
+    }), n;
+  });
+  return /* @__PURE__ */ o(H, { outline: O.id === m, borderColor: v.getActiveTab()?.id == m ? "info" : void 0, className: v.getActiveTab()?.id == m ? "d-flow-viewport-default-card--active" : void 0, color: (r?.filter((e) => e.type === c.ERROR)?.length ?? 0) > 0 ? "error" : "secondary", onClick: () => {
+    A.setViewport({
+      x: N / 2 + d.positionAbsoluteX * -1 - E / 2,
+      y: F / 2 + d.positionAbsoluteY * -1 - L / 2,
+      zoom: 1
+    }, {
+      duration: 250
+    }), v.add({
+      id: m,
+      active: !0,
+      closeable: !0,
+      children: /* @__PURE__ */ t(T, { size: "md", children: f?.names?.nodes[0]?.content }),
+      content: /* @__PURE__ */ t(se, { flowId: d.data.flowId, depthLevel: i.depth, scopeLevel: i.scope, nodeLevel: i.index, functionInstance: i.instance })
+    });
+  }, style: {
+    position: "relative"
+  }, children: [
+    /* @__PURE__ */ t(S, { border: !0, children: /* @__PURE__ */ o(s, { align: "center", justify: "space-between", style: {
+      gap: "0.7rem"
+    }, children: [
+      /* @__PURE__ */ o(s, { align: "center", style: {
+        gap: "0.7rem"
+      }, children: [
+        /* @__PURE__ */ t(V, { size: 16 }),
+        /* @__PURE__ */ t(T, { size: "md", children: f?.names?.nodes[0]?.content })
+      ] }),
+      /* @__PURE__ */ o(s, { align: "center", style: {
+        gap: "0.7rem"
+      }, children: [
+        /* @__PURE__ */ o(Q, { onOpenChange: (e) => {
+          setTimeout(() => {
+            _.setState({
+              nodesDraggable: !e,
+              nodesConnectable: !e,
+              elementsSelectable: !e
+            });
+          }, 250);
+        }, children: [
+          /* @__PURE__ */ t(U, { asChild: !0, children: /* @__PURE__ */ t(D, { variant: "none", children: /* @__PURE__ */ t(W, { size: 16 }) }) }),
+          /* @__PURE__ */ t(Z, { children: /* @__PURE__ */ o(ee, { children: [
+            /* @__PURE__ */ t(te, { children: "Actions" }),
+            /* @__PURE__ */ o(x, { onClick: () => {
+              i.instance.deleteNextNode(), C.update();
+            }, children: [
+              /* @__PURE__ */ t(k, { size: 16 }),
+              " Delete node"
+            ] }),
+            /* @__PURE__ */ o(x, { disabled: !0, children: [
+              /* @__PURE__ */ t($, { size: 16 }),
+              " Copy node"
+            ] })
+          ] }) })
+        ] }),
+        /* @__PURE__ */ t(D, { disabled: !0, children: /* @__PURE__ */ t(X, { size: 16 }) })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ t(I, { isConnectable: !1, draggable: !1, type: "target", className: "d-flow-viewport-default-card__handle d-flow-viewport-default-card__handle--target", style: {
+      ...i.isParameter ? {
+        right: "2px"
+      } : {
+        top: "2px"
+      }
+    }, position: i.isParameter ? u.Right : u.Top }),
+    (r?.length ?? 0) > 0 ? /* @__PURE__ */ t("div", { className: "d-flow-viewport-default-card__inspection", children: /* @__PURE__ */ o(s, { style: {
+      gap: "0.35rem"
+    }, children: [
+      (r?.filter((e) => e.type === c.ERROR)?.length ?? 0) > 0 ? /* @__PURE__ */ t(R, { color: "error", children: /* @__PURE__ */ o(s, { align: "center", style: {
+        gap: "0.35rem"
+      }, children: [
+        /* @__PURE__ */ t(Y, { size: 12 }),
+        r?.filter((e) => e.type === c.ERROR)?.length
+      ] }) }) : null,
+      (r?.filter((e) => e.type === c.WARNING)?.length ?? 0) > 0 ? /* @__PURE__ */ t(R, { color: "warning", children: /* @__PURE__ */ o(s, { align: "center", style: {
+        gap: "0.35rem"
+      }, children: [
+        /* @__PURE__ */ t(q, { size: 12 }),
+        r?.filter((e) => e.type === c.WARNING)?.length
+      ] }) }) : null,
+      (r?.filter((e) => e.type === c.GRAMMAR)?.length ?? 0) > 0 ? /* @__PURE__ */ t(R, { children: /* @__PURE__ */ o(s, { align: "center", style: {
+        gap: "0.35rem"
+      }, children: [
+        /* @__PURE__ */ t(J, { size: 12 }),
+        r?.filter((e) => e.type === c.GRAMMAR)?.length
+      ] }) }) : null
+    ] }) }) : null,
+    i.instance.parameters?.some((e) => {
+      const a = f?.parameterDefinitions.find((l) => l.id == e.id), n = w.getDataType(a?.dataTypeIdentifier)?.variant === "NODE";
+      return e.value instanceof b && !n || !e.value;
+    }) ? /* @__PURE__ */ t(S, { children: i.instance.parameters?.map((e, a) => {
+      const n = f?.parameterDefinitions.find((p) => p.id == e.id), l = w.getDataType(n?.dataTypeIdentifier)?.variant === "NODE", y = le(n?.dataTypeIdentifier ?? void 0, [], d.data.flowId, i.depth, i.scope, i.index);
+      return e.value instanceof b && !l || !e.value ? /* @__PURE__ */ o(s, { pos: "relative", justify: "space-between", align: "center", children: [
+        n?.names?.nodes[0]?.content ?? e.id,
+        e.value ? null : /* @__PURE__ */ t(ae, { onSuggestionSelect: (p) => {
+          e.value = p.value, C.update();
+        }, suggestions: y, triggerContent: /* @__PURE__ */ t(D, { variant: "none", children: /* @__PURE__ */ t(K, { size: 12 }) }) }),
+        /* @__PURE__ */ t(I, { type: "target", position: u.Right, style: {
+          position: "absolute",
+          transform: l ? "translate(-50%, -50%)" : "translate(50%, -50%)",
+          top: "50%",
+          right: l ? "50%" : "0"
+        }, id: `param-${e.id}`, isConnectable: !1, hidden: !P(e.id), className: "d-flow-viewport-default-card__handle d-flow-viewport-default-card__handle--target" }, e.id)
+      ] }, a) : null;
+    }) }) : null,
+    /* @__PURE__ */ t(I, { isConnectable: !1, type: "source", style: {
+      ...i.isParameter ? {
+        left: "2px"
+      } : {
+        bottom: "2px"
+      }
+    }, className: "d-flow-viewport-default-card__handle d-flow-viewport-default-card__handle--source", position: i.isParameter ? u.Left : u.Bottom })
+  ] });
+});
+export {
+  Me as DFlowFunctionDefaultCard
+};

package/dist/components/d-flow/function/DFlowFunctionGroupCard.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { NodeProps } from '@xyflow/react';
+export interface DFlowFunctionGroupCardProps extends NodeProps {
+}
+export declare const DFlowFunctionGroupCard: React.FC<DFlowFunctionGroupCardProps>;