@code0-tech/pictor 0.0.0-mvp.rc.1

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

@@ -0,0 +1,3 @@
+import { Node } from '@xyflow/react';
+import { Flow } from '@code0-tech/sagittarius-graphql-types';
+export declare const useFlowNodes: (flowId: Flow["id"]) => Node[];

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

@@ -0,0 +1,140 @@
+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-B7xAjgiJ.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);
+    } 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), m = n.charAt(r);
+        (h === "" || f.test(h) || m === "" || f.test(m)) && (a += 50);
+      }
+    }
+    a > i ? (i = a, t = l) : (a === i && t !== null && l.length > t.length || a === i && t === null) && (t = 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),
+      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
+      }
+    });
+    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);
+        }
+      } 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;
+};
+export {
+  O as useFlowNodes
+};

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

@@ -0,0 +1,10 @@
+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. */
+    abstract flowCreate(payload: NamespacesProjectsFlowsCreateInput): Promise<NamespacesProjectsFlowsCreatePayload | undefined>;
+    /** Deletes a namespace project. */
+    abstract flowDelete(payload: NamespacesProjectsFlowsDeleteInput): Promise<NamespacesProjectsFlowsDeletePayload | undefined>;
+}

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

@@ -0,0 +1,11 @@
+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);
+  }
+}
+export {
+  c as DFlowReactiveService
+};

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

@@ -0,0 +1,109 @@
+import { DataType, Flow, FlowSetting, FlowType, FunctionDefinition, LiteralValue, Maybe, NodeFunction, NodeParameter, NodeParameterValue, ReferenceValue, RuntimeParameterDefinition, Scalars } from '@code0-tech/sagittarius-graphql-types';
+import { ValidationResult } from '../../utils/inspection';
+export declare class FlowView {
+    /** Time when this Flow was created */
+    private readonly _createdAt?;
+    /** Global ID of this Flow */
+    private readonly _id?;
+    /** The input data type of the flow */
+    private _inputType?;
+    /** Nodes of the flow */
+    private _nodes?;
+    /** The return data type of the flow */
+    private readonly _returnType?;
+    /** The settings of the flow */
+    private readonly _settings?;
+    /** The ID of the starting node of the flow */
+    private _startingNodeId?;
+    /** The flow type of the flow */
+    private readonly _type?;
+    /** Time when this Flow was last updated */
+    private readonly _updatedAt?;
+    /** Name of the flow */
+    private _name?;
+    constructor(flow: Flow);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get id(): Maybe<Scalars["FlowID"]["output"]> | undefined;
+    get inputType(): Maybe<DataType> | undefined;
+    get nodes(): NodeFunctionView[] | undefined;
+    get returnType(): Maybe<DataType> | undefined;
+    get settings(): FlowSettingView[] | undefined;
+    get startingNodeId(): Maybe<Scalars["NodeFunctionID"]["output"]> | undefined;
+    get type(): Maybe<FlowType> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get name(): Maybe<Scalars["String"]["output"]> | undefined;
+    set inputType(value: Maybe<DataType>);
+    set startingNodeId(value: Maybe<Scalars["NodeFunctionID"]["output"]>);
+    set name(value: Maybe<Scalars["String"]["output"]>);
+    addNode(node: NodeFunctionView): void;
+    updateNode(updatedNode: NodeFunctionView): void;
+    removeNode(nodeId: Scalars['NodeFunctionID']['output']): void;
+    getNodeById(nodeId: Scalars['NodeFunctionID']['output']): NodeFunctionView | undefined;
+    json(): Flow;
+}
+export declare class NodeFunctionView {
+    /** Time when this NodeFunction was created */
+    private readonly _createdAt?;
+    /** Global ID of this NodeFunction */
+    private readonly _id?;
+    /** The ID of the next Node Function in the flow */
+    private _nextNodeId?;
+    /** The parameters of the Node Function */
+    private readonly _parameters?;
+    /** The definition of the Node Function */
+    private readonly _functionDefinition?;
+    /** Time when this NodeFunction was last updated */
+    private readonly _updatedAt?;
+    constructor(nodeFunction: NodeFunction);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get id(): Maybe<Scalars["NodeFunctionID"]["output"]> | undefined;
+    get nextNodeId(): Maybe<Scalars["NodeFunctionID"]["output"]> | undefined;
+    get parameters(): NodeParameterView[] | undefined;
+    get functionDefinition(): Maybe<FunctionDefinition> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    set nextNodeId(value: Maybe<Scalars["NodeFunctionID"]["output"]>);
+    deleteNextNode(): void;
+    json(): NodeFunction | undefined;
+}
+export declare class NodeParameterView {
+    /** Time when this NodeParameter was created */
+    private readonly _createdAt?;
+    /** Global ID of this NodeParameter */
+    private readonly _id?;
+    /** The definition of the parameter */
+    private readonly _runtimeParameter?;
+    /** Time when this NodeParameter was last updated */
+    private readonly _updatedAt?;
+    /** The value of the parameter */
+    private _value?;
+    private _validationResults;
+    constructor(nodeParameter: NodeParameter);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get id(): Maybe<Scalars["NodeParameterID"]["output"]> | undefined;
+    get runtimeParameter(): Maybe<RuntimeParameterDefinition> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get value(): LiteralValue | ReferenceValue | NodeFunctionView | undefined;
+    get validationResults(): ValidationResult[];
+    set validationResults(value: ValidationResult[]);
+    set value(value: NodeParameterValue | undefined);
+    json(): NodeParameter | undefined;
+}
+export declare class FlowSettingView {
+    private readonly _createdAt?;
+    /** The identifier of the flow setting */
+    private readonly _flowSettingIdentifier?;
+    /** Global ID of this FlowSetting */
+    private readonly _id?;
+    /** Time when this FlowSetting was last updated */
+    private readonly _updatedAt?;
+    /** The value of the flow setting */
+    private _value?;
+    constructor(flowSetting: FlowSetting);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get flowSettingIdentifier(): Maybe<Scalars["String"]["output"]> | undefined;
+    get id(): Maybe<Scalars["FlowSettingID"]["output"]> | undefined;
+    get value(): Maybe<Scalars["String"]["output"]> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    set value(value: Maybe<Scalars["JSON"]["output"]>);
+    json(): FlowSetting;
+}

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

