nuxt-ui-tools 0.1.2 → 1.0.0

package/dist/runtime/form/utils/field-instance.js

@@ -9,27 +9,27 @@ export function createFormFieldInstance(raw) {
     return state === expectedState;
   }
   return {
-    raw,
-    is,
-    isAny: (states) => states.some(is),
-    has,
-    hasAny: (capabilities) => capabilities.some(has),
-    hasAll: (capabilities) => capabilities.every(has),
-    type: {
-      value: raw.type,
-      is: (type) => raw.type === type,
-      isAny: (types) => types.some((type) => raw.type === type)
+    capability: {
+      has,
+      hasAll: (capabilities) => capabilities.every(has),
+      hasAny: (capabilities) => capabilities.some(has)
     },
     config,
+    has,
+    hasAll: (capabilities) => capabilities.every(has),
+    hasAny: (capabilities) => capabilities.some(has),
+    is,
+    isAny: (states) => states.some(is),
+    raw,
     state: {
-      value: state,
       is,
-      isAny: (states) => states.some(is)
+      isAny: (states) => states.some(is),
+      value: state
     },
-    capability: {
-      has,
-      hasAny: (capabilities) => capabilities.some(has),
-      hasAll: (capabilities) => capabilities.every(has)
+    type: {
+      is: (type) => raw.type === type,
+      isAny: (types) => types.some((type) => raw.type === type),
+      value: raw.type
     }
   };
 }
@@ -40,18 +40,44 @@ export function isRegisteredFormFieldType(type) {
   return getFormFieldKind(type) !== null;
 }
 export function fieldKindHas(kind, capability) {
-  if (capability === "value") return kind.state === "stateful";
-  if (capability === "children") return kind.state === "passthrough";
-  if (capability === "label") return kind.ui?.label === true;
-  if (capability === "description") return kind.ui?.description === true;
-  if (capability === "hint") return kind.ui?.hint === true;
-  if (capability === "layout") return kind.layout?.item === true || kind.layout?.container === true;
-  if (capability === "itemLayout") return kind.layout?.item === true;
-  if (capability === "containerLayout") return kind.layout?.container === true;
-  if (capability === "options") return kind.options?.enabled === true;
-  if (capability === "upload") return kind.upload?.enabled === true;
-  if (capability === "validation") return kind.validation === true;
-  if (capability === "transform") return kind.transform === true;
-  if (capability === "submit") return kind.state === "stateful";
+  if (capability === "value") {
+    return kind.state === "stateful";
+  }
+  if (capability === "children") {
+    return kind.state === "passthrough";
+  }
+  if (capability === "label") {
+    return kind.ui?.label === true;
+  }
+  if (capability === "description") {
+    return kind.ui?.description === true;
+  }
+  if (capability === "hint") {
+    return kind.ui?.hint === true;
+  }
+  if (capability === "layout") {
+    return kind.layout?.item === true || kind.layout?.container === true;
+  }
+  if (capability === "itemLayout") {
+    return kind.layout?.item === true;
+  }
+  if (capability === "containerLayout") {
+    return kind.layout?.container === true;
+  }
+  if (capability === "options") {
+    return kind.options?.enabled === true;
+  }
+  if (capability === "upload") {
+    return kind.upload?.enabled === true;
+  }
+  if (capability === "validation") {
+    return kind.validation === true;
+  }
+  if (capability === "transform") {
+    return kind.transform === true;
+  }
+  if (capability === "submit") {
+    return kind.state === "stateful";
+  }
   return false;
 }

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

@@ -1,3 +1,4 @@
+import { isString } from "./predicate.js";
 const focusableSelector = [
   'input:not([disabled]):not([type="hidden"])',
   "textarea:not([disabled])",
@@ -6,16 +7,20 @@ const focusableSelector = [
   '[tabindex]:not([tabindex="-1"])'
 ].join(",");
 export function normalizeFormFocusPath(path) {
-  return typeof path === "string" ? path : path.join(".");
+  return isString(path) ? path : path.join(".");
 }
 export async function focusFormField(path) {
-  if (typeof document === "undefined") return false;
+  if (!import.meta.client) {
+    return false;
+  }
   const fieldElement = findFieldElement(normalizeFormFocusPath(path));
   return focusFormFieldElement(fieldElement);
 }
 export async function focusFormFieldElement(fieldElement) {
   const focusableElement = fieldElement ? findFocusableElement(fieldElement) : null;
-  if (!fieldElement || !focusableElement) return false;
+  if (!fieldElement || !focusableElement) {
+    return false;
+  }
   focusableElement.focus({ preventScroll: true });
   fieldElement.scrollIntoView({ behavior: "smooth", block: "center", inline: "nearest" });
   await waitForFocusSettle();
@@ -24,22 +29,30 @@ export async function focusFormFieldElement(fieldElement) {
 export async function focusFirstInvalidFormField(errors) {
   for (const error of errors) {
     const focused = await focusFormField(error.path);
-    if (focused) return true;
+    if (focused) {
+      return true;
+    }
   }
   return false;
 }
 function findFieldElement(path) {
-  return Array.from(document.querySelectorAll("[data-form-field]")).find(
+  return [...document.querySelectorAll("[data-form-field]")].find(
     (element) => element.dataset.formField === path
   ) ?? null;
 }
 function findFocusableElement(element) {
-  if (element.matches(focusableSelector) && isFocusableElement(element)) return element;
-  return Array.from(element.querySelectorAll(focusableSelector)).find(isFocusableElement) ?? null;
+  if (element.matches(focusableSelector) && isFocusableElement(element)) {
+    return element;
+  }
+  return [...element.querySelectorAll(focusableSelector)].find(isFocusableElement) ?? null;
 }
 function isFocusableElement(element) {
-  if (element.hasAttribute("disabled")) return false;
-  if (element.getAttribute("aria-hidden") === "true") return false;
+  if (element.hasAttribute("disabled")) {
+    return false;
+  }
+  if (element.getAttribute("aria-hidden") === "true") {
+    return false;
+  }
   return true;
 }
 function waitForFocusSettle() {

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

@@ -1,3 +1,4 @@
+import { isNumber } from "./predicate.js";
 export const FORM_LAYOUT_DEFAULTS = {
   columns: 8,
   fieldSpan: "8 md:4",
@@ -12,7 +13,9 @@ export function resolveFormLayoutConfig(base, override) {
 }
 export function normalizeFormLayoutGap(value) {
   const gap = value ?? FORM_LAYOUT_DEFAULTS.gap;
-  if (typeof gap === "number") return `${gap}px`;
+  if (isNumber(gap)) {
+    return `${gap}px`;
+  }
   return gap;
 }
 export function normalizeFormGridColumnsStyle(value) {
@@ -20,12 +23,16 @@ export function normalizeFormGridColumnsStyle(value) {
   return `grid-template-columns: repeat(${columns}, minmax(0, 1fr))`;
 }
 export function normalizeFormGridColumnSpanStyle(value) {
-  if (value === "full") return "grid-column: 1 / -1";
+  if (value === "full") {
+    return "grid-column: 1 / -1";
+  }
   const span = normalizePositiveInteger(value, 1);
   return `grid-column: span ${span} / span ${span}`;
 }
 function normalizePositiveInteger(value, fallback) {
   const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return fallback;
+  if (!Number.isFinite(parsed)) {
+    return fallback;
+  }
   return Math.max(1, Math.trunc(parsed));
 }

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

@@ -0,0 +1,7 @@
+import { Mask } from 'maska';
+import type { MaskOptions } from 'maska';
+export type FormTextMask = string | MaskOptions;
+export declare function resolveTextMask(mask: FormTextMask | undefined): Mask | undefined;
+export declare function applyTextMask(value: string, mask: FormTextMask | undefined): string;
+export declare function stripTextMask(value: string, mask: FormTextMask | undefined): string;
+export declare function maskDirectiveOptions(mask: FormTextMask | undefined): MaskOptions | undefined;

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

@@ -0,0 +1,44 @@
+import { Mask } from "maska";
+import { isString } from "./predicate.js";
+const caseTokens = {
+  A: { pattern: /\p{L}/u, transform: (character) => character.toUpperCase() },
+  a: { pattern: /\p{L}/u, transform: (character) => character.toLowerCase() }
+};
+function withCaseTokens(options) {
+  return { ...options, tokens: { ...caseTokens, ...options.tokens } };
+}
+const masks = /* @__PURE__ */ new WeakMap();
+const stringMasks = /* @__PURE__ */ new Map();
+export function resolveTextMask(mask) {
+  if (mask === void 0) {
+    return;
+  }
+  if (isString(mask)) {
+    const existing2 = stringMasks.get(mask);
+    if (existing2) {
+      return existing2;
+    }
+    const created2 = new Mask(withCaseTokens({ mask }));
+    stringMasks.set(mask, created2);
+    return created2;
+  }
+  const existing = masks.get(mask);
+  if (existing) {
+    return existing;
+  }
+  const created = new Mask(withCaseTokens(mask));
+  masks.set(mask, created);
+  return created;
+}
+export function applyTextMask(value, mask) {
+  return resolveTextMask(mask)?.masked(value) ?? value;
+}
+export function stripTextMask(value, mask) {
+  return resolveTextMask(mask)?.unmasked(value) ?? value;
+}
+export function maskDirectiveOptions(mask) {
+  if (mask === void 0) {
+    return;
+  }
+  return withCaseTokens(isString(mask) ? { mask } : mask);
+}

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

@@ -1,4 +1,4 @@
-import type { FormFieldCallbackParams, FormOptionItem, FormOptionValue } from '../types/index.js';
+import type { FormValue, FormFieldCallbackParams, FormOptionItem, FormOptionValue } from '../types/index.js';
 export interface FormOptionKeys {
     value?: string;
     label?: string;
@@ -9,12 +9,18 @@ export interface ResolvedFormOption {
     label: string;
     description?: string;
     disabled?: boolean;
+    icon?: string;
     children?: readonly ResolvedFormOption[];
+    /** True when the option has children that load on demand. */
+    lazy?: boolean;
 }
-export declare function normalizeOptionItem(option: unknown, keys?: FormOptionKeys): ResolvedFormOption;
-export declare function normalizeOptionItems(options: readonly unknown[] | undefined, keys?: FormOptionKeys): ResolvedFormOption[];
+export declare function normalizeOptionItem(option: FormValue, keys?: FormOptionKeys): ResolvedFormOption;
+export declare function normalizeOptionItems(options: readonly FormValue[] | undefined, keys?: FormOptionKeys): ResolvedFormOption[];
+export declare const LOAD_MORE_OPTION_VALUE = "__nut:load-more__";
+export declare function isLoadMoreOption(item: FormValue): boolean;
+export declare function appendLoadMoreOption(items: readonly ResolvedFormOption[], show: boolean, label: string): readonly ResolvedFormOption[];
 export declare function formOptionKey(value: FormOptionValue): string;
 export declare function flattenResolvedOptions(options: readonly ResolvedFormOption[]): readonly ResolvedFormOption[];
 export declare function mergeResolvedOptions(...collections: readonly (readonly ResolvedFormOption[])[]): readonly ResolvedFormOption[];
-export declare function normalizeOptionSelection(value: unknown, options: readonly ResolvedFormOption[]): any[] | FormOptionValue | null | undefined;
-export declare function resolveOptionSource(source: unknown, params: FormFieldCallbackParams): readonly FormOptionItem[];
+export declare function normalizeOptionSelection(value: FormValue, options: readonly ResolvedFormOption[]): any[] | FormOptionValue | null | undefined;
+export declare function resolveOptionSource(source: FormValue, params: FormFieldCallbackParams): readonly FormOptionItem[];

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

@@ -1,31 +1,54 @@
 import { isRecord } from "./path.js";
+import { isBoolean, isFunction, isNumber, isString, isUndefined } from "./predicate.js";
 import { resolveFormText } from "./text.js";
 export function normalizeOptionItem(option, keys = {}) {
   if (isRecord(option)) {
     const rawValue = readOptionProperty(option, keys.value ?? "value");
-    const fallbackValue = typeof rawValue === "undefined" ? option.key : rawValue;
+    const fallbackValue = isUndefined(rawValue) ? option.key : rawValue;
     const rawChildren = readOptionProperty(option, keys.children ?? "children");
     const rawDescription = readOptionProperty(option, "description");
     const children = Array.isArray(rawChildren) ? rawChildren.map((child) => normalizeOptionItem(child, keys)) : void 0;
+    const lazy = option.isLeaf === false || option.hasChildren === true;
     const value = normalizeOptionValue(fallbackValue);
-    return {
-      value,
-      label: resolveFormText(readOptionProperty(option, keys.label ?? "label")) ?? String(value),
+    const rawIcon = readOptionProperty(option, "icon");
+    const normalized = {
       description: isFormText(rawDescription) ? resolveFormText(rawDescription) : void 0,
       disabled: option.disabled === true,
-      ...children ? { children } : {}
+      icon: isString(rawIcon) ? rawIcon : void 0,
+      label: resolveFormText(readOptionProperty(option, keys.label ?? "label")) ?? String(value),
+      value
     };
+    if (children) {
+      normalized.children = children;
+    } else if (lazy) {
+      normalized.children = [];
+    }
+    if (lazy) {
+      normalized.lazy = true;
+    }
+    return normalized;
   }
   return {
-    value: normalizeOptionValue(option),
-    label: String(option)
+    label: String(option),
+    value: normalizeOptionValue(option)
   };
 }
 export function normalizeOptionItems(options, keys = {}) {
   return (options ?? []).map((option) => normalizeOptionItem(option, keys));
 }
+export const LOAD_MORE_OPTION_VALUE = "__nut:load-more__";
+export function isLoadMoreOption(item) {
+  return isRecord(item) && item.value === LOAD_MORE_OPTION_VALUE;
+}
+export function appendLoadMoreOption(items, show, label) {
+  if (!show) {
+    return items;
+  }
+  return [...items, { disabled: true, label, value: LOAD_MORE_OPTION_VALUE }];
+}
 export function formOptionKey(value) {
-  return `${typeof value}:${String(value)}`;
+  const type = isString(value) ? "string" : isNumber(value) ? "number" : isBoolean(value) ? "boolean" : "unknown";
+  return `${type}:${String(value)}`;
 }
 export function flattenResolvedOptions(options) {
   return options.flatMap((option) => [option, ...flattenResolvedOptions(option.children ?? [])]);
@@ -35,7 +58,9 @@ export function mergeResolvedOptions(...collections) {
   return collections.flatMap(
     (collection) => collection.filter((option) => {
       const key = formOptionKey(option.value);
-      if (seen.has(key)) return false;
+      if (seen.has(key)) {
+        return false;
+      }
       seen.add(key);
       return true;
     })
@@ -48,37 +73,50 @@ export function normalizeOptionSelection(value, options) {
   if (Array.isArray(value)) {
     const selected = /* @__PURE__ */ new Set();
     return value.filter((item) => {
-      if (!isOptionValue(item)) return false;
+      if (!isOptionValue(item)) {
+        return false;
+      }
       const key = formOptionKey(item);
-      if (!validKeys.has(key) || selected.has(key)) return false;
+      if (!validKeys.has(key) || selected.has(key)) {
+        return false;
+      }
       selected.add(key);
       return true;
     });
   }
-  if (value === null || typeof value === "undefined") return value;
+  if (value === null || isUndefined(value)) {
+    return value;
+  }
   return isOptionValue(value) && validKeys.has(formOptionKey(value)) ? value : null;
 }
 export function resolveOptionSource(source, params) {
-  if (!source) return [];
-  if (Array.isArray(source)) return source;
-  if (typeof source === "function") {
+  if (!source) {
+    return [];
+  }
+  if (Array.isArray(source)) {
+    return source;
+  }
+  if (isFunction(source)) {
     const value = source(params);
-    if (Array.isArray(value)) return value;
+    if (Array.isArray(value)) {
+      return value;
+    }
     return [];
   }
   return [];
 }
 function normalizeOptionValue(value) {
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+  if (isString(value) || isNumber(value) || isBoolean(value)) {
     return value;
+  }
   return String(value);
 }
 function readOptionProperty(option, key) {
   return Object.getOwnPropertyDescriptor(option, key)?.value;
 }
 function isFormText(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "function";
+  return isString(value) || isNumber(value) || isFunction(value);
 }
 function isOptionValue(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  return isString(value) || isNumber(value) || isBoolean(value);
 }

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

@@ -1,8 +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;
+import type { FormValue, FormApiDisplayMode, FormDrawerConfig, FormFullscreenConfig, FormModalConfig } from '../types/index.js';
+export declare function normalizeFormOverlayMode(value: FormValue): FormApiDisplayMode;
+export declare function getFormOverlayTitle(schema: FormValue): string | undefined;
+export declare function getFormOverlayDescription(schema: FormValue): string | undefined;
+export declare function getFormHeader(schema: FormValue): FormValue;
+export declare function getFormModalConfig(schema: FormValue): FormModalConfig | undefined;
+export declare function getFormDrawerConfig(schema: FormValue): FormDrawerConfig | undefined;
+export declare function getFormFullscreenConfig(schema: FormValue): FormFullscreenConfig | undefined;

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

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

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

@@ -0,0 +1,9 @@
+import type { FormValue } from '../types/utils.js';
+type CallableValue<T> = T extends (...args: infer TArgs) => infer TResult ? (...args: TArgs) => TResult : (...args: FormValue[]) => FormValue;
+export { hasProperty, hasTypedProperty, isArray, isBoolean, isDefined, isNull, isNumber, isObject, isPlainObject, isPromise, isString, isSymbol, isUndefined, } from '../../shared/utils/predicate.js';
+/** Recognizes normal and async callbacks at form runtime boundaries. */
+export declare function isFunction<T>(value: T): value is T & CallableValue<T>;
+/** Invokes a parsed form callback and keeps its untrusted result at the form boundary. */
+export declare function invokeFormFunction(value: FormValue, args?: FormValue[]): FormValue;
+/** Parses a runtime value into the form's supported string-path list contract. */
+export declare function stringArray(value: FormValue): readonly string[];

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

@@ -0,0 +1,35 @@
+import {
+  isArray as isSharedArray,
+  isFunction as isSharedFunction,
+  isString as isSharedString
+} from "../../shared/utils/predicate.js";
+export {
+  hasProperty,
+  hasTypedProperty,
+  isArray,
+  isBoolean,
+  isDefined,
+  isNull,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isPromise,
+  isString,
+  isSymbol,
+  isUndefined
+} from "../../shared/utils/predicate.js";
+export function isFunction(value) {
+  return isSharedFunction(value) || value instanceof Function;
+}
+export function invokeFormFunction(value, args = []) {
+  if (!isFunction(value)) {
+    return void 0;
+  }
+  return value(...args);
+}
+export function stringArray(value) {
+  if (!isSharedArray(value)) {
+    return [];
+  }
+  return value.filter(isSharedString);
+}

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

@@ -1,4 +1,4 @@
-import type { FormContextData, FormField, FormFieldApi, FormFieldCallbackParams, FormLayoutConfig, FormObject, FormText, FormValidationMode } from '../types/index.js';
+import type { FormValue, FormContextData, FormField, FormFieldApi, FormFieldCallbackParams, FormLayoutConfig, FormObject, FormText, FormValidationMode } from '../types/index.js';
 export interface FormSubmitError {
     path: string;
     message: string;
@@ -10,15 +10,16 @@ export interface RuntimeFormStep {
     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 getSchemaFields(schema: FormValue): FormField[];
+export declare function getSchemaSteps(schema: FormValue): RuntimeFormStep[];
+export declare function isSteppedSchema(schema: FormValue): boolean;
+export declare function getSchemaLayout(schema: FormValue): FormLayoutConfig | undefined;
+export type InitialStateApiFactory = (state: FormObject, initial: FormObject) => FormFieldApiFactory;
+export declare function buildInitialFormState(schema: FormValue, ctx: FormContextData, input?: FormObject, createApiFactory?: InitialStateApiFactory): 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 buildFormOutput(schema: FormValue, state: FormObject, ctx: FormContextData, apiFactory: FormFieldApiFactory): import("../../shared/index.js").GenericObject;
+export declare function validateFormState(schema: FormValue, state: FormObject, ctx: FormContextData, apiFactory: FormFieldApiFactory, mode?: FormValidationMode): Promise<FormSubmitError[]>;
+export declare function collectFormFieldPaths(schema: FormValue): readonly string[];
 export declare function collectFormFieldsPaths(fields: readonly FormField[], parentPath: readonly string[]): readonly string[];
 export declare function validateFormFields(params: {
     fields: readonly FormField[];
@@ -32,3 +33,14 @@ export type FormFieldApiFactory = (path: readonly string[], field?: FormField) =
 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;
+export declare function isFlatPassthroughField(field: FormField): boolean;
+export declare function isObjectContainerField(field: FormField): boolean;
+export declare function isArrayField(field: FormField): boolean;
+export declare function readStaticFieldProp(field: FormField, name: string): FormValue;
+export declare function isPrimitiveArrayField(field: FormField): boolean;
+export declare function getPrimitiveArrayItemField(field: FormField, index: number): FormField | null;
+export declare function getMatrixRows(field: FormField): any[];
+export declare function resolveRequired(field: FormField, params: FormFieldCallbackParams): any;
+export declare function resolveRequiredMessage(field: FormField, fallback?: string): string;
+export declare function isEmptyValue(value: FormValue): boolean;
+export declare function getArrayItemFields(field: FormField, item: FormObject): FormField[];