@airoom/nextmin-react 0.1.0

package/dist/router/AdminRouteNormalizer.js

@@ -0,0 +1,32 @@
+'use client';
+import { useEffect } from 'react';
+import { usePathname, useSearchParams, useRouter } from 'next/navigation';
+export function AdminRouteNormalizer() {
+    const pathname = usePathname();
+    const search = useSearchParams();
+    const router = useRouter();
+    useEffect(() => {
+        if (!pathname)
+            return;
+        // Only touch /admin paths
+        if (!pathname.startsWith('/admin'))
+            return;
+        // Collapse duplicate slashes and trim trailing slash (except exactly "/admin")
+        let normalized = pathname.replace(/\/{2,}/g, '/');
+        if (normalized !== '/admin') {
+            normalized = normalized.replace(/\/+$/, '');
+        }
+        // If nothing changed, exit
+        if (normalized === pathname)
+            return;
+        const query = search?.toString();
+        const hash = typeof window !== 'undefined' ? window.location.hash : '';
+        let target = normalized;
+        if (query)
+            target += `?${query}`;
+        if (hash)
+            target += hash;
+        router.replace(target);
+    }, [pathname, search, router]);
+    return null;
+}

package/dist/router/NextMinRouter.d.ts

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

package/dist/router/NextMinRouter.js

@@ -0,0 +1,99 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo, useEffect } from 'react';
+import { usePathname, useRouter } from 'next/navigation';
+import { useSelector } from 'react-redux';
+import { ListPage } from '../views/ListPage';
+import { CreateEditPage } from '../views/CreateEditPage';
+import { NextNotFound } from '../views/NextNotFound';
+import { DashboardPage } from '../views/DashboardPage';
+import { SectionLoader } from '../components/SectionLoader';
+import SettingsEdit from '../views/SettingsEdit';
+import ProfilePage from '../views/ProfilePage';
+export function NextMinRouter() {
+    const pathname = usePathname();
+    const router = useRouter();
+    const { items: schemas, status } = useSelector((s) => s.schemas);
+    const { state, atAdminRoot } = useMemo(() => {
+        const parts = (pathname || '/').split('/').filter(Boolean);
+        const idx = parts.indexOf('admin');
+        const segs = idx >= 0 ? parts.slice(idx + 1) : [];
+        const atRoot = idx >= 0 && segs.length === 0;
+        if (atRoot) {
+            return {
+                atAdminRoot: true,
+                state: { model: null, mode: 'dashboard', id: null },
+            };
+        }
+        if (segs[0]?.toLowerCase() === 'auth') {
+            return {
+                atAdminRoot: false,
+                state: { model: null, mode: 'dashboard', id: null },
+            };
+        }
+        if (segs[0]?.toLowerCase() === 'dashboard') {
+            return {
+                atAdminRoot: false,
+                state: { model: null, mode: 'dashboard', id: null },
+            };
+        }
+        if (segs[0]?.toLowerCase() === 'profile') {
+            return {
+                atAdminRoot: false,
+                state: { model: null, mode: 'profile', id: null },
+            };
+        }
+        const model = segs[0]?.toLowerCase() ?? null;
+        if (!model)
+            return {
+                atAdminRoot: false,
+                state: { model: null, mode: null, id: null },
+            };
+        if (segs.length === 1)
+            return {
+                atAdminRoot: false,
+                state: { model, mode: 'list', id: null },
+            };
+        if (segs[1] === 'create')
+            return {
+                atAdminRoot: false,
+                state: { model, mode: 'create', id: null },
+            };
+        if (segs[0] === 'system' && segs[1] === 'update')
+            return {
+                atAdminRoot: false,
+                state: { model, mode: 'system', id: null },
+            };
+        return {
+            atAdminRoot: false,
+            state: { model, mode: 'edit', id: segs[1] ?? null },
+        };
+    }, [pathname]);
+    // Canonicalize /admin → /admin/dashboard
+    useEffect(() => {
+        if (atAdminRoot)
+            router.replace('/admin/dashboard');
+    }, [atAdminRoot, router]);
+    // While schemas are loading, show an overlay only in this pane
+    if (status !== 'succeeded') {
+        return (_jsx("div", { className: "relative min-h-[200px]", children: _jsx(SectionLoader, { label: "Loading schemas\u2026" }) }));
+    }
+    if (state.mode === 'dashboard')
+        return _jsx(DashboardPage, {});
+    if (state.mode === 'profile')
+        return _jsx(ProfilePage, {});
+    if (!state.model)
+        return _jsx(DashboardPage, {});
+    if (state.mode === 'system')
+        return _jsx(SettingsEdit, {});
+    const schema = schemas.find((s) => s.modelName.toLowerCase() === state.model);
+    if (!schema)
+        return _jsx(NextNotFound, {});
+    if (state.mode === 'list')
+        return _jsx(ListPage, { model: state.model });
+    if (state.mode === 'create')
+        return _jsx(CreateEditPage, { model: state.model });
+    if (state.mode === 'edit' && state.id)
+        return _jsx(CreateEditPage, { model: state.model, id: state.id });
+    return _jsx(NextNotFound, {});
+}

