@coffer-org/sdk 1.1.0

package/dist/fields.js

@@ -0,0 +1,911 @@
+/**
+ * Система типів полів — серце платформи. Чистий, ізоморфний модуль.
+ * Один опис поля → три споживачі:
+ *   1. `zod`    — валідація (однакова на сервері й клієнті)
+ *   2. `column` — тип колонки в БД
+ *   3. `prim`/`kind` — ключі для резолву рендера (див. web/render/registry)
+ */
+import { z } from 'zod';
+import ISO6391 from 'iso-639-1';
+import { resolveUnits } from './units.js';
+import { isCurrencyCode } from './currencies.js';
+// Пресети — тонкі обгортки над примітивами нижче. Циклічний імпорт безпечний:
+// преcети викликають фабрики лише в тілі функцій (фабрики — hoisted-декларації).
+import { presets } from './field-presets.js';
+export const isField = (x) => 'key' in x && !('el' in x);
+export const isStatic = (x) => 'el' in x && x.el === 'static';
+export const isGroup = (x) => 'el' in x && x.el === 'group';
+export const isDivider = (x) => 'el' in x && x.el === 'divider';
+export const isInfo = (x) => 'el' in x && x.el === 'info';
+export const isButton = (x) => 'el' in x && x.el === 'button';
+// ─── Layout-фабрики ──────────────────────────────────────────────────────────
+/**
+ * Візуальна або storage-група полів (один рівень вкладеності — груп усередині груп нема).
+ * Без `key` → layout-група (не зберігається). З `key` → storage:
+ *   - embedded (key, без multiple): зберігається як колонка або вкладений об'єкт.
+ *   - collection (key + multiple): child-таблиця (масив рядків).
+ * Storage-група вимагає `label` і лише `FieldItem`-нащадків (зі storage key).
+ */
+export function group(o) {
+    if (o.key) {
+        if (!o.label)
+            throw new Error(`[field.group] storage-група '${o.key}' потребує label`);
+        for (const f of o.fields) {
+            if (!('key' in f))
+                throw new Error(`[field.group] storage-група '${o.key}': діти мусять бути FieldItem (мати key)`);
+        }
+        for (const k of o.unique ?? []) {
+            if (!o.fields.some((f) => 'key' in f && f.key === k))
+                throw new Error(`[field.group] '${o.key}': unique-ключ '${k}' не є сабфілдом`);
+        }
+    }
+    return {
+        el: 'group',
+        key: o.key,
+        multiple: o.multiple,
+        required: o.required,
+        unique: o.unique,
+        label: o.label,
+        icon: o.icon,
+        fields: o.fields,
+    };
+}
+export const isStorageGroup = (g) => g.key != null;
+export const isCollectionGroup = (g) => g.key != null && g.multiple === true;
+export const isEmbeddedGroup = (g) => g.key != null && g.multiple !== true;
+/** Горизонтальний розділювач. */
+export function divider() {
+    return { el: 'divider' };
+}
+/** Довідковий markdown-блок за i18n-ключем. */
+export function info(textKey) {
+    return { el: 'info', text: textKey };
+}
+/** Кнопка-дія: викликає обробник, зареєстрований у actionRegistry під ключем `value`. */
+export function button(o) {
+    return { el: 'button', label: o.label, value: o.value, icon: o.icon, variant: o.variant };
+}
+/** Обгортає FieldMeta у FieldItem/StaticEl залежно від opts.key/opts.value. */
+export function wrapKey(opts, meta) {
+    // Бренд (phantom) існує лише в типі — у runtime повертаємо чистий { key, type }.
+    let m = opts.span != null ? { ...meta, span: opts.span } : meta;
+    if (opts.noEditControl)
+        m = { ...m, hints: { ...m.hints, noEditControl: true } };
+    if (opts.key)
+        return { key: opts.key, type: m };
+    if ('value' in opts && opts.value !== undefined)
+        return { el: 'static', type: m, value: opts.value };
+    return m;
+}
+// ─── Константи ────────────────────────────────────────────────────────────────
+/** Усі мови ISO 639-1 (native-назви як label). Джерело — пакет `iso-639-1`. */
+export const LANGUAGES = ISO6391.getAllCodes()
+    .map((code) => ({ code, name: ISO6391.getNativeName(code) }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+/** Стать — спільний optionList 'sex' (реєструє plugin-core). i18n: core.sex.*. */
+export const SEX_OPTIONS = [
+    { value: 'M', title: 'core.sex.M' },
+    { value: 'F', title: 'core.sex.F' },
+    { value: 'other', title: 'core.sex.other' },
+];
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/** Структуроване повідомлення для zod: JSON {code, params}. Декодує mutate.ts. */
+export function vmsg(code, params) {
+    return JSON.stringify(params ? { code, params } : { code });
+}
+/** v4 error-map: повідомлення для відсутнього значення (колишній required_error). */
+export function reqErr(code = 'required') {
+    return { error: (iss) => (iss.input === undefined ? vmsg(code) : undefined) };
+}
+/** v4 error-map: повідомлення для невалідного типу (колишній invalid_type_error). */
+export function typeErr(code = 'invalid_type') {
+    return { error: (iss) => (iss.code === 'invalid_type' ? vmsg(code) : undefined) };
+}
+/** v4 error-map: required + invalid_type разом (колишні required_error + invalid_type_error). */
+export function reqTypeErr() {
+    return {
+        error: (iss) => iss.code === 'invalid_type' ? (iss.input === undefined ? vmsg('required') : vmsg('invalid_type')) : undefined,
+    };
+}
+/**
+ * Спільна фабрика для полів, що зберігають JSON-рядок і валідуються вкладеною
+ * zod-схемою: parse → inner.safeParse → при невдачі issue з кодом `code`,
+ * при невалідному JSON — код 'json'. Уникає дублювання try/parse/superRefine.
+ */
+export function jsonRefined(inner, code) {
+    return z.string(reqErr()).superRefine((val, ctx) => {
+        try {
+            const r = inner.safeParse(JSON.parse(val));
+            if (!r.success)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg(code) });
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+}
+export function optionalize(schema, required) {
+    return z.preprocess((v) => (v === '' || v === null ? undefined : v), required ? schema : schema.optional());
+}
+function resolveDate(v) {
+    return v === 'today' ? new Date().toISOString().slice(0, 10) : v;
+}
+const uuidRe = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+// ─── Модифікатори ───────────────────────────────────────────────────────────
+/**
+ * Обгортає поле у JSON-масив значень (storage: TEXT). Внутрішній zod — `base.zod`.
+ * Порядок модифікаторів: base → applyMultiple.
+ *
+ * Виняток: kind 'image'/'media' обробляє multiple сам у рендері (галерея) —
+ * MultipleField*-обгортки на вебі їх пропускають.
+ */
+/** Zod «JSON-масив значень inner» — спільне для applyMultiple і bindSelectSourceZod. */
+function multipleZod(inner) {
+    return z.string(reqErr()).superRefine((val, ctx) => {
+        try {
+            const arr = JSON.parse(val);
+            if (!Array.isArray(arr)) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('array') });
+                return;
+            }
+            for (const item of arr) {
+                const r = inner.safeParse(item);
+                if (!r.success) {
+                    ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('array_item') });
+                    return;
+                }
+            }
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+}
+export function applyMultiple(base, multiple) {
+    if (!multiple)
+        return base;
+    const s = multipleZod(base.zod);
+    return { ...base, column: 'text', hints: { ...base.hints, multiple: true }, zod: optionalize(s, base.required) };
+}
+export function string(o) {
+    const required = o.required ?? false;
+    const cfg = o.config ?? {};
+    const min = cfg.min ?? (required ? 1 : 0);
+    let s = z.string(reqTypeErr());
+    if (min > 0)
+        s = s.min(min, { message: vmsg('min_length', { min }) });
+    if (cfg.max != null)
+        s = s.max(cfg.max, { message: vmsg('max_length', { max: cfg.max }) });
+    if (cfg.pattern)
+        s = s.regex(new RegExp(cfg.pattern), {
+            message: vmsg('pattern', cfg.messageKey ? { messageKey: cfg.messageKey } : undefined),
+        });
+    const base = {
+        kind: 'text',
+        label: o.label ?? '',
+        required,
+        prim: 'text',
+        column: 'text',
+        hints: {
+            minLength: cfg.min,
+            maxLength: cfg.max,
+        },
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function text(o) {
+    // Support legacy min/max at top-level (used internally by presets)
+    const mergedConfig = { ...o.config };
+    if (o.min != null && mergedConfig.min == null)
+        mergedConfig.min = o.min;
+    if (o.max != null && mergedConfig.max == null)
+        mergedConfig.max = o.max;
+    const meta = string({ ...o, key: undefined, value: undefined, config: mergedConfig });
+    const textMeta = { ...meta, prim: 'text', kind: 'textarea' };
+    return wrapKey(o, textMeta);
+}
+export function real(o) {
+    const required = o.required ?? false;
+    const cfg = o.config ?? {};
+    let s = z.coerce.number(typeErr());
+    if (cfg.min != null)
+        s = s.min(cfg.min, { message: vmsg('min', { min: cfg.min }) });
+    if (cfg.max != null)
+        s = s.max(cfg.max, { message: vmsg('max', { max: cfg.max }) });
+    const base = {
+        kind: 'number',
+        label: o.label ?? '',
+        required,
+        prim: 'number',
+        column: 'real',
+        hints: { min: cfg.min, max: cfg.max, step: cfg.step ?? 'any' },
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function int(o) {
+    const required = o.required ?? false;
+    const cfg = o.config ?? {};
+    let s = z.coerce.number(typeErr()).int({ message: vmsg('int') });
+    if (cfg.min != null)
+        s = s.min(cfg.min, { message: vmsg('min', { min: cfg.min }) });
+    if (cfg.max != null)
+        s = s.max(cfg.max, { message: vmsg('max', { max: cfg.max }) });
+    const base = {
+        kind: 'number',
+        label: o.label ?? '',
+        required,
+        prim: 'number',
+        column: 'integer',
+        hints: { min: cfg.min, max: cfg.max, step: cfg.step ?? 1 },
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function date(o) {
+    const required = o.required ?? false;
+    const granularity = o.config?.granularity ?? 'day';
+    let s;
+    if (granularity === 'year') {
+        // year/month: min/max порівнюються лексикографічно як рядки (без resolveDate, на відміну від day)
+        s = z
+            .string(reqErr())
+            .regex(/^\d{4}$/, { message: vmsg('date_format') })
+            .superRefine((val, ctx) => {
+            if (o.min && val < o.min)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('date_min', { min: o.min }) });
+            if (o.max && val > o.max)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('date_max', { max: o.max }) });
+        });
+    }
+    else if (granularity === 'month') {
+        s = z
+            .string(reqErr())
+            .regex(/^\d{4}-\d{2}$/, { message: vmsg('date_format') })
+            .superRefine((val, ctx) => {
+            if (o.min && val < o.min)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('date_min', { min: o.min }) });
+            if (o.max && val > o.max)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('date_max', { max: o.max }) });
+        });
+    }
+    else {
+        s = z
+            .string(reqErr())
+            .regex(/^\d{4}-\d{2}-\d{2}$/, { message: vmsg('date_format') })
+            .superRefine((val, ctx) => {
+            if (o.min && val < resolveDate(o.min))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('date_min', { min: resolveDate(o.min) }) });
+            if (o.max && val > resolveDate(o.max))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('date_max', { max: resolveDate(o.max) }) });
+        });
+    }
+    const base = {
+        kind: 'date',
+        label: o.label ?? '',
+        required,
+        prim: 'date',
+        column: granularity === 'day' ? 'date' : 'text',
+        hints: { min: o.min, max: o.max, granularity },
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function time(o) {
+    const required = o.required ?? false;
+    const granularity = o.config?.granularity ?? 'second';
+    const timeRegex = {
+        hour: /^([01]\d|2[0-3])$/,
+        minute: /^([01]\d|2[0-3]):[0-5]\d$/,
+        second: /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/,
+    };
+    const s = z.string(reqErr()).regex(timeRegex[granularity], { message: vmsg('time_format') });
+    const base = {
+        kind: 'time',
+        label: o.label ?? '',
+        required,
+        prim: 'time',
+        column: 'time',
+        hints: { granularity },
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function datetime(o) {
+    const required = o.required ?? false;
+    const granularity = o.config?.granularity ?? 'minute';
+    const dtRegex = {
+        hour: /^\d{4}-\d{2}-\d{2}T([01]\d|2[0-3])$/,
+        minute: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/,
+        second: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/,
+    };
+    const s = z.string(reqErr()).regex(dtRegex[granularity], { message: vmsg('datetime_format') });
+    const base = {
+        kind: 'datetime',
+        label: o.label ?? '',
+        required,
+        prim: 'datetime',
+        column: 'datetime',
+        hints: { granularity },
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function boolean(o) {
+    const s = z.preprocess((v) => (v === 'true' || v === 1 || v === '1' ? true : v === 'false' || v === 0 || v === '0' ? false : v), z.boolean().default(false));
+    const meta = {
+        kind: 'boolean',
+        label: o.label ?? '',
+        required: false,
+        prim: 'checkbox',
+        column: 'boolean',
+        hints: {},
+        zod: s,
+    };
+    return wrapKey(o, meta);
+}
+export function triState(o) {
+    const required = o.required ?? false;
+    const s = z.enum(['yes', 'no', 'unknown'], { error: () => vmsg('enum') });
+    const meta = {
+        kind: 'triState',
+        label: o.label ?? '',
+        required,
+        prim: 'triState',
+        column: 'text',
+        hints: {},
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, meta);
+}
+export function select(o) {
+    const required = o.required ?? false;
+    // ── статичне джерело: NamedOptionList (string) або inline OptionItem[] ──
+    const source = typeof o.options === 'string' ? o.options : null;
+    const inlineOpts = Array.isArray(o.options) ? o.options : [];
+    const s = inlineOpts.length > 0
+        ? z.enum(inlineOpts.map((x) => x.value), { error: () => vmsg('enum') })
+        : z.string(reqErr());
+    const base = {
+        kind: 'select',
+        label: o.label ?? '',
+        required,
+        prim: 'select',
+        column: 'text',
+        hints: { source },
+        options: inlineOpts,
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function relation(o) {
+    const required = o.required ?? false;
+    const multi = o.multiple ?? false;
+    let s;
+    if (multi) {
+        s = z.string().superRefine((val, ctx) => {
+            try {
+                const arr = JSON.parse(val);
+                if (!Array.isArray(arr) || !arr.every((id) => uuidRe.test(id)))
+                    ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('uuid_list') });
+            }
+            catch {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('uuid_list') });
+            }
+        });
+    }
+    else {
+        s = z.string().regex(uuidRe, { message: vmsg('uuid') });
+    }
+    const meta = {
+        kind: 'relation',
+        label: o.label ?? '',
+        required,
+        prim: 'relation',
+        column: 'text',
+        hints: { multi, displayKey: o.displayKey ?? 'name' },
+        relation: { vault: o.vault, type: o.module },
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, meta);
+}
+/**
+ * Compose-time: підв'язати enum-валідацію source-селекту до значень списку.
+ * Factory не знає вмісту optionList (списки збираються лише в composeRegistry),
+ * тому zod source-полів спочатку z.string(); реєстр викликає це для кожного
+ * такого поля, щоб сервер відхиляв значення поза списком.
+ * Відтворює повний ланцюг модифікаторів: enum → multiple.
+ */
+export function bindSelectSourceZod(field, values) {
+    if (!values.length)
+        return;
+    const enumS = z.enum(values, { error: () => vmsg('enum') });
+    // Точне відтворення ланцюга factory: кожен крок обгортається в optionalize,
+    // як у select → applyMultiple.
+    let s = optionalize(enumS, field.required);
+    if (field.hints['multiple'] === true)
+        s = optionalize(multipleZod(s), field.required);
+    field.zod = s;
+}
+export function json(o) {
+    const required = o.required ?? false;
+    const s = z.string().superRefine((val, ctx) => {
+        try {
+            JSON.parse(val);
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+    const meta = {
+        kind: 'json',
+        label: o.label ?? '',
+        required,
+        prim: 'json',
+        column: 'text',
+        hints: {},
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, meta);
+}
+export function checklist(o) {
+    const required = o.required ?? false;
+    const itemSchema = z.object({ done: z.boolean(), text: z.string().min(1) });
+    const s = jsonRefined(z.array(itemSchema), 'checklist_structure');
+    const base = {
+        kind: 'checklist',
+        label: o.label ?? '',
+        required,
+        prim: 'checklist',
+        column: 'text',
+        hints: {},
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function measured(o) {
+    const required = o.required ?? false;
+    const cfg = o.config ?? {};
+    // Resolve units: string preset name or inline array
+    const unitsSpec = (typeof o.options === 'string' ? o.options : o.options);
+    const units = resolveUnits(unitsSpec);
+    let numSchema = z.number().finite();
+    if (cfg.step === 1)
+        numSchema = numSchema.int({ message: vmsg('int') }); // int via step:1 is not used, kept for compat
+    if (cfg.min != null)
+        numSchema = numSchema.min(cfg.min);
+    if (cfg.max != null)
+        numSchema = numSchema.max(cfg.max);
+    const rowSchema = z.object({
+        value: numSchema,
+        unit: z.string().refine((v) => units.some((u) => u.value === v), { message: vmsg('measured_unit') }),
+    });
+    const s = z.string().superRefine((val, ctx) => {
+        try {
+            const r = rowSchema.safeParse(JSON.parse(val));
+            if (!r.success) {
+                const vmsgIssue = r.error.issues.find((iss) => {
+                    try {
+                        return typeof JSON.parse(iss.message).code === 'string';
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: vmsgIssue ? vmsgIssue.message : vmsg('measured_structure'),
+                });
+            }
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+    const base = {
+        kind: 'measured',
+        label: o.label ?? '',
+        required,
+        prim: 'measured',
+        column: 'text',
+        hints: {
+            units: o.options, // рядок або масив — як є
+            ...(cfg.min != null && { min: cfg.min }),
+            ...(cfg.max != null && { max: cfg.max }),
+            ...(cfg.step != null && { step: cfg.step }),
+        },
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function money(o) {
+    const required = o.required ?? false;
+    const cfg = o.config ?? {};
+    let numSchema = z.number().finite();
+    if (cfg.min != null)
+        numSchema = numSchema.min(cfg.min);
+    if (cfg.max != null)
+        numSchema = numSchema.max(cfg.max);
+    const rowSchema = z.object({
+        value: numSchema,
+        currency: z.string().refine(isCurrencyCode, { message: vmsg('money_currency') }),
+    });
+    const s = z.string().superRefine((val, ctx) => {
+        try {
+            const r = rowSchema.safeParse(JSON.parse(val));
+            if (!r.success)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('money_structure') });
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+    const base = {
+        kind: 'money',
+        label: o.label ?? '',
+        required,
+        prim: 'money',
+        column: 'text',
+        hints: {
+            ...(cfg.defaultCurrency && { defaultCurrency: cfg.defaultCurrency }),
+            ...(cfg.min != null && { min: cfg.min }),
+            ...(cfg.max != null && { max: cfg.max }),
+        },
+        zod: optionalize(s, required),
+    };
+    const meta = applyMultiple(base, o.multiple ?? false);
+    return wrapKey(o, meta);
+}
+export function code(o) {
+    const required = o.required ?? false;
+    const cfg = o.config ?? {};
+    const rowSchema = z.object({ code: z.string(), lang: z.string() });
+    const s = z.string().superRefine((val, ctx) => {
+        try {
+            if (!rowSchema.safeParse(JSON.parse(val)).success)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('code_structure') });
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+    const base = {
+        kind: 'code',
+        label: o.label ?? '',
+        required,
+        prim: 'code',
+        column: 'text',
+        hints: { ...(cfg.defaultLang && { defaultLang: cfg.defaultLang }) },
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, base);
+}
+export function geo(o) {
+    const required = o.required ?? false;
+    const rowSchema = z.object({
+        lat: z.number().min(-90).max(90),
+        lng: z.number().min(-180).max(180),
+        label: z.string().optional(),
+    });
+    const s = z.string().superRefine((val, ctx) => {
+        try {
+            if (!rowSchema.safeParse(JSON.parse(val)).success)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('geo_structure') });
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+    const base = {
+        kind: 'geo',
+        label: o.label ?? '',
+        required,
+        prim: 'geo',
+        column: 'text',
+        hints: {},
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, base);
+}
+export function perWeekday(o) {
+    const required = o.required ?? false;
+    const cfg = o.config ?? {};
+    let num = z.number(typeErr('per_weekday'));
+    if (cfg.min != null)
+        num = num.min(cfg.min, { message: vmsg('per_weekday') });
+    if (cfg.max != null)
+        num = num.max(cfg.max, { message: vmsg('per_weekday') });
+    const arrSchema = z.array(num).length(7);
+    const s = z.string().superRefine((val, ctx) => {
+        try {
+            const r = arrSchema.safeParse(JSON.parse(val));
+            if (!r.success)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('per_weekday') });
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+    const base = {
+        kind: 'perWeekday',
+        label: o.label ?? '',
+        required,
+        prim: 'per-weekday',
+        column: 'text',
+        hints: {
+            ...(cfg.min != null && { min: cfg.min }),
+            ...(cfg.max != null && { max: cfg.max }),
+            ...(cfg.step != null && { step: cfg.step }),
+        },
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, base);
+}
+export function lookup(o) {
+    const meta = {
+        kind: 'lookup',
+        label: o.label ?? '',
+        required: false,
+        prim: 'lookup',
+        column: 'text',
+        virtual: true,
+        hints: { from: o.from, pick: o.pick, compareWith: o.compareWith ?? null },
+        zod: z.any().optional(),
+    };
+    return wrapKey(o, meta);
+}
+/**
+ * Відновлює FieldMeta з клієнтського FieldClient (для рекурсивного рендеру
+ * сабфілдів групових полів через FieldInput/FieldValue). zod тут не потрібен —
+ * валідація відбувається на рівні схеми батьківського поля.
+ */
+export function clientToMeta(fc) {
+    return { ...fc, column: 'text', zod: z.any() };
+}
+export function period(o) {
+    const granularity = o.granularity ?? 'day';
+    const fromField = granularity === 'datetime'
+        ? datetime({ label: 'core.period.from' })
+        : date({ label: 'core.period.from', config: { granularity: granularity === 'month' ? 'month' : 'day' } });
+    const untilField = granularity === 'datetime'
+        ? datetime({ label: 'core.period.until' })
+        : date({ label: 'core.period.until', config: { granularity: granularity === 'month' ? 'month' : 'day' } });
+    // Самодостатній JSON-композит {from,until} (раніше будувався на field.row).
+    // Відчеплено від row, щоб row можна було видалити. Storage: JSON {from,until}
+    // (single) або [{from,until}] (multiple), як measured/keyValue.
+    const required = o.required ?? false;
+    const multiple = o.multiple ?? false;
+    const subDefs = { from: fromField, until: untilField };
+    const rowShape = {};
+    for (const [key, fm] of Object.entries(subDefs))
+        rowShape[key] = fm.zod.optional();
+    const rowSchema = z.object(rowShape).passthrough();
+    let s = jsonRefined(multiple ? z.array(rowSchema) : rowSchema, 'row_structure');
+    s = s.superRefine((val, ctx) => {
+        if (val == null || typeof val !== 'string')
+            return;
+        try {
+            const parsed = JSON.parse(val);
+            const items = Array.isArray(parsed) ? parsed : [parsed];
+            for (const item of items) {
+                const r = item;
+                if (r?.from && r?.until && String(r.from) > String(r.until))
+                    ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('period_order') });
+            }
+        }
+        catch {
+            /* already handled by jsonRefined */
+        }
+    });
+    const subFields = Object.entries(subDefs).map(([key, fm]) => ({ key, ...toClient(fm) }));
+    const meta = {
+        kind: 'period',
+        label: o.label ?? '',
+        required,
+        prim: 'period',
+        column: 'text',
+        hints: { fields: subFields, rowMultiple: multiple, unique: [], granularity },
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, meta);
+}
+function makeFile(kind, o) {
+    const required = o.required ?? false;
+    const multiple = o.multiple ?? false;
+    const rowSchema = z.object({
+        name: z.string().min(1),
+        mime: z.string().optional(),
+        size: z.number().optional(),
+    });
+    // Schema accepts both single {name,...} and array [{name,...},...] stored as JSON.
+    // multiple=true expects an array; single accepts a single object or array.
+    const s = z.string().superRefine((val, ctx) => {
+        try {
+            const parsed = JSON.parse(val);
+            const items = Array.isArray(parsed) ? parsed : [parsed];
+            for (const it of items) {
+                if (!rowSchema.safeParse(it).success) {
+                    ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('file_structure') });
+                    return;
+                }
+            }
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+    const meta = {
+        kind,
+        label: o.label ?? '',
+        required,
+        prim: 'file',
+        column: 'text',
+        hints: multiple ? { multiple: true } : {},
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, meta);
+}
+export function file(o) {
+    return makeFile('file', o);
+}
+export function document(o) {
+    return makeFile('document', o);
+}
+export function audio(o) {
+    return makeFile('audio', o);
+}
+export function video(o) {
+    return makeFile('video', o);
+}
+export function image(o) {
+    return makeFile('image', o);
+}
+export function media(o) {
+    return makeFile('media', o);
+}
+const kvItemSchema = z.object({ key: z.string().min(1), value: z.string() });
+export function keyValue(o) {
+    const required = o.required ?? false;
+    const multiple = o.multiple ?? true;
+    const s = z.string().superRefine((val, ctx) => {
+        try {
+            const r = z.array(kvItemSchema).safeParse(JSON.parse(val));
+            if (!r.success)
+                return ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('structure') });
+            if (!multiple && r.data.length > 1)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('kv_single') });
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+    const meta = {
+        kind: 'keyValue',
+        label: o.label ?? '',
+        required,
+        prim: 'key-value',
+        column: 'text',
+        // kvMultiple (НЕ multiple): «кілька пар» — внутрішня семантика віджету,
+        // не applyMultiple-обгортка. Інакше display/form гейти multiple ловлять його помилково.
+        hints: {
+            kvMultiple: multiple,
+            option: o.option ?? string({ label: '' }),
+            keyLabel: o.keyLabel,
+            valueLabel: o.valueLabel,
+        },
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, meta);
+}
+function makeRange(kind, int, o) {
+    const required = o.required ?? false;
+    const cfg = o.config ?? {};
+    let n = z.number().finite();
+    if (int)
+        n = n.int({ message: vmsg('int') });
+    if (cfg.min != null)
+        n = n.min(cfg.min);
+    if (cfg.max != null)
+        n = n.max(cfg.max);
+    const rowSchema = z.object({ from: n, to: n });
+    const s = z.string().superRefine((val, ctx) => {
+        try {
+            const r = rowSchema.safeParse(JSON.parse(val));
+            if (!r.success) {
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('range_structure') });
+                return;
+            }
+            if (r.data.from > r.data.to)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('range_order') });
+        }
+        catch {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: vmsg('json') });
+        }
+    });
+    const base = {
+        kind,
+        label: o.label ?? '',
+        required,
+        prim: kind,
+        column: 'text',
+        hints: {
+            ...(cfg.min != null && { min: cfg.min }),
+            ...(cfg.max != null && { max: cfg.max }),
+            ...(cfg.step != null && { step: cfg.step }),
+        },
+        zod: optionalize(s, required),
+    };
+    return wrapKey(o, base);
+}
+export function numberRange(o) {
+    return makeRange('numberRange', true, o);
+}
+export function realRange(o) {
+    return makeRange('realRange', false, o);
+}
+// ─────────────────────────────────────────────────────────────────────────────
+//  f — єдина точка входу для визначення полів у типах
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Базові примітиви (storage-aligned) + структурні типи. Пресети (тонкі обгортки
+ * над цими примітивами) додаються нижче з field-presets.ts і НЕ можуть перебивати
+ * жоден ключ звідси (guard у composeF).
+ */
+const PRIMITIVES = {
+    string,
+    text,
+    real,
+    int,
+    date,
+    time,
+    datetime,
+    boolean,
+    triState,
+    select,
+    relation,
+    json,
+    checklist,
+    measured,
+    money,
+    code,
+    geo,
+    lookup,
+    perWeekday,
+    period,
+    file,
+    document,
+    audio,
+    video,
+    image,
+    media,
+    keyValue,
+    numberRange,
+    realRange,
+    group,
+    divider,
+    info,
+    button,
+};
+/** Збирає `f`, гарантуючи, що жоден пресет не затіняє примітив. */
+function composeF(presets) {
+    for (const k of Object.keys(presets))
+        if (k in PRIMITIVES)
+            throw new Error(`[f] пресет '${k}' перебиває примітив`);
+    return { ...PRIMITIVES, ...presets };
+}
+export const field = composeF(presets);
+export function toClient(field) {
+    const { kind, label, required, prim, hints, options, relation, virtual } = field;
+    return { kind, label, required, prim, hints, options, relation, virtual };
+}
+//# sourceMappingURL=fields.js.map