@arkcit/engine 0.3.0

package/dist/bindings.d.ts

@@ -0,0 +1,8 @@
+import { UINode } from '@arkcit/engine-schema';
+import { UIRuntime } from '@arkcit/engine-runtime';
+
+declare const resolveUIValue: (value: unknown, runtime: UIRuntime) => unknown;
+declare const resolveNodeProps: (props: Record<string, unknown> | undefined, runtime: UIRuntime) => Record<string, unknown>;
+declare const bindNodeEvents: (events: UINode["events"], runtime: UIRuntime) => Partial<Record<keyof NonNullable<UINode["events"]>, (...args: unknown[]) => void>>;
+
+export { bindNodeEvents, resolveNodeProps, resolveUIValue };

package/dist/bindings.js

@@ -0,0 +1,146 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/runtime/bindings.ts
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var MISSING_TRANSLATION_FALLBACK = "Lorem ipsum dolor sit amet. (fallback)";
+var MISSING_REF_FALLBACK = "Lorem ipsum dolor sit amet. (fallback)";
+var isPlainObject = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+var isReactElementLike = (value) => isPlainObject(value) && typeof value.$$typeof === "symbol" && "props" in value;
+var isTranslationValue = (value) => isPlainObject(value) && typeof value.$t === "string";
+var isRefValue = (value) => isPlainObject(value) && typeof value.$ref === "string";
+var isExprValue = (value) => isPlainObject(value) && typeof value.$expr === "string";
+var parseStructuredString = (value) => {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return value;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!isPlainObject(parsed)) return value;
+    if ((typeof parsed.$ref === "string" || typeof parsed.$t === "string") && Object.keys(parsed).length >= 1) {
+      return parsed;
+    }
+    return value;
+  } catch (e) {
+    return value;
+  }
+};
+var resolveUIValue = (value, runtime) => {
+  const normalizedValue = parseStructuredString(value);
+  if (isTranslationValue(normalizedValue)) {
+    const fallback = typeof normalizedValue.defaultValue === "string" && normalizedValue.defaultValue.trim() ? normalizedValue.defaultValue : normalizedValue.$t;
+    if (!runtime.t) return fallback || MISSING_TRANSLATION_FALLBACK;
+    const translated = runtime.t(normalizedValue.$t, normalizedValue.values);
+    if (typeof translated !== "string") return fallback || MISSING_TRANSLATION_FALLBACK;
+    if (!translated.trim()) return fallback || MISSING_TRANSLATION_FALLBACK;
+    if (translated === normalizedValue.$t) return fallback || MISSING_TRANSLATION_FALLBACK;
+    return translated;
+  }
+  if (isRefValue(normalizedValue)) {
+    const resolved = runtime.get(normalizedValue.$ref);
+    if (resolved == null) return MISSING_REF_FALLBACK;
+    if (typeof resolved === "string" && !resolved.trim()) return MISSING_REF_FALLBACK;
+    return resolved;
+  }
+  if (isExprValue(normalizedValue)) {
+    return void 0;
+  }
+  if (Array.isArray(normalizedValue)) {
+    return normalizedValue.map((item) => resolveUIValue(item, runtime));
+  }
+  if (isReactElementLike(normalizedValue)) {
+    return normalizedValue;
+  }
+  if (isPlainObject(normalizedValue)) {
+    const next = {};
+    Object.entries(normalizedValue).forEach(([key, childValue]) => {
+      if (DANGEROUS_KEYS.has(key)) return;
+      next[key] = resolveUIValue(childValue, runtime);
+    });
+    return next;
+  }
+  return normalizedValue;
+};
+var resolveNodeProps = (props, runtime) => {
+  if (!props) return {};
+  const resolved = {};
+  Object.entries(props).forEach(([key, value]) => {
+    if (DANGEROUS_KEYS.has(key)) return;
+    resolved[key] = resolveUIValue(value, runtime);
+  });
+  return resolved;
+};
+var bindNodeEvents = (events, runtime) => {
+  if (!events) return {};
+  const handlers = {};
+  const extractDynamicPayload = (eventName, args) => {
+    var _a;
+    if (eventName !== "onChange") return void 0;
+    const firstArg = args[0];
+    if (!firstArg || typeof firstArg !== "object" || !("target" in firstArg)) {
+      return void 0;
+    }
+    const target = firstArg.target;
+    if (!target) return void 0;
+    const isCheckboxType = String((_a = target.type) != null ? _a : "").toLowerCase() === "checkbox";
+    const query = isCheckboxType ? target.checked : target.value;
+    return {
+      query,
+      value: target.value,
+      checked: target.checked
+    };
+  };
+  Object.entries(events).forEach(([eventName, action]) => {
+    if (!action) return;
+    handlers[eventName] = (...args) => {
+      const actionRef = action;
+      const dynamicPayload = extractDynamicPayload(eventName, args);
+      if (!dynamicPayload) {
+        runtime.dispatch(actionRef);
+        return;
+      }
+      if ("id" in actionRef) {
+        const basePayload = actionRef.payload && typeof actionRef.payload === "object" ? actionRef.payload : {};
+        runtime.dispatch(__spreadProps(__spreadValues({}, actionRef), {
+          payload: __spreadValues(__spreadValues({}, basePayload), dynamicPayload)
+        }));
+        return;
+      }
+      if ("type" in actionRef) {
+        const basePayload = actionRef.payload && typeof actionRef.payload === "object" ? actionRef.payload : {};
+        runtime.dispatch(__spreadProps(__spreadValues({}, actionRef), {
+          payload: __spreadValues(__spreadValues({}, basePayload), dynamicPayload)
+        }));
+        return;
+      }
+      runtime.dispatch(actionRef);
+    };
+  });
+  return handlers;
+};
+export {
+  bindNodeEvents,
+  resolveNodeProps,
+  resolveUIValue
+};