package/dist/state/nextMinSlice.d.ts

@@ -0,0 +1,14 @@
+export type SystemSettings = {
+    apiKey?: string;
+    siteName?: string;
+    siteLogo?: string[];
+    googleMapsKey: string;
+} | null;
+type NextMinState = {
+    system: SystemSettings;
+    status: 'idle' | 'loading' | 'succeeded' | 'failed';
+    error?: string;
+};
+export declare const systemLoading: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"nextMin/systemLoading">, systemLoaded: import("@reduxjs/toolkit").ActionCreatorWithPayload<SystemSettings, "nextMin/systemLoaded">, systemFailed: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "nextMin/systemFailed">, setSystem: import("@reduxjs/toolkit").ActionCreatorWithPayload<SystemSettings, "nextMin/setSystem">, clearSystem: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"nextMin/clearSystem">;
+declare const _default: import("redux").Reducer<NextMinState>;
+export default _default;

package/dist/state/nextMinSlice.js

@@ -0,0 +1,34 @@
+import { createSlice } from '@reduxjs/toolkit';
+const initialState = {
+    system: null,
+    status: 'idle',
+};
+const nextMinSlice = createSlice({
+    name: 'nextMin',
+    initialState,
+    reducers: {
+        systemLoading(state) {
+            state.status = 'loading';
+            state.error = undefined;
+        },
+        systemLoaded(state, action) {
+            state.status = 'succeeded';
+            state.system = action.payload ?? null;
+            state.error = undefined;
+        },
+        systemFailed(state, action) {
+            state.status = 'failed';
+            state.error = action.payload;
+        },
+        setSystem(state, action) {
+            state.system = action.payload ?? null;
+        },
+        clearSystem(state) {
+            state.system = null;
+            state.status = 'idle';
+            state.error = undefined;
+        },
+    },
+});
+export const { systemLoading, systemLoaded, systemFailed, setSystem, clearSystem, } = nextMinSlice.actions;
+export default nextMinSlice.reducer;

package/dist/state/schemaLive.d.ts

@@ -0,0 +1,2 @@
+import { NextMinStore } from './store';
+export declare function startSchemaLive(store: NextMinStore): void;

package/dist/state/schemaLive.js

@@ -0,0 +1,19 @@
+'use client';
+import { setSchemas } from './schemasSlice';
+import { getSchemaService } from '../lib/schemaService';
+export function startSchemaLive(store) {
+    const sock = getSchemaService();
+    if (!sock)
+        return;
+    if (sock.__nm_bound)
+        return;
+    sock.__nm_bound = true;
+    const push = (all) => {
+        const data = Array.isArray(all) ? all : Object.values(all || {});
+        store.dispatch(setSchemas(data));
+    };
+    sock.on('schemasData', push);
+    sock.on('schemasUpdated', push);
+    sock.on('connect', () => console.log('[nextmin] schema service connected', sock.id));
+    sock.on('connect_error', (e) => console.warn('[nextmin] schema service connect_error:', e?.message));
+}

package/dist/state/schemasSlice.d.ts

