@teamkeel/functions-runtime 0.414.7 → 0.415.1

package/dist/index.cjs

@@ -2483,20 +2483,15 @@ async function page(options, data, action) {
   }
   const contentUiConfig = await Promise.all(
     content.map(async (c) => {
-      const isInput = "__type" in c && c.__type == "input";
-      const hasData = data && c.uiConfig.name in data;
-      if (isInput && hasData && 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)
+      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);
@@ -2527,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 {
@@ -2729,6 +2819,84 @@ 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];
+  const dataPromises = dataConfig.map(async (d) => {
+    if ("type" in d && d.type) {
+      return {
+        type: d.type,
+        name: d.name,
+        data: Array.isArray(d.data) ? d.data : [d.data]
+      };
+    }
+    return null;
+  });
+  const data = (await Promise.all(dataPromises)).filter((x) => x !== null);
+  return {
+    uiConfig: {
+      __type: "ui.interactive.print",
+      title: options.title,
+      description: options.description,
+      data,
+      autoPrint: options.autoPrint ?? false
+    }
+  };
+}, "print");
+
+// src/flows/ui/elements/interactive/pickList.ts
+var pickList = /* @__PURE__ */ __name((name, options) => {
+  return {
+    __type: "input",
+    uiConfig: {
+      __type: "ui.interactive.pickList",
+      name,
+      data: options.data.map((item) => {
+        const rendered = options.render(item);
+        return {
+          id: rendered.id,
+          targetQuantity: rendered.targetQuantity,
+          title: rendered.title,
+          description: rendered.description,
+          image: rendered.image ?? void 0,
+          barcodes: rendered.barcodes ?? void 0
+        };
+      })
+    },
+    validate: /* @__PURE__ */ __name(async (data) => {
+      if (!("items" in data)) {
+        return "Missing items in response";
+      }
+      if (!Array.isArray(data.items)) {
+        return "Items must be an array";
+      }
+      if (data.items.some(
+        (item) => typeof item !== "object" || typeof item.id !== "string" || typeof item.qty !== "number"
+      )) {
+        return "Invalid data";
+      }
+      return options?.validate?.(data) ?? true;
+    }, "validate"),
+    getData: /* @__PURE__ */ __name((x) => x, "getData")
+  };
+}, "pickList");
+
 // src/flows/errors.ts
 var NonRetriableError = class extends Error {
   static {
@@ -2955,6 +3123,11 @@ function createFlowContext(runId, data, action, spanId, ctx) {
       select: {
         one: selectOne,
         table: selectTable
+      },
+      iterator,
+      interactive: {
+        print,
+        pickList
       }
     }
   };
@@ -2979,7 +3152,7 @@ async function complete(options) {
   const content = options.content || [];
   const contentUiConfig = await Promise.all(
     content.map(async (c) => {
-      return c.uiConfig;
+      return (await c).uiConfig;
     })
   );
   return {