package/dist/components/index.d.ts

@@ -0,0 +1,17 @@
+export { EngineWarningFallback, NodeErrorBoundary } from '@arkcit/engine-react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { a as UIInlineEditorState } from '../types-CyAE6ZLH.js';
+import { UINodeWrapperProps } from '@arkcit/engine-core';
+import 'react';
+
+type InlineTextEditorProps = {
+    editing: UIInlineEditorState;
+    onChange: (value: string) => void;
+    onCancel: () => void;
+    onCommit: () => void;
+};
+declare const InlineTextEditor: ({ editing, onChange, onCancel, onCommit, }: InlineTextEditorProps) => react_jsx_runtime.JSX.Element;
+
+declare const StudioNodeWrapper: ({ nodeId, wrapperClassName, cursorClassName, isSelected, allowResizeHandle, style, onClick, onDoubleClick, onTouchStart, onTouchMove, onTouchEnd, showResizeHandle, onResizeMouseDown, isInlineEditing, preserveContentWhileInlineEditing, children, inlineEditor, }: UINodeWrapperProps) => react_jsx_runtime.JSX.Element;
+
+export { InlineTextEditor, StudioNodeWrapper };

package/dist/components/index.js

@@ -0,0 +1,143 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/react-web/engine/EngineWarningFallback.tsx
+import { EngineWarningFallback } from "@arkcit/engine-react";
+
+// src/react-web/engine/NodeErrorBoundary.tsx
+import { NodeErrorBoundary } from "@arkcit/engine-react";
+
+// src/studio-bridge/inline/InlineTextEditor.tsx
+import { jsx } from "react/jsx-runtime";
+var InlineTextEditor = ({
+  editing,
+  onChange,
+  onCancel,
+  onCommit
+}) => editing.multiline ? /* @__PURE__ */ jsx(
+  "textarea",
+  {
+    className: "absolute z-[260] h-full w-full resize-none rounded-md border border-primary/70 bg-background/95 px-2 py-1 text-sm text-foreground outline-none ring-0 cursor-text shadow-lg",
+    style: editing.editorStyle,
+    value: editing.value,
+    autoFocus: true,
+    "aria-label": "Inline text editor",
+    onChange: (event) => onChange(event.target.value),
+    onBlur: onCommit,
+    onKeyDown: (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onCancel();
+        return;
+      }
+      if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+        event.preventDefault();
+        onCommit();
+      }
+    }
+  }
+) : /* @__PURE__ */ jsx(
+  "input",
+  {
+    className: "absolute z-[260] h-full w-full rounded-md border border-primary/70 bg-background/95 px-2 text-sm text-foreground outline-none ring-0 cursor-text shadow-lg",
+    style: editing.editorStyle,
+    value: editing.value,
+    autoFocus: true,
+    "aria-label": "Inline text editor",
+    onChange: (event) => onChange(event.target.value),
+    onBlur: onCommit,
+    onKeyDown: (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onCancel();
+        return;
+      }
+      if (event.key === "Enter") {
+        event.preventDefault();
+        onCommit();
+      }
+    }
+  }
+);
+
+// src/studio-bridge/nodes/StudioNodeWrapper.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var StudioNodeWrapper = ({
+  nodeId,
+  wrapperClassName = "",
+  cursorClassName = "",
+  isSelected,
+  allowResizeHandle = true,
+  style,
+  onClick,
+  onDoubleClick,
+  onTouchStart,
+  onTouchMove,
+  onTouchEnd,
+  showResizeHandle,
+  onResizeMouseDown,
+  isInlineEditing,
+  preserveContentWhileInlineEditing = false,
+  children,
+  inlineEditor
+}) => /* @__PURE__ */ jsxs(
+  "div",
+  {
+    "data-node-id": nodeId,
+    className: [
+      "relative block w-fit min-w-0 max-w-full rounded-md border border-transparent transition-colors",
+      wrapperClassName,
+      cursorClassName,
+      isSelected ? "border-dashed border-primary/60 bg-primary/5" : ""
+    ].filter(Boolean).join(" "),
+    style: __spreadValues({
+      position: "relative"
+    }, style != null ? style : {}),
+    onTouchStart,
+    onTouchMove,
+    onTouchEnd,
+    onClick,
+    onDoubleClick,
+    children: [
+      allowResizeHandle && showResizeHandle && onResizeMouseDown ? /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: "absolute -right-2 -top-2 z-20 inline-flex h-7 w-7 cursor-nwse-resize items-center justify-center rounded-md border border-primary bg-primary text-xs text-primary-foreground shadow-sm transition-colors hover:bg-primary-hover hover:border-primary-hover",
+          "aria-label": "Resize node",
+          onMouseDown: onResizeMouseDown,
+          children: "\u2922"
+        }
+      ) : null,
+      /* @__PURE__ */ jsx2(
+        "div",
+        {
+          className: isInlineEditing && !preserveContentWhileInlineEditing ? "pointer-events-none opacity-0" : void 0,
+          children
+        }
+      ),
+      isInlineEditing ? inlineEditor : null
+    ]
+  },
+  nodeId
+);
+export {
+  EngineWarningFallback,
+  InlineTextEditor,
+  NodeErrorBoundary,
+  StudioNodeWrapper
+};