@@ -0,0 +1,20 @@
+import { SchemaDef } from '../lib/types';
+type Status = 'idle' | 'loading' | 'succeeded' | 'failed';
+export type SchemasState = {
+    items: SchemaDef[];
+    status: Status;
+    error?: string;
+};
+export declare const fetchSchemas: import("@reduxjs/toolkit").AsyncThunk<SchemaDef[], void, {
+    state?: unknown;
+    dispatch?: import("redux-thunk").ThunkDispatch<unknown, unknown, import("redux").UnknownAction>;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const setSchemas: import("@reduxjs/toolkit").ActionCreatorWithPayload<SchemaDef[], "schemas/setSchemas">;
+declare const _default: import("redux").Reducer<SchemasState>;
+export default _default;

package/dist/state/schemasSlice.js

@@ -0,0 +1,43 @@
+import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
+import { api } from '../lib/api';
+const initialState = {
+    items: [],
+    status: 'idle',
+};
+export const fetchSchemas = createAsyncThunk('schemas/fetch', async () => {
+    const res = (await api.getSchemas());
+    return res.data;
+}, {
+    condition: (_arg, { getState }) => {
+        const { status } = getState().schemas;
+        // skip if already fetched or fetching
+        return status === 'idle';
+    },
+});
+const schemasSlice = createSlice({
+    name: 'schemas',
+    initialState,
+    reducers: {
+        setSchemas(state, action) {
+            state.items = action.payload;
+            state.status = 'succeeded';
+        },
+    },
+    extraReducers(builder) {
+        builder
+            .addCase(fetchSchemas.pending, (state) => {
+            state.status = 'loading';
+            state.error = undefined;
+        })
+            .addCase(fetchSchemas.fulfilled, (state, action) => {
+            state.status = 'succeeded';
+            state.items = action.payload;
+        })
+            .addCase(fetchSchemas.rejected, (state, action) => {
+            state.status = 'failed';
+            state.error = action.error.message;
+        });
+    },
+});
+export const { setSchemas } = schemasSlice.actions;
+export default schemasSlice.reducer;

package/dist/state/sessionSlice.d.ts

@@ -0,0 +1,10 @@
+type Session = {
+    token: string | null;
+    user: any | null;
+};
+export declare const setSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    token: string;
+    user: any;
+}, "session/setSession">, clearSession: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"session/clearSession">;
+declare const _default: import("redux").Reducer<Session>;
+export default _default;

package/dist/state/sessionSlice.js

@@ -0,0 +1,18 @@
+import { createSlice } from '@reduxjs/toolkit';
+const initialState = { token: null, user: null };
+const sessionSlice = createSlice({
+    name: 'session',
+    initialState,
+    reducers: {
+        setSession: (s, a) => {
+            s.token = a.payload.token;
+            s.user = a.payload.user;
+        },
+        clearSession: (s) => {
+            s.token = null;
+            s.user = null;
+        },
+    },
+});
+export const { setSession, clearSession } = sessionSlice.actions;
+export default sessionSlice.reducer;

package/dist/state/store.d.ts

