nuxt-ui-tools 0.1.0

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

@@ -0,0 +1,36 @@
+import { isRecord } from "./path.js";
+export function normalizeOptionItem(option) {
+  if (isRecord(option)) {
+    const rawValue = typeof option.value === "undefined" ? option.key : option.value;
+    const children = Array.isArray(option.children) ? option.children.map((child) => normalizeOptionItem(child)) : void 0;
+    return {
+      value: normalizeOptionValue(rawValue),
+      label: typeof option.label === "string" || typeof option.label === "number" ? String(option.label) : String(normalizeOptionValue(rawValue)),
+      description: typeof option.description === "string" || typeof option.description === "number" ? String(option.description) : void 0,
+      disabled: option.disabled === true,
+      children
+    };
+  }
+  return {
+    value: normalizeOptionValue(option),
+    label: String(option)
+  };
+}
+export function normalizeOptionItems(options) {
+  return (options ?? []).map((option) => normalizeOptionItem(option));
+}
+export function resolveOptionSource(source, params) {
+  if (!source) return [];
+  if (Array.isArray(source)) return source;
+  if (typeof source === "function") {
+    const value = source(params);
+    if (Array.isArray(value)) return value;
+    return [];
+  }
+  return [];
+}
+function normalizeOptionValue(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return value;
+  return String(value);
+}

package/dist/runtime/form/utils/overlay.d.ts

@@ -0,0 +1,8 @@
+import type { FormApiDisplayMode } from '../types/index.js';
+import type { FormDrawerConfig, FormFullscreenConfig, FormModalConfig } from '../types/index.js';
+export declare function normalizeFormOverlayMode(value: unknown): FormApiDisplayMode;
+export declare function getFormOverlayTitle(schema: unknown): string | undefined;
+export declare function getFormOverlayDescription(schema: unknown): string | undefined;
+export declare function getFormModalConfig(schema: unknown): FormModalConfig | undefined;
+export declare function getFormDrawerConfig(schema: unknown): FormDrawerConfig | undefined;
+export declare function getFormFullscreenConfig(schema: unknown): FormFullscreenConfig | undefined;

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

@@ -0,0 +1,34 @@
+import { isRecord } from "./path.js";
+import { resolveFormText } from "./text.js";
+export function normalizeFormOverlayMode(value) {
+  if (value === "drawer" || value === "fullscreen") return value;
+  return "modal";
+}
+export function getFormOverlayTitle(schema) {
+  return getFormOverlayText(schema, "title");
+}
+export function getFormOverlayDescription(schema) {
+  return getFormOverlayText(schema, "description");
+}
+export function getFormModalConfig(schema) {
+  return getFormOverlayConfig(schema, "modal");
+}
+export function getFormDrawerConfig(schema) {
+  return getFormOverlayConfig(schema, "drawer");
+}
+export function getFormFullscreenConfig(schema) {
+  return getFormOverlayConfig(schema, "fullscreen");
+}
+function getFormOverlayConfig(schema, key) {
+  if (!isRecord(schema)) return void 0;
+  const value = Object.getOwnPropertyDescriptor(schema, key)?.value;
+  return isRecord(value) ? value : void 0;
+}
+function getFormOverlayText(schema, key) {
+  if (!isRecord(schema)) return void 0;
+  const value = Object.getOwnPropertyDescriptor(schema, key)?.value;
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "function")
+    return void 0;
+  const resolvedValue = resolveFormText(value);
+  return resolvedValue === void 0 ? void 0 : String(resolvedValue);
+}

package/dist/runtime/form/utils/path.d.ts

@@ -0,0 +1 @@
+export { cloneValue as cloneFormValue, getPathValue, getScopedPathValue, isRecord, mergeObjects as mergeFormObjects, pathSegments, relativePathSegments, setPathValue, } from '../../shared/utils/path.js';

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

@@ -0,0 +1,10 @@
+export {
+  cloneValue as cloneFormValue,
+  getPathValue,
+  getScopedPathValue,
+  isRecord,
+  mergeObjects as mergeFormObjects,
+  pathSegments,
+  relativePathSegments,
+  setPathValue
+} from "../../shared/utils/path.js";

package/dist/runtime/form/utils/state.d.ts