package/dist/core/index.d.ts

@@ -0,0 +1,4 @@
+export { ComponentRegistry, ComponentRegistryEntry, ReactWebRendererProps, ResolvedNode, ResolvedNodeBase, ResolvedNodeChildDescriptor, ResolvedNodeContentDescriptor, RuntimeRenderInput, SchemaRenderInput, StudioAuthoringProps, UIEngineProps, UINodeDropPreview, UINodeDropState, UINodeDropTarget, UINodeSize, UINodeWrapperProps, createResolvedNode, createResolvedNodeBase } from '@arkcit/engine-core';
+import '@arkcit/engine-render-layer';
+import '@arkcit/engine-runtime';
+import '@arkcit/engine-schema';

package/dist/core/index.js

@@ -0,0 +1,9 @@
+// src/core/index.ts
+import {
+  createResolvedNode,
+  createResolvedNodeBase
+} from "@arkcit/engine-core";
+export {
+  createResolvedNode,
+  createResolvedNodeBase
+};

package/dist/form/engineFormValidation.d.ts

@@ -0,0 +1,2 @@
+export { D as DeclarativeValidatorConfig, a as DeclarativeValidatorType, F as FormErrors, b as FormState, c as FormTouched, d as FormValues, V as ValidationIssue, createFormState, defaultDeclarativeValidatorRegistry, hasDeclarativeValidators, resolveBindableText, resolveIssueMessage, validateFormValues } from '../form.js';
+import '../types-9TZ2lQDP.js';

