@airoom/nextmin-react 0.1.0

package/dist/views/ProfilePage.js

@@ -0,0 +1,193 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState, useCallback } from 'react';
+import { Input, Button, Card, CardBody, CardHeader, Divider, } from '@heroui/react';
+import { request, api } from '../lib/api';
+import { useDispatch } from 'react-redux';
+import { setSession } from '../state/sessionSlice';
+import { FileUploader } from '../components/FileUploader';
+import { PasswordInput } from '../components/PasswordInput';
+// Small helpers for current user endpoints (plural 'users' per nextmin-node)
+async function getMe() {
+    return request('/auth/users/me');
+}
+async function changePassword(payload) {
+    return request('/auth/users/change-password', { method: 'POST', body: payload });
+}
+export default function ProfilePage() {
+    const dispatch = useDispatch();
+    const [loading, setLoading] = useState(true);
+    const [saving, setSaving] = useState(false);
+    const [pwdBusy, setPwdBusy] = useState(false);
+    const [error, setError] = useState(null);
+    const [success, setSuccess] = useState(null);
+    const [me, setMe] = useState(null);
+    // Editable fields (keep minimal and generic)
+    const [name, setName] = useState('');
+    const [firstName, setFirstName] = useState('');
+    const [lastName, setLastName] = useState('');
+    const [email, setEmail] = useState('');
+    const [picture, setPicture] = useState([]);
+    const [pictureKey, setPictureKey] = useState(null);
+    // Password fields
+    const [oldPassword, setOldPassword] = useState('');
+    const [newPassword, setNewPassword] = useState('');
+    useEffect(() => {
+        let cancelled = false;
+        const extractUrl = (v) => {
+            if (!v)
+                return null;
+            if (typeof v === 'string')
+                return v;
+            if (typeof v === 'object') {
+                const u = (typeof v.url === 'string' && v.url) ||
+                    (typeof v.src === 'string' && v.src) ||
+                    (typeof v.value === 'string' && v.value) ||
+                    null;
+                return u;
+            }
+            return null;
+        };
+        (async () => {
+            try {
+                setLoading(true);
+                const res = await getMe();
+                const user = res?.data ?? null;
+                if (!cancelled) {
+                    setMe(user);
+                    const baseName = user && user.name != null && String(user.name).trim() !== ''
+                        ? String(user.name)
+                        : `${user?.firstName ?? ''} ${user?.lastName ?? ''}`;
+                    setName(String(baseName || '').trim());
+                    setFirstName(String(user?.firstName ?? ''));
+                    setLastName(String(user?.lastName ?? ''));
+                    setEmail(String(user?.email ?? ''));
+                    // Detect existing picture field and normalize to [string]
+                    const picKeys = [
+                        'avatar',
+                        'photo',
+                        'profilePicture',
+                        'picture',
+                        'image',
+                    ];
+                    let foundKey = null;
+                    let urls = [];
+                    for (const k of picKeys) {
+                        if (user && user[k] != null) {
+                            foundKey = k;
+                            const val = user[k];
+                            if (Array.isArray(val)) {
+                                urls = val.map(extractUrl).filter(Boolean);
+                            }
+                            else {
+                                const one = extractUrl(val);
+                                urls = one ? [one] : [];
+                            }
+                            break;
+                        }
+                    }
+                    setPictureKey(foundKey);
+                    setPicture(urls);
+                }
+            }
+            catch (e) {
+                if (!cancelled)
+                    setError(e?.message || 'Failed to load profile');
+            }
+            finally {
+                if (!cancelled)
+                    setLoading(false);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    const handleSave = useCallback(async () => {
+        if (!me?.id)
+            return;
+        try {
+            setSaving(true);
+            setError(null);
+            setSuccess(null);
+            const payload = {};
+            if (name.trim())
+                payload.name = name.trim();
+            if (firstName.trim())
+                payload.firstName = firstName.trim();
+            if (lastName.trim())
+                payload.lastName = lastName.trim();
+            if (email.trim())
+                payload.email = email.trim().toLowerCase();
+            // Picture handling: preserve existing key and shape
+            const key = pictureKey;
+            if (key) {
+                const wasArray = Array.isArray(me?.[key]);
+                if (picture.length === 0) {
+                    payload[key] = wasArray ? [] : '';
+                }
+                else {
+                    payload[key] = wasArray ? picture : picture[0];
+                }
+            }
+            else if (picture.length > 0) {
+                // default to 'avatar' if none existed
+                payload['avatar'] = picture[0];
+            }
+            const res = await api.update('users', me.id, payload);
+            const updated = res?.data ?? { ...me, ...payload };
+            // Update local copies
+            try {
+                const token = (typeof window !== 'undefined' &&
+                    localStorage.getItem('nextmin.token')) ||
+                    null;
+                if (typeof window !== 'undefined') {
+                    localStorage.setItem('nextmin.user', JSON.stringify(updated));
+                }
+                if (token)
+                    dispatch(setSession({ token, user: updated }));
+            }
+            catch { }
+            setMe(updated);
+            setSuccess('Profile updated.');
+        }
+        catch (e) {
+            setError(e?.message || 'Failed to save profile');
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [me, name, firstName, lastName, email, picture, pictureKey, dispatch]);
+    const handleChangePassword = useCallback(async () => {
+        try {
+            setPwdBusy(true);
+            setError(null);
+            setSuccess(null);
+            if (!oldPassword || !newPassword) {
+                setError('Please provide both old and new passwords.');
+                return;
+            }
+            await changePassword({ oldPassword, newPassword });
+            setSuccess('Password changed successfully.');
+            setOldPassword('');
+            setNewPassword('');
+        }
+        catch (e) {
+            setError(e?.message || 'Failed to change password');
+        }
+        finally {
+            setPwdBusy(false);
+        }
+    }, [oldPassword, newPassword]);
+    return (_jsxs("div", { className: "grid gap-4 px-4", children: [_jsx("div", { className: "flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between", children: _jsx("h2", { className: "m-0 text-xl font-semibold", children: "My Profile" }) }), _jsx(Divider, { className: "my-3" }), loading ? (_jsx("div", { children: "Loading\u2026" })) : (_jsxs(_Fragment, { children: [(error || success) && (_jsx("div", { className: 'rounded-md px-3 py-2 ' +
+                            (error
+                                ? 'bg-red-100 text-red-700'
+                                : 'bg-green-100 text-green-700'), children: error || success })), _jsxs("div", { className: "grid grid-cols-1 md:grid-cols-2 gap-4", children: [_jsxs(Card, { children: [_jsx(CardHeader, { className: "font-medium", children: "Profile info" }), _jsxs(CardBody, { className: "space-y-8", children: [_jsxs("div", { className: "grid grid-cols-1 md:grid-cols-2 gap-4", children: [_jsx(Input, { label: "First name", labelPlacement: "outside", variant: "bordered", value: firstName, onChange: (e) => setFirstName(e.target.value), classNames: { inputWrapper: 'bg-transparent shadow-none' } }), _jsx(Input, { label: "Last name", labelPlacement: "outside", variant: "bordered", value: lastName, onChange: (e) => setLastName(e.target.value), classNames: { inputWrapper: 'bg-transparent shadow-none' } })] }), _jsx(Input, { label: "Display name", labelPlacement: "outside", variant: "bordered", description: "Shown in some places if provided; otherwise composed from first/last name", value: name, onChange: (e) => setName(e.target.value), classNames: { inputWrapper: 'bg-transparent shadow-none' } }), _jsx(Input, { type: "email", label: "Email", labelPlacement: "outside", variant: "bordered", value: email, onChange: (e) => setEmail(e.target.value), classNames: { inputWrapper: 'bg-transparent shadow-none' } }), _jsx("div", { children: _jsx(FileUploader, { name: "profilePicture", label: "Profile picture", multiple: false, value: picture.length ? picture[0] : null, onChange: (v) => {
+                                                        if (Array.isArray(v))
+                                                            setPicture(v);
+                                                        else if (typeof v === 'string' && v)
+                                                            setPicture([v]);
+                                                        else
+                                                            setPicture([]);
+                                                    }, accept: ['image/*'], description: "Upload a square image for best results" }) }), _jsx("div", { children: _jsx(Button, { color: "primary", isLoading: saving, onPress: handleSave, children: "Save changes" }) })] })] }), _jsxs(Card, { children: [_jsx(CardHeader, { className: "font-medium", children: "Change password" }), _jsxs(CardBody, { className: "space-y-8", children: [_jsx(PasswordInput, { name: "oldPassword", label: "Current password", value: oldPassword, onChange: (v) => setOldPassword(v), className: "w-full", classNames: { inputWrapper: 'bg-transparent shadow-none' } }), _jsx(PasswordInput, { name: "newPassword", label: "New password", value: newPassword, onChange: (v) => setNewPassword(v), description: "At least 8 characters", className: "w-full", classNames: { inputWrapper: 'bg-transparent shadow-none' } }), _jsx("div", { children: _jsx(Button, { color: "secondary", isLoading: pwdBusy, onPress: handleChangePassword, children: "Update password" }) })] })] })] })] }))] }));
+}

package/dist/views/SettingsEdit.d.ts

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

package/dist/views/SettingsEdit.js

@@ -0,0 +1,87 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { ListHeader } from './list/ListHeader';
+import { NoAccess } from '../components/NoAccess';
+import { SchemaForm } from '../components/SchemaForm';
+import { api, ApiError } from '../lib/api';
+import { systemLoaded } from '../state/nextMinSlice';
+const MODEL = 'settings'; // use lowercase to match router/api paths
+const getId = (doc) => doc && (doc.id || doc._id) ? String(doc.id ?? doc._id) : undefined;
+export function SettingsEdit() {
+    const dispatch = useDispatch();
+    const { items } = useSelector((s) => s.schemas);
+    const schema = useMemo(() => items.find((s) => s.modelName.toLowerCase() === MODEL.toLowerCase()), [items]);
+    const [doc, setDoc] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [saving, setSaving] = useState(false);
+    const [forbidden, setForbidden] = useState(null);
+    const [error, setError] = useState(null);
+    const fetchSingleton = useCallback(async () => {
+        setLoading(true);
+        setForbidden(null);
+        setError(null);
+        try {
+            // Only one Settings row exists; fetch first page with 1 item
+            const resp = await api.list(MODEL, 0, 1);
+            const first = resp?.data?.[0] ?? null;
+            setDoc(first);
+            const normalized = first == null
+                ? null
+                : {
+                    apiKey: first.apiKey ?? undefined,
+                    siteName: first.siteName ?? undefined,
+                    googleMapsKey: first.googleMapsKey ?? undefined,
+                    siteLogo: Array.isArray(first.siteLogo)
+                        ? first.siteLogo
+                        : typeof first.siteLogo === 'string' && first.siteLogo
+                            ? [first.siteLogo]
+                            : undefined,
+                };
+            dispatch(systemLoaded(normalized));
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 403) {
+                setForbidden('You are not permitted to view Settings.');
+            }
+            else {
+                setError(e?.message || 'Failed to fetch settings.');
+            }
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
+    useEffect(() => {
+        void fetchSingleton();
+    }, [fetchSingleton]);
+    const handleSubmit = useCallback(async (payload) => {
+        setError(null);
+        const id = getId(doc);
+        if (!id) {
+            throw new Error('Settings document not found. Please run the initializer.');
+        }
+        setSaving(true);
+        try {
+            await api.update(MODEL, id, payload);
+            // Re-fetch to reflect any server-side normalization (e.g., processed file URLs)
+            await fetchSingleton();
+        }
+        catch (e) {
+            setError(e?.message || 'Save failed');
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [doc, fetchSingleton]);
+    const title = schema?.modelName ?? 'Settings';
+    if (!schema) {
+        return (_jsx("div", { className: "p-4 text-danger text-sm", children: "Settings schema not found." }));
+    }
+    if (forbidden) {
+        return (_jsxs("div", { className: "px-4", children: [_jsx(ListHeader, { title: title, createHref: "", loading: false }), _jsx(NoAccess, { message: forbidden })] }));
+    }
+    return (_jsxs("div", { className: "grid gap-3 px-4", children: [_jsx(ListHeader, { title: title, hideCreate: true, createHref: "", loading: loading || saving }), error ? (_jsx("div", { className: "text-danger text-sm", children: error })) : (_jsx(SchemaForm, { model: MODEL, schemaOverride: schema, initialValues: doc ?? undefined, submitLabel: "Save", busy: loading || saving, onSubmit: handleSubmit, showReset: false }))] }));
+}
+export default SettingsEdit;

package/dist/views/list/DataTableHero.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+type Props = {
+    modelName: string;
+    columns: string[];
+    topContent?: React.ReactNode;
+    rows: any[];
+    total: number;
+    page: number;
+    pageSize: number;
+    onPageChange: (p: number) => void;
+    onPageSizeChange: (n: number) => void;
+    baseHref: string;
+    loading?: boolean;
+    error?: string | null;
+    /** optional hook so parent can refetch or optimistically remove */
+    onDeleted?: (id: string) => void;
+};
+/** ---------- truncation helper ---------- */
+export declare function truncateText(text: unknown, maxLength?: number): string;
+/** ---------- component ---------- */
+export declare function DataTableHero({ modelName, columns, rows, total, page, pageSize, onPageChange, onPageSizeChange, baseHref, loading, error, onDeleted, topContent, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/views/list/DataTableHero.js

@@ -0,0 +1,350 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import Link from 'next/link';
+import { Table, TableHeader, TableBody, TableColumn, TableRow, TableCell, Pagination, Select, SelectItem, Skeleton, Button, Tooltip, Spinner, } from '@heroui/react';
+import { formatCell } from './formatters';
+import { api } from '../../lib/api';
+import { ConfirmDialog } from '../../components/ConfirmDialog';
+/** ---------- helpers: image detection/rendering ---------- */
+const IMG_EXT_RE = /\.(png|jpe?g|gif|webp|bmp|svg|avif|heic|heif)$/i;
+const IMG_COLUMN_RE = /(image|photo|avatar|logo|picture|thumbnail|icon)/i;
+function isUrlLike(s) {
+    return /^https?:\/\//i.test(s) || s.startsWith('/') || s.startsWith('data:');
+}
+function isLikelyImageUrl(s) {
+    if (!isUrlLike(s))
+        return false;
+    if (s.startsWith('data:image/'))
+        return true;
+    try {
+        const url = new URL(s, 'http://x'); // base for relative paths
+        const pathname = url.pathname || '';
+        if (IMG_EXT_RE.test(pathname))
+            return true;
+    }
+    catch {
+        if (IMG_EXT_RE.test(s.split('?')[0]))
+            return true;
+    }
+    return false;
+}
+function extractUrl(v) {
+    if (!v)
+        return null;
+    if (typeof v === 'string' && isLikelyImageUrl(v))
+        return v;
+    if (typeof v === 'object') {
+        const u = (typeof v.url === 'string' && v.url) ||
+            (typeof v.src === 'string' && v.src) ||
+            (typeof v.value === 'string' && v.value) ||
+            null;
+        return u && isLikelyImageUrl(u) ? u : null;
+    }
+    return null;
+}
+function extractAllImageUrls(val) {
+    if (Array.isArray(val)) {
+        const list = val.map(extractUrl).filter(Boolean);
+        if (!list.length) {
+            return (val.filter((s) => typeof s === 'string' && isLikelyImageUrl(s)) ??
+                []);
+        }
+        return list;
+    }
+    const one = extractUrl(val);
+    return one ? [one] : [];
+}
+function ImageCell({ urls, alt, size = 40, }) {
+    const shown = urls.slice(0, 1);
+    const rest = urls.length - shown.length;
+    return (_jsxs("div", { className: "flex items-center justify-center gap-1", children: [shown.map((u, i) => (_jsx("img", { src: u, alt: alt, width: size, height: size, className: "h-10 w-10 rounded-md object-cover border border-default-200 bg-default-100", loading: "lazy" }, `${u}-${i}`))), rest > 0 ? (_jsxs("div", { className: "h-10 w-10 rounded-md border border-default-200 bg-default-50 text-xs flex items-center justify-center", children: ["+", rest] })) : null] }));
+}
+/** decide if a column should be treated as image by header hint or value */
+function maybeRenderImageCell(item, columnKey) {
+    const val = item?.[columnKey];
+    const urls = extractAllImageUrls(val);
+    if (urls.length || IMG_COLUMN_RE.test(String(columnKey))) {
+        if (!urls.length)
+            return null;
+        return _jsx(ImageCell, { urls: urls, alt: `${columnKey}` });
+    }
+    return null;
+}
+/** ---------- truncation helper ---------- */
+export function truncateText(text, maxLength = 35) {
+    if (typeof text !== 'string')
+        return String(text ?? '');
+    if (text.length <= maxLength)
+        return text;
+    return text.slice(0, maxLength) + '…';
+}
+/** ---------- JSON-ish string -> object ---------- */
+function maybeParseJson(val) {
+    if (typeof val !== 'string')
+        return val;
+    const s = val.trim();
+    if (!s)
+        return val;
+    // quick gate to avoid parsing normal text
+    if (!(s.startsWith('{') || s.startsWith('[')))
+        return val;
+    try {
+        const parsed = JSON.parse(s);
+        // only treat as object/array; don't convert primitives
+        if (parsed && (typeof parsed === 'object' || Array.isArray(parsed))) {
+            return parsed;
+        }
+        return val;
+    }
+    catch {
+        return val;
+    }
+}
+/** ---------- time-only range formatting (24h -> am/pm) ---------- */
+const TIME_24_RE = /^([01]\d|2[0-3]):([0-5]\d)$/;
+function to12h(hhmm) {
+    const m = TIME_24_RE.exec(hhmm);
+    if (!m)
+        return hhmm;
+    let h = parseInt(m[1], 10);
+    const mm = m[2];
+    const ampm = h >= 12 ? 'pm' : 'am';
+    h = h % 12 || 12;
+    const hh = String(h).padStart(2, '0');
+    return `${hh}:${mm}${ampm}`;
+}
+function parseTimeRangeToken(tok) {
+    const [s, e] = tok.split('..');
+    if (s == null && e == null)
+        return null;
+    const startOk = typeof s === 'string' && TIME_24_RE.test(s.trim());
+    const endOk = typeof e === 'string' && TIME_24_RE.test(e.trim());
+    if (!startOk && !endOk)
+        return null;
+    const start = startOk ? s.trim() : undefined;
+    const end = endOk ? e.trim() : undefined;
+    return { start, end };
+}
+function extractTimeRanges24(val) {
+    if (val == null)
+        return null;
+    if (typeof val === 'string') {
+        const tokens = val
+            .split(/[,\s]+/)
+            .map((t) => t.trim())
+            .filter(Boolean);
+        const ranges = tokens
+            .map(parseTimeRangeToken)
+            .filter((r) => !!r);
+        return ranges.length ? ranges : null;
+    }
+    if (typeof val === 'object' && !Array.isArray(val)) {
+        const anyv = val;
+        const r = parseTimeRangeToken(`${String(anyv?.start ?? '').trim()}..${String(anyv?.end ?? '').trim()}`);
+        return r ? [r] : null;
+    }
+    if (Array.isArray(val)) {
+        const ranges = [];
+        for (const x of val) {
+            if (typeof x === 'string') {
+                const r = parseTimeRangeToken(x.trim());
+                if (r)
+                    ranges.push(r);
+            }
+            else if (typeof x === 'object' && x) {
+                const xx = x;
+                const r = parseTimeRangeToken(`${String(xx?.start ?? '').trim()}..${String(xx?.end ?? '').trim()}`);
+                if (r)
+                    ranges.push(r);
+            }
+        }
+        return ranges.length ? ranges : null;
+    }
+    return null;
+}
+function formatTimeOnlyRanges(val) {
+    const ranges = extractTimeRanges24(val);
+    if (!ranges)
+        return null;
+    const parts = ranges
+        .map(({ start, end }) => {
+        const left = start ? to12h(start) : '';
+        const right = end ? to12h(end) : '';
+        if (left && right)
+            return `${left}-${right}`;
+        if (left)
+            return `${left}-`;
+        if (right)
+            return `-${right}`;
+        return '';
+    })
+        .filter(Boolean);
+    return parts.length ? parts.join(', ') : null;
+}
+/** ---------- object "show key" formatting ---------- */
+function getByPath(obj, path) {
+    if (!obj || typeof obj !== 'object' || !path)
+        return undefined;
+    const parts = path
+        .replace(/\[(\d+)\]/g, '.$1')
+        .split('.')
+        .filter(Boolean);
+    let cur = obj;
+    for (const p of parts) {
+        if (cur == null)
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+function extractShowFromObject(o) {
+    if (!o || typeof o !== 'object')
+        return null;
+    // explicit hints
+    const showKey = (typeof o.show === 'string' && o.show) ||
+        (typeof o.showKey === 'string' && o.showKey) ||
+        null;
+    if (showKey) {
+        const v = getByPath(o, showKey);
+        if (v != null && (typeof v === 'string' || typeof v === 'number')) {
+            return String(v);
+        }
+        const vv = o[showKey];
+        if (vv != null && (typeof vv === 'string' || typeof vv === 'number')) {
+            return String(vv);
+        }
+    }
+    // smart fallbacks (domain-aware)
+    const first = o.firstName;
+    const last = o.lastName;
+    if (typeof first === 'string' && typeof last === 'string') {
+        const full = `${first} ${last}`.trim();
+        if (full)
+            return full;
+    }
+    const candidates = [
+        'display',
+        'name',
+        'title',
+        'label',
+        'value',
+        'fullName',
+        'appointmentName',
+        'email',
+        'username',
+    ];
+    for (const k of candidates) {
+        const v = o[k];
+        if (v != null && (typeof v === 'string' || typeof v === 'number')) {
+            return String(v);
+        }
+    }
+    return null;
+}
+function formatShowValue(val) {
+    if (val == null)
+        return null;
+    // If it's a JSON-like string, parse first
+    const parsed = maybeParseJson(val);
+    if (Array.isArray(parsed)) {
+        const parts = parsed
+            .map((x) => (typeof x === 'object' ? extractShowFromObject(x) : null))
+            .filter((s) => !!s);
+        return parts.length ? parts.join(', ') : null;
+    }
+    if (typeof parsed === 'object') {
+        return extractShowFromObject(parsed);
+    }
+    return null;
+}
+/** ---------- component ---------- */
+export function DataTableHero({ modelName, columns, rows, total, page, pageSize, onPageChange, onPageSizeChange, baseHref, loading, error, onDeleted, topContent, }) {
+    const pageCount = Math.max(1, Math.ceil(total / Math.max(1, pageSize)));
+    const [pendingDeleteId, setPendingDeleteId] = React.useState(null);
+    const [isDeleting, setIsDeleting] = React.useState(false);
+    const [isDialogOpen, setIsDialogOpen] = React.useState(false);
+    const headerItems = React.useMemo(() => [
+        ...columns.map((c) => ({ key: c, label: c })),
+        { key: 'actions', label: 'Actions' },
+    ], [columns]);
+    const skeletonItems = React.useMemo(() => Array.from({ length: Math.min(pageSize, 10) }, (_, i) => ({
+        id: `s-${i}`,
+    })), [pageSize]);
+    const bodyItems = loading ? skeletonItems : rows;
+    const requestDelete = (id) => {
+        setPendingDeleteId(id);
+        setIsDialogOpen(true);
+    };
+    const handleConfirmDelete = async () => {
+        if (!pendingDeleteId) {
+            setIsDialogOpen(false);
+            return;
+        }
+        try {
+            setIsDeleting(true);
+            await api.remove(modelName, pendingDeleteId);
+            onDeleted?.(pendingDeleteId);
+        }
+        finally {
+            setIsDeleting(false);
+            setPendingDeleteId(null);
+            setIsDialogOpen(false);
+        }
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs(Table, { "aria-label": "Model table", removeWrapper: true, bottomContent: _jsxs("div", { className: "flex items-center justify-between px-2 py-2", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("span", { className: "text-sm text-foreground/70", children: "Rows per page:" }), _jsx(Select, { size: "sm", "aria-label": "Rows per page", selectedKeys: new Set([String(pageSize)]), onSelectionChange: (keys) => {
+                                        const val = Array.from(keys)[0];
+                                        if (val)
+                                            onPageSizeChange(Number(val));
+                                    }, className: "w-24", children: [10, 20, 50, 100].map((n) => (_jsx(SelectItem, { textValue: String(n), children: n }, String(n)))) })] }), _jsx(Pagination, { size: "sm", total: pageCount, page: Math.min(page, pageCount), onChange: onPageChange, showControls: true })] }), topContent: topContent, children: [_jsx(TableHeader, { columns: headerItems, children: (col) => (_jsx(TableColumn, { className: "text-xs uppercase tracking-wide", children: col.label }, col.key)) }), _jsx(TableBody, { items: bodyItems, emptyContent: loading ? undefined : error || 'No data', children: (item) => (_jsx(TableRow, { children: (columnKey) => {
+                                const key = String(columnKey);
+                                if (loading) {
+                                    return (_jsx(TableCell, { children: _jsx(Skeleton, { className: "h-3 w-3/4 rounded-md" }) }, `${item.id}-${key}`));
+                                }
+                                if (key === 'actions') {
+                                    const typeCol = columns.find((c) => c.toLowerCase() === 'type');
+                                    const typeVal = typeCol ? item?.[typeCol] : undefined;
+                                    const typeString = typeof typeVal === 'string'
+                                        ? typeVal
+                                        : typeof typeVal?.value === 'string'
+                                            ? typeVal.value
+                                            : typeof typeVal?.name === 'string'
+                                                ? typeVal.name
+                                                : '';
+                                    const isSystemRow = String(typeString ?? '').toLowerCase() === 'system';
+                                    return (_jsx(TableCell, { children: _jsxs("div", { className: "flex items-center gap-1", children: [_jsx(Tooltip, { content: isSystemRow
+                                                        ? 'System record — editing disabled'
+                                                        : 'Edit', children: _jsx(Button, { as: isSystemRow ? undefined : Link, href: isSystemRow ? undefined : `${baseHref}/${item.id}`, isIconOnly: true, size: "sm", variant: "light", isDisabled: isSystemRow, "aria-disabled": isSystemRow, children: _jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", focusable: "false", children: [_jsx("path", { d: "M12 20h9" }), _jsx("path", { d: "M16.5 3.5a2.121 2.121 0 0 1 3 3L7 19l-4 1 1-4 12.5-12.5z" })] }) }) }), _jsx(Tooltip, { content: isSystemRow
+                                                        ? 'System record — deletion disabled'
+                                                        : 'Delete', children: _jsx(Button, { isIconOnly: true, size: "sm", variant: "light", color: "danger", isDisabled: isSystemRow, "aria-disabled": isSystemRow, onPress: () => {
+                                                            if (!isSystemRow)
+                                                                requestDelete(item.id);
+                                                        }, children: isDeleting && pendingDeleteId === item.id ? (_jsx(Spinner, { size: "sm" })) : (
+                                                        // Trash icon
+                                                        _jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": "true", focusable: "false", children: [_jsx("polyline", { points: "3 6 5 6 21 6" }), _jsx("path", { d: "M19 6l-1 14H6L5 6" }), _jsx("path", { d: "M10 11v6" }), _jsx("path", { d: "M14 11v6" })] })) }) })] }) }, `${item.id}-actions`));
+                                }
+                                // Image-aware cell; fallback to formatter
+                                const maybeImg = maybeRenderImageCell(item, key);
+                                // Prepare raw value (parse JSON-like strings first)
+                                const rawRawVal = item[key];
+                                const rawVal = maybeParseJson(rawRawVal);
+                                // 1) Time-only ranges like "15:00..00:00 17:00..23:00"
+                                const timeRangePretty = formatTimeOnlyRanges(rawVal);
+                                if (timeRangePretty) {
+                                    return (_jsx(TableCell, { children: timeRangePretty }, `${item.id ?? item._id}-${key}`));
+                                }
+                                // 2) Object/array with "show"/"showKey" or common label fields
+                                const showPretty = formatShowValue(rawVal);
+                                if (showPretty) {
+                                    return (_jsx(TableCell, { children: truncateText(showPretty, 35) }, `${item.id ?? item._id}-${key}`));
+                                }
+                                // 3) Existing formatter pipeline
+                                const formatted = formatCell(rawVal, key);
+                                const isSimple = typeof formatted === 'string' ||
+                                    typeof formatted === 'number';
+                                const displayValue = isSimple
+                                    ? truncateText(String(formatted), 35)
+                                    : formatted;
+                                return (_jsx(TableCell, { children: maybeImg ?? displayValue }, `${item.id ?? item._id}-${key}`));
+                            } }, item.id)) })] }), _jsx(ConfirmDialog, { isOpen: isDialogOpen, onClose: () => setIsDialogOpen(false), onConfirm: handleConfirmDelete, isLoading: isDeleting, title: "Delete this record?", description: "This action cannot be undone. The record will be permanently removed.", confirmText: "Delete", cancelText: "Cancel" })] }));
+}

package/dist/views/list/ListHeader.d.ts

@@ -0,0 +1,8 @@
+type Props = {
+    title: string;
+    createHref: string;
+    hideCreate?: boolean;
+    loading?: boolean;
+};
+export declare function ListHeader({ title, createHref, hideCreate, loading, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};