@code0-tech/pictor 0.0.0-mvp.40 → 0.0.0-mvp.42

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

@@ -1,49 +1,49 @@
-import l from "react";
-import { useService as F, useStore as N } from "../../utils/contextStore.js";
+import g from "react";
+import { useService as I, useStore as N } from "../../utils/contextStore.js";
 import "merge-props";
-import { DFlowDataTypeReactiveService as h } from "../d-flow-data-type/DFlowDataType.service.js";
+import { DFlowDataTypeReactiveService as x } 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 { DFlowSuggestionType as A } from "./DFlowSuggestion.view.js";
+import { replaceGenericsAndSortType as C, resolveType as P, isMatchingType as V, resolveGenericKeys as Y, targetForGenericKey as k, replaceGenericKeysInType as J } from "../../utils/generics.js";
+import { DFlowFunctionReactiveService as O } 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 [];
+import { DFlowReactiveService as R } from "../d-flow/DFlow.service.js";
+import { useReturnTypes as j } from "../d-flow-node/DFlowNode.return.hook.js";
+const re = (n, t, o, u = []) => {
+  const f = I(x), r = N(x), v = I(R), T = N(R), M = $(n), S = g.useMemo(() => t ? M?.find((i) => i.nodeFunctionId === t) : void 0, [M, t]), B = g.useMemo(() => t ? v.getNodeById(n, t)?.parameters?.nodes?.map((a) => a?.value).filter((a) => a?.__typename === "NodeFunctionIdWrapper") ?? [] : [], [n, t, v, T]), c = g.useMemo(() => o ? C(P(o, f), u) : void 0, [o, f, r, u]), p = U(n), m = j(n);
+  return g.useMemo(() => {
+    if (!c || !S) return [];
     const {
       depth: i,
-      scope: s,
-      node: d
-    } = D;
-    return T.flatMap((e) => {
+      scope: a,
+      node: l
+    } = S;
+    return p.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 [];
+      const d = e.parameterIndex !== void 0 && e.inputTypeIndex !== void 0, D = d ? e.scope?.every((s, F) => a?.[F] === s) : !0;
+      if (d && !D) return [];
+      if (B.some((s) => s.id === e.nodeFunctionId)) return [];
+      if (!d && e.node >= l) 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) ? [{
+      if (e.scope.some((s) => !a.includes(s))) return [];
+      const h = m.get(e.nodeFunctionId), E = C(P(h, f), []);
+      return V(c, E) ? [{
         path: [],
-        type: $.REF_OBJECT,
-        displayText: [`${e.depth}-${e.scope}-${e.node || ""}-${e.referencePath?.map((f) => f.path).join(".") ?? ""}`],
+        type: A.REF_OBJECT,
+        displayText: [`${e.depth}-${e.scope}-${e.node || ""}-${e.referencePath?.map((s) => s.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({
+  }, [f, S, B, p, c]);
+}, U = (n) => {
+  const t = I(x);
+  N(x);
+  const o = I(O), u = I(R), f = N(R), r = g.useMemo(() => u.getById(n), [n, f]), v = $(n), T = j(n), M = g.useMemo(() => r?.nodes?.nodes?.map((c) => {
+    const p = T.get(c?.id), m = v?.find((i) => i.nodeFunctionId === c?.id);
+    return p && m ? G(m, p, t) : {};
+  }) ?? [], [r]), S = g.useMemo(() => G({
     node: 0,
     depth: 0,
     nodeFunctionId: "gid://sagittarius/NodeFunction/-1",
@@ -51,37 +51,37 @@ const oe = (n, t, o, m = []) => {
   }, {
     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);
+  return [...g.useMemo(() => r?.nodes?.nodes?.length ? r.nodes.nodes.flatMap((c) => {
+    const p = o.getById(c?.functionDefinition?.id);
+    if (!p) return [];
+    const m = c?.parameters?.nodes?.map((i) => i?.value).filter(Boolean) ?? [];
+    return (p.parameterDefinitions ?? []).flatMap((i, a) => {
+      const l = i?.dataTypeIdentifier;
+      if (!l) return [];
+      const e = t.getDataType(l);
       if (!e || e.variant !== "NODE") return [];
-      const c = a?.parameters?.nodes?.find((p) => p?.parameterDefinition?.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) : [];
+      const d = c?.parameters?.nodes?.find((y) => y?.parameterDefinition?.id === i?.id);
+      if (!d?.value || d.value.__typename !== "NodeFunctionIdWrapper") return [];
+      const D = v?.find((y) => d?.value?.__typename === "NodeFunctionIdWrapper" && y.nodeFunctionId === d.value?.id);
+      if (!D) return [];
+      const h = e.rules?.nodes?.filter((y) => y?.variant === "INPUT_TYPES") ?? [], E = Y(p, m, t, o), s = k(p, l), F = new Map([...E].map(([y, b]) => [s.get(y) ?? y, b]));
+      return h.flatMap((y) => (y?.config?.inputTypes ?? []).flatMap((W, K) => {
+        const w = J(W.dataTypeIdentifier, F);
+        return w ? G({
+          ...D,
+          nodeFunctionId: c?.id,
+          parameterIndex: a,
+          inputTypeIndex: K,
+          inputTypeIdentifier: W.inputIdentifier
+        }, w, 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) => {
+  }) : [], [r, v, o, t]), ...S, ...M].flat();
+}, G = (n, t, o) => {
+  const u = o ? o.getDataType(t) : t.dataType ?? t.genericType?.dataType;
+  return u ? [...u.rules?.nodes?.map((r) => {
     if (r?.variant === "CONTAINS_KEY")
-      return t ? w({
+      return t ? G({
         ...n,
         referencePath: [...n.referencePath ?? [], {
           path: r.config.key
@@ -89,45 +89,44 @@ const oe = (n, t, o, m = []) => {
       }, 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;
+}, $ = (n) => {
+  const t = I(x), o = I(R), u = I(O), f = N(R), r = N(O), v = N(x), T = g.useMemo(() => o.getById(n), [n, f]);
+  return g.useMemo(() => {
+    if (!t || !o || !u || !T?.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?.parameterDefinition?.id === f.id);
-            if (B?.variant === "NODE") {
-              if (S?.value && S.value.__typename === "NodeFunctionIdWrapper") {
-                const p = [...e, D()];
-                i(S.value, d + 1, p);
+    const S = () => ++M;
+    let B = 0;
+    const c = () => ++B, p = [], m = (i, a, l) => {
+      if (!i) return;
+      let e = i.__typename === "NodeFunctionIdWrapper" ? o.getNodeById(n, i.id) : i;
+      for (; e; ) {
+        const d = u.getById(e.functionDefinition?.id);
+        if (!d) break;
+        if (e.parameters && d.parameterDefinitions)
+          for (const h of d.parameterDefinitions) {
+            const E = t.getDataType(h.dataTypeIdentifier), s = e.parameters?.nodes?.find((F) => F?.parameterDefinition?.id === h.id);
+            if (E?.variant === "NODE") {
+              if (s?.value && s.value.__typename === "NodeFunctionIdWrapper") {
+                const F = [...l, S()];
+                m(s.value, a + 1, F);
               }
-            } else S?.value && S.value.__typename === "NodeFunctionIdWrapper" && i(S.value, d, e);
+            } else s?.value && s.value.__typename === "NodeFunctionIdWrapper" && m(s.value, a, l);
           }
-        const R = u();
-        T.push({
-          node: R,
-          depth: d,
-          scope: e,
-          nodeFunctionId: c.id
-        }), c = o.getNodeById(g.id, c.nextNodeId);
+        const D = c();
+        p.push({
+          node: D,
+          depth: a,
+          scope: l,
+          nodeFunctionId: e.id
+        }), e = o.getNodeById(T.id, e.nextNodeId);
       }
     };
-    return i(o.getNodeById(g.id, g.startingNodeId), 0, [0]), T;
-  }, [t, g, n, o, m, v, y, r]) ?? [];
+    return m(o.getNodeById(T.id, T.startingNodeId), 0, [0]), p;
+  }, [t, T, n, o, u, v, f, r]) ?? [];
 };
 export {
-  oe as useReferenceSuggestions
+  re as useReferenceSuggestions
 };

package/dist/components/d-flow-validation/DDataTypeValidation.hook.js

@@ -1,5 +1,5 @@
 const g = ["id", "__typename", "createdAt", "updatedAt", "aliases", "displayMessages", "name", "runtime"], h = (l, u) => {
-  if (l.variant !== u.variant) return !1;
+  if (l?.variant !== u?.variant) return !1;
   const c = (e) => e !== null && typeof e == "object", i = (e, r) => {
     if (e === r) return !0;
     const a = Array.isArray(e), y = Array.isArray(r);

package/dist/components/d-flow-validation/DNodeValidation.hook.js

@@ -1,57 +1,57 @@
-import R from "react";
+import S from "react";
 import { DFlowDataTypeReactiveService as E } from "../d-flow-data-type/DFlowDataType.service.js";
 import { DataTypeView as C } from "../d-flow-data-type/DFlowDataType.view.js";
-import { useService as V, useStore as N } from "../../utils/contextStore.js";
+import { useService as V, useStore as _ } from "../../utils/contextStore.js";
 import { InspectionSeverity as P } from "../../utils/inspection.js";
 import "merge-props";
 import { resolveGenericKeys as U, replaceGenericKeysInType as q, replaceGenericKeysInDataTypeObject as z } from "../../utils/generics.js";
 import { useReturnType as H } from "../d-flow-function/DFlowFunction.return.hook.js";
 import { DFlowFunctionReactiveService as G } from "../d-flow-function/DFlowFunction.service.js";
 import "js-md5";
-import { useDataTypeValidation as I } from "./DDataTypeValidation.hook.js";
-import { useValueValidation as O } from "./DValueValidation.hook.js";
+import { useDataTypeValidation as O } from "./DDataTypeValidation.hook.js";
+import { useValueValidation as w } from "./DValueValidation.hook.js";
 import "../d-flow/DFlow.js";
-import { DFlowReactiveService as w } from "../d-flow/DFlow.service.js";
-const M = (e) => e.__typename === "ReferenceValue", K = (e) => e.__typename === "NodeFunctionIdWrapper", b = (e, r) => new C(z(e.json, r)), j = (e, r, p) => ({
-  parameterId: e,
+import { DFlowReactiveService as M } from "../d-flow/DFlow.service.js";
+const N = (t) => t.__typename === "ReferenceValue", F = (t) => t.__typename === "NodeFunctionIdWrapper", b = (t, r) => new C(z(t.json, r)), W = (t, r, i) => ({
+  parameterId: t,
   type: P.ERROR,
   message: [{
     code: "en-US",
-    content: `Argument of type ${p?.name[0]?.content} is not assignable to parameter of type ${r?.name[0]?.content}`
+    content: `Argument of type ${i?.name[0]?.content} is not assignable to parameter of type ${r?.name[0]?.content}`
   }]
-}), ae = (e, r) => {
-  const p = V(G), W = N(G), d = V(w), _ = N(w), t = V(E), F = N(E), s = d.getById(r), f = d.getNodeById(r, e), v = f?.parameters?.nodes?.map((n) => n?.value) ?? [], m = p.getById(f?.functionDefinition?.id), S = m?.parameterDefinitions ?? [], h = m?.genericKeys ?? [], T = R.useMemo(() => U(m, v, t, s), [m, v, t, F, s, _]), x = R.useCallback((n, c) => {
-    if (K(n) && c?.variant !== "NODE") {
-      const u = d.getNodeById(r, n.id), o = p.getById(u?.functionDefinition?.id), D = u?.parameters?.nodes?.map((a) => a?.value) ?? [];
-      return H(o, D, t);
+}), ae = (t, r) => {
+  const i = V(G), j = _(G), f = V(M), I = _(M), n = V(E), K = _(E), s = f.getById(r), l = f.getNodeById(r, t), T = l?.parameters?.nodes?.map((e) => e?.value) ?? [], m = i.getById(l?.functionDefinition?.id), R = m?.parameterDefinitions ?? [], h = m?.genericKeys ?? [], D = S.useMemo(() => U(m, T, n, i, s), [m, T, n, K, s, I]), x = S.useCallback((e, a) => {
+    if (F(e) && a?.variant !== "NODE" || N(e)) {
+      const d = f.getNodeById(r, e.__typename == "NodeFunctionIdWrapper" ? e.id : e.__typename === "ReferenceValue" ? e.nodeFunctionId : void 0), o = i.getById(d?.functionDefinition?.id), g = d?.parameters?.nodes?.map((p) => p?.value) ?? [];
+      return H(o, g, n, i);
     }
-    return t.getTypeFromValue(n, s);
-  }, [t, s, r, d, p]);
-  return R.useMemo(() => {
-    const n = [];
-    for (let c = 0; c < S.length; c++) {
-      const u = S[c], o = v[c], D = f?.parameters?.nodes?.find((g) => g?.parameterDefinition?.id === u.id);
+    return n.getTypeFromValue(e, s);
+  }, [n, s, r, f, i]);
+  return S.useMemo(() => {
+    const e = [];
+    for (let a = 0; a < R.length; a++) {
+      const d = R[a], o = T[a], g = l?.parameters?.nodes?.find((v) => v?.parameterDefinition?.id === d.id);
       if (!o) continue;
-      const a = u.dataTypeIdentifier, B = q(a, T), i = t.getDataType(B), $ = x(o, i), l = t.getDataType($);
-      if (!i || !l) {
-        n.push(j(D?.id, i, l));
+      const p = d.dataTypeIdentifier, B = q(p, D), c = n.getDataType(B), $ = x(o, c), y = n.getDataType($);
+      if (!c || !y) {
+        e.push(W(g?.id, c, y));
         continue;
       }
-      const k = !!a?.genericType || !!a?.genericKey && h.includes(a.genericKey);
-      let y = !0;
+      const k = !!p?.genericType || !!p?.genericKey && h.includes(p.genericKey);
+      let u = !0;
       if (k) {
-        const g = b(i, T);
-        if (M(o) || K(o) && i.variant !== "NODE") {
-          const A = b(l, T);
-          y = I(g, A);
+        const v = b(c, D);
+        if (N(o) || F(o) && c.variant !== "NODE") {
+          const A = b(y, D);
+          u = O(v, A);
         } else
-          y = O(o, g, t, s, B?.genericType?.genericMappers);
+          u = w(o, v, n, s, B?.genericType?.genericMappers, i);
       } else
-        M(o) || K(o) && i.variant !== "NODE" ? y = I(i, l) : y = O(o, i, t, s);
-      y || n.push(j(D?.id, i, l));
+        N(o) || F(o) && c.variant !== "NODE" ? u = O(c, y) : u = w(o, c, n, s, [], i);
+      u || e.push(W(g?.id, c, y));
     }
-    return n.length > 0 ? n : null;
-  }, [s, f, v, m, S, h, T, x, e, r, W, _, F, t]);
+    return e.length > 0 ? e : null;
+  }, [s, l, T, m, R, h, D, x, t, r, j, I, K, n]);
 };
 export {
   ae as useNodeValidation

package/dist/components/d-flow-validation/DValueValidation.hook.d.ts

@@ -1,3 +1,4 @@
 import { Flow, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
 import { DataTypeView, DFlowDataTypeReactiveService } from '../d-flow-data-type';
-export declare const useValueValidation: (value: NodeParameterValue, dataType: DataTypeView, dataTypeService: DFlowDataTypeReactiveService, flow?: Flow, generics?: GenericMapper[]) => boolean;
+import { DFlowFunctionReactiveService } from '../d-flow-function';
+export declare const useValueValidation: (value: NodeParameterValue, dataType: DataTypeView, dataTypeService: DFlowDataTypeReactiveService, flow?: Flow, generics?: GenericMapper[], functionService?: DFlowFunctionReactiveService) => boolean;

package/dist/components/d-flow-validation/DValueValidation.hook.js

@@ -1,9 +1,9 @@
 import { RuleMap as r } from "../d-flow-data-type/rules/DFlowDataTypeRules.js";
-import { VariantsMap as m } from "../d-flow-data-type/variants/DFlowDataTypeVariants.js";
-const V = (a, i, n, e, o) => {
-  const s = new Map(o?.map((t) => [t.target, t])), f = i.rules?.nodes?.every((t) => !t || !t.variant || !t.config ? !1 : r.get(t.variant) ? r.get(t.variant)?.validate(a, t.config, s, n, e) : !0) ?? !0, p = m.get(i.variant)?.validate(a) ?? !0;
-  return f && p;
+import { VariantsMap as u } from "../d-flow-data-type/variants/DFlowDataTypeVariants.js";
+const c = (a, i, n, e, o, s) => {
+  const f = new Map(o?.map((t) => [t.target, t])), p = i?.rules?.nodes?.every((t) => !t || !t.variant || !t.config ? !1 : r.get(t.variant) ? r.get(t.variant)?.validate(a, t.config, f, e, n, s) : !0) ?? !0, m = u.get(i.variant)?.validate(a) ?? !0;
+  return p && m;
 };
 export {
-  V as useValueValidation
+  c as useValueValidation
 };

package/dist/components/d-project/DNamespaceProject.service.d.ts

@@ -1,4 +1,4 @@
-import { Namespace, NamespaceProject, NamespacesProjectsAssignRuntimesInput, NamespacesProjectsAssignRuntimesPayload, NamespacesProjectsCreateInput, NamespacesProjectsCreatePayload, NamespacesProjectsDeleteInput, NamespacesProjectsDeletePayload } from '@code0-tech/sagittarius-graphql-types';
+import { Namespace, NamespaceProject, NamespacesProjectsAssignRuntimesInput, NamespacesProjectsAssignRuntimesPayload, NamespacesProjectsCreateInput, NamespacesProjectsCreatePayload, NamespacesProjectsDeleteInput, NamespacesProjectsDeletePayload, NamespacesProjectsUpdateInput, NamespacesProjectsUpdatePayload } from '@code0-tech/sagittarius-graphql-types';
 import { DNamespaceProjectView } from './DNamespaceProject.view';
 import { ReactiveArrayService } from '../../utils';
 export type DProjectDependencies = {
@@ -7,6 +7,7 @@ export type DProjectDependencies = {
 export declare abstract class DNamespaceProjectReactiveService extends ReactiveArrayService<DNamespaceProjectView, DProjectDependencies> {
     getById(id: NamespaceProject['id'], dependencies?: DProjectDependencies): DNamespaceProjectView | undefined;
     abstract projectAssignRuntimes(payload: NamespacesProjectsAssignRuntimesInput): Promise<NamespacesProjectsAssignRuntimesPayload | undefined>;
+    abstract projectUpdate(payload: NamespacesProjectsUpdateInput): Promise<NamespacesProjectsUpdatePayload | undefined>;
     abstract projectCreate(payload: NamespacesProjectsCreateInput): Promise<NamespacesProjectsCreatePayload | undefined>;
     abstract projectDelete(payload: NamespacesProjectsDeleteInput): Promise<NamespacesProjectsDeletePayload | undefined>;
 }

package/dist/components/data-table/DataTable.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { Code0Component } from '../../utils';
+export type DataTableFilterOperator = "isOneOf" | "isNotOneOf";
+export interface DataTableFilterProps {
+    [key: string]: {
+        operator: DataTableFilterOperator;
+        value: string | string[];
+    };
+}
+export interface DataTableSortProps {
+    [key: string]: 'asc' | 'desc' | undefined;
+}
+export interface DataTableProps<T> extends Omit<Code0Component<HTMLTableElement>, 'data' | 'children' | 'onSelect'> {
+    data: Array<T>;
+    sort?: DataTableSortProps;
+    filter?: DataTableFilterProps;
+    loading?: boolean;
+    loadingComponent?: React.ReactNode;
+    emptyComponent?: React.ReactNode;
+    onSelect?: (item: T | undefined) => void;
+    children?: (item: T, index: number) => React.ReactNode;
+}
+export declare const DataTable: <T>(props: DataTableProps<T>) => React.JSX.Element;

package/dist/components/data-table/DataTable.js

@@ -0,0 +1,41 @@
+import { jsxs as g, jsx as O } from "react/jsx-runtime";
+import h from "react";
+import '../../assets/components/data-table/DataTable.style.css';/* empty css                     */
+import "../../utils/contextStore.js";
+import { mergeCode0Props as C } from "../../utils/utils.js";
+const d = (l, y) => y.split(".").reduce((t, f) => {
+  if (t != null)
+    return Array.isArray(t) ? t.map((a) => a?.[f]).filter((a) => a !== void 0) : t[f];
+}, l), N = (l) => {
+  const {
+    data: y,
+    sort: t,
+    filter: f,
+    loading: a,
+    loadingComponent: j,
+    emptyComponent: A,
+    onSelect: u,
+    children: p,
+    ...b
+  } = l, m = y.filter((i) => Object.entries(f || {}).every(([o, {
+    operator: n,
+    value: r
+  }]) => {
+    const e = d(i, o);
+    return n === "isOneOf" && !Array.isArray(r) && !Array.isArray(e) ? e === r : n === "isOneOf" && !Array.isArray(r) && Array.isArray(e) ? Array.from(e).includes(r) : n === "isOneOf" && Array.isArray(r) && !Array.isArray(e) ? Array.from(r).some((s) => s === e) : n === "isOneOf" && Array.isArray(r) && Array.isArray(e) ? Array.from(r).some((s) => Array.from(e).includes(s)) : !1;
+  })), c = h.useMemo(() => t ? [...m].sort((i, o) => {
+    for (const [n, r] of Object.entries(t)) {
+      const e = d(i, n), s = d(o, n);
+      if (e < s) return r === "asc" ? -1 : 1;
+      if (e > s) return r === "asc" ? 1 : -1;
+    }
+    return 0;
+  }) : m, [m, t]);
+  return /* @__PURE__ */ g("table", { ...C("data-table", b), children: [
+    c.map((i, o) => /* @__PURE__ */ O("tr", { className: "data-table__row", onClick: () => u?.(i), children: p?.(i, o) })),
+    c.length === 0 && !a && A ? /* @__PURE__ */ O("tr", { className: "data-table__row", onClick: () => u?.(void 0), children: A }) : null
+  ] });
+};
+export {
+  N as DataTable
+};

package/dist/components/data-table/DataTableColumn.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { Code0Component } from '../../utils';
+export interface DataTableColumnProps extends Code0Component<HTMLTableCellElement> {
+    children?: React.ReactNode | React.ReactNode[];
+}
+export declare const DataTableColumn: React.FC<DataTableColumnProps>;

package/dist/components/data-table/DataTableColumn.js

@@ -0,0 +1,22 @@
+import { jsx as c } from "react/jsx-runtime";
+import { c as n } from "../../_virtual/compiler-runtime.js";
+import "../../utils/contextStore.js";
+import "react";
+import { mergeCode0Props as s } from "../../utils/utils.js";
+const x = (m) => {
+  const t = n.c(6);
+  let e, r;
+  if (t[0] !== m) {
+    const {
+      children: i,
+      ...l
+    } = m;
+    e = i, r = s("", l), t[0] = m, t[1] = e, t[2] = r;
+  } else
+    e = t[1], r = t[2];
+  let o;
+  return t[3] !== e || t[4] !== r ? (o = /* @__PURE__ */ c("td", { ...r, children: e }), t[3] = e, t[4] = r, t[5] = o) : o = t[5], o;
+};
+export {
+  x as DataTableColumn
+};

package/dist/components/data-table/DataTableFilterInput.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { StreamLanguage } from '@codemirror/language';
+import { CompletionContext } from '@codemirror/autocomplete';
+import { DataTableFilterOperator, DataTableFilterProps } from './DataTable';
+export interface DataTableFilterTokens {
+    token: string;
+    key: string;
+    operators: DataTableFilterOperator[];
+    suggestion?: (context: CompletionContext, operator: DataTableFilterOperator, currentValue: string, applySuggestion: (value: string, silently?: boolean) => void) => React.ReactNode;
+}
+export interface DataTableFilterInputProps {
+    filterTokens?: DataTableFilterTokens[];
+    onChange?: (filter: DataTableFilterProps) => void;
+}
+export declare const createFilterQueryLanguage: (validTokens: string[]) => StreamLanguage<{
+    tokens: string[];
+}>;
+export declare const DataTableFilterInput: React.FC<DataTableFilterInputProps>;