@airoom/nextmin-react 0.1.0

package/dist/components/SchemaForm.js

@@ -0,0 +1,592 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState, useId } from 'react';
+import { Form, Input, Textarea, Checkbox, RadioGroup, Radio, Select, SelectItem, Button, DatePicker, DateRangePicker, TimeInput, } from '@heroui/react';
+import { useSelector } from 'react-redux';
+import { inputTypeFor } from '../lib/schemaUtils';
+import { RefMultiSelect } from './RefMultiSelect';
+import { RefSingleSelect } from './RefSingleSelect';
+import { PasswordInput } from './PasswordInput';
+import { PhoneInput } from './PhoneInput';
+import { FileUploader } from './FileUploader';
+import AddressAutocompleteGoogle from './AddressAutocomplete';
+import { useGoogleMapsKey } from '../hooks/useGoogleMapsKey';
+import { parseDate, parseDateTime, parseTime, } from '@internationalized/date';
+const inputClassNames = { inputWrapper: 'bg-transparent shadow-none' };
+const selectClassNames = { trigger: 'bg-transparent shadow-none' };
+const AUDIT_FIELDS = new Set(['createdAt', 'updatedAt']);
+const digitsOnly = (s) => String(s ?? '').replace(/\D/g, '');
+function readLocalUser() {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const raw = localStorage.getItem('nextmin.user');
+        return raw ? JSON.parse(raw) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** ---------------------------- NEW HELPERS (DATE/TIME/RANGE) ---------------------------- **/
+// Decide if an attribute is a date, time, or range, plus the withTime flag
+function isDateType(attr) {
+    const t = String(attr?.type ?? '').toLowerCase();
+    const f = String(attr?.format ?? '').toLowerCase();
+    const it = String(inputTypeFor(attr) ?? '').toLowerCase(); // <-- force string
+    return (t === 'date' ||
+        f === 'date' ||
+        it === 'date' ||
+        it === 'datetime-local' ||
+        f === 'datetime' ||
+        t === 'datetime');
+}
+function isTimeType(attr) {
+    const t = String(attr?.type ?? '').toLowerCase();
+    const f = String(attr?.format ?? '').toLowerCase();
+    const it = String(inputTypeFor(attr) ?? '').toLowerCase(); // <-- force string
+    return t === 'time' || f === 'time' || it === 'time';
+}
+function isRangeType(attr) {
+    const t = String(attr?.type ?? '').toLowerCase();
+    const f = String(attr?.format ?? '').toLowerCase();
+    // support { type: 'range' }, { type: 'date-range' }, or { format: 'date-range' }
+    return (t === 'range' || t === 'date-range' || f === 'date-range' || f === 'range');
+}
+function withTimeEnabled(attr) {
+    return Boolean(attr?.withTime);
+}
+function parseTimeString(value) {
+    if (value == null)
+        return null;
+    let s = String(value).trim();
+    // accept 930 / 1530 → "09:30" / "15:30"
+    if (/^\d{3,4}$/.test(s)) {
+        const pad = s.padStart(4, '0');
+        s = `${pad.slice(0, 2)}:${pad.slice(2)}`;
+    }
+    // AM/PM path (e.g., "3:05 PM", "12:00 am")
+    const ampm = s.match(/\s*([AaPp][Mm])\s*$/);
+    if (ampm) {
+        const core = s.replace(/\s*[AaPp][Mm]\s*$/, '').trim();
+        const m = core.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
+        if (!m)
+            return null;
+        let h = Number(m[1]);
+        const min = Number(m[2]);
+        const sec = m[3] ? Number(m[3]) : 0;
+        const isPM = /^[Pp]/.test(ampm[1]);
+        if (isPM && h < 12)
+            h += 12; // 1..11 PM → 13..23
+        if (!isPM && h === 12)
+            h = 0; // 12 AM    → 00
+        const hh = String(h).padStart(2, '0');
+        const mm = String(min).padStart(2, '0');
+        const ss = String(sec).padStart(2, '0');
+        try {
+            return parseTime(`${hh}:${mm}:${ss}`);
+        }
+        catch {
+            return null;
+        }
+    }
+    // 24h path: "H:mm" / "HH:mm" / "HH:mm:ss"
+    const m24 = s.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/);
+    if (m24) {
+        const hh = String(Number(m24[1])).padStart(2, '0');
+        const mm = String(Number(m24[2])).padStart(2, '0');
+        const ss = String(m24[3] ? Number(m24[3]) : 0).padStart(2, '0');
+        try {
+            return parseTime(`${hh}:${mm}:${ss}`);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function serializeTime(t) {
+    // store canonical 24h "HH:mm"
+    return t ? t.toString().slice(0, 5) : '';
+}
+function parseDateString(v, withTime) {
+    if (!v || typeof v !== 'string')
+        return null;
+    try {
+        return withTime ? parseDateTime(v) : parseDate(v);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeRangeIn(value) {
+    if (!value)
+        return null;
+    if (Array.isArray(value)) {
+        const [s, e] = value;
+        return s && e ? { start: String(s), end: String(e) } : null;
+    }
+    if (typeof value === 'object') {
+        const anyv = value;
+        const s = anyv?.start ?? anyv?.from ?? anyv?.begin;
+        const e = anyv?.end ?? anyv?.to ?? anyv?.finish;
+        return s && e ? { start: String(s), end: String(e) } : null;
+    }
+    if (typeof value === 'string') {
+        const m = value.split('..');
+        return m.length === 2 && m[0] && m[1] ? { start: m[0], end: m[1] } : null;
+    }
+    return null;
+}
+function serializeDate(v, withTime) {
+    const raw = v.toString(); // "YYYY-MM-DD" or "YYYY-MM-DDThh:mm"
+    return withTime ? raw : raw.slice(0, 10);
+}
+function serializeRangeOut(start, end, withTime) {
+    if (!start || !end)
+        return null;
+    return {
+        start: serializeDate(start, withTime),
+        end: serializeDate(end, withTime),
+    };
+}
+function normalizeTimeRangeLoose(value) {
+    if (!value)
+        return {};
+    if (Array.isArray(value)) {
+        const [s, e] = value;
+        return {
+            start: s != null && s !== '' ? String(s) : undefined,
+            end: e != null && e !== '' ? String(e) : undefined,
+        };
+    }
+    if (typeof value === 'object') {
+        const anyv = value;
+        const s = anyv?.start ?? anyv?.from ?? anyv?.begin ?? '';
+        const e = anyv?.end ?? anyv?.to ?? anyv?.finish ?? '';
+        return {
+            start: s != null && s !== '' ? String(s) : undefined,
+            end: e != null && e !== '' ? String(e) : undefined,
+        };
+    }
+    if (typeof value === 'string') {
+        const parts = value.split('..');
+        if (parts.length === 2) {
+            const [s, e] = parts;
+            return {
+                start: s != null && s !== '' ? s : undefined,
+                end: e != null && e !== '' ? e : undefined,
+            };
+        }
+    }
+    return {};
+}
+/** --------------------------------------------------------------------------------------- **/
+export function SchemaForm({ model, schemaOverride, initialValues, submitLabel = 'Save', busy = false, showReset = true, onSubmit, }) {
+    const formUid = useId();
+    const { items } = useSelector((s) => s.schemas);
+    const reduxUser = useSelector((s) => s?.session?.user ?? null) ??
+        null;
+    const effectiveUser = useMemo(() => reduxUser ?? readLocalUser(), [reduxUser]);
+    const sessionRole = useMemo(() => {
+        if (!effectiveUser)
+            return [];
+        const raw = effectiveUser.roles ?? effectiveUser.role;
+        const toName = (r) => {
+            if (!r)
+                return null;
+            if (typeof r === 'string')
+                return r;
+            if (typeof r?.name === 'string')
+                return r.name;
+            return null;
+        };
+        if (Array.isArray(raw)) {
+            return raw.map(toName).filter((s) => !!s);
+        }
+        const single = toName(raw);
+        return single ? [single] : [];
+    }, [effectiveUser]);
+    const schema = useMemo(() => schemaOverride ??
+        items.find((s) => s.modelName.toLowerCase() === model.toLowerCase()), [items, model, schemaOverride]);
+    const [form, setForm] = useState(initialValues ?? {});
+    const [error, setError] = useState();
+    const isEdit = useMemo(() => !!(initialValues &&
+        (initialValues.id || initialValues._id)), [initialValues]);
+    useEffect(() => {
+        const next = { ...(initialValues ?? {}) };
+        if ('password' in next)
+            next.password = '';
+        if (schema) {
+            for (const [name, attr] of Object.entries(schema.attributes)) {
+                if (isPhoneAttr(name, attr) &&
+                    typeof next[name] === 'string') {
+                    next[name] = digitsOnly(next[name]);
+                }
+            }
+        }
+        setForm(next);
+    }, [initialValues, schema]);
+    if (!schema)
+        return _jsx("div", { className: "text-danger text-sm", children: "Schema not found" });
+    const bypassRoles = useMemo(() => {
+        const raw = schema?.access?.bypassPrivacy?.roles ?? [];
+        const toName = (r) => typeof r === 'string' ? r : typeof r?.name === 'string' ? r.name : null;
+        const configured = raw
+            .map(toName)
+            .filter((s) => !!s)
+            .map((s) => s.toLowerCase());
+        return configured.length > 0 ? configured : ['admin', 'superadmin'];
+    }, [schema]);
+    const canBypassPrivacy = useMemo(() => {
+        const userRolesLC = sessionRole.map((r) => r.toLowerCase());
+        return userRolesLC.some((r) => bypassRoles.includes(r));
+    }, [sessionRole, bypassRoles]);
+    const fields = useMemo(() => Object.entries(schema.attributes)
+        .filter(([name]) => !AUDIT_FIELDS.has(name))
+        .filter(([, attr]) => canBypassPrivacy ? true : !attr?.private)
+        .filter(([, attr]) => !isHiddenAttr(attr, isEdit))
+        .filter(([name, attr]) => !(isEdit && isPasswordAttr(name, attr)))
+        .map(([name, attr]) => ({ name, attr })), [schema, canBypassPrivacy, isEdit]);
+    const gridClass = 'grid gap-4 grid-cols-2';
+    const handleChange = (name, value) => setForm((f) => ({ ...f, [name]: value }));
+    const handleSubmit = async (e) => {
+        e.preventDefault();
+        setError(undefined);
+        try {
+            const { createdAt, updatedAt, ...payload } = form;
+            await onSubmit(payload);
+        }
+        catch (err) {
+            setError(err?.message || 'Submission failed');
+        }
+    };
+    const handleReset = () => {
+        const next = { ...(initialValues ?? {}) };
+        if ('password' in next)
+            next.password = '';
+        if (schema) {
+            for (const [name, attr] of Object.entries(schema.attributes)) {
+                if (isPhoneAttr(name, attr) &&
+                    typeof next[name] === 'string') {
+                    next[name] = digitsOnly(next[name]);
+                }
+            }
+        }
+        setForm(next);
+    };
+    return (_jsxs(Form, { className: gridClass, onSubmit: handleSubmit, onReset: handleReset, validationBehavior: "native", encType: "multipart/form-data", children: [fields.map(({ name, attr }) => {
+                const colClass = 'col-span-1';
+                // --- 1) Array of references → multi select (1 column)
+                const refArray = getRefArraySpec(attr);
+                if (refArray) {
+                    return (_jsx("div", { className: colClass, children: _jsx(RefMultiSelect, { name: name, label: attr?.label ?? formatLabel(name), refModel: refArray.ref, showKey: refArray.show ?? 'name', description: attr?.description, value: normalizeIdsArray(form[name]), onChange: (ids) => handleChange(name, ids), disabled: busy, required: !!attr?.required, pageSize: attr?.pageSize }) }, name));
+                }
+                // --- 2) Single reference → single select (1 column)
+                const refSingle = getRefSingleSpec(attr);
+                if (refSingle) {
+                    return (_jsx("div", { className: colClass, children: _jsx(RefSingleSelect, { name: name, label: attr?.label ?? formatLabel(name), refModel: refSingle.ref, showKey: refSingle.show ?? 'name', description: attr?.description, value: normalizeId(form[name]), onChange: (id) => handleChange(name, id), disabled: busy, required: !!attr?.required, classNames: selectClassNames, pageSize: attr?.pageSize }) }, name));
+                }
+                // let password reflect local state, but never prefill
+                const baseValue = name.toLowerCase() === 'password'
+                    ? typeof form[name] === 'string'
+                        ? form[name]
+                        : ''
+                    : (form[name] ?? (Array.isArray(attr) ? [] : ''));
+                return (_jsx("div", { className: colClass, children: _jsx(SchemaField, { uid: formUid, name: name, attr: attr, value: baseValue, onChange: handleChange, disabled: busy, inputClassNames: inputClassNames, selectClassNames: selectClassNames }) }, name));
+            }), error && (_jsx("div", { className: "col-span-2", children: _jsx("div", { className: "text-danger text-sm", children: error }) })), _jsxs("div", { className: "flex gap-2 col-span-2", children: [_jsx(Button, { type: "submit", color: "primary", isLoading: busy, children: submitLabel }), showReset && (_jsx(Button, { type: "reset", variant: "flat", isDisabled: busy, children: "Reset" }))] })] }));
+}
+function SchemaField({ uid, name, attr, value, onChange, disabled, inputClassNames, selectClassNames, }) {
+    const id = `${uid}-${name}`;
+    const label = attr?.label ?? formatLabel(name);
+    const required = !!attr?.required;
+    const description = attr?.description;
+    // Prefer ref over enum. Only use enum when there is NO ref.
+    const enumVals = attr?.ref
+        ? undefined
+        : attr?.enum;
+    const isPasswordField = name.toLowerCase() === 'password' ||
+        attr?.format === 'password' ||
+        attr?.writeOnly === true;
+    const isPhoneField = isPhoneAttr(name, attr);
+    const rawMask = typeof attr?.mask === 'string' ? attr.mask : '';
+    const hasSlots = /[Xx9#_]/.test(rawMask);
+    const phoneMask = hasSlots ? rawMask : 'xxx-xxxx-xxxx';
+    const isFileField = String(attr?.format || '').toLowerCase() === 'file' ||
+        /^(file|image|avatar|photo|picture|logo|siteLogo|sitelogo|profilepicture|bannerImage)$/i.test(name);
+    if (isFileField) {
+        const head = Array.isArray(attr) ? attr[0] : attr;
+        const multiple = Array.isArray(attr) || Boolean(head?.multiple);
+        const fileTypes = head?.fileTypes;
+        const maxFileSize = typeof head?.maxFileSize === 'number' ? head.maxFileSize : undefined;
+        const maxFilesCount = multiple && typeof head?.maxFilesCount === 'number'
+            ? Math.max(1, head.maxFilesCount)
+            : undefined;
+        const isRequired = !!attr?.required ||
+            (Array.isArray(attr) ? !!head?.required : false);
+        const controlledValue = multiple
+            ? Array.isArray(value)
+                ? value
+                : typeof value === 'string' && value
+                    ? [value]
+                    : []
+            : typeof value === 'string'
+                ? value
+                : null;
+        return (_jsx(FileUploader, { name: name, label: label, value: controlledValue, onChange: (v) => onChange(name, v), required: isRequired, disabled: disabled, accept: fileTypes, maxSizeBytes: maxFileSize, multiple: multiple, maxFilesCount: maxFilesCount, description: attr?.description, className: "w-full" }));
+    }
+    if (isPasswordField) {
+        return (_jsx(PasswordInput, { id: id, name: name, label: label, value: typeof value === 'string' ? value : '', onChange: (v) => onChange(name, v), disabled: disabled, required: required, description: description, className: "w-full", classNames: inputClassNames, autoComplete: "new-password" }));
+    }
+    if (isPhoneField) {
+        const rawDigits = typeof value === 'string' || typeof value === 'number'
+            ? String(value).replace(/\D/g, '')
+            : '';
+        return (_jsx(PhoneInput, { id: id, name: name, label: label, mask: phoneMask, value: rawDigits, onChange: (raw) => onChange(name, raw), disabled: disabled, required: required, description: description, className: "w-full", classNames: inputClassNames }));
+    }
+    const mapsKey = useGoogleMapsKey();
+    const populateField = getPopulateTarget(attr);
+    // Address → Autocomplete
+    if (isAddressAttr(name, attr)) {
+        if (!mapsKey) {
+            return (_jsxs("div", { className: "text-danger text-xs", children: ["Google Maps API key is missing. Set ", _jsx("b", { children: "googleMapsKey" }), " in", ' ', _jsx("b", { children: "Settings" }), " or define ", _jsx("b", { children: "NEXT_PUBLIC_GOOGLE_MAPS_KEY" }), " in the environment file."] }));
+        }
+        return (_jsx(AddressAutocompleteGoogle, { apiKey: mapsKey, name: name, label: label, description: description, value: typeof value === 'string' ? value : '', onChange: (addr, latlng) => {
+                if (!latlng)
+                    return;
+                onChange(name, addr);
+                if (populateField) {
+                    onChange(populateField, `${latlng.lat.toFixed(6)},${latlng.lng.toFixed(6)}`);
+                }
+            }, disabled: disabled, required: required, className: "w-full", classNames: inputClassNames, countryCodes: attr?.countryCodes, limit: attr?.limit ?? 8 }));
+    }
+    /** ----------------------- NEW: DATE / TIME / RANGE RENDERERS ----------------------- **/
+    // 1) TIME-ONLY RANGE → two TimeInput fields (AM/PM UI)
+    if (isRangeType(attr) && attr?.timeOnly === true) {
+        const raw = normalizeTimeRangeLoose(value);
+        const startT = parseTimeString(raw.start ?? null);
+        const endT = parseTimeString(raw.end ?? null);
+        const setStart = (t) => {
+            onChange(name, {
+                start: serializeTime(t),
+                end: endT ? serializeTime(endT) : '',
+            });
+        };
+        const setEnd = (t) => {
+            onChange(name, {
+                start: startT ? serializeTime(startT) : '00:00', // default start if user sets end first
+                end: serializeTime(t),
+            });
+        };
+        return (_jsx("div", { className: "w-full", children: _jsxs("div", { className: "grid grid-cols-2 gap-4", children: [_jsx(TimeInput, { variant: "bordered", label: `${label} (Start)`, labelPlacement: "outside", className: "w-full", isDisabled: disabled, isRequired: required, description: description, value: startT ?? undefined, onChange: setStart, granularity: "minute", hourCycle: 12 }), _jsx(TimeInput, { variant: "bordered", label: `${label} (End)`, labelPlacement: "outside", className: "w-full", isDisabled: disabled, isRequired: required, description: description, value: endT ?? undefined, onChange: setEnd, granularity: "minute", hourCycle: 12 })] }) }));
+    }
+    // 2) DATE RANGE (default; supports withTime)
+    if (isRangeType(attr)) {
+        const withTime = withTimeEnabled(attr);
+        const norm = normalizeRangeIn(value);
+        const startVal = norm?.start ? parseDateString(norm.start, withTime) : null;
+        const endVal = norm?.end ? parseDateString(norm.end, withTime) : null;
+        return (_jsx(DateRangePicker, { variant: "bordered", label: label, labelPlacement: "outside", className: "w-full", isDisabled: disabled, isRequired: required, description: description, value: startVal && endVal ? { start: startVal, end: endVal } : null, onChange: (val) => {
+                if (!val)
+                    return onChange(name, null);
+                const { start, end } = val;
+                onChange(name, serializeRangeOut(start, end, withTime));
+            }, granularity: withTime ? 'minute' : 'day', hourCycle: withTime ? 24 : undefined }));
+    }
+    // 3) SINGLE DATE (supports withTime)
+    if (isDateType(attr)) {
+        const withTime = withTimeEnabled(attr);
+        const parsed = parseDateString(value, withTime);
+        return (_jsx(DatePicker, { variant: "bordered", label: label, labelPlacement: "outside", className: "w-full", isDisabled: disabled, isRequired: required, description: description, value: parsed ?? null, onChange: (v) => onChange(name, v
+                ? serializeDate(v, withTime)
+                : ''), granularity: withTime ? 'minute' : 'day', hourCycle: withTime ? 24 : undefined }));
+    }
+    // 4) SINGLE TIME (uses your existing isTimeType)
+    if (isTimeType(attr)) {
+        const tVal = parseTimeString(value);
+        return (_jsx(TimeInput, { variant: "bordered", label: label, labelPlacement: "outside", className: "w-full", isDisabled: disabled, isRequired: required, description: description, value: tVal ?? undefined, onChange: (t) => onChange(name, serializeTime(t)), granularity: "minute", hourCycle: 12 }));
+    }
+    const normalize = (s) => (s ?? '').toLowerCase().trim();
+    const canSeeOption = (opt) => {
+        const raw = typeof window !== 'undefined'
+            ? localStorage.getItem('nextmin.user')
+            : null;
+        const currentUser = raw ? JSON.parse(raw) : null;
+        if (!currentUser)
+            return false;
+        const o = normalize(opt);
+        const roles = currentUser.role ?? currentUser.roles ?? [];
+        const roleNames = new Set(roles.map((r) => normalize(r.name)));
+        if (roleNames.has('superadmin'))
+            return true;
+        if (o === 'system')
+            return false;
+        return true;
+    };
+    // Enum → RadioGroup (≤4) or Select (>4)
+    if (enumVals && enumVals.length > 0) {
+        if (enumVals.length <= 4) {
+            return (_jsx(RadioGroup, { id: id, name: name, label: label, orientation: "horizontal", value: (value ?? ''), onValueChange: (v) => onChange(name, v), isDisabled: disabled, description: description, isRequired: required, className: "w-full", children: enumVals.map((opt) => {
+                    if (!canSeeOption(opt))
+                        return null;
+                    return (_jsx(Radio, { value: opt, children: opt }, opt));
+                }) }));
+        }
+        return (_jsx(Select, { variant: "bordered", classNames: selectClassNames, labelPlacement: "outside", id: id, name: name, label: label, selectedKeys: value ? new Set([String(value)]) : new Set(), onSelectionChange: (keys) => {
+                if (keys === 'all')
+                    return;
+                const v = Array.from(keys)[0];
+                onChange(name, v != null ? String(v) : '');
+            }, isDisabled: disabled, description: description, className: "w-full", selectionMode: "single", isRequired: required, children: enumVals.map((opt) => (_jsx(SelectItem, { textValue: opt, children: opt }, opt))) }));
+    }
+    // Boolean → Checkbox
+    if (inputTypeFor(attr) === 'checkbox') {
+        return (_jsxs("div", { className: "w-full", children: [_jsx(Checkbox, { id: id, name: name, isSelected: !!value, onValueChange: (v) => onChange(name, v), isDisabled: disabled, isRequired: required, children: label }), description ? (_jsx("p", { className: "text-default-500 text-xs mt-1", children: description })) : null] }));
+    }
+    // Textarea
+    if (inputTypeFor(attr) === 'textarea') {
+        return (_jsx(Textarea, { variant: "bordered", classNames: inputClassNames, id: id, name: name, label: label, labelPlacement: "outside", value: value ?? '', onChange: (e) => onChange(name, e.target.value), isDisabled: disabled, minRows: 3, isReadOnly: attr.readOnly, description: description, className: "w-full", isRequired: required }));
+    }
+    function attrHead(attr) {
+        return Array.isArray(attr) ? attr[0] : attr;
+    }
+    function isAttrReadOnly(attr) {
+        const a = attrHead(attr);
+        return !!a?.readOnly;
+    }
+    // Array (non-ref) → comma-separated input
+    if (Array.isArray(attr)) {
+        return (_jsx(Input, { variant: "bordered", classNames: inputClassNames, id: id, name: name, label: label, isReadOnly: isAttrReadOnly(attr), labelPlacement: "outside-top", placeholder: "comma-separated values", value: Array.isArray(value) ? value.join(', ') : (value ?? ''), onChange: (e) => onChange(name, e.target.value
+                .split(',')
+                .map((s) => s.trim())
+                .filter(Boolean)), isDisabled: disabled, description: description ?? 'Enter values separated by commas.', className: "w-full", isRequired: required }));
+    }
+    function pickInputType(x, fieldName) {
+        if (fieldName.toLowerCase() === 'password')
+            return 'password';
+        switch (x) {
+            case 'number':
+            case 'email':
+            case 'password':
+            case 'date':
+            case 'time':
+            case 'datetime-local':
+                return x;
+            default:
+                return 'text';
+        }
+    }
+    const inputType = pickInputType(inputTypeFor(attr), name);
+    return (_jsx(Input, { variant: "bordered", classNames: inputClassNames, id: id, name: name, label: label, isReadOnly: attr.readOnly, labelPlacement: "outside-top", type: inputType, value: value ?? '', onChange: (e) => onChange(name, inputType === 'number'
+            ? numberOrEmpty(e.target.value)
+            : e.target.value), isDisabled: disabled, description: description, className: "w-full", isRequired: required, autoComplete: name.toLowerCase() === 'password' ? 'new-password' : undefined }));
+}
+function isHiddenAttr(attr, isEdit) {
+    const head = Array.isArray(attr) ? (attr?.[0] ?? {}) : (attr ?? {});
+    const rule = head?.hidden;
+    if (typeof rule === 'boolean')
+        return rule;
+    if (rule && typeof rule === 'object') {
+        return isEdit ? !!rule.edit : !!rule.create;
+    }
+    return false;
+}
+function isPhoneAttr(name, attr) {
+    const byName = /phone/i.test(name);
+    const byFormat = String(attr?.format || '').toLowerCase() === 'phone';
+    const byType = String(attr?.type || '').toLowerCase() === 'phone';
+    const byMask = typeof attr?.mask === 'string' && attr.mask.includes('x');
+    return byName || byFormat || byType || byMask;
+}
+function isPasswordAttr(name, attr) {
+    const byName = /^password$/i.test(name);
+    const byFormat = String(attr?.format || '').toLowerCase() === 'password';
+    const byWriteOnly = attr?.writeOnly === true;
+    return byName || byFormat || byWriteOnly;
+}
+function getRefArraySpec(attr) {
+    if (!Array.isArray(attr) || attr.length === 0)
+        return null;
+    const head = attr[0];
+    if (head &&
+        typeof head === 'object' &&
+        String(head.type).toLowerCase() === 'objectid' &&
+        typeof head.ref === 'string') {
+        return { ref: head.ref, show: head.show };
+    }
+    return null;
+}
+function getRefSingleSpec(attr) {
+    if (!attr || typeof attr !== 'object' || Array.isArray(attr))
+        return null;
+    const a = attr;
+    const t = String(a.type || '').toLowerCase();
+    if (t === 'objectid' && typeof a.ref === 'string' && a.ref.trim()) {
+        return { ref: a.ref, show: a.show };
+    }
+    return null;
+}
+function normalizeIdsArray(raw) {
+    if (!raw)
+        return [];
+    if (Array.isArray(raw)) {
+        return raw
+            .map((v) => {
+            if (typeof v === 'string')
+                return v;
+            if (v && typeof v === 'object') {
+                const anyv = v;
+                return ((typeof anyv.id === 'string' && anyv.id) ||
+                    (typeof anyv._id === 'string' && anyv._id) ||
+                    null);
+            }
+            return null;
+        })
+            .filter((x) => !!x);
+    }
+    return [];
+}
+function normalizeId(raw) {
+    if (!raw)
+        return null;
+    if (typeof raw === 'string')
+        return raw;
+    if (typeof raw === 'object') {
+        const anyv = raw;
+        const id = (typeof anyv.id === 'string' && anyv.id) ||
+            (typeof anyv._id === 'string' && anyv._id) ||
+            null;
+        return id;
+    }
+    return null;
+}
+function formatLabel(raw) {
+    const spaced = raw
+        .replace(/[_\-]+/g, ' ')
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .trim();
+    return spaced
+        .split(/\s+/)
+        .map((w) => (w ? w[0].toUpperCase() + w.slice(1).toLowerCase() : w))
+        .join(' ');
+}
+function numberOrEmpty(v) {
+    if (v === '' || v === null || v === undefined)
+        return '';
+    const n = Number(v);
+    return Number.isNaN(n) ? '' : n;
+}
+function isAddressAttr(name, attr) {
+    const fname = String(name || '').toLowerCase();
+    const byName = /(address|location)/i.test(fname);
+    const byFormat = String(attr?.format || '').toLowerCase() === 'address';
+    const byPopulate = typeof attr?.populate === 'string' &&
+        attr.populate.length > 0;
+    const isStringType = String(attr?.type || '').toLowerCase() === 'string' ||
+        !('type' in attr);
+    return isStringType && (byName || byFormat || byPopulate);
+}
+function getPopulateTarget(attr) {
+    const head = Array.isArray(attr) ? (attr?.[0] ?? {}) : (attr ?? {});
+    const t = head?.populate ?? attr?.populate;
+    return typeof t === 'string' && t.trim() ? t.trim() : null;
+}

package/dist/components/SectionLoader.d.ts

@@ -0,0 +1,3 @@
+export declare function SectionLoader({ label }: {
+    label?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/SectionLoader.js

@@ -0,0 +1,7 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Spinner } from '@heroui/react';
+export function SectionLoader({ label = 'Loading…' }) {
+    // Fills only the parent area; parent should have `relative`
+    return (_jsx("div", { className: "absolute inset-0 grid place-items-center", children: _jsxs("div", { className: "flex items-center gap-3 rounded-xl border bg-background/70 backdrop-blur px-4 py-3 shadow-sm", children: [_jsx(Spinner, { size: "sm" }), _jsx("span", { className: "text-sm text-foreground/80", children: label })] }) }));
+}

package/dist/components/Sidebar.d.ts

@@ -0,0 +1 @@
+export declare function Sidebar(): import("react/jsx-runtime").JSX.Element;