@teamkeel/functions-runtime 0.415.0 → 0.415.1

package/dist/index.cjs

@@ -2482,22 +2482,16 @@ async function page(options, data, action) {
     }
   }
   const contentUiConfig = await Promise.all(
-    content.map(async (content2) => {
-      let c = await content2;
-      const isInput = "__type" in c && c.__type == "input";
-      const hasData = data && c.uiConfig.name in data;
-      if (isInput && hasData && "validate" in c && c.validate) {
-        const validationError2 = await c.validate(data[c.uiConfig.name]);
-        if (typeof validationError2 === "string") {
-          hasValidationErrors = true;
-          return {
-            ...c.uiConfig,
-            validationError: validationError2
-          };
-        }
-      }
-      return c.uiConfig;
-    }).filter(Boolean)
+    content.map(async (c) => {
+      const resolvedC = await c;
+      const elementData = data && typeof data === "object" && resolvedC.uiConfig.name in data ? data[resolvedC.uiConfig.name] : void 0;
+      const { uiConfig, validationErrors } = await recursivelyProcessElement(
+        c,
+        elementData
+      );
+      if (validationErrors) hasValidationErrors = true;
+      return uiConfig;
+    })
   );
   if (data && options.validate) {
     const validationResult = await options.validate(data);
@@ -2528,6 +2522,101 @@ async function page(options, data, action) {
   };
 }
 __name(page, "page");
+var recursivelyProcessElement = /* @__PURE__ */ __name(async (c, data) => {
+  const resolvedC = await c;
+  const elementType = "__type" in resolvedC ? resolvedC.__type : null;
+  switch (elementType) {
+    case "input":
+      return processInputElement(
+        resolvedC,
+        data
+      );
+    case "iterator":
+      return processIteratorElement(
+        resolvedC,
+        data
+      );
+    default:
+      return {
+        uiConfig: { ...resolvedC.uiConfig },
+        validationErrors: false
+      };
+  }
+}, "recursivelyProcessElement");
+var processInputElement = /* @__PURE__ */ __name(async (element, data) => {
+  const hasData = data !== void 0 && data !== null;
+  if (!hasData || !element.validate) {
+    return {
+      uiConfig: { ...element.uiConfig },
+      validationErrors: false
+    };
+  }
+  const validationError = await element.validate(data);
+  const hasValidationErrors = typeof validationError === "string";
+  return {
+    uiConfig: {
+      ...element.uiConfig,
+      validationError: hasValidationErrors ? validationError : void 0
+    },
+    validationErrors: hasValidationErrors
+  };
+}, "processInputElement");
+var processIteratorElement = /* @__PURE__ */ __name(async (element, data) => {
+  const elements = element.uiConfig.content;
+  const dataArr = data;
+  const ui = [];
+  for (const el of elements) {
+    const result = await recursivelyProcessElement(el, void 0);
+    ui.push(result.uiConfig);
+  }
+  const validationErrors = await validateIteratorData(elements, dataArr);
+  let hasValidationErrors = validationErrors.length > 0;
+  let validationError = void 0;
+  if (dataArr && element.validate) {
+    const v = await element.validate(dataArr);
+    if (typeof v === "string") {
+      hasValidationErrors = true;
+      validationError = v;
+    }
+  }
+  return {
+    uiConfig: {
+      ...element.uiConfig,
+      content: ui,
+      validationError,
+      contentValidationErrors: hasValidationErrors ? validationErrors : void 0
+    },
+    validationErrors: hasValidationErrors
+  };
+}, "processIteratorElement");
+var validateIteratorData = /* @__PURE__ */ __name(async (elements, dataArr) => {
+  const validationErrors = [];
+  if (!dataArr || dataArr.length === 0) {
+    return validationErrors;
+  }
+  for (let i = 0; i < dataArr.length; i++) {
+    const rowData = dataArr[i];
+    for (const el of elements) {
+      const resolvedEl = await el;
+      if ("__type" in resolvedEl && resolvedEl.__type === "input" && "validate" in resolvedEl && resolvedEl.validate && typeof resolvedEl.validate === "function") {
+        const fieldName = resolvedEl.uiConfig.name;
+        if (rowData && typeof rowData === "object" && fieldName in rowData) {
+          const validationError = await resolvedEl.validate(
+            rowData[fieldName]
+          );
+          if (typeof validationError === "string") {
+            validationErrors.push({
+              index: i,
+              name: fieldName,
+              validationError
+            });
+          }
+        }
+      }
+    }
+  }
+  return validationErrors;
+}, "validateIteratorData");
 
 // src/flows/disrupts.ts
 var FlowDisrupt = class {
@@ -2730,6 +2819,22 @@ var dataGridInput = /* @__PURE__ */ __name((name, options) => {
   };
 }, "dataGridInput");
 
+// src/flows/ui/elements/iterator.ts
+var iterator = /* @__PURE__ */ __name((name, options) => {
+  return {
+    __type: "iterator",
+    uiConfig: {
+      __type: "ui.iterator",
+      name,
+      content: options.content,
+      max: options.max,
+      min: options.min
+    },
+    validate: options?.validate,
+    getData: /* @__PURE__ */ __name((x) => x, "getData")
+  };
+}, "iterator");
+
 // src/flows/ui/elements/interactive/print.ts
 var print = /* @__PURE__ */ __name(async (options) => {
   const dataConfig = Array.isArray(options.jobs) ? options.jobs : [options.jobs];
@@ -3019,6 +3124,7 @@ function createFlowContext(runId, data, action, spanId, ctx) {
         one: selectOne,
         table: selectTable
       },
+      iterator,
       interactive: {
         print,
         pickList