@@ -0,0 +1,28 @@
+export declare const nextminstore: import("@reduxjs/toolkit").EnhancedStore<{
+    schemas: import("./schemasSlice").SchemasState;
+    nextMin: {
+        system: import("./nextMinSlice").SystemSettings;
+        status: "idle" | "loading" | "succeeded" | "failed";
+        error?: string;
+    };
+    session: {
+        token: string | null;
+        user: any | null;
+    };
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        schemas: import("./schemasSlice").SchemasState;
+        nextMin: {
+            system: import("./nextMinSlice").SystemSettings;
+            status: "idle" | "loading" | "succeeded" | "failed";
+            error?: string;
+        };
+        session: {
+            token: string | null;
+            user: any | null;
+        };
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type NextMinStore = typeof nextminstore;
+export type NextMinRootState = ReturnType<NextMinStore['getState']>;
+export type NextMinDispatch = NextMinStore['dispatch'];

package/dist/state/store.js

@@ -0,0 +1,7 @@
+import { configureStore } from '@reduxjs/toolkit';
+import schemasReducer from './schemasSlice';
+import nextMinReducer from './nextMinSlice';
+import sessionReducer from './sessionSlice';
+export const nextminstore = configureStore({
+    reducer: { schemas: schemasReducer, nextMin: nextMinReducer, session: sessionReducer },
+});

package/dist/views/CreateEditPage.d.ts

@@ -0,0 +1,4 @@
+export declare function CreateEditPage({ model, id }: {
+    model: string;
+    id?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/views/CreateEditPage.js

@@ -0,0 +1,64 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { useRouter } from 'next/navigation';
+import { useSelector } from 'react-redux';
+import { api } from '../lib/api';
+import { SchemaForm } from '../components/SchemaForm';
+import Link from 'next/link';
+import { Button, Divider } from '@heroui/react';
+export function CreateEditPage({ model, id }) {
+    const router = useRouter();
+    const { items } = useSelector((s) => s.schemas);
+    const schema = useMemo(() => items.find((s) => s.modelName.toLowerCase() === model.toLowerCase()), [items, model]);
+    const [initialValues, setInitialValues] = useState({});
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState();
+    useEffect(() => {
+        let cancelled = false;
+        if (!id) {
+            setInitialValues({});
+            setError(undefined);
+            return;
+        }
+        (async () => {
+            try {
+                const res = await api.get(model, id);
+                if (!cancelled) {
+                    setInitialValues(res.data || {});
+                    setError(undefined);
+                }
+            }
+            catch (e) {
+                if (!cancelled)
+                    setError(e?.message || 'Failed to load');
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [id, model]);
+    const handleSubmit = async (values) => {
+        setBusy(true);
+        setError(undefined);
+        try {
+            if (id) {
+                await api.update(model, id, values);
+            }
+            else {
+                await api.create(model, values);
+            }
+            router.push(`/admin/${model}`);
+            router.refresh();
+        }
+        catch (e) {
+            setError(e?.message || 'Save failed');
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    if (!schema)
+        return _jsx("div", { className: "text-danger text-sm", children: "Schema not found" });
+    return (_jsxs("div", { className: "grid gap-4 px-4", children: [_jsxs("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: id ? `Edit ${schema.modelName}` : `Create ${schema.modelName}` }), _jsx("div", { className: "flex items-center gap-3", children: _jsx(Button, { as: Link, href: `/admin/${model}`, size: "sm", variant: "flat", color: "danger", isDisabled: busy, children: "Cancel" }) })] }), _jsx(Divider, { className: "my-3" }), error && _jsx("div", { className: "text-danger text-sm", children: error }), _jsx(SchemaForm, { model: model, schemaOverride: schema, initialValues: initialValues, submitLabel: id ? 'Save' : 'Create', busy: busy, onSubmit: handleSubmit })] }));
+}

package/dist/views/DashboardPage.d.ts

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

package/dist/views/DashboardPage.js

@@ -0,0 +1,107 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { useSelector } from 'react-redux';
+import { api } from '../lib/api';
+import { Divider, Card, CardBody } from '@heroui/react';
+function ArrowUpRightIcon(props) {
+    return (_jsx("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, ...props, children: _jsx("path", { d: "M7 17L17 7M17 7H9M17 7v8", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }) }));
+}
+function UsersIcon(props) {
+    return (_jsxs("svg", { width: "22", height: "22", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, ...props, children: [_jsx("path", { d: "M16 21v-2a4 4 0 00-4-4H7a4 4 0 00-4 4v2", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }), _jsx("circle", { cx: "9", cy: "7", r: "4", stroke: "currentColor", strokeWidth: "2" }), _jsx("path", { d: "M22 21v-2a3 3 0 00-3-3h-2", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }), _jsx("path", { d: "M16 3.13a4 4 0 010 7.75", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })] }));
+}
+function DoctorIcon(props) {
+    return (_jsxs("svg", { width: "22", height: "22", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, ...props, children: [_jsx("path", { d: "M12 12a5 5 0 100-10 5 5 0 000 10z", stroke: "currentColor", strokeWidth: "2" }), _jsx("path", { d: "M4 22v-1a7 7 0 017-7h2a7 7 0 017 7v1", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }), _jsx("path", { d: "M12 7v3M10.5 8.5h3", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" })] }));
+}
+function HospitalIcon(props) {
+    return (_jsxs("svg", { width: "22", height: "22", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, ...props, children: [_jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", stroke: "currentColor", strokeWidth: "2" }), _jsx("path", { d: "M12 7v10M7 12h10", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" })] }));
+}
+function CalendarIcon(props) {
+    return (_jsxs("svg", { width: "22", height: "22", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, ...props, children: [_jsx("rect", { x: "3", y: "4", width: "18", height: "17", rx: "2", stroke: "currentColor", strokeWidth: "2" }), _jsx("path", { d: "M8 2v4M16 2v4M3 10h18", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" })] }));
+}
+export function DashboardPage() {
+    const schemas = useSelector((s) => s.schemas.items);
+    const status = useSelector((s) => s.schemas.status);
+    const cards = useMemo(() => {
+        const byName = (name) => schemas.some((s) => s.modelName?.toLowerCase() === name);
+        return [
+            {
+                key: 'users',
+                label: 'Total users',
+                icon: _jsx(UsersIcon, { className: "text-primary" }),
+                colorClass: 'bg-primary/10 text-primary',
+                model: byName('users') ? 'users' : undefined,
+            },
+            {
+                key: 'doctors',
+                label: 'Total doctors',
+                icon: _jsx(DoctorIcon, { className: "text-success" }),
+                colorClass: 'bg-success/10 text-success',
+                model: byName('doctors') ? 'doctors' : undefined,
+            },
+            {
+                key: 'hospitals',
+                label: 'Total hospitals',
+                icon: _jsx(HospitalIcon, { className: "text-warning" }),
+                colorClass: 'bg-warning/10 text-warning',
+                model: byName('hospitals') ? 'hospitals' : undefined,
+            },
+            {
+                key: 'appointments',
+                label: 'Total appointments',
+                icon: _jsx(CalendarIcon, { className: "text-secondary" }),
+                colorClass: 'bg-secondary/10 text-secondary',
+                model: byName('appointments') ? 'appointments' : undefined,
+            },
+        ];
+    }, [schemas]);
+    const [counts, setCounts] = useState({});
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        let cancelled = false;
+        async function load() {
+            if (status !== 'succeeded')
+                return;
+            setLoading(true);
+            setError(null);
+            try {
+                const entries = await Promise.all(cards.map(async (c) => {
+                    if (!c.model)
+                        return [c.key, null]; // schema missing
+                    try {
+                        const res = await api.list(c.model, 0, 1);
+                        const total = res?.pagination?.totalRows ?? res?.data?.length ?? 0;
+                        return [c.key, total];
+                    }
+                    catch (e) {
+                        return [c.key, null];
+                    }
+                }));
+                if (!cancelled) {
+                    const map = {};
+                    for (const [k, v] of entries)
+                        map[k] = v;
+                    setCounts(map);
+                }
+            }
+            catch (e) {
+                if (!cancelled)
+                    setError(e?.message || 'Failed to load stats');
+            }
+            finally {
+                if (!cancelled)
+                    setLoading(false);
+            }
+        }
+        load();
+        return () => {
+            cancelled = true;
+        };
+    }, [cards, status]);
+    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: "Dashboard" }) }), _jsx(Divider, { className: "my-3" }), (error || loading) && (_jsx("div", { className: 'rounded-md px-3 py-2 ' +
+                    (error ? 'bg-red-100 text-red-700' : 'bg-default-100 text-default-700'), children: error || 'Loading summary…' })), _jsx("div", { className: "grid grid-cols-1 sm:grid-cols-2 xl:grid-cols-4 gap-4", children: cards.map((c) => {
+                    const value = counts[c.key];
+                    return (_jsx(Card, { className: "shadow-sm border border-default-200", children: _jsxs(CardBody, { className: "flex flex-row items-center justify-between gap-3", children: [_jsxs("div", { children: [_jsx("div", { className: "text-sm text-foreground/60", children: c.label }), _jsx("div", { className: "text-2xl font-semibold mt-1", children: value == null ? '—' : value })] }), _jsx("div", { className: `h-10 w-10 rounded-md flex items-center justify-center ${c.colorClass}`, children: c.icon })] }) }, c.key));
+                }) })] }));
+}

package/dist/views/ListPage.d.ts

@@ -0,0 +1,5 @@
+type Props = {
+    model: string;
+};
+export declare function ListPage({ model }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/views/ListPage.js

@@ -0,0 +1,76 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState, useEffect, useCallback } from 'react';
+import { useSelector } from 'react-redux';
+import { useListData } from './list/useListData';
+import { ListHeader } from './list/ListHeader';
+import { DataTableHero } from './list/DataTableHero';
+import { TableFilters } from '../components/TableFilters';
+import { NoAccess } from '../components/NoAccess';
+export function ListPage({ model }) {
+    // paging + filters
+    const [page, setPage] = useState(1); // 1-based
+    const [pageSize, setPageSize] = useState(10);
+    const [filters, setFilters] = useState({});
+    // schema
+    const { items } = useSelector((s) => s.schemas);
+    const schema = useMemo(() => items.find((s) => s.modelName.toLowerCase() === model.toLowerCase()), [items, model]);
+    // reset on model change
+    useEffect(() => {
+        setPage(1);
+        setPageSize(10);
+        setFilters({});
+    }, [model]);
+    // data
+    const [{ rows, total, loading, forbidden, err }, refetch] = useListData(model, page, pageSize, {
+        q: filters.q,
+        searchKey: filters.searchKey,
+    });
+    // columns (ALWAYS call hooks; derive from schema or empty object)
+    const attributes = (schema?.attributes ?? {});
+    const allColumns = useMemo(() => Object.entries(attributes)
+        .filter(([, a]) => !a?.private)
+        .map(([k]) => k), [attributes]);
+    // default visible: first 4 + 'createdAt' if present (stable via useMemo)
+    const defaultVisible = useMemo(() => {
+        const set = new Set();
+        // first 4 non-private fields
+        allColumns.slice(0, 4).forEach((c) => set.add(c));
+        // force-include 'type' if present
+        if (allColumns.includes('type'))
+            set.add('type');
+        // force-include 'createdAt' if present
+        if (allColumns.includes('createdAt'))
+            set.add('createdAt');
+        return Array.from(set);
+    }, [allColumns]);
+    // visible columns state (init once, update when model/defaultVisible change)
+    const [visibleColumns, setVisibleColumns] = useState(() => new Set(defaultVisible));
+    useEffect(() => {
+        // whenever model or defaultVisible changes, reset visible columns
+        setVisibleColumns(new Set(defaultVisible));
+    }, [model, defaultVisible]);
+    const tableColumns = useMemo(() => allColumns.filter((c) => visibleColumns.has(c)), [allColumns, visibleColumns]);
+    const baseHref = useMemo(() => `/admin/${model}`, [model]);
+    const handleRefetch = useCallback(async () => {
+        await refetch();
+    }, [refetch]);
+    // Choose content WITHOUT early-returning before hooks
+    let content = null;
+    if (!schema) {
+        content = _jsx("div", { style: { padding: 16 }, children: "Schema not found" });
+    }
+    else if (forbidden) {
+        content = (_jsx(NoAccess, { message: err ?? 'You are not permitted to view this resource.' }));
+    }
+    else {
+        content = (_jsx("div", { className: "overflow-hidden", children: _jsx(DataTableHero, { topContent: _jsx(TableFilters, { model: model, value: filters, busy: loading, onChange: (v) => {
+                        setFilters(v);
+                        setPage(1);
+                    }, columns: allColumns, visibleColumns: visibleColumns, onVisibleColumnsChange: (keys) => setVisibleColumns(new Set([...keys])) }), modelName: model, columns: tableColumns, rows: rows, total: total, page: page, pageSize: pageSize, onPageChange: setPage, onDeleted: handleRefetch, onPageSizeChange: (n) => {
+                    setPageSize(n);
+                    setPage(1);
+                }, baseHref: baseHref, loading: loading, error: err ?? undefined }) }));
+    }
+    return (_jsxs("div", { className: "grid gap-3 px-4", children: [_jsx(ListHeader, { title: schema?.modelName ?? model, createHref: `${baseHref}/create`, loading: loading }), content] }));
+}

package/dist/views/NextNotFound.d.ts

@@ -0,0 +1 @@
+export declare function NextNotFound(): null;

package/dist/views/NextNotFound.js

@@ -0,0 +1,6 @@
+'use client';
+import { notFound } from 'next/navigation';
+export function NextNotFound() {
+    notFound(); // renders app/not-found.tsx if present, or Next's default 404
+    return null;
+}

package/dist/views/ProfilePage.d.ts

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