package/dist/form/engineFormValidation.js

@@ -0,0 +1,241 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/form/engineFormValidation.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var isEmptyValue = (value) => {
+  if (value == null) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+};
+var toNumber = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+var getPathValue = (source, ref) => {
+  const normalizedRef = ref.replace(/^@/, "").trim();
+  if (!normalizedRef) return void 0;
+  return normalizedRef.split(".").filter(Boolean).reduce((accumulator, segment) => {
+    if (!accumulator || typeof accumulator !== "object") return void 0;
+    return accumulator[segment];
+  }, source);
+};
+var resolveBindableText = (value, options) => {
+  var _a;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        return resolveBindableText(parsed, options);
+      } catch (e) {
+        return value;
+      }
+    }
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (!value || typeof value !== "object" || Array.isArray(value)) return "";
+  const candidate = value;
+  if (typeof candidate.$t === "string") {
+    const translated = (_a = options == null ? void 0 : options.t) == null ? void 0 : _a.call(
+      options,
+      candidate.$t,
+      candidate.values && typeof candidate.values === "object" ? candidate.values : void 0
+    );
+    if (typeof translated === "string" && translated.trim().length > 0) return translated;
+    return candidate.$t;
+  }
+  if (typeof candidate.$ref === "string" && (options == null ? void 0 : options.values)) {
+    const resolved = getPathValue(options.values, candidate.$ref);
+    if (resolved == null) return "";
+    return String(resolved);
+  }
+  return "";
+};
+var defaultDeclarativeValidatorRegistry = {
+  required: (value) => isEmptyValue(value) ? { code: "required" } : null,
+  minLength: (value, params) => {
+    var _a;
+    if (isEmptyValue(value)) return null;
+    const min = toNumber((_a = params == null ? void 0 : params.min) != null ? _a : params == null ? void 0 : params.value);
+    if (min == null) return null;
+    return String(value).length < min ? { code: "minLength", params: { min } } : null;
+  },
+  maxLength: (value, params) => {
+    var _a;
+    if (isEmptyValue(value)) return null;
+    const max = toNumber((_a = params == null ? void 0 : params.max) != null ? _a : params == null ? void 0 : params.value);
+    if (max == null) return null;
+    return String(value).length > max ? { code: "maxLength", params: { max } } : null;
+  },
+  email: (value) => {
+    if (isEmptyValue(value)) return null;
+    return EMAIL_REGEX.test(String(value)) ? null : { code: "email" };
+  },
+  pattern: (value, params) => {
+    var _a, _b;
+    if (isEmptyValue(value)) return null;
+    const rawPattern = String((_b = (_a = params == null ? void 0 : params.pattern) != null ? _a : params == null ? void 0 : params.value) != null ? _b : "").trim();
+    if (!rawPattern) return null;
+    try {
+      const regex = new RegExp(rawPattern);
+      return regex.test(String(value)) ? null : { code: "pattern", params: { pattern: rawPattern } };
+    } catch (e) {
+      return { code: "pattern" };
+    }
+  }
+};
+var buildLegacyValidators = (field) => {
+  var _a, _b, _c;
+  const validators = [];
+  if (field.required) {
+    validators.push({
+      id: `${String((_a = field.name) != null ? _a : "field")}:required`,
+      type: "required",
+      stopOnFailure: true
+    });
+  }
+  if (String((_b = field.pattern) != null ? _b : "").trim()) {
+    validators.push({
+      id: `${String((_c = field.name) != null ? _c : "field")}:pattern`,
+      type: "pattern",
+      params: { pattern: String(field.pattern) }
+    });
+  }
+  return validators;
+};
+var normalizeValidators = (field, options) => {
+  const explicit = Array.isArray(field.validators) ? field.validators : [];
+  if (explicit.length > 0) return explicit;
+  if (!(options == null ? void 0 : options.useLegacyFieldConstraints)) return [];
+  return buildLegacyValidators(field);
+};
+var toIssueArray = (issue) => {
+  if (!issue) return [];
+  return Array.isArray(issue) ? issue : [issue];
+};
+var validateFieldWithConfig = (field, value, values, config, registry) => {
+  if (config.enabled === false) return [];
+  const validate = registry[config.type];
+  if (!validate) return [];
+  const baseIssues = toIssueArray(
+    validate(value, config.params, {
+      field,
+      values
+    })
+  );
+  return baseIssues.map((baseIssue) => {
+    var _a, _b, _c, _d, _e;
+    return {
+      field: String((_a = field.name) != null ? _a : ""),
+      validatorId: config.id || baseIssue.validatorId,
+      code: baseIssue.code,
+      messageKey: (_b = baseIssue.messageKey) != null ? _b : config.messageKey,
+      message: (_c = baseIssue.message) != null ? _c : config.message,
+      params: __spreadValues(__spreadValues({}, (_d = config.params) != null ? _d : {}), (_e = baseIssue.params) != null ? _e : {})
+    };
+  });
+};
+var hasDeclarativeValidators = (fields) => fields.some((field) => Array.isArray(field.validators) && field.validators.length > 0);
+var resolveIssueMessage = (issue, t) => {
+  const defaultMessageByCode = () => {
+    var _a, _b, _c, _d, _e, _f;
+    switch (issue.code) {
+      case "required":
+        return "This field is required";
+      case "email":
+        return "Invalid email address";
+      case "pattern":
+        return "Invalid format";
+      case "minLength": {
+        const min = (_c = (_a = issue.params) == null ? void 0 : _a.min) != null ? _c : (_b = issue.params) == null ? void 0 : _b.value;
+        return min != null ? `Minimum ${String(min)} characters` : "Value is too short";
+      }
+      case "maxLength": {
+        const max = (_f = (_d = issue.params) == null ? void 0 : _d.max) != null ? _f : (_e = issue.params) == null ? void 0 : _e.value;
+        return max != null ? `Maximum ${String(max)} characters` : "Value is too long";
+      }
+      default:
+        return void 0;
+    }
+  };
+  if (issue.messageKey && t) {
+    const translated = t(issue.messageKey, issue.params);
+    if (typeof translated === "string" && translated.trim().length > 0) {
+      return translated;
+    }
+  }
+  if (issue.message && issue.message.trim().length > 0) return issue.message;
+  if (issue.messageKey && issue.messageKey.trim().length > 0) return issue.messageKey;
+  return defaultMessageByCode();
+};
+var validateFormValues = (fields, values, options) => {
+  var _a;
+  const mergedRegistry = __spreadValues(__spreadValues({}, defaultDeclarativeValidatorRegistry), (_a = options == null ? void 0 : options.registry) != null ? _a : {});
+  const issues = [];
+  fields.forEach((field) => {
+    var _a2;
+    const fieldName = String((_a2 = field.name) != null ? _a2 : "").trim();
+    if (!fieldName) return;
+    const fieldValue = values[fieldName];
+    const validators = normalizeValidators(field, options);
+    if (validators.length === 0) return;
+    for (const validatorConfig of validators) {
+      const fieldIssues = validateFieldWithConfig(
+        field,
+        fieldValue,
+        values,
+        validatorConfig,
+        mergedRegistry
+      );
+      if (fieldIssues.length > 0) {
+        issues.push(...fieldIssues);
+        if (validatorConfig.stopOnFailure) break;
+      }
+    }
+  });
+  const errors = {};
+  issues.forEach((issue) => {
+    if (errors[issue.field]) return;
+    errors[issue.field] = resolveIssueMessage(issue, options == null ? void 0 : options.t);
+  });
+  return { issues, errors };
+};
+var createFormState = (input) => ({
+  values: input.values,
+  touched: input.touched,
+  issues: input.issues,
+  errors: input.errors,
+  dirty: input.dirty,
+  isValid: Object.values(input.errors).every((error) => !error),
+  isSubmitting: input.isSubmitting,
+  submitCount: input.submitCount
+});
+export {
+  createFormState,
+  defaultDeclarativeValidatorRegistry,
+  hasDeclarativeValidators,
+  resolveBindableText,
+  resolveIssueMessage,
+  validateFormValues
+};

