nuxt-ui-tools 0.1.3 → 1.0.0

package/dist/runtime/form/utils/state.js

@@ -1,35 +1,126 @@
 import { resolveFieldDependencies } from "./dependencies.js";
 import { createFormFieldInstance, isRegisteredFormFieldType } from "./field-instance.js";
 import { cloneFormValue, getPathValue, isRecord, mergeFormObjects, setPathValue } from "./path.js";
+import {
+  invokeFormFunction,
+  isBoolean,
+  isFunction,
+  isNumber,
+  isString,
+  isUndefined
+} from "./predicate.js";
 export function getSchemaFields(schema) {
-  if (!isRecord(schema)) return [];
+  if (!isRecord(schema)) {
+    return [];
+  }
   const fields = Object.getOwnPropertyDescriptor(schema, "fields")?.value;
   return Array.isArray(fields) ? fields.filter(isFormField) : [];
 }
 export function getSchemaSteps(schema) {
-  if (!isRecord(schema)) return [];
+  if (!isRecord(schema)) {
+    return [];
+  }
   const steps = Object.getOwnPropertyDescriptor(schema, "steps")?.value;
-  if (!Array.isArray(steps)) return [];
+  if (!Array.isArray(steps)) {
+    return [];
+  }
   return steps.map(normalizeStep).filter(isRuntimeStep);
 }
 export function isSteppedSchema(schema) {
   return getSchemaSteps(schema).length > 0;
 }
 export function getSchemaLayout(schema) {
-  if (!isRecord(schema)) return void 0;
+  if (!isRecord(schema)) {
+    return void 0;
+  }
   return normalizeLayout(Object.getOwnPropertyDescriptor(schema, "layout")?.value);
 }
