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

package/dist/components/d-flow-data-type/rules/DFlowDataTypeContainsTypeRule.js

@@ -0,0 +1,229 @@
+import { genericMapping as E, staticImplements as T } from "./DFlowDataTypeRule.js";
+import { useValueValidation as y } from "../../d-flow-validation/DValueValidation.hook.js";
+function D(r, e, t, n) {
+  var i = w(), o = e(function(s) {
+    i.initializeInstanceElements(s, a.elements);
+  }, t), a = i.decorateClass(C(o.d.map(A)), r);
+  return i.initializeClassElements(o.F, a.elements), i.runClassFinishers(o.F, a.finishers);
+}
+function w() {
+  w = function() {
+    return r;
+  };
+  var r = { elementsDefinitionOrder: [["method"], ["field"]], initializeInstanceElements: function(e, t) {
+    ["method", "field"].forEach(function(n) {
+      t.forEach(function(i) {
+        i.kind === n && i.placement === "own" && this.defineClassElement(e, i);
+      }, this);
+    }, this);
+  }, initializeClassElements: function(e, t) {
+    var n = e.prototype;
+    ["method", "field"].forEach(function(i) {
+      t.forEach(function(o) {
+        var a = o.placement;
+        if (o.kind === i && (a === "static" || a === "prototype")) {
+          var s = a === "static" ? e : n;
+          this.defineClassElement(s, o);
+        }
+      }, this);
+    }, this);
+  }, defineClassElement: function(e, t) {
+    var n = t.descriptor;
+    if (t.kind === "field") {
+      var i = t.initializer;
+      n = { enumerable: n.enumerable, writable: n.writable, configurable: n.configurable, value: i === void 0 ? void 0 : i.call(e) };
+    }
+    Object.defineProperty(e, t.key, n);
+  }, decorateClass: function(e, t) {
+    var n = [], i = [], o = { static: [], prototype: [], own: [] };
+    if (e.forEach(function(s) {
+      this.addElementPlacement(s, o);
+    }, this), e.forEach(function(s) {
+      if (!m(s)) return n.push(s);
+      var l = this.decorateElement(s, o);
+      n.push(l.element), n.push.apply(n, l.extras), i.push.apply(i, l.finishers);
+    }, this), !t) return { elements: n, finishers: i };
+    var a = this.decorateConstructor(n, t);
+    return i.push.apply(i, a.finishers), a.finishers = i, a;
+  }, addElementPlacement: function(e, t, n) {
+    var i = t[e.placement];
+    if (!n && i.indexOf(e.key) !== -1) throw new TypeError("Duplicated element (" + e.key + ")");
+    i.push(e.key);
+  }, decorateElement: function(e, t) {
+    for (var n = [], i = [], o = e.decorators, a = o.length - 1; a >= 0; a--) {
+      var s = t[e.placement];
+      s.splice(s.indexOf(e.key), 1);
+      var l = this.fromElementDescriptor(e), p = this.toElementFinisherExtras((0, o[a])(l) || l);
+      e = p.element, this.addElementPlacement(e, t), p.finisher && i.push(p.finisher);
+      var d = p.extras;
+      if (d) {
+        for (var c = 0; c < d.length; c++) this.addElementPlacement(d[c], t);
+        n.push.apply(n, d);
+      }
+    }
+    return { element: e, finishers: i, extras: n };
+  }, decorateConstructor: function(e, t) {
+    for (var n = [], i = t.length - 1; i >= 0; i--) {
+      var o = this.fromClassDescriptor(e), a = this.toClassDescriptor((0, t[i])(o) || o);
+      if (a.finisher !== void 0 && n.push(a.finisher), a.elements !== void 0) {
+        e = a.elements;
+        for (var s = 0; s < e.length - 1; s++) for (var l = s + 1; l < e.length; l++) if (e[s].key === e[l].key && e[s].placement === e[l].placement) throw new TypeError("Duplicated element (" + e[s].key + ")");
+      }
+    }
+    return { elements: e, finishers: n };
+  }, fromElementDescriptor: function(e) {
+    var t = { kind: e.kind, key: e.key, placement: e.placement, descriptor: e.descriptor };
+    return Object.defineProperty(t, Symbol.toStringTag, { value: "Descriptor", configurable: !0 }), e.kind === "field" && (t.initializer = e.initializer), t;
+  }, toElementDescriptors: function(e) {
+    if (e !== void 0) return _(e).map(function(t) {
+      var n = this.toElementDescriptor(t);
+      return this.disallowProperty(t, "finisher", "An element descriptor"), this.disallowProperty(t, "extras", "An element descriptor"), n;
+    }, this);
+  }, toElementDescriptor: function(e) {
+    var t = e.kind + "";
+    if (t !== "method" && t !== "field") throw new TypeError(`An element descriptor's .kind property must be either "method" or "field", but a decorator created an element descriptor with .kind "` + t + '"');
+    var n = g(e.key), i = e.placement + "";
+    if (i !== "static" && i !== "prototype" && i !== "own") throw new TypeError(`An element descriptor's .placement property must be one of "static", "prototype" or "own", but a decorator created an element descriptor with .placement "` + i + '"');
+    var o = e.descriptor;
+    this.disallowProperty(e, "elements", "An element descriptor");
+    var a = { kind: t, key: n, placement: i, descriptor: Object.assign({}, o) };
+    return t !== "field" ? this.disallowProperty(e, "initializer", "A method descriptor") : (this.disallowProperty(o, "get", "The property descriptor of a field descriptor"), this.disallowProperty(o, "set", "The property descriptor of a field descriptor"), this.disallowProperty(o, "value", "The property descriptor of a field descriptor"), a.initializer = e.initializer), a;
+  }, toElementFinisherExtras: function(e) {
+    return { element: this.toElementDescriptor(e), finisher: v(e, "finisher"), extras: this.toElementDescriptors(e.extras) };
+  }, fromClassDescriptor: function(e) {
+    var t = { kind: "class", elements: e.map(this.fromElementDescriptor, this) };
+    return Object.defineProperty(t, Symbol.toStringTag, { value: "Descriptor", configurable: !0 }), t;
+  }, toClassDescriptor: function(e) {
+    var t = e.kind + "";
+    if (t !== "class") throw new TypeError(`A class descriptor's .kind property must be "class", but a decorator created a class descriptor with .kind "` + t + '"');
+    this.disallowProperty(e, "key", "A class descriptor"), this.disallowProperty(e, "placement", "A class descriptor"), this.disallowProperty(e, "descriptor", "A class descriptor"), this.disallowProperty(e, "initializer", "A class descriptor"), this.disallowProperty(e, "extras", "A class descriptor");
+    var n = v(e, "finisher");
+    return { elements: this.toElementDescriptors(e.elements), finisher: n };
+  }, runClassFinishers: function(e, t) {
+    for (var n = 0; n < t.length; n++) {
+      var i = (0, t[n])(e);
+      if (i !== void 0) {
+        if (typeof i != "function") throw new TypeError("Finishers must return a constructor.");
+        e = i;
+      }
+    }
+    return e;
+  }, disallowProperty: function(e, t, n) {
+    if (e[t] !== void 0) throw new TypeError(n + " can't have a ." + t + " property.");
+  } };
+  return r;
+}
+function A(r) {
+  var e, t = g(r.key);
+  r.kind === "method" ? e = { value: r.value, writable: !0, configurable: !0, enumerable: !1 } : r.kind === "get" ? e = { get: r.value, configurable: !0, enumerable: !1 } : r.kind === "set" ? e = { set: r.value, configurable: !0, enumerable: !1 } : r.kind === "field" && (e = { configurable: !0, writable: !0, enumerable: !0 });
+  var n = { kind: r.kind === "field" ? "field" : "method", key: t, placement: r.static ? "static" : r.kind === "field" ? "own" : "prototype", descriptor: e };
+  return r.decorators && (n.decorators = r.decorators), r.kind === "field" && (n.initializer = r.value), n;
+}
+function P(r, e) {
+  r.descriptor.get !== void 0 ? e.descriptor.get = r.descriptor.get : e.descriptor.set = r.descriptor.set;
+}
+function C(r) {
+  for (var e = [], t = function(a) {
+    return a.kind === "method" && a.key === o.key && a.placement === o.placement;
+  }, n = 0; n < r.length; n++) {
+    var i, o = r[n];
+    if (o.kind === "method" && (i = e.find(t)))
+      if (h(o.descriptor) || h(i.descriptor)) {
+        if (m(o) || m(i)) throw new ReferenceError("Duplicated methods (" + o.key + ") can't be decorated.");
+        i.descriptor = o.descriptor;
+      } else {
+        if (m(o)) {
+          if (m(i)) throw new ReferenceError("Decorators can't be placed on different accessors with for the same property (" + o.key + ").");
+          i.decorators = o.decorators;
+        }
+        P(o, i);
+      }
+    else e.push(o);
+  }
+  return e;
+}
+function m(r) {
+  return r.decorators && r.decorators.length;
+}
+function h(r) {
+  return r !== void 0 && !(r.value === void 0 && r.writable === void 0);
+}
+function v(r, e) {
+  var t = r[e];
+  if (t !== void 0 && typeof t != "function") throw new TypeError("Expected '" + e + "' to be a function");
+  return t;
+}
+function g(r) {
+  var e = I(r, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function I(r, e) {
+  if (typeof r != "object" || !r) return r;
+  var t = r[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var n = t.call(r, e);
+    if (typeof n != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(r);
+}
+function _(r) {
+  return F(r) || z(r) || S(r) || x();
+}
+function x() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function S(r, e) {
+  if (r) {
+    if (typeof r == "string") return b(r, e);
+    var t = {}.toString.call(r).slice(8, -1);
+    return t === "Object" && r.constructor && (t = r.constructor.name), t === "Map" || t === "Set" ? Array.from(r) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? b(r, e) : void 0;
+  }
+}
+function b(r, e) {
+  (e == null || e > r.length) && (e = r.length);
+  for (var t = 0, n = Array(e); t < e; t++) n[t] = r[t];
+  return n;
+}
+function z(r) {
+  if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null) return Array.from(r);
+}
+function F(r) {
+  if (Array.isArray(r)) return r;
+}
+let K = D([T()], function(r) {
+  class e {
+    constructor() {
+      r(this);
+    }
+  }
+  return {
+    F: e,
+    d: [{
+      kind: "method",
+      static: !0,
+      key: "validate",
+      value: function(n, i, o, a, s) {
+        const l = o?.get(i?.dataTypeIdentifier?.genericKey), p = o?.get(i?.dataTypeIdentifier?.genericKey)?.sourceDataTypeIdentifiers, d = o?.get(i?.dataTypeIdentifier?.genericKey)?.genericCombinationStrategies;
+        if ("value" in n && !Array.isArray(n.value)) return !1;
+        if (i?.dataTypeIdentifier?.genericKey && !l && !a?.getDataType(i.dataTypeIdentifier)) return !0;
+        if (!(a?.getDataType(i.dataTypeIdentifier) || l) || l && !a?.hasDataTypes(p) || l && (d?.length ?? 0) + 1 != p.length) return !1;
+        if (i?.dataTypeIdentifier?.genericKey && l && p) {
+          const c = p.map((f) => n.value.every((u) => f.genericType ? y({
+            __typename: "LiteralValue",
+            value: u
+          }, a?.getDataType(f), a, s, f.genericType.genericMappers) : y({
+            __typename: "LiteralValue",
+            value: u
+          }, a?.getDataType(f), a, s)));
+          return c.length > 1 ? c.reduce((f, u, k) => d && d[k - 1].type == "OR" ? f || u : f && u) : c[0];
+        }
+        return i?.dataTypeIdentifier?.dataType ? n.value.every((c) => y(c, a?.getDataType(i.dataTypeIdentifier), a)) : n.value.every((c) => y(c, a?.getDataType(i.dataTypeIdentifier), a, s, E((i.dataTypeIdentifier?.genericType).genericMappers, o)));
+      }
+    }]
+  };
+});
+export {
+  K as DFlowDataTypeContainsTypeRule
+};

package/dist/components/{d-flow/data-type → d-flow-data-type}/rules/DFlowDataTypeParentRule.d.ts

@@ -1,9 +1,8 @@
 import { DFlowDataTypeReactiveService } from '../DFlowDataType.service';
-import { DataTypeIdentifier, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
-import { FlowView } from '../../DFlow.view';
+import { DataTypeIdentifier, Flow, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
 export interface DFlowDataTypeParentRuleConfig {
     type: DataTypeIdentifier;
 }
 export declare class DFlowDataTypeParentRule {
-    static validate(value: NodeParameterValue, config: DFlowDataTypeParentRuleConfig, generics?: Map<string, GenericMapper>, service?: DFlowDataTypeReactiveService, flow?: FlowView): boolean;
+    static validate(value: NodeParameterValue, config: DFlowDataTypeParentRuleConfig, generics?: Map<string, GenericMapper>, service?: DFlowDataTypeReactiveService, flow?: Flow): boolean;
 }

package/dist/components/{d-flow/data-type → d-flow-data-type}/rules/DFlowDataTypeParentRule.js

@@ -1,6 +1,6 @@
 import { staticImplements as w } from "./DFlowDataTypeRule.js";
-import { replaceGenericKeysInType as b } from "../../../../utils/generics.js";
-import { u as E } from "../../../../DFlowDataType.service-Dz8pQUeO.js";
+import { replaceGenericKeysInType as b } from "../../../utils/generics.js";
+import { useValueValidation as E } from "../../d-flow-validation/DValueValidation.hook.js";
 function k(r, e, t, i) {
   var n = y(), o = e(function(a) {
     n.initializeInstanceElements(a, s.elements);
@@ -207,7 +207,7 @@ let j = k([w()], function(r) {
       key: "validate",
       value: function(i, n, o, s, a) {
         const l = o ? b(n.type, o) : n.type;
-        return s ? E(i, s.getDataType(l), a, Array.from(o, ([p, c]) => c)) : !1;
+        return s ? E(i, s.getDataType(l), s, a, Array.from(o, ([p, c]) => c)) : !1;
       }
     }]
   };

package/dist/components/{d-flow/data-type → d-flow-data-type}/rules/DFlowDataTypeReturnTypeRule.d.ts

@@ -1,6 +1,5 @@
 import { DFlowDataTypeReactiveService } from '../DFlowDataType.service';
-import { DataTypeRulesReturnTypeConfig, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
-import { FlowView } from '../../DFlow.view';
+import { DataTypeRulesReturnTypeConfig, Flow, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
 export declare class DFlowDataTypeReturnTypeRule {
-    static validate(value: NodeParameterValue, config: DataTypeRulesReturnTypeConfig, generics?: Map<string, GenericMapper>, service?: DFlowDataTypeReactiveService, flow?: FlowView): boolean;
+    static validate(value: NodeParameterValue, config: DataTypeRulesReturnTypeConfig, generics?: Map<string, GenericMapper>, service?: DFlowDataTypeReactiveService, flow?: Flow): boolean;
 }

package/dist/components/d-flow-data-type/rules/DFlowDataTypeReturnTypeRule.js

@@ -0,0 +1,246 @@
+import { genericMapping as I, staticImplements as A } from "./DFlowDataTypeRule.js";
+import { useDataTypeValidation as T } from "../../d-flow-validation/DDataTypeValidation.hook.js";
+import { useValueValidation as v } from "../../d-flow-validation/DValueValidation.hook.js";
+function P(r, e, t, n) {
+  var i = k(), o = e(function(s) {
+    i.initializeInstanceElements(s, a.elements);
+  }, t), a = i.decorateClass(x(o.d.map(_)), r);
+  return i.initializeClassElements(o.F, a.elements), i.runClassFinishers(o.F, a.finishers);
+}
+function k() {
+  k = function() {
+    return r;
+  };
+  var r = { elementsDefinitionOrder: [["method"], ["field"]], initializeInstanceElements: function(e, t) {
+    ["method", "field"].forEach(function(n) {
+      t.forEach(function(i) {
+        i.kind === n && i.placement === "own" && this.defineClassElement(e, i);
+      }, this);
+    }, this);
+  }, initializeClassElements: function(e, t) {
+    var n = e.prototype;
+    ["method", "field"].forEach(function(i) {
+      t.forEach(function(o) {
+        var a = o.placement;
+        if (o.kind === i && (a === "static" || a === "prototype")) {
+          var s = a === "static" ? e : n;
+          this.defineClassElement(s, o);
+        }
+      }, this);
+    }, this);
+  }, defineClassElement: function(e, t) {
+    var n = t.descriptor;
+    if (t.kind === "field") {
+      var i = t.initializer;
+      n = { enumerable: n.enumerable, writable: n.writable, configurable: n.configurable, value: i === void 0 ? void 0 : i.call(e) };
+    }
+    Object.defineProperty(e, t.key, n);
+  }, decorateClass: function(e, t) {
+    var n = [], i = [], o = { static: [], prototype: [], own: [] };
+    if (e.forEach(function(s) {
+      this.addElementPlacement(s, o);
+    }, this), e.forEach(function(s) {
+      if (!y(s)) return n.push(s);
+      var l = this.decorateElement(s, o);
+      n.push(l.element), n.push.apply(n, l.extras), i.push.apply(i, l.finishers);
+    }, this), !t) return { elements: n, finishers: i };
+    var a = this.decorateConstructor(n, t);
+    return i.push.apply(i, a.finishers), a.finishers = i, a;
+  }, addElementPlacement: function(e, t, n) {
+    var i = t[e.placement];
+    if (!n && i.indexOf(e.key) !== -1) throw new TypeError("Duplicated element (" + e.key + ")");
+    i.push(e.key);
+  }, decorateElement: function(e, t) {
+    for (var n = [], i = [], o = e.decorators, a = o.length - 1; a >= 0; a--) {
+      var s = t[e.placement];
+      s.splice(s.indexOf(e.key), 1);
+      var l = this.fromElementDescriptor(e), p = this.toElementFinisherExtras((0, o[a])(l) || l);
+      e = p.element, this.addElementPlacement(e, t), p.finisher && i.push(p.finisher);
+      var c = p.extras;
+      if (c) {
+        for (var d = 0; d < c.length; d++) this.addElementPlacement(c[d], t);
+        n.push.apply(n, c);
+      }
+    }
+    return { element: e, finishers: i, extras: n };
+  }, decorateConstructor: function(e, t) {
+    for (var n = [], i = t.length - 1; i >= 0; i--) {
+      var o = this.fromClassDescriptor(e), a = this.toClassDescriptor((0, t[i])(o) || o);
+      if (a.finisher !== void 0 && n.push(a.finisher), a.elements !== void 0) {
+        e = a.elements;
+        for (var s = 0; s < e.length - 1; s++) for (var l = s + 1; l < e.length; l++) if (e[s].key === e[l].key && e[s].placement === e[l].placement) throw new TypeError("Duplicated element (" + e[s].key + ")");
+      }
+    }
+    return { elements: e, finishers: n };
+  }, fromElementDescriptor: function(e) {
+    var t = { kind: e.kind, key: e.key, placement: e.placement, descriptor: e.descriptor };
+    return Object.defineProperty(t, Symbol.toStringTag, { value: "Descriptor", configurable: !0 }), e.kind === "field" && (t.initializer = e.initializer), t;
+  }, toElementDescriptors: function(e) {
+    if (e !== void 0) return R(e).map(function(t) {
+      var n = this.toElementDescriptor(t);
+      return this.disallowProperty(t, "finisher", "An element descriptor"), this.disallowProperty(t, "extras", "An element descriptor"), n;
+    }, this);
+  }, toElementDescriptor: function(e) {
+    var t = e.kind + "";
+    if (t !== "method" && t !== "field") throw new TypeError(`An element descriptor's .kind property must be either "method" or "field", but a decorator created an element descriptor with .kind "` + t + '"');
+    var n = E(e.key), i = e.placement + "";
+    if (i !== "static" && i !== "prototype" && i !== "own") throw new TypeError(`An element descriptor's .placement property must be one of "static", "prototype" or "own", but a decorator created an element descriptor with .placement "` + i + '"');
+    var o = e.descriptor;
+    this.disallowProperty(e, "elements", "An element descriptor");
+    var a = { kind: t, key: n, placement: i, descriptor: Object.assign({}, o) };
+    return t !== "field" ? this.disallowProperty(e, "initializer", "A method descriptor") : (this.disallowProperty(o, "get", "The property descriptor of a field descriptor"), this.disallowProperty(o, "set", "The property descriptor of a field descriptor"), this.disallowProperty(o, "value", "The property descriptor of a field descriptor"), a.initializer = e.initializer), a;
+  }, toElementFinisherExtras: function(e) {
+    return { element: this.toElementDescriptor(e), finisher: g(e, "finisher"), extras: this.toElementDescriptors(e.extras) };
+  }, fromClassDescriptor: function(e) {
+    var t = { kind: "class", elements: e.map(this.fromElementDescriptor, this) };
+    return Object.defineProperty(t, Symbol.toStringTag, { value: "Descriptor", configurable: !0 }), t;
+  }, toClassDescriptor: function(e) {
+    var t = e.kind + "";
+    if (t !== "class") throw new TypeError(`A class descriptor's .kind property must be "class", but a decorator created a class descriptor with .kind "` + t + '"');
+    this.disallowProperty(e, "key", "A class descriptor"), this.disallowProperty(e, "placement", "A class descriptor"), this.disallowProperty(e, "descriptor", "A class descriptor"), this.disallowProperty(e, "initializer", "A class descriptor"), this.disallowProperty(e, "extras", "A class descriptor");
+    var n = g(e, "finisher");
+    return { elements: this.toElementDescriptors(e.elements), finisher: n };
+  }, runClassFinishers: function(e, t) {
+    for (var n = 0; n < t.length; n++) {
+      var i = (0, t[n])(e);
+      if (i !== void 0) {
+        if (typeof i != "function") throw new TypeError("Finishers must return a constructor.");
+        e = i;
+      }
+    }
+    return e;
+  }, disallowProperty: function(e, t, n) {
+    if (e[t] !== void 0) throw new TypeError(n + " can't have a ." + t + " property.");
+  } };
+  return r;
+}
+function _(r) {
+  var e, t = E(r.key);
+  r.kind === "method" ? e = { value: r.value, writable: !0, configurable: !0, enumerable: !1 } : r.kind === "get" ? e = { get: r.value, configurable: !0, enumerable: !1 } : r.kind === "set" ? e = { set: r.value, configurable: !0, enumerable: !1 } : r.kind === "field" && (e = { configurable: !0, writable: !0, enumerable: !0 });
+  var n = { kind: r.kind === "field" ? "field" : "method", key: t, placement: r.static ? "static" : r.kind === "field" ? "own" : "prototype", descriptor: e };
+  return r.decorators && (n.decorators = r.decorators), r.kind === "field" && (n.initializer = r.value), n;
+}
+function C(r, e) {
+  r.descriptor.get !== void 0 ? e.descriptor.get = r.descriptor.get : e.descriptor.set = r.descriptor.set;
+}
+function x(r) {
+  for (var e = [], t = function(a) {
+    return a.kind === "method" && a.key === o.key && a.placement === o.placement;
+  }, n = 0; n < r.length; n++) {
+    var i, o = r[n];
+    if (o.kind === "method" && (i = e.find(t)))
+      if (b(o.descriptor) || b(i.descriptor)) {
+        if (y(o) || y(i)) throw new ReferenceError("Duplicated methods (" + o.key + ") can't be decorated.");
+        i.descriptor = o.descriptor;
+      } else {
+        if (y(o)) {
+          if (y(i)) throw new ReferenceError("Decorators can't be placed on different accessors with for the same property (" + o.key + ").");
+          i.decorators = o.decorators;
+        }
+        C(o, i);
+      }
+    else e.push(o);
+  }
+  return e;
+}
+function y(r) {
+  return r.decorators && r.decorators.length;
+}
+function b(r) {
+  return r !== void 0 && !(r.value === void 0 && r.writable === void 0);
+}
+function g(r, e) {
+  var t = r[e];
+  if (t !== void 0 && typeof t != "function") throw new TypeError("Expected '" + e + "' to be a function");
+  return t;
+}
+function E(r) {
+  var e = F(r, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function F(r, e) {
+  if (typeof r != "object" || !r) return r;
+  var t = r[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var n = t.call(r, e);
+    if (typeof n != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(r);
+}
+function R(r) {
+  return j(r) || O(r) || z(r) || S();
+}
+function S() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function z(r, e) {
+  if (r) {
+    if (typeof r == "string") return w(r, e);
+    var t = {}.toString.call(r).slice(8, -1);
+    return t === "Object" && r.constructor && (t = r.constructor.name), t === "Map" || t === "Set" ? Array.from(r) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? w(r, e) : void 0;
+  }
+}
+function w(r, e) {
+  (e == null || e > r.length) && (e = r.length);
+  for (var t = 0, n = Array(e); t < e; t++) n[t] = r[t];
+  return n;
+}
+function O(r) {
+  if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null) return Array.from(r);
+}
+function j(r) {
+  if (Array.isArray(r)) return r;
+}
+let W = P([A()], function(r) {
+  class e {
+    constructor() {
+      r(this);
+    }
+  }
+  return {
+    F: e,
+    d: [{
+      kind: "method",
+      static: !0,
+      key: "validate",
+      value: function(n, i, o, a, s) {
+        const l = o?.get(i?.dataTypeIdentifier?.genericKey), p = o?.get(i?.dataTypeIdentifier?.genericKey)?.sourceDataTypeIdentifiers, c = o?.get(i?.dataTypeIdentifier?.genericKey)?.genericCombinationStrategies;
+        if (n.__typename != "NodeFunctionIdWrapper") return !1;
+        const d = D(n, s);
+        if (!d) return !1;
+        if (i?.dataTypeIdentifier?.genericKey && !l && !a?.getDataType(i.dataTypeIdentifier)) return !0;
+        if (!(a?.getDataType(i.dataTypeIdentifier) || l) || l && !a?.hasDataTypes(p) || l && (c?.length ?? 0) + 1 != p.length) return !1;
+        if (d?.parameters?.nodes[0]?.value.__typename === "ReferenceValue") {
+          if (i?.dataTypeIdentifier?.genericKey && l && p) {
+            const u = p.map((f) => T(a?.getDataType(f), a?.getDataType((d?.parameters?.nodes[0]?.value).dataTypeIdentifier)));
+            return u.length > 1 ? u.reduce((f, m, h) => c && c[h - 1].type == "OR" ? f || m : f && m) : u[0];
+          }
+          if (i?.dataTypeIdentifier?.dataType)
+            return T(a?.getDataType(i.dataTypeIdentifier), a?.getDataType(d?.parameters?.nodes[0]?.value?.dataTypeIdentifier));
+        } else if (d?.parameters?.nodes[0]?.value?.__typename != "NodeFunctionIdWrapper") {
+          if (i?.dataTypeIdentifier?.genericKey && l && p) {
+            const u = p.map((f) => v(d?.parameters?.nodes[0]?.value, a?.getDataType(f), a, s, f.genericType.genericMappers));
+            return u.length > 1 ? u.reduce((f, m, h) => c && c[h - 1].type == "OR" ? f || m : f && m) : u[0];
+          }
+          return i?.dataTypeIdentifier?.dataType ? v(d?.parameters?.nodes[0]?.value, a?.getDataType(i.dataTypeIdentifier), a) : v(d?.parameters?.nodes[0]?.value, a?.getDataType(i.dataTypeIdentifier), a, s, I(i.dataTypeIdentifier?.genericType?.genericMappers, o));
+        }
+        return !1;
+      }
+    }]
+  };
+});
+const D = (r, e) => {
+  const t = e.nodes?.nodes?.find((n) => n?.id === r.id);
+  if (t?.functionDefinition?.runtimeFunctionDefinition?.identifier === "RETURN") return t;
+  if (t) {
+    const n = D({
+      id: t.nextNodeId
+    }, e);
+    if (n) return n;
+  }
+};
+export {
+  W as DFlowDataTypeReturnTypeRule
+};

package/dist/components/{d-flow/data-type → d-flow-data-type}/rules/DFlowDataTypeRule.d.ts

@@ -1,8 +1,7 @@
 import { DFlowDataTypeReactiveService } from '../DFlowDataType.service';
-import { GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
-import { FlowView } from '../../DFlow.view';
+import { Flow, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
 export interface DFlowDataTypeRule {
-    validate(value: NodeParameterValue, config: object, generics?: Map<string, GenericMapper>, service?: DFlowDataTypeReactiveService, flow?: FlowView): boolean;
+    validate(value: NodeParameterValue, config: object, generics?: Map<string, GenericMapper>, service?: DFlowDataTypeReactiveService, flow?: Flow): boolean;
 }
 export declare const staticImplements: <T>() => <U extends T>(constructor: U) => U;
 export declare const genericMapping: (to?: GenericMapper[], from?: Map<string, GenericMapper>) => GenericMapper[] | undefined;

package/dist/components/d-flow-data-type/rules/DFlowDataTypeRules.js

@@ -0,0 +1,10 @@
+import { DFlowDataTypeRegexRule as e } from "./DFlowDataTypeRegexRule.js";
+import { DFlowDataTypeRangeRule as o } from "./DFlowDataTypeNumberRangeRule.js";
+import { DFlowDataTypeItemOfCollectionRule as t } from "./DFlowDataTypeItemOfCollectionRule.js";
+import { DFlowDataTypeContainsTypeRule as a } from "./DFlowDataTypeContainsTypeRule.js";
+import { DFlowDataTypeContainsKeyRule as p } from "./DFlowDataTypeContainsKeyRule.js";
+import { DFlowDataTypeReturnTypeRule as l } from "./DFlowDataTypeReturnTypeRule.js";
+const i = /* @__PURE__ */ new Map([["REGEX", e], ["NUMBER_RANGE", o], ["ITEM_OF_COLLECTION", t], ["CONTAINS_TYPE", a], ["CONTAINS_KEY", p], ["RETURN_TYPE", l]]);
+export {
+  i as RuleMap
+};

package/dist/components/d-flow-file/DFlowTabDefault.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { NodeFunction, Scalars } from '@code0-tech/sagittarius-graphql-types';
+export interface DFlowTabDefaultProps {
+    node: NodeFunction;
+    flowId: Scalars["FlowID"]["output"];
+}
+export declare const DFlowTabDefault: React.FC<DFlowTabDefaultProps>;

package/dist/components/d-flow-file/DFlowTabDefault.js

@@ -0,0 +1,104 @@
+import { jsx as m } from "react/jsx-runtime";
+import r from "react";
+import "../../_virtual/compiler-runtime.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 "../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 { useForm as M } from "../form/useForm.js";
+import { Flex as k } from "../flex/Flex.js";
+import { useService as p, useStore as S } from "../../utils/contextStore.js";
+import { DFlowFunctionReactiveService as V } from "../d-flow-function/DFlowFunction.service.js";
+import "js-md5";
+import "../d-flow/DFlow.js";
+import { DFlowReactiveService as g } 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 { useNodeValidation as B } from "../d-flow-validation/DNodeValidation.hook.js";
+import { FileTabsService as E } from "../file-tabs/FileTabs.service.js";
+import { DFlowInputDefault as J } from "../d-flow-input/DFlowInputDefault.js";
+const ve = (w) => {
+  const {
+    node: o,
+    flowId: a
+  } = w, D = p(V), I = S(V), l = p(g), _ = S(g), h = p(E), f = B(o.id, a), c = r.useRef(/* @__PURE__ */ new Set()), [, F] = r.useTransition(), v = r.useMemo(() => D.getById(o.functionDefinition?.id), [I]), N = r.useMemo(() => {
+    const t = {};
+    return v?.parameterDefinitions?.forEach((e) => {
+      t[e.id] = e;
+    }), t;
+  }, [v]), s = r.useMemo(() => [...o.parameters?.nodes || []].sort((t, e) => t.id.localeCompare(e?.id)), [o]), b = r.useMemo(() => {
+    const t = {};
+    return s.forEach((e) => {
+      t[e?.id] = e?.value?.__typename === "LiteralValue" ? typeof e.value?.value == "object" ? JSON.stringify(e.value?.value) : e.value.value : JSON.stringify(e?.value);
+    }), t;
+  }, [s]), P = r.useMemo(() => {
+    const t = {};
+    return s.forEach((e) => {
+      t[e?.id] = (u) => {
+        const n = f?.find((i) => i.parameterId === e?.id);
+        return n ? n.message[0]?.content || "Invalid value" : null;
+      };
+    }), t;
+  }, [s, f]), x = r.useCallback((t) => {
+    F(async () => {
+      for (const e of s) {
+        if (!c.current.has(e?.id)) continue;
+        const u = t[e?.id], n = e?.value, i = u?.[0]?.value;
+        n && n.__typename === "NodeFunctionIdWrapper" && n.id && l.getLinkedNodesById(a, n.id).reverse().forEach((y) => {
+          y.id && h.deleteById(y.id);
+        }), (!i || !u) && await l.setParameterValue(a, o.id, e.id, void 0);
+        try {
+          const d = JSON.parse(String(i));
+          if (!i?.__typename) {
+            await l.setParameterValue(a, o.id, e.id, i ? {
+              __typename: "LiteralValue",
+              value: d
+            } : void 0);
+            continue;
+          }
+        } catch {
+          if (!i?.__typename) {
+            await l.setParameterValue(a, o.id, e.id, i ? {
+              __typename: "LiteralValue",
+              value: i
+            } : void 0);
+            continue;
+          }
+        }
+        await l.setParameterValue(a, o.id, e.id, i.__typename === "LiteralValue" ? i.value ? i : void 0 : i);
+      }
+      c.current.clear();
+    });
+  }, [_, s]), [T, L] = M({
+    initialValues: b,
+    validate: P,
+    truthyValidationBeforeSubmit: !1,
+    onSubmit: x
+  });
+  return /* @__PURE__ */ m(k, { style: {
+    gap: ".7rem",
+    flexDirection: "column"
+  }, children: s.map((t) => {
+    if (!t) return null;
+    const e = N[t.id], u = e?.names ? e?.names[0]?.content : e?.id, n = e?.descriptions ? e?.descriptions[0]?.content : JSON.stringify(e?.dataTypeIdentifier);
+    return /* @__PURE__ */ m("div", { children: /* @__PURE__ */ m(J, { flowId: a, nodeId: o.id, parameterId: t.id, title: u, description: n, clearable: !0, onChange: () => {
+      c.current.add(t.id), L();
+    }, ...T.getInputProps(t.id) }) });
+  }) });
+};
+export {
+  ve as DFlowTabDefault
+};

package/dist/components/{d-flow/tab → d-flow-file}/DFlowTabTrigger.d.ts

@@ -1,6 +1,6 @@
 import { default as React } from 'react';
-import { FlowView } from '../DFlow.view';
+import { Flow } from '@code0-tech/sagittarius-graphql-types';
 export interface DFlowTabTriggerProps {
-    instance: FlowView;
+    instance: Flow;
 }
 export declare const DFlowTabTrigger: React.FC<DFlowTabTriggerProps>;