package/dist/form.d.ts

@@ -0,0 +1,67 @@
+import { F as FieldConfig, a as Field } from './types-9TZ2lQDP.js';
+export { D as DeclarativeValidatorConfig, b as DeclarativeValidatorType, c as FieldOption, d as FormErrors, e as FormState, f as FormTouched, g as FormValues, V as ValidationIssue } from './types-9TZ2lQDP.js';
+
+type FormValues = Record<string, unknown>;
+type FormErrors = Record<string, string | undefined>;
+type FormTouched = Record<string, boolean | undefined>;
+type ValidationIssue = {
+    field: string;
+    validatorId?: string;
+    code?: string;
+    message?: string;
+    messageKey?: string;
+    params?: Record<string, unknown>;
+};
+type FormState = {
+    values: FormValues;
+    errors: FormErrors;
+    touched: FormTouched;
+    dirty: boolean;
+    isValid: boolean;
+    isSubmitting: boolean;
+    submitCount: number;
+    issues: ValidationIssue[];
+};
+type DeclarativeValidatorType = "required" | "minLength" | "maxLength" | "email" | "pattern";
+type DeclarativeValidatorConfig = {
+    id: string;
+    type: DeclarativeValidatorType;
+    enabled?: boolean;
+    params?: Record<string, unknown>;
+    message?: string;
+    messageKey?: string;
+    stopOnFailure?: boolean;
+};
+type ValidatorContext = {
+    field: FieldConfig;
+    values: FormValues;
+};
+type ValidationIssueDraft = Omit<ValidationIssue, "field">;
+type ValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: ValidatorContext) => ValidationIssueDraft | ValidationIssueDraft[] | null;
+type ValidatorRegistry = Record<DeclarativeValidatorType, ValidatorFn>;
+declare const resolveBindableText: (value: unknown, options?: {
+    t?: (key: string, values?: Record<string, unknown>) => string;
+    values?: Record<string, unknown>;
+}) => string;
+declare const defaultDeclarativeValidatorRegistry: ValidatorRegistry;
+declare const hasDeclarativeValidators: (fields: FieldConfig[]) => boolean;
+declare const resolveIssueMessage: (issue: ValidationIssue, t?: (key: string, values?: Record<string, unknown>) => string) => string | undefined;
+declare const validateFormValues: (fields: FieldConfig[], values: Record<string, Field | unknown>, options?: {
+    t?: (key: string, values?: Record<string, unknown>) => string;
+    useLegacyFieldConstraints?: boolean;
+    registry?: Partial<ValidatorRegistry>;
+}) => {
+    issues: ValidationIssue[];
+    errors: FormErrors;
+};
+declare const createFormState: (input: {
+    values: FormValues;
+    touched: FormTouched;
+    issues: ValidationIssue[];
+    errors: FormErrors;
+    dirty: boolean;
+    isSubmitting: boolean;
+    submitCount: number;
+}) => FormState;
+
+export { type DeclarativeValidatorConfig as D, type FormErrors as F, Field, FieldConfig, type ValidationIssue as V, type DeclarativeValidatorType as a, type FormState as b, type FormTouched as c, createFormState, type FormValues as d, defaultDeclarativeValidatorRegistry, hasDeclarativeValidators, resolveBindableText, resolveIssueMessage, validateFormValues };