@@ -0,0 +1,209 @@
+function e(s, t, i) {
+  return (t = n(t)) in s ? Object.defineProperty(s, t, { value: i, enumerable: !0, configurable: !0, writable: !0 }) : s[t] = i, s;
+}
+function n(s) {
+  var t = a(s, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function a(s, t) {
+  if (typeof s != "object" || !s) return s;
+  var i = s[Symbol.toPrimitive];
+  if (i !== void 0) {
+    var r = i.call(s, t);
+    if (typeof r != "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(s);
+}
+class h {
+  constructor(t) {
+    e(this, "_createdAt", void 0), e(this, "_id", void 0), e(this, "_inputType", void 0), e(this, "_nodes", void 0), e(this, "_returnType", void 0), e(this, "_settings", void 0), e(this, "_startingNodeId", void 0), e(this, "_type", void 0), e(this, "_updatedAt", void 0), e(this, "_name", void 0), this._createdAt = t.createdAt, this._id = t.id, this._inputType = t.inputType, this._nodes = t.nodes?.nodes?.map((i) => new d(i)), this._returnType = t.returnType, this._settings = t.settings?.nodes?.map((i) => new _(i)), this._startingNodeId = t.startingNodeId, this._type = t.type, this._updatedAt = t.updatedAt, this._name = t.name;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get id() {
+    return this._id;
+  }
+  get inputType() {
+    return this._inputType;
+  }
+  get nodes() {
+    return this._nodes;
+  }
+  get returnType() {
+    return this._returnType;
+  }
+  get settings() {
+    return this._settings;
+  }
+  get startingNodeId() {
+    return this._startingNodeId;
+  }
+  get type() {
+    return this._type;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  get name() {
+    return this._name;
+  }
+  set inputType(t) {
+    this._inputType = t;
+  }
+  set startingNodeId(t) {
+    this._startingNodeId = t;
+  }
+  set name(t) {
+    this._name = t;
+  }
+  addNode(t) {
+    this._nodes || (this._nodes = []), this._nodes.push(t);
+  }
+  updateNode(t) {
+    this._nodes && (this._nodes = this._nodes.map((i) => i.id === t.id ? t : i));
+  }
+  removeNode(t) {
+    this._nodes && (this._nodes = this._nodes.filter((i) => i.id !== t));
+  }
+  getNodeById(t) {
+    if (this._nodes)
+      return this._nodes.find((i) => i.id === t);
+  }
+  json() {
+    return {
+      createdAt: this._createdAt,
+      id: this._id,
+      inputType: this._inputType,
+      nodes: this._nodes ? {
+        nodes: this._nodes.map((t) => t.json())
+      } : void 0,
+      returnType: this._returnType,
+      settings: this._settings ? {
+        nodes: this._settings.map((t) => t.json())
+      } : void 0,
+      startingNodeId: this._startingNodeId,
+      type: this._type,
+      updatedAt: this._updatedAt,
+      name: this._name
+    };
+  }
+}
+class d {
+  constructor(t) {
+    e(this, "_createdAt", void 0), e(this, "_id", void 0), e(this, "_nextNodeId", void 0), e(this, "_parameters", void 0), e(this, "_functionDefinition", void 0), e(this, "_updatedAt", void 0), this._createdAt = t.createdAt, this._id = t.id, this._nextNodeId = t.nextNodeId, this._functionDefinition = t.functionDefinition, this._updatedAt = t.updatedAt, this._parameters = t.parameters ? t.parameters.nodes?.map((i) => new u(i)) : void 0;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get id() {
+    return this._id;
+  }
+  get nextNodeId() {
+    return this._nextNodeId;
+  }
+  get parameters() {
+    return this._parameters;
+  }
+  get functionDefinition() {
+    return this._functionDefinition;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  set nextNodeId(t) {
+    this._nextNodeId = t;
+  }
+  deleteNextNode() {
+    this._nextNodeId = void 0;
+  }
+  json() {
+    return {
+      createdAt: this._createdAt,
+      id: this._id,
+      nextNodeId: this._nextNodeId,
+      parameters: this._parameters ? {
+        nodes: this._parameters.map((t) => t.json())
+      } : void 0,
+      functionDefinition: this._functionDefinition,
+      updatedAt: this._updatedAt
+    };
+  }
+}
+class u {
+  constructor(t) {
+    e(this, "_createdAt", void 0), e(this, "_id", void 0), e(this, "_runtimeParameter", void 0), e(this, "_updatedAt", void 0), e(this, "_value", void 0), e(this, "_validationResults", void 0), this._createdAt = t.createdAt, this._id = t.id, this._runtimeParameter = t.runtimeParameter, this._updatedAt = t.updatedAt, t.value?.__typename === "NodeFunction" ? this._value = new d(t.value) : this._value = t.value, this._validationResults = [];
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get id() {
+    return this._id;
+  }
+  get runtimeParameter() {
+    return this._runtimeParameter;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  get value() {
+    return this._value;
+  }
+  get validationResults() {
+    return this._validationResults;
+  }
+  set validationResults(t) {
+    this._validationResults = t;
+  }
+  set value(t) {
+    t?.__typename === "NodeFunction" ? this._value = new d(t) : this._value = t;
+  }
+  json() {
+    return {
+      createdAt: this._createdAt,
+      id: this._id,
+      runtimeParameter: this._runtimeParameter,
+      updatedAt: this._updatedAt,
+      value: this._value instanceof d ? this._value.json() : this._value
+    };
+  }
+}
+class _ {
+  constructor(t) {
+    e(this, "_createdAt", void 0), e(this, "_flowSettingIdentifier", void 0), e(this, "_id", void 0), e(this, "_updatedAt", void 0), e(this, "_value", void 0), this._createdAt = t.createdAt, this._flowSettingIdentifier = t.flowSettingIdentifier, this._id = t.id, this._value = t.value, this._updatedAt = t.updatedAt;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get flowSettingIdentifier() {
+    return this._flowSettingIdentifier;
+  }
+  get id() {
+    return this._id;
+  }
+  get value() {
+    return this._value;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  set value(t) {
+    this._value = t;
+  }
+  json() {
+    return {
+      createdAt: this._createdAt,
+      flowSettingIdentifier: this._flowSettingIdentifier,
+      id: this._id,
+      value: this._value,
+      updatedAt: this._updatedAt
+    };
+  }
+}
+export {
+  _ as FlowSettingView,
+  h as FlowView,
+  d as NodeFunctionView,
+  u as NodeParameterView
+};

package/dist/components/d-flow/control/DFlowControl.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const DFlowControl: React.FC;

package/dist/components/d-flow/control/DFlowControl.js

@@ -0,0 +1,77 @@
+import { jsx as o, jsxs as k } from "react/jsx-runtime";
+import { c as j } from "../../../compiler-runtime-Cu50tn6L.js";
+import { useViewport as D, useReactFlow as M, Panel as O } from "@xyflow/react";
+import { ButtonGroup as R } from "../../button-group/ButtonGroup.js";
+import { Button as B } from "../../button/Button.js";
+import { IconPlus as V, IconMinus as v, IconFocusCentered as E } from "@tabler/icons-react";
+import { Badge as G } from "../../badge/Badge.js";
+import { Flex as P } from "../../flex/Flex.js";
+const N = () => {
+  const e = j.c(36), C = D(), t = M();
+  let p;
+  e[0] !== t ? (p = () => {
+    t.zoomIn();
+  }, e[0] = t, e[1] = p) : p = e[1];
+  const I = p;
+  let d;
+  e[2] !== t ? (d = () => {
+    t.zoomOut();
+  }, e[2] = t, e[3] = d) : d = e[3];
+  const g = d;
+  let h;
+  e[4] !== t ? (h = () => {
+    t.fitView();
+  }, e[4] = t, e[5] = h) : h = e[5];
+  const F = h;
+  let u;
+  e[6] !== C.zoom ? (u = () => Math.round(C.zoom * 100), e[6] = C.zoom, e[7] = u) : u = e[7];
+  const S = u;
+  let y;
+  e[8] === Symbol.for("react.memo_cache_sentinel") ? (y = {
+    flexDirection: "column",
+    gap: "1rem"
+  }, e[8] = y) : y = e[8];
+  let z;
+  e[9] === Symbol.for("react.memo_cache_sentinel") ? (z = {
+    gap: ".35rem"
+  }, e[9] = z) : z = e[9];
+  let l;
+  e[10] !== I ? (l = () => I(), e[10] = I, e[11] = l) : l = e[11];
+  let _;
+  e[12] === Symbol.for("react.memo_cache_sentinel") ? (_ = /* @__PURE__ */ o(V, { size: 15 }), e[12] = _) : _ = e[12];
+  let r;
+  e[13] !== l ? (r = /* @__PURE__ */ o(B, { color: "secondary", onClick: l, children: _ }), e[13] = l, e[14] = r) : r = e[14];
+  let i;
+  e[15] !== g ? (i = () => g(), e[15] = g, e[16] = i) : i = e[16];
+  let b;
+  e[17] === Symbol.for("react.memo_cache_sentinel") ? (b = /* @__PURE__ */ o(v, { size: 15 }), e[17] = b) : b = e[17];
+  let c;
+  e[18] !== i ? (c = /* @__PURE__ */ o(B, { color: "secondary", onClick: i, children: b }), e[18] = i, e[19] = c) : c = e[19];
+  let n;
+  e[20] !== F ? (n = () => F(), e[20] = F, e[21] = n) : n = e[21];
+  let w;
+  e[22] === Symbol.for("react.memo_cache_sentinel") ? (w = /* @__PURE__ */ o(E, { size: 15 }), e[22] = w) : w = e[22];
+  let s;
+  e[23] !== n ? (s = /* @__PURE__ */ o(B, { color: "secondary", onClick: n, children: w }), e[23] = n, e[24] = s) : s = e[24];
+  let m;
+  e[25] !== c || e[26] !== s || e[27] !== r ? (m = /* @__PURE__ */ k(R, { children: [
+    r,
+    c,
+    s
+  ] }), e[25] = c, e[26] = s, e[27] = r, e[28] = m) : m = e[28];
+  let f;
+  e[29] !== S ? (f = S(), e[29] = S, e[30] = f) : f = e[30];
+  let a;
+  e[31] !== f ? (a = /* @__PURE__ */ k(G, { color: "secondary", children: [
+    f,
+    "%"
+  ] }), e[31] = f, e[32] = a) : a = e[32];
+  let x;
+  return e[33] !== m || e[34] !== a ? (x = /* @__PURE__ */ o(O, { position: "bottom-left", children: /* @__PURE__ */ o(P, { style: y, children: /* @__PURE__ */ k(P, { align: "stretch", style: z, children: [
+    m,
+    a
+  ] }) }) }), e[33] = m, e[34] = a, e[35] = x) : x = e[35], x;
+};
+export {
+  N as DFlowControl
+};

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

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

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

@@ -0,0 +1,4 @@
+import { DFlowControl as l } from "./DFlowControl.js";
+export {
+  l as DFlowControl
+};

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

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

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

@@ -0,0 +1,7 @@
+import "../../../utils/reactiveArrayService.js";
+import "../../../utils/generics.js";
+import "@code0-tech/sagittarius-graphql-types";
+import { D as p } from "../../../DFlowDataType.service-B7xAjgiJ.js";
+export {
+  p as DFlowDataTypeReactiveService
+};

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

@@ -0,0 +1,2 @@
+import { DataTypeView } from './DFlowDataType.view';
+export declare const useValidateDataType: (firstDataType: DataTypeView, secondDataType: DataTypeView) => boolean;

package/dist/components/d-flow/data-type/DFlowDataType.validation.type.js

@@ -0,0 +1,18 @@
+const g = ["id", "__typename", "createdAt", "updatedAt"], h = (c, u) => {
+  if (c.variant !== u.variant) return !1;
+  const l = (r) => r !== null && typeof r == "object", i = (r, e) => {
+    if (r === e) return !0;
+    const y = Array.isArray(r), a = Array.isArray(e);
+    if (y || a)
+      return !y || !a || r.length !== e.length ? !1 : r.every((s, f) => i(s, e[f]));
+    if (l(r) && l(e)) {
+      const s = Object.keys(r), f = Object.keys(e);
+      return s.length !== f.length ? !1 : s.every((o) => g.includes(o) ? !0 : i(r[o], e[o]));
+    }
+    return !1;
+  }, t = c.rules?.nodes ?? [], n = u.rules?.nodes ?? [];
+  return !t.length && !n.length ? !0 : !t.length || !n.length || t.length !== n.length ? !1 : t.every((r, e) => i(r, n[e]));
+};
+export {
+  h as useValidateDataType
+};

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

@@ -0,0 +1,4 @@
+import { GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
+import { DataTypeView } from './DFlowDataType.view';
+import { FlowView } from '../DFlow.view';
+export declare const useValidateValue: (value: NodeParameterValue, dataType: DataTypeView, flow?: FlowView, generics?: GenericMapper[]) => boolean;

package/dist/components/d-flow/data-type/DFlowDataType.validation.value.js

@@ -0,0 +1,6 @@
+import "../../../compiler-runtime-Cu50tn6L.js";
+import { u as t } from "../../../DFlowDataType.service-B7xAjgiJ.js";
+import "../../../utils/contextStore.js";
+export {
+  t as useValidateValue
+};

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

@@ -0,0 +1,32 @@
+import { DataType, DataTypeRuleConnection, DataTypeVariant, Maybe, Runtime, Scalars, TranslationConnection } from '@code0-tech/sagittarius-graphql-types';
+export declare class DataTypeView {
+    /** Time when this DataType was created */
+    private readonly _createdAt?;
+    /** Generic keys of the datatype */
+    private readonly _genericKeys?;
+    /** Global ID of this DataType */
+    private readonly _id?;
+    /** The identifier scoped to the namespace */
+    private readonly _identifier?;
+    /** Names of the flow type setting */
+    private readonly _name?;
+    /** The namespace where this datatype belongs to */
+    private readonly _runtime?;
+    /** Rules of the datatype */
+    private readonly _rules?;
+    /** Time when this DataType was last updated */
+    private readonly _updatedAt?;
+    /** The type of the datatype */
+    private readonly _variant?;
+    constructor(dataType: DataType);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get genericKeys(): Maybe<Array<Scalars["String"]["output"]>> | undefined;
+    get id(): Maybe<Scalars["DataTypeID"]["output"]> | undefined;
+    get identifier(): Maybe<Scalars["String"]["output"]> | undefined;
+    get name(): Maybe<TranslationConnection> | undefined;
+    get runtime(): Maybe<Runtime> | undefined;
+    get rules(): Maybe<DataTypeRuleConnection> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get variant(): Maybe<DataTypeVariant> | undefined;
+    get json(): DataType;
+}