@@ -0,0 +1,34 @@
+import type { FormContextData, FormField, FormFieldApi, FormFieldCallbackParams, FormLayoutConfig, FormObject, FormText, FormValidationMode } from '../types/index.js';
+export interface FormSubmitError {
+    path: string;
+    message: string;
+}
+export interface RuntimeFormStep {
+    key?: string;
+    title?: FormText;
+    root?: string;
+    layout?: FormLayoutConfig;
+    fields: readonly FormField[];
+}
+export declare function getSchemaFields(schema: unknown): FormField[];
+export declare function getSchemaSteps(schema: unknown): RuntimeFormStep[];
+export declare function isSteppedSchema(schema: unknown): boolean;
+export declare function getSchemaLayout(schema: unknown): FormLayoutConfig | undefined;
+export declare function buildInitialFormState(schema: unknown, ctx: FormContextData, input?: FormObject): import("../../shared/index.js").GenericObject;
+export declare function buildInitialFormFieldsState(fields: readonly FormField[], ctx: FormContextData): import("../../shared/index.js").GenericObject;
+export declare function buildFormOutput(schema: unknown, state: FormObject, ctx: FormContextData, apiFactory: FormFieldApiFactory): import("../../shared/index.js").GenericObject;
+export declare function validateFormState(schema: unknown, state: FormObject, ctx: FormContextData, apiFactory: FormFieldApiFactory, mode?: FormValidationMode): Promise<FormSubmitError[]>;
+export declare function collectFormFieldPaths(schema: unknown): readonly string[];
+export declare function collectFormFieldsPaths(fields: readonly FormField[], parentPath: readonly string[]): readonly string[];
+export declare function validateFormFields(params: {
+    fields: readonly FormField[];
+    state: FormObject;
+    ctx: FormContextData;
+    apiFactory: FormFieldApiFactory;
+    parentPath: readonly string[];
+    mode?: FormValidationMode;
+}): Promise<FormSubmitError[]>;
+export type FormFieldApiFactory = (path: readonly string[], field?: FormField) => FormFieldApi;
+export declare function fieldPath(parentPath: readonly string[], field: FormField): string[];
+export declare function childParentPath(parentPath: readonly string[], field: FormField): readonly string[];
+export declare function shouldRenderField(field: FormField, params: FormFieldCallbackParams): boolean;

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

