@letar/forms 1.0.3 → 1.2.0

package/chunk-XFWLD5EO.js

@@ -0,0 +1,1045 @@
+import { useFormI18n, getLocalizedValue, useLocalizedOptions } from './chunk-R2RTCKXY.js';
+import { createContext, memo, useContext, useState, useEffect, useMemo, useRef, useCallback, Component } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { Field, HStack, Tooltip, Circle, Portal, VStack, Text, Box, createListCollection } from '@chakra-ui/react';
+import { LuCircleHelp } from 'react-icons/lu';
+
+var FormGroupContext = createContext(null);
+function FormGroup({ name, children }) {
+  const parentContext = useContext(FormGroupContext);
+  const contextValue = {
+    originalName: name,
+    name: parentContext ? `${parentContext.name}.${name}` : name
+  };
+  return /* @__PURE__ */ jsx(FormGroupContext.Provider, { value: contextValue, children });
+}
+function useFormGroup() {
+  return useContext(FormGroupContext);
+}
+var DeclarativeFormContext = createContext(null);
+function useDeclarativeForm() {
+  const context = useContext(DeclarativeFormContext);
+  if (!context) {
+    throw new Error("useDeclarativeForm must be used inside a Form component");
+  }
+  return context;
+}
+function useDeclarativeFormOptional() {
+  return useContext(DeclarativeFormContext);
+}
+function FieldTooltip({ title, description, example, impact }) {
+  return /* @__PURE__ */ jsxs(Tooltip.Root, { openDelay: 200, positioning: { placement: "top" }, children: [
+    /* @__PURE__ */ jsx(Tooltip.Trigger, { asChild: true, children: /* @__PURE__ */ jsx(
+      Circle,
+      {
+        size: "5",
+        cursor: "help",
+        color: "fg.muted",
+        _hover: { color: "colorPalette.fg" },
+        transition: "color 0.2s",
+        display: "inline-flex",
+        children: /* @__PURE__ */ jsx(LuCircleHelp, { size: 16 })
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Portal, { children: /* @__PURE__ */ jsx(Tooltip.Positioner, { children: /* @__PURE__ */ jsxs(Tooltip.Content, { children: [
+      /* @__PURE__ */ jsx(Tooltip.Arrow, { children: /* @__PURE__ */ jsx(Tooltip.ArrowTip, {}) }),
+      /* @__PURE__ */ jsxs(VStack, { align: "start", gap: 2, maxW: "280px", p: 1, children: [
+        title && /* @__PURE__ */ jsx(Text, { fontWeight: "semibold", fontSize: "sm", children: title }),
+        /* @__PURE__ */ jsx(Text, { fontSize: "sm", children: description }),
+        example && /* @__PURE__ */ jsxs(Box, { bg: "bg.emphasized", px: 2, py: 1, borderRadius: "md", w: "full", children: [
+          /* @__PURE__ */ jsx(Text, { fontSize: "xs", color: "fg.muted", children: "Example:" }),
+          /* @__PURE__ */ jsxs(Text, { fontSize: "sm", fontStyle: "italic", children: [
+            '"',
+            example,
+            '"'
+          ] })
+        ] }),
+        impact && /* @__PURE__ */ jsx(Text, { fontSize: "xs", color: "green.fg", children: impact })
+      ] })
+    ] }) }) })
+  ] });
+}
+function FieldLabel({ label, tooltip, required }) {
+  if (!label) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Field.Label, { children: [
+    tooltip ? /* @__PURE__ */ jsxs(HStack, { gap: 1, children: [
+      /* @__PURE__ */ jsx("span", { children: label }),
+      /* @__PURE__ */ jsx(FieldTooltip, { ...tooltip })
+    ] }) : label,
+    required && /* @__PURE__ */ jsx(Field.RequiredIndicator, {})
+  ] });
+}
+
+// src/lib/declarative/zod-utils.ts
+function unwrapSchema(schema) {
+  if (!schema?._zod?.def) {
+    return schema;
+  }
+  const type = schema._zod.def.type;
+  if (type === "optional" || type === "nullable" || type === "default") {
+    const inner = schema._zod.def.inner ?? schema._zod.def.innerType;
+    if (inner) {
+      return unwrapSchema(inner);
+    }
+  }
+  return schema;
+}
+function unwrapSchemaWithRequired(schema) {
+  if (!schema?._zod?.def) {
+    return { schema, required: true };
+  }
+  const type = schema._zod.def.type;
+  if (type === "optional" || type === "nullable") {
+    const inner = schema._zod.def.inner ?? schema._zod.def.innerType;
+    if (inner) {
+      const result = unwrapSchemaWithRequired(inner);
+      return { schema: result.schema, required: false };
+    }
+  }
+  if (type === "default") {
+    const inner = schema._zod.def.inner ?? schema._zod.def.innerType;
+    if (inner) {
+      const result = unwrapSchemaWithRequired(inner);
+      return { schema: result.schema, required: false };
+    }
+  }
+  return { schema, required: true };
+}
+
+// src/lib/declarative/schema-constraints.ts
+function getZodConstraints(schema, path) {
+  if (!schema) {
+    return { schemaType: "unknown" };
+  }
+  const fieldSchema = getSchemaAtPath(schema, path);
+  if (!fieldSchema) {
+    return { schemaType: "unknown" };
+  }
+  const def = fieldSchema._zod?.def;
+  if (!def) {
+    return { schemaType: "unknown" };
+  }
+  const type = def.type;
+  const checks = def.checks || [];
+  switch (type) {
+    case "string":
+      return {
+        schemaType: "string",
+        string: extractStringConstraints(checks)
+      };
+    case "number":
+      return {
+        schemaType: "number",
+        number: extractNumberConstraints(checks)
+      };
+    case "date":
+      return {
+        schemaType: "date",
+        date: extractDateConstraints(checks)
+      };
+    case "array":
+      return {
+        schemaType: "array",
+        array: extractArrayConstraints(checks)
+      };
+    case "boolean":
+      return { schemaType: "boolean" };
+    case "enum":
+      return { schemaType: "enum" };
+    default:
+      return { schemaType: "unknown" };
+  }
+}
+function extractConstraints(checks, handlers) {
+  const constraints = {};
+  for (const check of checks) {
+    const checkDef = check._zod?.def;
+    if (!checkDef) {
+      continue;
+    }
+    const handler = handlers[checkDef.check];
+    if (handler) {
+      handler(constraints, checkDef);
+    }
+  }
+  return constraints;
+}
+var stringConstraintHandlers = {
+  min_length: (c, def) => {
+    c.minLength = def.minimum;
+  },
+  max_length: (c, def) => {
+    c.maxLength = def.maximum;
+  },
+  length_equals: (c, def) => {
+    c.minLength = def.length;
+    c.maxLength = def.length;
+  },
+  string_format: (c, def) => {
+    if (def.format === "email") {
+      c.inputType = "email";
+    } else if (def.format === "url") {
+      c.inputType = "url";
+    } else if (def.format === "regex" && def.pattern?.source) {
+      c.pattern = def.pattern.source;
+    }
+  }
+};
+function extractStringConstraints(checks) {
+  return extractConstraints(checks, stringConstraintHandlers);
+}
+var numberConstraintHandlers = {
+  greater_than: (c, def) => {
+    c.min = def.value;
+  },
+  less_than: (c, def) => {
+    c.max = def.value;
+  },
+  number_format: (c, def) => {
+    if (def.format === "safeint") {
+      c.isInteger = true;
+      c.step = 1;
+    }
+  },
+  multiple_of: (c, def) => {
+    c.step = def.value;
+  }
+};
+function extractNumberConstraints(checks) {
+  return extractConstraints(checks, numberConstraintHandlers);
+}
+var dateConstraintHandlers = {
+  greater_than: (c, def) => {
+    if (def.value) {
+      c.min = formatDateToISO(def.value);
+    }
+  },
+  less_than: (c, def) => {
+    if (def.value) {
+      c.max = formatDateToISO(def.value);
+    }
+  }
+};
+function extractDateConstraints(checks) {
+  return extractConstraints(checks, dateConstraintHandlers);
+}
+var arrayConstraintHandlers = {
+  min_length: (c, def) => {
+    c.minItems = def.minimum;
+  },
+  max_length: (c, def) => {
+    c.maxItems = def.maximum;
+  },
+  length: (c, def) => {
+    c.minItems = def.length;
+    c.maxItems = def.length;
+  }
+};
+function extractArrayConstraints(checks) {
+  return extractConstraints(checks, arrayConstraintHandlers);
+}
+function getSchemaAtPath(schema, path) {
+  if (!schema || !path) {
+    return schema;
+  }
+  const parts = path.split(".");
+  let current = schema;
+  for (const part of parts) {
+    current = unwrapSchema(current);
+    if (!current) {
+      return void 0;
+    }
+    if (/^\d+$/.test(part)) {
+      if (current._zod?.def?.type === "array") {
+        current = current._zod.def.element;
+      }
+      continue;
+    }
+    if (current._zod?.def?.type === "object") {
+      const shape = current._zod.def.shape;
+      if (shape && part in shape) {
+        current = shape[part];
+      } else {
+        return void 0;
+      }
+    } else {
+      return void 0;
+    }
+  }
+  return unwrapSchema(current);
+}
+function formatDateToISO(value) {
+  let date;
+  if (value instanceof Date) {
+    date = value;
+  } else if (typeof value === "string") {
+    date = new Date(value);
+  } else if (typeof value === "number") {
+    date = new Date(value);
+  } else {
+    return "";
+  }
+  if (isNaN(date.getTime())) {
+    return "";
+  }
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+// src/lib/declarative/schema-meta.ts
+function getFieldMeta(schema, path) {
+  if (!schema) {
+    return { required: false };
+  }
+  const result = getSchemaAtPath2(schema, path);
+  if (!result.schema) {
+    return { required: false };
+  }
+  const fieldSchema = result.schema;
+  const meta = typeof fieldSchema?.meta === "function" ? fieldSchema.meta() : void 0;
+  return {
+    ui: meta?.ui,
+    required: result.required
+  };
+}
+function unwrapToBaseSchema(schema) {
+  if (!schema?._zod?.def) {
+    return schema;
+  }
+  const type = schema._zod.def.type;
+  if (type === "effects" || type === "transform" || type === "preprocess") {
+    const inner = schema._zod.def.inner ?? schema._zod.def.schema;
+    if (inner) {
+      return unwrapToBaseSchema(inner);
+    }
+  }
+  if (type === "pipeline") {
+    const inner = schema._zod.def.in;
+    if (inner) {
+      return unwrapToBaseSchema(inner);
+    }
+  }
+  return schema;
+}
+function getSchemaAtPath2(schema, path) {
+  if (!schema || !path) {
+    return { schema, required: true };
+  }
+  const parts = path.split(".");
+  let current = schema;
+  let isRequired = true;
+  for (const part of parts) {
+    current = unwrapToBaseSchema(current);
+    const unwrapped = unwrapSchemaWithRequired(current);
+    current = unwrapped.schema;
+    if (!unwrapped.required) {
+      isRequired = false;
+    }
+    if (!current) {
+      return { schema: void 0, required: false };
+    }
+    current = unwrapToBaseSchema(current);
+    if (/^\d+$/.test(part)) {
+      if (current._zod?.def?.type === "array") {
+        current = current._zod.def.element;
+      }
+      continue;
+    }
+    if (current._zod?.def?.type === "object") {
+      const shape = current._zod.def.shape;
+      if (shape && part in shape) {
+        current = shape[part];
+      } else {
+        return { schema: void 0, required: false };
+      }
+    } else {
+      return { schema: void 0, required: false };
+    }
+  }
+  current = unwrapToBaseSchema(current);
+  const finalUnwrap = unwrapSchemaWithRequired(current);
+  return {
+    // Возвращаем схему ДО unwrap — на ней can быть мета (.default().meta())
+    schema: current,
+    required: isRequired && finalUnwrap.required
+  };
+}
+
+// src/lib/declarative/form-fields/base/base-field.tsx
+function useDeclarativeField(name) {
+  const { form, schema, primitiveArrayIndex, disabled, readOnly } = useDeclarativeForm();
+  const parentGroup = useFormGroup();
+  let fullPath;
+  if (name) {
+    fullPath = parentGroup ? `${parentGroup.name}.${name}` : name;
+  } else if (parentGroup) {
+    fullPath = parentGroup.name;
+  } else {
+    throw new Error("Field must have a name prop or be inside Form.Group.List for primitive arrays");
+  }
+  const schemaInfo = getFieldMeta(schema, fullPath);
+  const constraints = getZodConstraints(schema, fullPath);
+  return {
+    form,
+    fullPath,
+    name: name ?? String(primitiveArrayIndex),
+    meta: schemaInfo.ui,
+    required: schemaInfo.required,
+    formDisabled: disabled ?? false,
+    formReadOnly: readOnly ?? false,
+    constraints
+  };
+}
+function useDebounce(value, delay = 300) {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => setDebouncedValue(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debouncedValue;
+}
+function useAsyncSearch(options = {}) {
+  const { useQuery, debounce = 300, minChars = 1, initialValue = "" } = options;
+  const [inputValue, setInputValue] = useState(initialValue);
+  const debouncedSearch = useDebounce(inputValue, debounce);
+  const shouldQuery = debouncedSearch.length >= minChars;
+  const queryResult = useQuery?.(shouldQuery ? debouncedSearch : "");
+  const { data, isLoading = false, error } = queryResult ?? {};
+  return {
+    inputValue,
+    setInputValue,
+    debouncedSearch,
+    shouldQuery,
+    isLoading,
+    data,
+    error
+  };
+}
+var FieldErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false, error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    console.error(`[Form] \u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043E\u043B\u0435 "${this.props.fieldName}":`, error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError) {
+      return /* @__PURE__ */ jsx(Box, { p: 3, borderWidth: "1px", borderColor: "red.500", borderRadius: "md", bg: "red.50", _dark: { bg: "red.950" }, children: /* @__PURE__ */ jsxs(Text, { color: "red.600", _dark: { color: "red.300" }, fontSize: "sm", children: [
+        '\u041E\u0448\u0438\u0431\u043A\u0430 \u0432 \u043F\u043E\u043B\u0435 "',
+        this.props.fieldName,
+        '": ',
+        this.state.error?.message
+      ] }) });
+    }
+    return this.props.children;
+  }
+};
+
+// src/lib/declarative/form-fields/base/field-utils.ts
+function formatFieldErrors(errors) {
+  return errors.map((e) => extractErrorMessage(e)).filter(Boolean).join(", ");
+}
+function extractErrorMessage(e) {
+  if (typeof e === "string") {
+    return e;
+  }
+  if (e === null || e === void 0) {
+    return "";
+  }
+  if (typeof e === "object") {
+    if (Array.isArray(e)) {
+      return e.map((item) => {
+        if (typeof item === "object" && item && "message" in item) {
+          return item.message;
+        }
+        if (typeof item === "string") {
+          return item;
+        }
+        return "";
+      }).filter(Boolean).join(", ");
+    }
+    if ("message" in e && typeof e.message === "string") {
+      return e.message;
+    }
+    if ("issues" in e && Array.isArray(e.issues)) {
+      return e.issues.map((issue) => {
+        if (typeof issue === "object" && issue && "message" in issue) {
+          return issue.message;
+        }
+        return "";
+      }).filter(Boolean).join(", ");
+    }
+    if ("fieldErrors" in e && typeof e.fieldErrors === "object" && e.fieldErrors) {
+      const fieldErrors = e.fieldErrors;
+      return Object.values(fieldErrors).flat().filter(Boolean).join(", ");
+    }
+    if ("_errors" in e && Array.isArray(e._errors)) {
+      return e._errors.filter(Boolean).join(", ");
+    }
+    try {
+      const json = JSON.stringify(e);
+      if (json === "{}" || json.length > 200) {
+        return "";
+      }
+      if (process.env.NODE_ENV === "development") {
+        console.warn("[form-components] Unknown error format:", e);
+      }
+      return json;
+    } catch {
+      return "";
+    }
+  }
+  return String(e);
+}
+function hasFieldErrors(errors) {
+  return Boolean(errors && errors.length > 0);
+}
+function getFieldErrors(field) {
+  const errors = field.state.meta.errors ?? [];
+  const hasError = hasFieldErrors(errors);
+  const errorMessage = hasError ? formatFieldErrors(errors) : "";
+  return { errors, hasError, errorMessage };
+}
+function getAsyncValidateFromSchema(schema, fieldPath) {
+  if (!schema) return void 0;
+  try {
+    const unwrapped = unwrapSchema(schema);
+    if (!unwrapped?._zod?.def?.shape) return void 0;
+    const parts = fieldPath.split(".");
+    let current = unwrapped._zod.def.shape;
+    for (const part of parts) {
+      if (/^\d+$/.test(part)) continue;
+      const fieldSchema = current[part];
+      if (!fieldSchema) return void 0;
+      const fieldUnwrapped = unwrapSchema(fieldSchema);
+      const fieldType = fieldUnwrapped?._zod?.def?.type;
+      if (fieldType === "object" && fieldUnwrapped._zod.def.shape) {
+        current = fieldUnwrapped._zod.def.shape;
+        continue;
+      }
+      if (fieldType === "array" && fieldUnwrapped._zod.def.element) {
+        const elementUnwrapped = unwrapSchema(fieldUnwrapped._zod.def.element);
+        if (elementUnwrapped?._zod?.def?.shape) {
+          current = elementUnwrapped._zod.def.shape;
+          continue;
+        }
+      }
+      if (fieldSchema?.meta) {
+        const meta = fieldSchema.meta();
+        if (meta?.asyncValidate && typeof meta.asyncValidate === "function") {
+          return {
+            asyncValidate: meta.asyncValidate,
+            asyncDebounce: meta.asyncDebounce,
+            asyncTrigger: meta.asyncTrigger
+          };
+        }
+      }
+      return void 0;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function useAsyncFieldValidation(schema, fieldPath, propsConfig) {
+  const abortRef = useRef(null);
+  const cacheRef = useRef(/* @__PURE__ */ new Map());
+  const schemaConfig = useMemo(
+    () => getAsyncValidateFromSchema(schema, fieldPath),
+    [schema, fieldPath]
+  );
+  const asyncFn = propsConfig?.asyncValidate ?? schemaConfig?.asyncValidate;
+  const debounce = propsConfig?.asyncDebounce ?? schemaConfig?.asyncDebounce ?? 500;
+  const trigger = propsConfig?.asyncTrigger ?? schemaConfig?.asyncTrigger ?? "onBlur";
+  const wrappedAsyncFn = useCallback(
+    async ({ value }) => {
+      if (!asyncFn) return void 0;
+      if (typeof navigator !== "undefined" && !navigator.onLine) return void 0;
+      const cacheKey = String(value);
+      if (cacheRef.current.has(cacheKey)) {
+        return cacheRef.current.get(cacheKey);
+      }
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      try {
+        const result = await asyncFn(value);
+        if (controller.signal.aborted) return void 0;
+        cacheRef.current.set(cacheKey, result);
+        return result;
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") return void 0;
+        return void 0;
+      }
+    },
+    [asyncFn]
+  );
+  const validators = useMemo(() => {
+    if (!asyncFn) return void 0;
+    if (trigger === "onChange") {
+      return { onChangeAsync: wrappedAsyncFn };
+    }
+    return { onBlurAsync: wrappedAsyncFn };
+  }, [asyncFn, trigger, wrappedAsyncFn]);
+  return {
+    validators,
+    asyncDebounceMs: asyncFn ? debounce : void 0,
+    hasAsyncValidation: !!asyncFn
+  };
+}
+
+// src/lib/declarative/constraint-hints.ts
+var EN_TRANSLATIONS = {
+  string_exact: "Exactly {n} {chars}",
+  string_range: "From {min} to {max} characters",
+  string_max: "Maximum {n} {chars}",
+  string_min: "Minimum {n} {chars}",
+  number_range: "From {min} to {max}{suffix}",
+  number_max: "Maximum {max}{suffix}",
+  number_min: "Minimum {min}{suffix}",
+  number_integer: "Integer",
+  number_integer_suffix: " (integer)",
+  date_range: "From {min} to {max}",
+  date_after: "Not before {min}",
+  date_before: "Not after {max}",
+  array_exact: "Exactly {n} {items}",
+  array_range: "From {min} to {max} items",
+  array_max: "Maximum {n} {items}",
+  array_min: "Minimum {n} {items}"
+};
+var RU_TRANSLATIONS = {
+  string_exact: "\u0420\u043E\u0432\u043D\u043E {n} {chars}",
+  string_range: "\u041E\u0442 {min} \u0434\u043E {max} \u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432",
+  string_max: "\u041C\u0430\u043A\u0441\u0438\u043C\u0443\u043C {n} {chars}",
+  string_min: "\u041C\u0438\u043D\u0438\u043C\u0443\u043C {n} {chars}",
+  number_range: "\u041E\u0442 {min} \u0434\u043E {max}{suffix}",
+  number_max: "\u041C\u0430\u043A\u0441\u0438\u043C\u0443\u043C {max}{suffix}",
+  number_min: "\u041C\u0438\u043D\u0438\u043C\u0443\u043C {min}{suffix}",
+  number_integer: "\u0426\u0435\u043B\u043E\u0435 \u0447\u0438\u0441\u043B\u043E",
+  number_integer_suffix: " (\u0446\u0435\u043B\u043E\u0435)",
+  date_range: "\u0421 {min} \u043F\u043E {max}",
+  date_after: "\u041D\u0435 \u0440\u0430\u043D\u0435\u0435 {min}",
+  date_before: "\u041D\u0435 \u043F\u043E\u0437\u0434\u043D\u0435\u0435 {max}",
+  array_exact: "\u0420\u043E\u0432\u043D\u043E {n} {items}",
+  array_range: "\u041E\u0442 {min} \u0434\u043E {max} \u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432",
+  array_max: "\u041C\u0430\u043A\u0441\u0438\u043C\u0443\u043C {n} {items}",
+  array_min: "\u041C\u0438\u043D\u0438\u043C\u0443\u043C {n} {items}"
+};
+var BUILTIN_TRANSLATIONS = {
+  en: EN_TRANSLATIONS,
+  ru: RU_TRANSLATIONS
+};
+var CHAR_PLURALS = {
+  en: { one: "character", other: "characters" },
+  ru: { one: "\u0441\u0438\u043C\u0432\u043E\u043B", few: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", many: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432", other: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432" }
+};
+var ITEM_PLURALS = {
+  en: { one: "item", other: "items" },
+  ru: { one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442", few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430", many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432", other: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432" }
+};
+function pluralizeWord(n, locale, plurals) {
+  const lang = locale.split("-")[0];
+  const forms = plurals[lang] ?? plurals.en;
+  const rule = new Intl.PluralRules(locale).select(n);
+  return forms[rule] ?? forms.other;
+}
+function formatNumber(n, locale) {
+  if (Number.isInteger(n)) {
+    return new Intl.NumberFormat(locale).format(n);
+  }
+  return new Intl.NumberFormat(locale, { maximumFractionDigits: 2 }).format(n);
+}
+function formatDate(dateStr, locale) {
+  try {
+    const date = new Date(dateStr);
+    return new Intl.DateTimeFormat(locale, {
+      day: "numeric",
+      month: "long",
+      year: "numeric"
+    }).format(date);
+  } catch {
+    return dateStr;
+  }
+}
+function template(str, vars) {
+  return str.replace(/\{(\w+)\}/g, (_, key) => String(vars[key] ?? ""));
+}
+function getTranslations(locale, custom) {
+  const lang = locale.split("-")[0];
+  const base = BUILTIN_TRANSLATIONS[lang] ?? BUILTIN_TRANSLATIONS[locale] ?? EN_TRANSLATIONS;
+  return base;
+}
+function generateConstraintHint(constraints, locale = "en", customTranslations) {
+  if (!constraints) {
+    return void 0;
+  }
+  const t = getTranslations(locale);
+  switch (constraints.schemaType) {
+    case "string":
+      return generateStringHint(constraints.string, locale, t);
+    case "number":
+      return generateNumberHint(constraints.number, locale, t);
+    case "date":
+      return generateDateHint(constraints.date, locale, t);
+    case "array":
+      return generateArrayHint(constraints.array, locale, t);
+    default:
+      return void 0;
+  }
+}
+function generateStringHint(constraints, locale, t) {
+  if (!constraints) return void 0;
+  const { minLength, maxLength, inputType } = constraints;
+  if (inputType === "email" || inputType === "url") {
+    if (maxLength) {
+      return template(t.string_max, { n: maxLength, chars: pluralizeWord(maxLength, locale, CHAR_PLURALS) });
+    }
+    return void 0;
+  }
+  if (minLength !== void 0 && maxLength !== void 0) {
+    if (minLength === maxLength) {
+      return template(t.string_exact, { n: minLength, chars: pluralizeWord(minLength, locale, CHAR_PLURALS) });
+    }
+    return template(t.string_range, { min: minLength, max: maxLength });
+  }
+  if (maxLength !== void 0) {
+    return template(t.string_max, { n: maxLength, chars: pluralizeWord(maxLength, locale, CHAR_PLURALS) });
+  }
+  if (minLength !== void 0) {
+    return template(t.string_min, { n: minLength, chars: pluralizeWord(minLength, locale, CHAR_PLURALS) });
+  }
+  return void 0;
+}
+function generateNumberHint(constraints, locale, t) {
+  if (!constraints) return void 0;
+  const { min, max, isInteger } = constraints;
+  const suffix = isInteger ? t.number_integer_suffix : "";
+  if (min !== void 0 && max !== void 0) {
+    return template(t.number_range, { min: formatNumber(min, locale), max: formatNumber(max, locale), suffix });
+  }
+  if (max !== void 0) {
+    return template(t.number_max, { max: formatNumber(max, locale), suffix });
+  }
+  if (min !== void 0) {
+    return template(t.number_min, { min: formatNumber(min, locale), suffix });
+  }
+  if (isInteger) {
+    return t.number_integer;
+  }
+  return void 0;
+}
+function generateDateHint(constraints, locale, t) {
+  if (!constraints) return void 0;
+  const { min, max } = constraints;
+  if (min && max) {
+    return template(t.date_range, { min: formatDate(min, locale), max: formatDate(max, locale) });
+  }
+  if (min) {
+    return template(t.date_after, { min: formatDate(min, locale) });
+  }
+  if (max) {
+    return template(t.date_before, { max: formatDate(max, locale) });
+  }
+  return void 0;
+}
+function generateArrayHint(constraints, locale, t) {
+  if (!constraints) return void 0;
+  const { minItems, maxItems } = constraints;
+  if (minItems !== void 0 && maxItems !== void 0) {
+    if (minItems === maxItems) {
+      return template(t.array_exact, { n: minItems, items: pluralizeWord(minItems, locale, ITEM_PLURALS) });
+    }
+    return template(t.array_range, { min: minItems, max: maxItems });
+  }
+  if (maxItems !== void 0) {
+    return template(t.array_max, { n: maxItems, items: pluralizeWord(maxItems, locale, ITEM_PLURALS) });
+  }
+  if (minItems !== void 0) {
+    return template(t.array_min, { n: minItems, items: pluralizeWord(minItems, locale, ITEM_PLURALS) });
+  }
+  return void 0;
+}
+
+// src/lib/declarative/form-fields/base/autocomplete-map.ts
+var AUTOCOMPLETE_MAP = {
+  // Идентификация
+  email: "email",
+  "e-mail": "email",
+  username: "username",
+  // Имя
+  name: "name",
+  fullName: "name",
+  full_name: "name",
+  firstName: "given-name",
+  first_name: "given-name",
+  lastName: "family-name",
+  last_name: "family-name",
+  surname: "family-name",
+  middleName: "additional-name",
+  middle_name: "additional-name",
+  patronymic: "additional-name",
+  // Телефон
+  phone: "tel",
+  tel: "tel",
+  mobile: "tel",
+  telephone: "tel",
+  // Пароль
+  password: "current-password",
+  newPassword: "new-password",
+  new_password: "new-password",
+  confirmPassword: "new-password",
+  confirm_password: "new-password",
+  // Адрес
+  address: "street-address",
+  street: "street-address",
+  city: "address-level2",
+  state: "address-level1",
+  region: "address-level1",
+  zip: "postal-code",
+  postal: "postal-code",
+  postalCode: "postal-code",
+  postal_code: "postal-code",
+  zipCode: "postal-code",
+  zip_code: "postal-code",
+  country: "country-name",
+  // Организация
+  company: "organization",
+  organization: "organization",
+  companyName: "organization",
+  company_name: "organization",
+  jobTitle: "organization-title",
+  job_title: "organization-title",
+  // Платёжные данные
+  cardNumber: "cc-number",
+  card_number: "cc-number",
+  cardName: "cc-name",
+  card_name: "cc-name",
+  expiry: "cc-exp",
+  cvv: "cc-csc",
+  cvc: "cc-csc"
+};
+function resolveAutoComplete(fieldName, metaAutocomplete, propAutocomplete) {
+  if (metaAutocomplete !== void 0) {
+    return metaAutocomplete;
+  }
+  const lastSegment = fieldName.split(".").pop() ?? fieldName;
+  const cleanName = lastSegment.replace(/\[\d+\]/g, "");
+  return AUTOCOMPLETE_MAP[cleanName];
+}
+
+// src/lib/declarative/form-fields/base/use-resolved-field-props.ts
+function useResolvedFieldProps(name, props) {
+  const {
+    form,
+    fullPath,
+    meta,
+    required: schemaRequired,
+    formDisabled,
+    formReadOnly,
+    constraints
+  } = useDeclarativeField(name);
+  const i18n = useFormI18n();
+  const i18nKey = meta?.i18nKey;
+  const resolvedTitle = getLocalizedValue(i18n, i18nKey, "title", meta?.title);
+  const resolvedPlaceholder = getLocalizedValue(i18n, i18nKey, "placeholder", meta?.placeholder);
+  const resolvedDescription = getLocalizedValue(i18n, i18nKey, "description", meta?.description);
+  const autoHint = generateConstraintHint(constraints, i18n?.locale ?? "en");
+  const helperText = props.helperText ?? resolvedDescription ?? autoHint;
+  const localizedOptions = useLocalizedOptions(meta?.options);
+  return {
+    form,
+    fullPath,
+    // Props override i18n override schema meta
+    label: props.label ?? resolvedTitle,
+    placeholder: props.placeholder ?? resolvedPlaceholder,
+    helperText,
+    // Tooltip from props or schema meta
+    tooltip: props.tooltip ?? meta?.tooltip,
+    // Required from schema or prop
+    required: props.required ?? schemaRequired,
+    // Form-level + local props (local wins)
+    disabled: props.disabled ?? formDisabled,
+    readOnly: props.readOnly ?? formReadOnly,
+    // Constraints for additional component configuration
+    constraints,
+    // Options with i18n translations
+    options: localizedOptions,
+    // HTML autocomplete (авто-определение по имени + meta override)
+    autocomplete: resolveAutoComplete(fullPath, meta?.autocomplete)
+  };
+}
+function createField(options) {
+  const { displayName, render } = options;
+  const useFieldState = options.useFieldState ?? (() => ({}));
+  function FieldComponent(props) {
+    const {
+      name,
+      label,
+      placeholder,
+      helperText,
+      required,
+      disabled,
+      readOnly,
+      tooltip,
+      asyncValidate,
+      asyncDebounce,
+      asyncTrigger,
+      ...componentProps
+    } = props;
+    const { form, fullPath, ...resolvedRest } = useResolvedFieldProps(name, {
+      label,
+      placeholder,
+      helperText,
+      required,
+      disabled,
+      readOnly,
+      tooltip
+    });
+    const resolved = {
+      label: resolvedRest.label,
+      placeholder: resolvedRest.placeholder,
+      helperText: resolvedRest.helperText,
+      tooltip: resolvedRest.tooltip,
+      required: resolvedRest.required,
+      disabled: resolvedRest.disabled,
+      readOnly: resolvedRest.readOnly,
+      constraints: resolvedRest.constraints,
+      options: resolvedRest.options,
+      autocomplete: resolvedRest.autocomplete
+    };
+    const fieldState = useFieldState(componentProps, resolved);
+    const declarativeCtx = useDeclarativeFormOptional();
+    const asyncValidation = useAsyncFieldValidation(
+      declarativeCtx?.schema,
+      fullPath,
+      asyncValidate ? { asyncValidate, asyncDebounce, asyncTrigger } : void 0
+    );
+    return /* @__PURE__ */ jsx(FieldErrorBoundary, { fieldName: fullPath, children: /* @__PURE__ */ jsx(
+      form.Field,
+      {
+        name: fullPath,
+        ...asyncValidation.validators ? { validators: asyncValidation.validators } : {},
+        ...asyncValidation.asyncDebounceMs ? { asyncDebounceMs: asyncValidation.asyncDebounceMs } : {},
+        children: (field) => {
+          const errors = field.state.meta.errors;
+          const isTouched = field.state.meta.isTouched;
+          const hasError = isTouched && hasFieldErrors(errors);
+          const errorMessage = hasError ? formatFieldErrors(errors) : "";
+          const isValidating = !!field.state.meta.isValidating;
+          return render({
+            field,
+            value: field.state.value,
+            fullPath,
+            resolved,
+            hasError,
+            errorMessage,
+            isValidating,
+            fieldState,
+            componentProps
+          });
+        }
+      }
+    ) });
+  }
+  FieldComponent.displayName = displayName;
+  return FieldComponent;
+}
+function FieldError({
+  hasError,
+  errorMessage,
+  helperText,
+  isValidating
+}) {
+  if (isValidating) {
+    return /* @__PURE__ */ jsx(Field.HelperText, { color: "blue.500", children: "\u27F3 \u041F\u0440\u043E\u0432\u0435\u0440\u044F\u044E..." });
+  }
+  if (hasError) {
+    return /* @__PURE__ */ jsx(Field.ErrorText, { children: errorMessage });
+  }
+  if (helperText) {
+    return /* @__PURE__ */ jsx(Field.HelperText, { children: helperText });
+  }
+  return null;
+}
+var FieldWrapper = memo(function FieldWrapper2({
+  resolved,
+  hasError,
+  errorMessage,
+  isValidating,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(
+    Field.Root,
+    {
+      invalid: hasError,
+      required: resolved.required,
+      disabled: resolved.disabled,
+      readOnly: resolved.readOnly,
+      children: [
+        /* @__PURE__ */ jsx(FieldLabel, { label: resolved.label, tooltip: resolved.tooltip, required: resolved.required }),
+        children,
+        /* @__PURE__ */ jsx(
+          FieldError,
+          {
+            hasError,
+            errorMessage,
+            helperText: resolved.helperText,
+            isValidating
+          }
+        )
+      ]
+    }
+  );
+});
+function SelectionFieldLabel({ label, tooltip, required }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    tooltip ? /* @__PURE__ */ jsxs(HStack, { gap: 1, children: [
+      /* @__PURE__ */ jsx("span", { children: label }),
+      /* @__PURE__ */ jsx(FieldTooltip, { ...tooltip })
+    ] }) : label,
+    required && /* @__PURE__ */ jsx(Field.RequiredIndicator, {})
+  ] });
+}
+function getOptionLabel(item) {
+  return typeof item.label === "string" ? item.label : String(item.value);
+}
+function useGroupedOptions(options) {
+  const collection = useMemo(() => {
+    const hasGroups = options.some((opt) => opt.group);
+    return createListCollection({
+      items: options,
+      itemToString: getOptionLabel,
+      itemToValue: (item) => item.value,
+      isItemDisabled: (item) => item.disabled ?? false,
+      ...hasGroups && {
+        groupBy: (item) => item.group ?? ""
+      }
+    });
+  }, [options]);
+  const groups = useMemo(() => {
+    const hasGroups = options.some((opt) => opt.group);
+    if (!hasGroups) {
+      return null;
+    }
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const opt of options) {
+      const group = opt.group ?? "";
+      const existing = groupMap.get(group) ?? [];
+      groupMap.set(group, [...existing, opt]);
+    }
+    return groupMap;
+  }, [options]);
+  return { collection, groups };
+}
+
+export { DeclarativeFormContext, FieldError, FieldLabel, FieldTooltip, FieldWrapper, FormGroup, SelectionFieldLabel, createField, formatFieldErrors, getFieldErrors, getOptionLabel, getZodConstraints, hasFieldErrors, unwrapSchema, useAsyncSearch, useDebounce, useDeclarativeField, useDeclarativeForm, useDeclarativeFormOptional, useFormGroup, useGroupedOptions, useResolvedFieldProps };
+//# sourceMappingURL=chunk-XFWLD5EO.js.map
+//# sourceMappingURL=chunk-XFWLD5EO.js.map