-export function buildInitialFormState(schema, ctx, input) {
+export function buildInitialFormState(schema, ctx, input, createApiFactory) {
   const state = {};
-  if (input) mergeFormObjects(state, input);
-  if (isSteppedSchema(schema)) {
-    for (const step of getSchemaSteps(schema))
-      mergeMissingFieldDefaults(state, step.fields, ctx, step.root ? [step.root] : []);
-    return state;
+  if (input) {
+    mergeFormObjects(state, input);
+  }
+  const raw = cloneFormObject(state);
+  const inputApiFactory = createApiFactory?.(state, raw);
+  const scopes = isSteppedSchema(schema) ? getSchemaSteps(schema).map((step) => ({
+    fields: step.fields,
+    parentPath: step.root ? [step.root] : []
+  })) : [{ fields: getSchemaFields(schema), parentPath: [] }];
+  for (const scope of scopes) {
+    applyInputTransforms(state, scope.fields, ctx, scope.parentPath, inputApiFactory);
+  }
+  const defaultsApiFactory = createApiFactory?.(state, cloneFormObject(state));
+  for (const scope of scopes) {
+    mergeMissingFieldDefaults(state, scope.fields, ctx, scope.parentPath, defaultsApiFactory);
   }
-  mergeMissingFieldDefaults(state, getSchemaFields(schema), ctx, []);
   return state;
 }
+function cloneFormObject(value) {
+  const cloned = cloneFormValue(value);
+  return isRecord(cloned) ? cloned : {};
+}
+function applyInputTransforms(target, fields, ctx, parentPath, apiFactory) {
+  for (const field of fields) {
+    if (field.ignore === true) {
+      continue;
+    }
+    const fieldInstance = createFormFieldInstance(field);
+    if (fieldInstance.state.is("stateless")) {
+      continue;
+    }
+    if (isFlatPassthroughField(field)) {
+      applyInputTransforms(target, getChildFields(field), ctx, parentPath, apiFactory);
+      continue;
+    }
+    const path = fieldPath(parentPath, field);
+    const value = getPathValue(target, path);
+    if (isObjectContainerField(field)) {
+      if (isRecord(value)) {
+        applyInputTransforms(target, getChildFields(field), ctx, path, apiFactory);
+      }
+      continue;
+    }
+    if (fieldInstance.type.is("matrix")) {
+      for (const row of getMatrixRows(field)) {
+        if (isRecord(getPathValue(target, [...path, row]))) {
+          applyInputTransforms(target, getChildFields(field), ctx, [...path, row], apiFactory);
+        }
+      }
+      continue;
+    }
+    if (isPrimitiveArrayField(field)) {
+      applyPrimitiveArrayInputTransforms(target, field, value, ctx, path, apiFactory);
+      continue;
+    }
+    if (isArrayField(field)) {
+      if (!Array.isArray(value)) {
+        continue;
+      }
+      for (const [index, item] of value.entries()) {
+        if (isRecord(item)) {
+          applyInputTransforms(
+            target,
+            getArrayItemFields(field, item),
+            ctx,
+            [...path, String(index)],
+            apiFactory
+          );
+        }
+      }
+      continue;
+    }
+    if (isUndefined(value)) {
+      continue;
+    }
+    const transform = Object.getOwnPropertyDescriptor(field, "transform")?.value;
+    if (!isRecord(transform) || !isFunction(transform.input)) {
+      continue;
+    }
+    const api = apiFactory?.(path, field);
+    const params = api ? callbackParams({ api, ctx, field, parentPath, state: target }) : void 0;
+    setPathValue(target, path, transform.input(value, params));
+  }
+}
 export function buildInitialFormFieldsState(fields, ctx) {
   const state = {};
   mergeMissingFieldDefaults(state, fields, ctx, []);
@@ -38,20 +129,33 @@ export function buildInitialFormFieldsState(fields, ctx) {
 export function buildFormOutput(schema, state, ctx, apiFactory) {
   const output = {};
   if (isSteppedSchema(schema)) {
-    for (const step of getSchemaSteps(schema))
-      mergeFormObjects(
-        output,
-        buildFieldsOutput(step.fields, state, ctx, apiFactory, step.root ? [step.root] : [])
+    for (const step of getSchemaSteps(schema)) {
+      const stepOutput = buildFieldsOutput(
+        step.fields,
+        state,
+        ctx,
+        apiFactory,
+        step.root ? [step.root] : []
       );
+      if (!step.root) {
+        mergeFormObjects(output, stepOutput);
+        continue;
+      }
+      const rooted = {};
+      setPathValue(rooted, step.root, stepOutput);
+      mergeFormObjects(output, rooted);
+    }
     return output;
   }
   return buildFieldsOutput(getSchemaFields(schema), state, ctx, apiFactory, []);
 }
 export async function validateFormState(schema, state, ctx, apiFactory, mode = true) {
-  if (mode === false) return [];
+  if (mode === false) {
+    return [];
+  }
   const errors = [];
   if (isSteppedSchema(schema)) {
-    for (const step of getSchemaSteps(schema))
+    for (const step of getSchemaSteps(schema)) {
       errors.push(
         ...await validateFields(
           step.fields,
@@ -62,22 +166,26 @@ export async function validateFormState(schema, state, ctx, apiFactory, mode = t
           mode
         )
       );
+    }
     return errors;
   }
   return validateFields(getSchemaFields(schema), state, ctx, apiFactory, [], mode);
 }
 export function collectFormFieldPaths(schema) {
-  if (isSteppedSchema(schema))
+  if (isSteppedSchema(schema)) {
     return getSchemaSteps(schema).flatMap(
       (step) => collectFormFieldsPaths(step.fields, step.root ? [step.root] : [])
     );
+  }
   return collectFormFieldsPaths(getSchemaFields(schema), []);
 }
 export function collectFormFieldsPaths(fields, parentPath) {
   return collectFieldPaths(fields, parentPath);
 }
 export async function validateFormFields(params) {
-  if (params.mode === false) return [];
+  if (params.mode === false) {
+    return [];
+  }
   return await validateFields(
     params.fields,
     params.state,
@@ -91,37 +199,53 @@ export function fieldPath(parentPath, field) {
   return [...parentPath, field.key];
 }
 export function childParentPath(parentPath, field) {
-  if (isFlatPassthroughField(field)) return parentPath;
+  if (isFlatPassthroughField(field)) {
+    return parentPath;
+  }
   return fieldPath(parentPath, field);
 }
 export function shouldRenderField(field, params) {
-  if (field.ignore === true) return false;
+  if (field.ignore === true) {
+    return false;
+  }
   const condition = Object.getOwnPropertyDescriptor(field, "condition")?.value;
-  if (typeof condition !== "function") return true;
+  if (!isFunction(condition)) {
+    return true;
+  }
   return condition(params) === true;
 }
-function mergeMissingFieldDefaults(target, fields, ctx, parentPath) {
+function mergeMissingFieldDefaults(target, fields, ctx, parentPath, apiFactory) {
   for (const field of fields) {
-    if (field.ignore === true) continue;
+    if (field.ignore === true) {
+      continue;
+    }
     const fieldInstance = createFormFieldInstance(field);
-    if (fieldInstance.state.is("stateless")) continue;
+    if (fieldInstance.state.is("stateless")) {
+      continue;
+    }
     if (isFlatPassthroughField(field)) {
-      mergeMissingFieldDefaults(target, getChildFields(field), ctx, parentPath);
+      mergeMissingFieldDefaults(target, getChildFields(field), ctx, parentPath, apiFactory);
       continue;
     }
     if (isObjectContainerField(field)) {
       const path2 = fieldPath(parentPath, field);
-      if (!isRecord(getPathValue(target, path2))) setPathValue(target, path2, {});
-      mergeMissingFieldDefaults(target, getChildFields(field), ctx, path2);
+      if (!isRecord(getPathValue(target, path2))) {
+        setPathValue(target, path2, {});
+      }
+      mergeMissingFieldDefaults(target, getChildFields(field), ctx, path2, apiFactory);
       continue;
     }
     if (fieldInstance.type.is("matrix")) {
       const path2 = fieldPath(parentPath, field);
-      if (!isRecord(getPathValue(target, path2))) setPathValue(target, path2, {});
+      if (!isRecord(getPathValue(target, path2))) {
+        setPathValue(target, path2, {});
+      }
       for (const row of getMatrixRows(field)) {
         const rowPath = [...path2, row];
-        if (!isRecord(getPathValue(target, rowPath))) setPathValue(target, rowPath, {});
-        mergeMissingFieldDefaults(target, getChildFields(field), ctx, rowPath);
+        if (!isRecord(getPathValue(target, rowPath))) {
+          setPathValue(target, rowPath, {});
+        }
+        mergeMissingFieldDefaults(target, getChildFields(field), ctx, rowPath, apiFactory);
       }
       continue;
     }
@@ -133,25 +257,35 @@ function mergeMissingFieldDefaults(target, fields, ctx, parentPath) {
         continue;
       }
       for (const [index, item] of value.entries()) {
-        if (!isRecord(item)) continue;
-        mergeMissingFieldDefaults(target, getArrayItemFields(field, item), ctx, [
-          ...path2,
-          String(index)
-        ]);
+        if (!isRecord(item)) {
+          continue;
+        }
+        mergeMissingFieldDefaults(
+          target,
+          getArrayItemFields(field, item),
+          ctx,
+          [...path2, String(index)],
+          apiFactory
+        );
       }
       continue;
     }
     const path = fieldPath(parentPath, field);
-    if (typeof getPathValue(target, path) === "undefined")
-      setPathValue(target, path, resolveFieldDefault(field, ctx));
+    if (isUndefined(getPathValue(target, path))) {
+      setPathValue(target, path, resolveFieldDefault(field, ctx, apiFactory?.(path, field)));
+    }
   }
 }
 function buildFieldsOutput(fields, state, ctx, apiFactory, parentPath) {
   const output = {};
   for (const field of fields) {
-    if (field.ignore === true) continue;
+    if (field.ignore === true) {
+      continue;
+    }
     const fieldInstance = createFormFieldInstance(field);
-    if (fieldInstance.state.is("stateless")) continue;
+    if (fieldInstance.state.is("stateless")) {
+      continue;
+    }
     if (isFlatPassthroughField(field)) {
       mergeFormObjects(
         output,
@@ -159,22 +293,38 @@ function buildFieldsOutput(fields, state, ctx, apiFactory, parentPath) {
       );
       continue;
     }
-    if (fieldInstance.capability.has("submit") && "submit" in field && field.submit?.omit) continue;
+    if (fieldInstance.capability.has("submit") && "submit" in field && field.submit?.omit) {
+      continue;
+    }
     const path = fieldPath(parentPath, field);
     const api = apiFactory(path, field);
     const params = callbackParams({
-      field,
-      state,
-      ctx,
       api,
-      parentPath
+      ctx,
+      field,
+      parentPath,
+      state
     });
-    if (!shouldRenderField(field, params)) continue;
+    if (!shouldRenderField(field, params)) {
+      continue;
+    }
     if (isObjectContainerField(field)) {
       const objectValue = buildFieldsOutput(getChildFields(field), state, ctx, apiFactory, path);
       setPathValue(output, field.key, applyOutputTransform(field, objectValue, params));
       continue;
     }
+    if (isPrimitiveArrayField(field)) {
+      const items = buildPrimitiveArrayOutput(
+        field,
+        getPathValue(state, path),
+        state,
+        ctx,
+        apiFactory,
+        path
+      );
+      setPathValue(output, field.key, applyOutputTransform(field, items, params));
+      continue;
+    }
     if (isArrayField(field)) {
       const value = getPathValue(state, path);
       const items = Array.isArray(value) ? value.map((item, index) => {
@@ -193,12 +343,13 @@ function buildFieldsOutput(fields, state, ctx, apiFactory, parentPath) {
     }
     if (fieldInstance.type.is("matrix")) {
       const matrixValue = {};
-      for (const row of getMatrixRows(field))
+      for (const row of getMatrixRows(field)) {
         setPathValue(
           matrixValue,
           row,
           buildFieldsOutput(getChildFields(field), state, ctx, apiFactory, [...path, row])
         );
+      }
       setPathValue(output, field.key, applyOutputTransform(field, matrixValue, params));
       continue;
     }
@@ -209,9 +360,13 @@ function buildFieldsOutput(fields, state, ctx, apiFactory, parentPath) {
 async function validateFields(fields, state, ctx, apiFactory, parentPath, mode) {
   const errors = [];
   for (const field of fields) {
-    if (field.ignore === true) continue;
+    if (field.ignore === true) {
+      continue;
+    }
     const fieldInstance = createFormFieldInstance(field);
-    if (fieldInstance.state.is("stateless")) continue;
+    if (fieldInstance.state.is("stateless")) {
+      continue;
+    }
     if (isFlatPassthroughField(field)) {
       errors.push(
         ...await validateFields(getChildFields(field), state, ctx, apiFactory, parentPath, mode)
@@ -221,23 +376,38 @@ async function validateFields(fields, state, ctx, apiFactory, parentPath, mode)
     const path = fieldPath(parentPath, field);
     const api = apiFactory(path, field);
     const params = callbackParams({
-      field,
-      state,
-      ctx,
       api,
-      parentPath
+      ctx,
+      field,
+      parentPath,
+      state
     });
-    if (!shouldRenderField(field, params)) continue;
+    if (!shouldRenderField(field, params)) {
+      continue;
+    }
     if (isObjectContainerField(field)) {
       errors.push(
         ...await validateFields(getChildFields(field), state, ctx, apiFactory, path, mode)
       );
       continue;
     }
+    if (isPrimitiveArrayField(field)) {
+      errors.push(
+        ...await validatePrimitiveArrayItems(
+          field,
+          getPathValue(state, path),
+          state,
+          ctx,
+          apiFactory,
+          path,
+          mode
+        )
+      );
+    }
     if (isArrayField(field)) {
       const value2 = getPathValue(state, path);
-      if (Array.isArray(value2))
-        for (const index of value2.keys())
+      if (Array.isArray(value2)) {
+        for (const index of value2.keys()) {
           errors.push(
             ...await validateFields(
               getArrayItemFields(field, isRecord(value2[index]) ? value2[index] : {}),
@@ -248,10 +418,12 @@ async function validateFields(fields, state, ctx, apiFactory, parentPath, mode)
               mode
             )
           );
+        }
+      }
       continue;
     }
     if (fieldInstance.type.is("matrix")) {
-      for (const row of getMatrixRows(field))
+      for (const row of getMatrixRows(field)) {
         errors.push(
           ...await validateFields(
             getChildFields(field),
@@ -262,66 +434,183 @@ async function validateFields(fields, state, ctx, apiFactory, parentPath, mode)
             mode
           )
         );
+      }
       continue;
     }
     const value = getPathValue(state, path);
     const required = mode !== "rules" && resolveRequired(field, params);
     if (required && isEmptyValue(value)) {
       errors.push({
-        path: path.join("."),
-        message: resolveRequiredMessage(field)
+        message: resolveRequiredMessage(field),
+        path: path.join(".")
       });
     }
-    if (mode !== "required") errors.push(...await validateFieldRules(field, value, params, path));
+    if (mode !== "required") {
+      errors.push(...await validateFieldRules(field, value, params, path));
+    }
   }
   return errors;
 }
 function collectFieldPaths(fields, parentPath) {
   return fields.flatMap((field) => {
-    if (field.ignore === true) return [];
+    if (field.ignore === true) {
+      return [];
+    }
     const fieldInstance = createFormFieldInstance(field);
-    if (fieldInstance.state.is("stateless")) return [];
-    if (isFlatPassthroughField(field)) return collectFieldPaths(getChildFields(field), parentPath);
+    if (fieldInstance.state.is("stateless")) {
+      return [];
+    }
+    if (isFlatPassthroughField(field)) {
+      return collectFieldPaths(getChildFields(field), parentPath);
+    }
     const path = fieldPath(parentPath, field);
-    if (isObjectContainerField(field)) return collectFieldPaths(getChildFields(field), path);
-    if (fieldInstance.type.is("matrix"))
+    if (isObjectContainerField(field)) {
+      return collectFieldPaths(getChildFields(field), path);
+    }
+    if (fieldInstance.type.is("matrix")) {
       return getMatrixRows(field).flatMap(
         (row) => collectFieldPaths(getChildFields(field), [...path, row])
       );
+    }
     return [path.join(".")];
   });
 }
-function isFlatPassthroughField(field) {
-  return createFormFieldInstance(field).type.isAny(["input-group", "card", "column"]);
+export function isFlatPassthroughField(field) {
+  return createFormFieldInstance(field).type.isAny(["input-group", "tabs", "card", "column"]);
 }
-function isObjectContainerField(field) {
+export function isObjectContainerField(field) {
   return createFormFieldInstance(field).type.isAny(["object", "group"]);
 }
-function isArrayField(field) {
+export function isArrayField(field) {
   return createFormFieldInstance(field).type.isAny([
     "array-list",
     "array-table",
     "array-tabs",
-    "array-variant"
+    "array-variant",
+    "array-collapse"
   ]);
 }
-function getMatrixRows(field) {
-  if (!createFormFieldInstance(field).type.is("matrix")) return [];
+function applyPrimitiveArrayInputTransforms(target, field, value, ctx, path, apiFactory) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  for (const [index, item] of value.entries()) {
+    const itemPath = [...path, String(index)];
+    const normalized = item === null ? void 0 : item;
+    const itemField = getPrimitiveArrayItemField(field, index);
+    const transform = itemField ? Object.getOwnPropertyDescriptor(itemField, "transform")?.value : void 0;
+    if (!itemField || !isRecord(transform) || !isFunction(transform.input)) {
+      if (normalized !== item) {
+        setPathValue(target, itemPath, normalized);
+      }
+      continue;
+    }
+    const itemApi = apiFactory?.(itemPath, itemField);
+    const itemParams = itemApi ? callbackParams({ api: itemApi, ctx, field: itemField, parentPath: path, state: target }) : void 0;
+    setPathValue(target, itemPath, transform.input(normalized, itemParams));
+  }
+}
+function buildPrimitiveArrayOutput(field, value, state, ctx, apiFactory, path) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((item, index) => {
+    if (isUndefined(item)) {
+      return [];
+    }
+    const itemField = getPrimitiveArrayItemField(field, index);
+    if (!itemField) {
+      return [cloneFormValue(item)];
+    }
+    const itemPath = [...path, String(index)];
+    const itemParams = callbackParams({
+      api: apiFactory(itemPath, itemField),
+      ctx,
+      field: itemField,
+      parentPath: path,
+      state
+    });
+    return [applyOutputTransform(itemField, item, itemParams)];
+  });
+}
+async function validatePrimitiveArrayItems(field, value, state, ctx, apiFactory, path, mode) {
+  const errors = [];
+  if (!Array.isArray(value)) {
+    return errors;
+  }
+  for (const [index, item] of value.entries()) {
+    const itemField = getPrimitiveArrayItemField(field, index);
+    if (!itemField) {
+      continue;
+    }
+    const itemPath = [...path, String(index)];
+    const itemParams = callbackParams({
+      api: apiFactory(itemPath, itemField),
+      ctx,
+      field: itemField,
+      parentPath: path,
+      state
+    });
+    if (mode !== "rules" && resolveRequired(itemField, itemParams) && isEmptyValue(item)) {
+      errors.push({ message: resolveRequiredMessage(itemField), path: itemPath.join(".") });
+    }
+    if (mode !== "required") {
+      errors.push(...await validateFieldRules(itemField, item, itemParams, itemPath));
+    }
+  }
+  return errors;
+}
+export function readStaticFieldProp(field, name) {
+  const props = Object.getOwnPropertyDescriptor(field, "props")?.value;
+  if (!isRecord(props)) {
+    return void 0;
+  }
+  return props[name];
+}
+export function isPrimitiveArrayField(field) {
+  return createFormFieldInstance(field).type.is("array-primitive");
+}
+export function getPrimitiveArrayItemField(field, index) {
+  const itemField = Object.getOwnPropertyDescriptor(field, "field")?.value;
+  if (!isRecord(itemField)) {
+    return null;
+  }
+  const candidate = { required: true, ...itemField, key: String(index) };
+  return isFormField(candidate) ? candidate : null;
+}
+export function getMatrixRows(field) {
+  if (!createFormFieldInstance(field).type.is("matrix")) {
+    return [];
+  }
   const rows = Object.getOwnPropertyDescriptor(field, "rows")?.value;
-  if (!Array.isArray(rows)) return [];
+  if (!Array.isArray(rows)) {
+    return [];
+  }
   return rows.flatMap((row) => {
-    if (!isRecord(row) || typeof row.key !== "string") return [];
+    if (!isRecord(row) || !isString(row.key)) {
+      return [];
+    }
     return row.key;
   });
 }
-function resolveFieldDefault(field, ctx) {
+function resolveFieldDefault(field, ctx, api) {
   const fieldInstance = createFormFieldInstance(field);
   const value = Object.getOwnPropertyDescriptor(field, "default")?.value;
-  if (typeof value !== "undefined")
-    return typeof value === "function" ? cloneFormValue(value({ ctx })) : cloneFormValue(value);
-  if (fieldInstance.type.is("checkbox")) return false;
-  if (fieldInstance.type.is("switch")) return resolveSwitchDefault(field);
-  if (fieldInstance.type.isAny(["checkbox-group", "checkbox-card", "switch-group"])) return [];
+  if (!isUndefined(value)) {
+    if (isFunction(value)) {
+      return cloneFormValue(invokeFormFunction(value, [{ api, ctx }]));
+    }
+    return cloneFormValue(value);
+  }
+  if (fieldInstance.type.is("checkbox")) {
+    return false;
+  }
+  if (fieldInstance.type.is("switch")) {
+    return resolveSwitchDefault(field);
+  }
+  if (fieldInstance.type.isAny(["checkbox-group", "checkbox-card", "switch-group"])) {
+    return [];
+  }
   if (fieldInstance.type.isAny([
     "auto-complete",
     "select",
@@ -330,147 +619,228 @@ function resolveFieldDefault(field, ctx) {
     "tree",
     "tree-select",
     "cascader"
-  ]) && Object.getOwnPropertyDescriptor(field, "multiple")?.value === true)
+  ]) && readStaticFieldProp(field, "multiple") === true) {
     return [];
-  if (fieldInstance.type.is("tag")) return [];
-  if (fieldInstance.type.is("slider")) return 0;
-  if (fieldInstance.type.is("one-time-code")) return "";
+  }
+  if (fieldInstance.type.isAny(["tag", "array-primitive"])) {
+    return [];
+  }
+  if (fieldInstance.type.is("slider")) {
+    return 0;
+  }
+  if (fieldInstance.type.is("one-time-code")) {
+    return "";
+  }
   return null;
 }
 function resolveSwitchDefault(field) {
-  const trueValue = Object.getOwnPropertyDescriptor(field, "trueValue")?.value;
-  return typeof trueValue === "string" || typeof trueValue === "number" || typeof trueValue === "boolean" ? trueValue : false;
+  const trueValue = readStaticFieldProp(field, "trueValue");
+  return isString(trueValue) || isNumber(trueValue) || isBoolean(trueValue) ? trueValue : false;
 }
 function applyOutputTransform(field, value, params) {
   const transform = Object.getOwnPropertyDescriptor(field, "transform")?.value;
-  if (isRecord(transform) && typeof transform.output === "function")
+  if (isRecord(transform) && isFunction(transform.output)) {
     return transform.output(value, params);
+  }
   return cloneFormValue(value);
 }
-function resolveRequired(field, params) {
+export function resolveRequired(field, params) {
+  const authoredRequired = Object.getOwnPropertyDescriptor(field, "required")?.value;
+  if (isFunction(authoredRequired)) {
+    return authoredRequired(params);
+  }
+  if (isBoolean(authoredRequired)) {
+    return authoredRequired;
+  }
   const validation = Object.getOwnPropertyDescriptor(field, "validation")?.value;
-  if (!isRecord(validation)) return false;
-  const required = validation.required;
-  if (typeof required === "function") return required(params);
+  if (!isRecord(validation)) {
+    return false;
+  }
+  const { required } = validation;
+  if (isFunction(required)) {
+    return required(params);
+  }
   return required ?? false;
 }
-function resolveRequiredMessage(field) {
+export function resolveRequiredMessage(field, fallback = "This field is required.") {
+  const authoredMessage = Object.getOwnPropertyDescriptor(field, "requiredMessage")?.value;
+  if (isFunction(authoredMessage)) {
+    return String(authoredMessage());
+  }
+  if (isNumber(authoredMessage)) {
+    return String(authoredMessage);
+  }
+  if (isString(authoredMessage)) {
+    return authoredMessage;
+  }
   const validation = Object.getOwnPropertyDescriptor(field, "validation")?.value;
-  if (!isRecord(validation)) return "This field is required.";
+  if (!isRecord(validation)) {
+    return fallback;
+  }
   const message = validation.requiredMessage;
-  if (typeof message === "function") return String(message());
-  if (typeof message === "number") return String(message);
-  if (typeof message === "string") return message;
-  return "This field is required.";
+  if (isFunction(message)) {
+    return String(message());
+  }
+  if (isNumber(message)) {
+    return String(message);
+  }
+  if (isString(message)) {
+    return message;
+  }
+  return fallback;
 }
 async function validateFieldRules(field, value, params, path) {
   const validation = Object.getOwnPropertyDescriptor(field, "validation")?.value;
-  if (!isRecord(validation)) return [];
+  if (!isRecord(validation)) {
+    return [];
+  }
   const rules = Object.getOwnPropertyDescriptor(validation, "rules")?.value;
-  if (!Array.isArray(rules)) return [];
+  if (!Array.isArray(rules)) {
+    return [];
+  }
   const errors = [];
   for (const rule of rules) {
-    if (!isRecord(rule)) continue;
+    if (!isRecord(rule)) {
+      continue;
+    }
     const validate = Object.getOwnPropertyDescriptor(rule, "validate")?.value;
-    if (typeof validate !== "function") continue;
+    if (!isFunction(validate)) {
+      continue;
+    }
     const result = await validate({
       ...params,
       api: params.api
     });
-    if (result === true || result === null || typeof result === "undefined") continue;
+    if (result === true || result === null || isUndefined(result)) {
+      continue;
+    }
     errors.push({
-      path: path.join("."),
-      message: typeof result === "string" ? result : resolveRuleMessage(rule, value)
+      message: isString(result) ? result : resolveRuleMessage(rule, value),
+      path: path.join(".")
     });
   }
   return errors;
 }
 function resolveRuleMessage(rule, _value) {
   const message = Object.getOwnPropertyDescriptor(rule, "message")?.value;
-  if (typeof message === "function") return String(message());
-  if (typeof message === "string" || typeof message === "number") return String(message);
+  if (isFunction(message)) {
+    return String(message());
+  }
+  if (isString(message) || isNumber(message)) {
+    return String(message);
+  }
   const name = Object.getOwnPropertyDescriptor(rule, "name")?.value;
-  return typeof name === "string" ? `Invalid value for ${name}.` : "Invalid value.";
+  return isString(name) ? `Invalid value for ${name}.` : "Invalid value.";
 }
-function isEmptyValue(value) {
-  if (value === null || typeof value === "undefined") return true;
-  if (typeof value === "string") return value.trim().length === 0;
-  if (Array.isArray(value)) return value.length === 0;
+export function isEmptyValue(value) {
+  if (value === null || isUndefined(value)) {
+    return true;
+  }
+  if (isString(value)) {
+    return value.trim().length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
   return false;
 }
 function normalizeStep(value) {
-  if (!isRecord(value)) return null;
+  if (!isRecord(value)) {
+    return null;
+  }
   const fields = Object.getOwnPropertyDescriptor(value, "fields")?.value;
   const key = Object.getOwnPropertyDescriptor(value, "key")?.value;
   const title = Object.getOwnPropertyDescriptor(value, "title")?.value;
   const root = Object.getOwnPropertyDescriptor(value, "root")?.value;
   const layout = Object.getOwnPropertyDescriptor(value, "layout")?.value;
   return {
-    key: typeof key === "string" ? key : void 0,
-    title: isFormText(title) ? title : void 0,
-    root: typeof root === "string" ? root : void 0,
+    fields: Array.isArray(fields) ? fields.filter(isFormField) : [],
+    key: isString(key) ? key : void 0,
     layout: normalizeLayout(layout),
-    fields: Array.isArray(fields) ? fields.filter(isFormField) : []
+    root: isString(root) ? root : void 0,
+    title: isFormText(title) ? title : void 0
   };
 }
 function isRuntimeStep(value) {
   return value !== null;
 }
 function normalizeLayout(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord(value)) {
+    return void 0;
+  }
   const columns = Object.getOwnPropertyDescriptor(value, "columns")?.value;
   const fieldSpan = Object.getOwnPropertyDescriptor(value, "fieldSpan")?.value;
   const gap = Object.getOwnPropertyDescriptor(value, "gap")?.value;
   return {
-    columns: typeof columns === "string" || typeof columns === "number" ? columns : void 0,
-    fieldSpan: typeof fieldSpan === "string" || typeof fieldSpan === "number" ? fieldSpan : void 0,
-    gap: typeof gap === "string" || typeof gap === "number" ? gap : void 0
+    columns: isString(columns) || isNumber(columns) ? columns : void 0,
+    fieldSpan: isString(fieldSpan) || isNumber(fieldSpan) ? fieldSpan : void 0,
+    gap: isString(gap) || isNumber(gap) ? gap : void 0
   };
 }
 function isFormText(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "function";
+  return isString(value) || isNumber(value) || isFunction(value);
 }
 function isFormField(value) {
-  if (!isRecord(value)) return false;
+  if (!isRecord(value)) {
+    return false;
+  }
   const type = Object.getOwnPropertyDescriptor(value, "type")?.value;
-  return typeof value.key === "string" && typeof type === "string" && isRegisteredFormFieldType(type);
+  return isString(value.key) && isString(type) && isRegisteredFormFieldType(type);
 }
 function getChildFields(field) {
+  const tabs = Object.getOwnPropertyDescriptor(field, "tabs")?.value;
+  if (Array.isArray(tabs)) {
+    return tabs.flatMap((tab) => {
+      const fields2 = isRecord(tab) ? tab.fields : void 0;
+      return Array.isArray(fields2) ? fields2.filter(isFormField) : [];
+    });
+  }
   const fields = Object.getOwnPropertyDescriptor(field, "fields")?.value;
   return Array.isArray(fields) ? fields.filter(isFormField) : [];
 }
-function getArrayItemFields(field, item) {
-  if (!createFormFieldInstance(field).type.is("array-variant")) return getChildFields(field);
+export function getArrayItemFields(field, item) {
+  if (!createFormFieldInstance(field).type.is("array-variant")) {
+    return getChildFields(field);
+  }
   const variantKey = Object.getOwnPropertyDescriptor(field, "variantKey")?.value;
   const variants = Object.getOwnPropertyDescriptor(field, "variants")?.value;
-  if (typeof variantKey !== "string" || !Array.isArray(variants)) return [];
+  if (!isString(variantKey) || !Array.isArray(variants)) {
+    return [];
+  }
   const value = item[variantKey];
   const variant = variants.find((candidate) => isRecord(candidate) && candidate.key === value);
-  if (!isRecord(variant)) return [];
-  const fields = variant.fields;
+  if (!isRecord(variant)) {
+    return [];
+  }
+  const { fields } = variant;
   return Array.isArray(fields) ? fields.filter(isFormField) : [];
 }
 function completeArrayItemOutput(field, input, output, index) {
   const result = arrayExtraProperties(field) ? { ...input, ...output } : output;
   const variantKey = Object.getOwnPropertyDescriptor(field, "variantKey")?.value;
-  if (typeof variantKey === "string" && typeof input[variantKey] !== "undefined")
+  if (isString(variantKey) && !isUndefined(input[variantKey])) {
     result[variantKey] = cloneFormValue(input[variantKey]);
+  }
   const virtualFields = getArrayVirtualFields(field, input);
   for (const key of Object.keys(virtualFields)) {
     const resolver = virtualFields[key];
-    if (typeof resolver === "function") result[key] = resolver(index);
+    if (isFunction(resolver)) {
+      result[key] = resolver(index);
+    }
   }
   return result;
 }
 function getArrayVirtualFields(field, item) {
   const variantKey = Object.getOwnPropertyDescriptor(field, "variantKey")?.value;
-  if (typeof variantKey === "string") {
+  if (isString(variantKey)) {
     const variants = Object.getOwnPropertyDescriptor(field, "variants")?.value;
     if (Array.isArray(variants)) {
       const variant = variants.find(
         (candidate) => isRecord(candidate) && candidate.key === item[variantKey]
       );
-      if (isRecord(variant) && isRecord(variant.virtualFields)) return variant.virtualFields;
+      if (isRecord(variant) && isRecord(variant.virtualFields)) {
+        return variant.virtualFields;
+      }
     }
   }
   const virtualFields = Object.getOwnPropertyDescriptor(field, "virtualFields")?.value;
@@ -481,8 +851,8 @@ function arrayExtraProperties(field) {
 }
 function callbackParams(params) {
   return {
+    api: params.api,
     ctx: params.ctx,
-    deps: resolveFieldDependencies(params),
-    api: params.api
+    deps: resolveFieldDependencies(params)
   };
 }