@@ -0,0 +1,480 @@
+import { resolveFieldDependencies } from "./dependencies.js";
+import { createFormFieldInstance, isRegisteredFormFieldType } from "./field-instance.js";
+import { cloneFormValue, getPathValue, isRecord, mergeFormObjects, setPathValue } from "./path.js";
+export function getSchemaFields(schema) {
+  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 [];
+  const steps = Object.getOwnPropertyDescriptor(schema, "steps")?.value;
+  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;
+  return normalizeLayout(Object.getOwnPropertyDescriptor(schema, "layout")?.value);
+}
+export function buildInitialFormState(schema, ctx, input) {
+  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;
+  }
+  mergeMissingFieldDefaults(state, getSchemaFields(schema), ctx, []);
+  return state;
+}
+export function buildInitialFormFieldsState(fields, ctx) {
+  const state = {};
+  mergeMissingFieldDefaults(state, fields, ctx, []);
+  return state;
+}
+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] : [])
+      );
+    return output;
+  }
+  return buildFieldsOutput(getSchemaFields(schema), state, ctx, apiFactory, []);
+}
+export async function validateFormState(schema, state, ctx, apiFactory, mode = true) {
+  if (mode === false) return [];
+  const errors = [];
+  if (isSteppedSchema(schema)) {
+    for (const step of getSchemaSteps(schema))
+      errors.push(
+        ...await validateFields(
+          step.fields,
+          state,
+          ctx,
+          apiFactory,
+          step.root ? [step.root] : [],
+          mode
+        )
+      );
+    return errors;
+  }
+  return validateFields(getSchemaFields(schema), state, ctx, apiFactory, [], mode);
+}
+export function collectFormFieldPaths(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 [];
+  return await validateFields(
+    params.fields,
+    params.state,
+    params.ctx,
+    params.apiFactory,
+    params.parentPath,
+    params.mode ?? true
+  );
+}
+export function fieldPath(parentPath, field) {
+  return [...parentPath, field.key];
+}
+export function childParentPath(parentPath, field) {
+  if (isFlatPassthroughField(field)) return parentPath;
+  return fieldPath(parentPath, field);
+}
+export function shouldRenderField(field, params) {
+  if (field.ignore === true) return false;
+  const condition = Object.getOwnPropertyDescriptor(field, "condition")?.value;
+  if (typeof condition !== "function") return true;
+  return condition(params) === true;
+}
+function mergeMissingFieldDefaults(target, fields, ctx, parentPath) {
+  for (const field of fields) {
+    if (field.ignore === true) continue;
+    const fieldInstance = createFormFieldInstance(field);
+    if (fieldInstance.state.is("stateless")) continue;
+    if (isFlatPassthroughField(field)) {
+      mergeMissingFieldDefaults(target, getChildFields(field), ctx, parentPath);
+      continue;
+    }
+    if (isObjectContainerField(field)) {
+      const path2 = fieldPath(parentPath, field);
+      if (!isRecord(getPathValue(target, path2))) setPathValue(target, path2, {});
+      mergeMissingFieldDefaults(target, getChildFields(field), ctx, path2);
+      continue;
+    }
+    if (fieldInstance.type.is("matrix")) {
+      const path2 = fieldPath(parentPath, field);
+      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);
+      }
+      continue;
+    }
+    if (isArrayField(field)) {
+      const path2 = fieldPath(parentPath, field);
+      const value = getPathValue(target, path2);
+      if (!Array.isArray(value)) {
+        setPathValue(target, path2, []);
+        continue;
+      }
+      for (const [index, item] of value.entries()) {
+        if (!isRecord(item)) continue;
+        mergeMissingFieldDefaults(target, getArrayItemFields(field, item), ctx, [
+          ...path2,
+          String(index)
+        ]);
+      }
+      continue;
+    }
+    const path = fieldPath(parentPath, field);
+    if (typeof getPathValue(target, path) === "undefined")
+      setPathValue(target, path, resolveFieldDefault(field, ctx));
+  }
+}
+function buildFieldsOutput(fields, state, ctx, apiFactory, parentPath) {
+  const output = {};
+  for (const field of fields) {
+    if (field.ignore === true) continue;
+    const fieldInstance = createFormFieldInstance(field);
+    if (fieldInstance.state.is("stateless")) continue;
+    if (isFlatPassthroughField(field)) {
+      mergeFormObjects(
+        output,
+        buildFieldsOutput(getChildFields(field), state, ctx, apiFactory, parentPath)
+      );
+      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
+    });
+    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 (isArrayField(field)) {
+      const value = getPathValue(state, path);
+      const items = Array.isArray(value) ? value.map((item, index) => {
+        const itemValue = isRecord(item) ? item : {};
+        const itemOutput = buildFieldsOutput(
+          getArrayItemFields(field, itemValue),
+          state,
+          ctx,
+          apiFactory,
+          [...path, String(index)]
+        );
+        return completeArrayItemOutput(field, itemValue, itemOutput, index);
+      }) : [];
+      setPathValue(output, field.key, applyOutputTransform(field, items, params));
+      continue;
+    }
+    if (fieldInstance.type.is("matrix")) {
+      const matrixValue = {};
+      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;
+    }
+    setPathValue(output, field.key, applyOutputTransform(field, getPathValue(state, path), params));
+  }
+  return output;
+}
+async function validateFields(fields, state, ctx, apiFactory, parentPath, mode) {
+  const errors = [];
+  for (const field of fields) {
+    if (field.ignore === true) continue;
+    const fieldInstance = createFormFieldInstance(field);
+    if (fieldInstance.state.is("stateless")) continue;
+    if (isFlatPassthroughField(field)) {
+      errors.push(
+        ...await validateFields(getChildFields(field), state, ctx, apiFactory, parentPath, mode)
+      );
+      continue;
+    }
+    const path = fieldPath(parentPath, field);
+    const api = apiFactory(path, field);
+    const params = callbackParams({
+      field,
+      state,
+      ctx,
+      api,
+      parentPath
+    });
+    if (!shouldRenderField(field, params)) continue;
+    if (isObjectContainerField(field)) {
+      errors.push(
+        ...await validateFields(getChildFields(field), state, ctx, apiFactory, path, mode)
+      );
+      continue;
+    }
+    if (isArrayField(field)) {
+      const value2 = getPathValue(state, path);
+      if (Array.isArray(value2))
+        for (const index of value2.keys())
+          errors.push(
+            ...await validateFields(
+              getArrayItemFields(field, isRecord(value2[index]) ? value2[index] : {}),
+              state,
+              ctx,
+              apiFactory,
+              [...path, String(index)],
+              mode
+            )
+          );
+      continue;
+    }
+    if (fieldInstance.type.is("matrix")) {
+      for (const row of getMatrixRows(field))
+        errors.push(
+          ...await validateFields(
+            getChildFields(field),
+            state,
+            ctx,
+            apiFactory,
+            [...path, row],
+            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)
+      });
+    }
+    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 [];
+    const fieldInstance = createFormFieldInstance(field);
+    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"))
+      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"]);
+}
+function isObjectContainerField(field) {
+  return createFormFieldInstance(field).type.isAny(["object", "group"]);
+}
+function isArrayField(field) {
+  return createFormFieldInstance(field).type.isAny([
+    "array-list",
+    "array-table",
+    "array-tabs",
+    "array-variant"
+  ]);
+}
+function getMatrixRows(field) {
+  if (!createFormFieldInstance(field).type.is("matrix")) return [];
+  const rows = Object.getOwnPropertyDescriptor(field, "rows")?.value;
+  if (!Array.isArray(rows)) return [];
+  return rows.flatMap((row) => {
+    if (!isRecord(row) || typeof row.key !== "string") return [];
+    return row.key;
+  });
+}
+function resolveFieldDefault(field, ctx) {
+  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.is("checkbox-group")) return [];
+  if (fieldInstance.type.isAny(["tree", "tree-select", "cascader"]) && Object.getOwnPropertyDescriptor(field, "multiple")?.value === true)
+    return [];
+  if (fieldInstance.type.is("tag")) 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;
+}
+function applyOutputTransform(field, value, params) {
+  const transform = Object.getOwnPropertyDescriptor(field, "transform")?.value;
+  if (isRecord(transform) && typeof transform.output === "function")
+    return transform.output(value, params);
+  return cloneFormValue(value);
+}
+function resolveRequired(field, params) {
+  const validation = Object.getOwnPropertyDescriptor(field, "validation")?.value;
+  if (!isRecord(validation)) return false;
+  const required = validation.required;
+  if (typeof required === "function") return required(params);
+  return required ?? false;
+}
+function resolveRequiredMessage(field) {
+  const validation = Object.getOwnPropertyDescriptor(field, "validation")?.value;
+  if (!isRecord(validation)) return "This field is required.";
+  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.";
+}
+async function validateFieldRules(field, value, params, path) {
+  const validation = Object.getOwnPropertyDescriptor(field, "validation")?.value;
+  if (!isRecord(validation)) return [];
+  const rules = Object.getOwnPropertyDescriptor(validation, "rules")?.value;
+  if (!Array.isArray(rules)) return [];
+  const errors = [];
+  for (const rule of rules) {
+    if (!isRecord(rule)) continue;
+    const validate = Object.getOwnPropertyDescriptor(rule, "validate")?.value;
+    if (typeof validate !== "function") continue;
+    const result = await validate({
+      ...params,
+      api: params.api
+    });
+    if (result === true || result === null || typeof result === "undefined") continue;
+    errors.push({
+      path: path.join("."),
+      message: typeof result === "string" ? result : resolveRuleMessage(rule, value)
+    });
+  }
+  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);
+  const name = Object.getOwnPropertyDescriptor(rule, "name")?.value;
+  return typeof name === "string" ? `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;
+  return false;
+}
+function normalizeStep(value) {
+  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,
+    layout: normalizeLayout(layout),
+    fields: Array.isArray(fields) ? fields.filter(isFormField) : []
+  };
+}
+function isRuntimeStep(value) {
+  return value !== null;
+}
+function normalizeLayout(value) {
+  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
+  };
+}
+function isFormText(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "function";
+}
+function isFormField(value) {
+  if (!isRecord(value)) return false;
+  const type = Object.getOwnPropertyDescriptor(value, "type")?.value;
+  return typeof value.key === "string" && typeof type === "string" && isRegisteredFormFieldType(type);
+}
+function getChildFields(field) {
+  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);
+  const variantKey = Object.getOwnPropertyDescriptor(field, "variantKey")?.value;
+  const variants = Object.getOwnPropertyDescriptor(field, "variants")?.value;
+  if (typeof variantKey !== "string" || !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;
+  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")
+    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);
+  }
+  return result;
+}
+function getArrayVirtualFields(field, item) {
+  const variantKey = Object.getOwnPropertyDescriptor(field, "variantKey")?.value;
+  if (typeof variantKey === "string") {
+    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;
+    }
+  }
+  const virtualFields = Object.getOwnPropertyDescriptor(field, "virtualFields")?.value;
+  return isRecord(virtualFields) ? virtualFields : {};
+}
+function arrayExtraProperties(field) {
+  return Object.getOwnPropertyDescriptor(field, "extraProperties")?.value === true;
+}
+function callbackParams(params) {
+  return {
+    ctx: params.ctx,
+    deps: resolveFieldDependencies(params),
+    api: params.api
+  };
+}

package/dist/runtime/form/utils/text.d.ts

@@ -0,0 +1,2 @@
+import type { FormText } from '../types/index.js';
+export declare function resolveFormText(text: FormText | undefined): string | undefined;

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

@@ -0,0 +1,5 @@
+export function resolveFormText(text) {
+  if (typeof text === "function") return String(text());
+  if (typeof text === "number") return String(text);
+  return text;
+}

package/dist/runtime/form/utils/ui.d.ts

@@ -0,0 +1,5 @@
+import type { FormUiClass, FormUiConfig } from '../types/index.js';
+/** Merges form slot classes with the same conflict resolution used by Nuxt UI. */
+export declare function mergeFormUiClass(defaults?: FormUiClass, root?: FormUiClass, local?: FormUiClass): string;
+export declare function mergeFormUi(...configs: readonly (FormUiConfig | undefined)[]): FormUiConfig;
+export declare function resolveAppFormUi(config: object): FormUiConfig | undefined;