@airoom/nextmin-react 0.1.0

package/dist/components/Sidebar.js

@@ -0,0 +1,87 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { useRouter } from 'next/navigation';
+import { clearSession } from '../state/sessionSlice';
+import { Button } from '@heroui/react';
+import Link from 'next/link';
+export function Sidebar() {
+    const router = useRouter();
+    const dispatch = useDispatch();
+    const system = useSelector((s) => s.nextMin.system);
+    const systemStatus = useSelector((s) => s.nextMin.status);
+    const { items, status, error } = useSelector((s) => s.schemas);
+    const logout = React.useCallback(() => {
+        try {
+            localStorage.removeItem('nextmin.token');
+            localStorage.removeItem('nextmin.user');
+        }
+        catch { }
+        dispatch(clearSession());
+        router.replace('/admin/auth/sign-in');
+    }, [dispatch, router]);
+    const isLoading = status === 'idle' || status === 'loading';
+    const orderedItems = React.useMemo(() => {
+        const normal = [];
+        const sysBucket = [];
+        const pickAttrString = (obj, prop) => {
+            if (obj &&
+                typeof obj === 'object' &&
+                prop in obj) {
+                const v = obj[prop];
+                return typeof v === 'string' ? v : null;
+            }
+            return null;
+        };
+        const pickTypeValue = (t) => {
+            if (typeof t === 'string')
+                return t;
+            const d = pickAttrString(t, 'default');
+            if (d)
+                return d;
+            const v = pickAttrString(t, 'value');
+            if (v)
+                return v;
+            return '';
+        };
+        for (const sc of items || []) {
+            const t = sc?.attributes?.type;
+            const typeString = pickTypeValue(t);
+            const isSystem = typeString.toLowerCase() === 'system';
+            (isSystem ? sysBucket : normal).push(sc);
+        }
+        const byName = (a, b) => String(a?.modelName || '').localeCompare(String(b?.modelName || ''));
+        normal.sort(byName);
+        sysBucket.sort(byName);
+        return [...normal, ...sysBucket];
+    }, [items]);
+    // Read user info from localStorage (client only)
+    const [user, setUser] = React.useState(null);
+    React.useEffect(() => {
+        try {
+            const raw = localStorage.getItem('nextmin.user');
+            if (raw)
+                setUser(JSON.parse(raw));
+        }
+        catch {
+            setUser(null);
+        }
+    }, []);
+    // —— Brand (logo/name) ——
+    const siteName = React.useMemo(() => (system?.siteName && system.siteName.trim()) || 'NextMin', [system]);
+    const logoUrl = React.useMemo(() => {
+        const arr = Array.isArray(system?.siteLogo) ? system.siteLogo : [];
+        const first = arr.find((u) => typeof u === 'string' && u.trim().length > 0);
+        return first || undefined;
+    }, [system]);
+    return (_jsxs("aside", { className: "flex h-full min-h-screen w-64 flex-col border-r", children: [_jsx(Link, { href: "/admin/dashboard", className: "h-20 px-3 border-b flex items-center justify-center", children: logoUrl ? (_jsx("img", { src: logoUrl, alt: siteName, className: "h-10 max-w-[160px] object-contain" })) : (_jsx("div", { className: "text-lg font-semibold truncate", children: siteName })) }), _jsxs("div", { className: "flex-1 overflow-y-auto p-2", children: [isLoading && _jsx("div", { children: "Loading\u2026" }), status === 'failed' && error && (_jsx("div", { className: "text-red-600", children: error })), status === 'succeeded' && (_jsxs("ul", { className: "list-none space-y-2", children: [_jsx("li", { children: _jsx(Link, { href: "/admin/dashboard", className: "w-full hover:bg-gray-200 px-3 py-2 rounded-md inline-flex items-center gap-2", children: "Dashboard" }) }, "dashboard"), orderedItems.map((s) => {
+                                const slug = String(s.modelName || '').toLowerCase();
+                                // Hide auto Settings model from the list; we link a fixed Settings route below
+                                if (slug === 'settings')
+                                    return null;
+                                return (_jsx("li", { children: _jsx(Link, { href: `/admin/${slug}`, className: "w-full hover:bg-gray-200 px-3 py-2 rounded-md inline-flex items-center gap-2", children: s.modelName }) }, s.modelName));
+                            }), _jsx("li", { children: _jsx(Link, { href: "/admin/system/update", className: "w-full hover:bg-gray-200 px-3 py-2 rounded-md inline-flex items-center gap-2", children: "Settings" }) }, "settings"), !items.length && (_jsx("li", { className: "text-gray-500", children: "No schemas found" }))] }))] }), _jsxs("div", { className: "mt-auto border-t p-4 space-y-2", children: [_jsx(Link, { href: "/admin/profile", className: "w-full block hover:bg-gray-200 px-3 py-2 rounded-md", children: _jsxs("div", { className: "flex items-center justify-between gap-3", children: [user && (_jsxs("div", { className: "text-sm text-gray-700 text-left", children: [_jsx("div", { className: "font-semibold", children: `${user.firstName ?? ''} ${user.lastName ?? ''}`.trim() ||
+                                                user.name ||
+                                                '' }), _jsx("div", { className: "text-gray-500", children: user.email })] })), _jsx("svg", { "aria-hidden": "true", width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", className: "text-default-500 flex-shrink-0", children: _jsx("path", { d: "M9 6l6 6-6 6", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }) })] }) }), _jsx(Button, { fullWidth: true, variant: "flat", onPress: logout, children: "Log out" })] })] }));
+}

package/dist/components/TableFilters.d.ts

@@ -0,0 +1,16 @@
+export type FilterValue = {
+    q?: string;
+    searchKey?: string;
+};
+type Props = {
+    model: string;
+    value: FilterValue;
+    onChange: (v: FilterValue) => void;
+    busy?: boolean;
+    /** NEW: column visibility control */
+    columns: string[];
+    visibleColumns: Set<string>;
+    onVisibleColumnsChange: (v: Set<string>) => void;
+};
+export declare function TableFilters({ model, value, onChange, busy, columns, visibleColumns, onVisibleColumnsChange, }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/TableFilters.js

@@ -0,0 +1,69 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Form, Input, Select, SelectItem, Button, Dropdown, DropdownTrigger, DropdownMenu, DropdownItem, } from '@heroui/react';
+import { useSelector } from 'react-redux';
+import { inputTypeFor } from '../lib/schemaUtils';
+export function TableFilters({ model, value, onChange, busy, columns, visibleColumns, onVisibleColumnsChange, }) {
+    const { items } = useSelector((s) => s.schemas);
+    const schema = React.useMemo(() => items.find((s) => s.modelName.toLowerCase() === model.toLowerCase()), [items, model]);
+    const [searchKey, setSearchKey] = React.useState(value.searchKey);
+    const [q, setQ] = React.useState(value.q ?? '');
+    React.useEffect(() => {
+        setSearchKey(value.searchKey);
+        setQ(value.q ?? '');
+    }, [value]);
+    if (!schema)
+        return null;
+    const keys = React.useMemo(() => Object.entries(schema.attributes)
+        .filter(([, a]) => !a?.private)
+        .map(([k]) => k), [schema]);
+    const selectedAttr = searchKey
+        ? schema.attributes[searchKey]
+        : undefined;
+    const isBoolean = selectedAttr && inputTypeFor(selectedAttr) === 'checkbox';
+    const apply = (e) => {
+        e.preventDefault();
+        onChange({
+            q: q?.trim() || undefined,
+            searchKey: searchKey || undefined,
+        });
+    };
+    const clear = () => {
+        setSearchKey(undefined);
+        setQ('');
+        onChange({});
+    };
+    return (_jsxs(Form, { onSubmit: apply, onReset: clear, className: "grid gap-3 md:grid-cols-5 grid-cols-1 items-end", children: [_jsx(Select, { placeholder: "Search Field", "aria-label": "Search Field", variant: "bordered", size: "sm", selectedKeys: searchKey ? new Set([searchKey]) : new Set(), onSelectionChange: (s) => {
+                    if (s === 'all')
+                        return;
+                    const v = Array.from(s)[0];
+                    setSearchKey(v);
+                    setQ(''); // reset q when field changes
+                }, className: "w-full", selectionMode: "single", isDisabled: busy, children: keys.map((k) => (_jsx(SelectItem, { textValue: String(formatLabel(k)), children: formatLabel(k) }, k))) }), _jsx("div", { className: "w-full md:col-span-2", children: isBoolean ? (_jsxs(Select, { variant: "bordered", size: "sm", placeholder: "Select value", "aria-label": "Select value", selectedKeys: q ? new Set([q]) : new Set(), onSelectionChange: (s) => {
+                        if (s === 'all')
+                            return;
+                        const v = Array.from(s)[0];
+                        setQ(v === 'true' ? 'true' : v === 'false' ? 'false' : '');
+                    }, className: "w-full", isDisabled: busy, children: [_jsx(SelectItem, { textValue: "True", children: "True" }, "true"), _jsx(SelectItem, { textValue: "True", children: "False" }, "false")] })) : (_jsx(Input, { size: "sm", placeholder: "Search", variant: "bordered", type: "search", fullWidth: true, classNames: {
+                        input: 'px-2',
+                    }, value: q, onChange: (e) => setQ(e.target.value), isDisabled: busy })) }), _jsxs("div", { className: "flex md:col-span-1 gap-2", children: [_jsx(Button, { type: "submit", color: "primary", isDisabled: busy, size: "sm", children: "Apply" }), _jsx(Button, { type: "reset", variant: "flat", isDisabled: busy, size: "sm", children: "Clear" })] }), _jsx("div", { className: "flex justify-end md:col-span-1 gap-2", children: _jsxs(Dropdown, { size: "sm", children: [_jsx(DropdownTrigger, { className: "hidden sm:flex", children: _jsx(Button, { size: "sm", variant: "flat", endContent: _jsx(ChevronDownSmall, {}), children: "Columns" }) }), _jsx(DropdownMenu, { disallowEmptySelection: true, "aria-label": "Table Columns", closeOnSelect: false, selectionMode: "multiple", selectedKeys: visibleColumns, onSelectionChange: (keys) => {
+                                if (keys === 'all')
+                                    return;
+                                onVisibleColumnsChange(keys);
+                            }, children: columns.map((col) => (_jsx(DropdownItem, { className: "capitalize", children: formatLabel(col) }, col))) })] }) })] }));
+}
+/** tiny inline chevron (no icon pkg) */
+function ChevronDownSmall() {
+    return (_jsx("svg", { width: "14", height: "14", viewBox: "0 0 20 20", fill: "currentColor", "aria-hidden": "true", className: "text-small", children: _jsx("path", { d: "M5.23 7.21a.75.75 0 011.06.02L10 10.94l3.71-3.71a.75.75 0 111.06 1.06l-4.24 4.24a.75.75 0 01-1.06 0L5.21 8.29a.75.75 0 01.02-1.08z" }) }));
+}
+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(' ');
+}

package/dist/components/TableSkeleton.d.ts

@@ -0,0 +1,7 @@
+type Props = {
+    columns: string[];
+    rows?: number;
+    showActions?: boolean;
+};
+export declare function TableSkeleton({ columns, rows, showActions, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/TableSkeleton.js

@@ -0,0 +1,5 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function TableSkeleton({ columns, rows = 10, showActions = true, }) {
+    return (_jsx("div", { className: "overflow-auto border border-default-200 rounded-lg", children: _jsxs("table", { className: "w-full border-collapse", children: [_jsx("thead", { children: _jsxs("tr", { children: [columns.map((c) => (_jsx("th", { className: "text-left text-xs font-medium uppercase tracking-wide text-foreground/60 px-3 py-2 border-b border-default-200", children: c }, c))), showActions && (_jsx("th", { className: "w-[120px] border-b border-default-200" }))] }) }), _jsx("tbody", { children: Array.from({ length: rows }).map((_, i) => (_jsxs("tr", { children: [columns.map((c, idx) => (_jsx("td", { className: "px-3 py-3 border-b border-default-100", children: _jsx("div", { className: "h-3 w-full max-w-[200px] rounded-md bg-foreground/10 animate-pulse" }) }, `${i}-${c}`))), showActions && (_jsx("td", { className: "px-3 py-3 border-b border-default-100", children: _jsx("div", { className: "h-8 w-16 rounded-md bg-foreground/10 animate-pulse" }) }))] }, i))) })] }) }));
+}

package/dist/hooks/useGoogleMapsKey.d.ts

@@ -0,0 +1,5 @@
+/** Priority:
+ * 1) Redux: s.nextMin.system.googleMapsKey
+ * 2) process.env.NEXT_PUBLIC_GOOGLE_MAPS_KEY
+ */
+export declare function useGoogleMapsKey(): string | undefined;

package/dist/hooks/useGoogleMapsKey.js

@@ -0,0 +1,16 @@
+'use client';
+import { useMemo } from 'react';
+import { useSelector } from 'react-redux';
+const pick = (s) => (s && s.trim() ? s.trim() : undefined);
+/** Priority:
+ * 1) Redux: s.nextMin.system.googleMapsKey
+ * 2) process.env.NEXT_PUBLIC_GOOGLE_MAPS_KEY
+ */
+export function useGoogleMapsKey() {
+    const system = useSelector((s) => s?.nextMin?.system);
+    return useMemo(() => {
+        const fromSystem = pick(system?.googleMapsKey);
+        const fromEnv = pick(process.env.NEXT_PUBLIC_GOOGLE_MAPS_KEY);
+        return fromSystem ?? fromEnv;
+    }, [system]);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './providers/NextMinProvider';
+export * from './components/AdminApp';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './providers/NextMinProvider';
+export * from './components/AdminApp';

package/dist/lib/api.d.ts

@@ -0,0 +1,31 @@
+import { ApiItemResponse, ApiListResponse } from './types';
+export declare class ApiError extends Error {
+    status: number;
+    info?: unknown;
+    constructor(message: string, status: number, info?: unknown);
+}
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type FetchOpts = {
+    method?: HttpMethod;
+    body?: unknown;
+    token?: string | null;
+    json?: boolean;
+    auth?: boolean;
+};
+declare function request<T>(path: string, opts?: FetchOpts): Promise<T>;
+export type ListParams = {
+    q?: string;
+    searchKey?: string;
+    dateFrom?: string;
+    dateTo?: string;
+    dateKey?: string;
+};
+export declare const api: {
+    getSchemas: () => Promise<unknown>;
+    list: <T>(modelName: string, page?: number, limit?: number, params?: ListParams) => Promise<ApiListResponse<T>>;
+    get: <T>(modelName: string, id: string) => Promise<ApiItemResponse<T>>;
+    create: <T>(modelName: string, data: unknown) => Promise<ApiItemResponse<T>>;
+    update: <T>(modelName: string, id: string, data: unknown) => Promise<ApiItemResponse<T>>;
+    remove: <T>(modelName: string, id: string) => Promise<ApiItemResponse<T>>;
+};
+export { request };

package/dist/lib/api.js

@@ -0,0 +1,94 @@
+const RAW_API = process.env.NEXT_PUBLIC_NEXTMIN_API_URL ?? 'http://localhost:8081/rest';
+const API_KEY = process.env.NEXT_PUBLIC_NEXTMIN_API_KEY ?? '';
+function normalizeBase(base) {
+    return base.replace(/\/+$/, '');
+}
+const API_BASE = normalizeBase(RAW_API);
+export class ApiError extends Error {
+    constructor(message, status, info) {
+        super(message);
+        this.name = 'ApiError';
+        this.status = status;
+        this.info = info;
+    }
+}
+function tokenFromStorage() {
+    try {
+        if (typeof window === 'undefined')
+            return null;
+        return localStorage.getItem('nextmin.token');
+    }
+    catch {
+        return null;
+    }
+}
+function modelPath(modelName) {
+    return modelName.toLowerCase() === 'user' ? '/auth/user' : `/${modelName}`;
+}
+async function request(path, opts = {}) {
+    const { method = 'GET', body, token, json = true, auth = true } = opts;
+    const headers = { 'x-api-key': API_KEY };
+    if (json)
+        headers['Content-Type'] = 'application/json';
+    const bearer = token ?? tokenFromStorage();
+    if (auth && bearer)
+        headers.Authorization = `Bearer ${bearer}`;
+    const res = await fetch(`${API_BASE}${path}`, {
+        method,
+        headers,
+        body: body && json ? JSON.stringify(body) : body,
+    });
+    const raw = await res.text();
+    let payload = {};
+    try {
+        payload = raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        payload = raw || {};
+    }
+    if (!res.ok) {
+        const status = res.status;
+        const serverMsg = payload?.message ??
+            payload?.error ??
+            res.statusText;
+        // Normalize common auth/permission errors for the UI
+        if (status === 401)
+            throw new ApiError('Not authenticated', 401, payload);
+        if (status === 403)
+            throw new ApiError('Not permitted', 403, payload);
+        throw new ApiError(typeof serverMsg === 'string' && serverMsg.trim()
+            ? serverMsg
+            : 'API error', status, payload);
+    }
+    return payload;
+}
+function qs(params) {
+    const sp = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+        if (v === undefined || v === null)
+            continue;
+        const s = String(v);
+        if (s.trim() === '')
+            continue;
+        sp.append(k, s);
+    }
+    const q = sp.toString();
+    return q ? `?${q}` : '';
+}
+export const api = {
+    getSchemas: () => request('/_schemas'),
+    list: (modelName, page = 0, limit = 10, params = {}) => request(`${modelPath(modelName)}${qs({ page, limit, ...params })}`),
+    get: (modelName, id) => request(`${modelPath(modelName)}/${id}`),
+    create: (modelName, data) => request(modelPath(modelName), {
+        method: 'POST',
+        body: data,
+    }),
+    update: (modelName, id, data) => request(`${modelPath(modelName)}/${id}`, {
+        method: 'PUT',
+        body: data,
+    }),
+    remove: (modelName, id) => request(`${modelPath(modelName)}/${id}`, {
+        method: 'DELETE',
+    }),
+};
+export { request };

package/dist/lib/auth.d.ts

@@ -0,0 +1,23 @@
+export type LoginPayload = {
+    email: string;
+    password: string;
+};
+export type RegisterPayload = {
+    name: string;
+    email: string;
+    password: string;
+    role?: string;
+};
+export declare function login({ email, password }: LoginPayload): Promise<{
+    token: string;
+    user: any;
+}>;
+export declare function register(payload: RegisterPayload, token?: string): Promise<{
+    success?: boolean;
+    message?: string;
+    data?: any;
+}>;
+export declare function requestPasswordReset(email: string): Promise<{
+    success?: boolean;
+    message?: string;
+}>;

package/dist/lib/auth.js

@@ -0,0 +1,51 @@
+import { request } from './api';
+function normalizeRole(value) {
+    try {
+        if (!value)
+            return null;
+        if (typeof value === 'string')
+            return value.toLowerCase();
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                const n = typeof v === 'string' ? v : (v && typeof v === 'object' && typeof v.name === 'string' ? v.name : null);
+                if (n)
+                    return String(n).toLowerCase();
+            }
+            return null;
+        }
+        if (typeof value === 'object' && typeof value.name === 'string') {
+            return String(value.name).toLowerCase();
+        }
+    }
+    catch { }
+    return null;
+}
+export async function login({ email, password }) {
+    const payload = { email: String(email || '').trim().toLowerCase(), password };
+    const res = await request('/auth/users/login', { method: 'POST', body: payload, auth: false });
+    const data = res?.data ?? res;
+    const token = data?.token;
+    const user = data?.user;
+    if (!token || !user) {
+        throw new Error(res?.message || 'Login failed');
+    }
+    // Enforce admin-only access here (superadmin/admin)
+    const role = normalizeRole(user?.role);
+    if (role !== 'admin' && role !== 'superadmin') {
+        throw new Error('You are not authorized to access the admin panel');
+    }
+    return { token, user };
+}
+export async function register(payload, token) {
+    // Not used in Admin, but keep for API parity. Use request() client.
+    const res = await request('/auth/users/register', { method: 'POST', body: payload, auth: false });
+    if (res?.error)
+        throw new Error(res?.message || 'Registration failed');
+    return res;
+}
+export async function requestPasswordReset(email) {
+    const res = await request('/auth/users/forgot-password', { method: 'POST', body: { email }, auth: false });
+    if (res?.error)
+        throw new Error(res?.message || 'Reset request failed');
+    return res;
+}

package/dist/lib/googleLoader.d.ts

@@ -0,0 +1 @@
+export declare function loadGoogleMaps(apiKey?: string): Promise<typeof google>;

package/dist/lib/googleLoader.js

@@ -0,0 +1,25 @@
+import { Loader } from '@googlemaps/js-api-loader';
+let mapsPromise = null;
+let cachedKey = null;
+export function loadGoogleMaps(apiKey) {
+    const key = (apiKey ??
+        process.env.NEXT_PUBLIC_GOOGLE_MAPS_KEY ??
+        '').trim();
+    if (!key)
+        return Promise.reject(new Error('GOOGLE_MAPS_KEY_MISSING'));
+    if (!mapsPromise || cachedKey !== key) {
+        cachedKey = key;
+        const loader = new Loader({
+            apiKey: key,
+            version: 'weekly',
+            language: 'en',
+            region: 'BD',
+        });
+        mapsPromise = (async () => {
+            (await loader.importLibrary('core'));
+            (await loader.importLibrary('places'));
+            return window.google;
+        })();
+    }
+    return mapsPromise;
+}

package/dist/lib/schemaService.d.ts

@@ -0,0 +1,2 @@
+import { type Socket } from 'socket.io-client';
+export declare function getSchemaService(): Socket | null;

package/dist/lib/schemaService.js

@@ -0,0 +1,39 @@
+import { Manager, } from 'socket.io-client';
+const SOCKET_PATH = '/__nextmin__/schema';
+const NAMESPACE = '/schema';
+let schemaSocket = null;
+export function getSchemaService() {
+    if (typeof window === 'undefined')
+        return null; // SSR guard
+    const urlStr = process.env.NEXT_PUBLIC_NEXTMIN_API_URL || 'http://localhost:8081/rest';
+    let origin = 'http://localhost:8081';
+    try {
+        const u = new URL(urlStr);
+        origin = u.origin;
+    }
+    catch {
+        // keep default
+    }
+    // Keep a single Manager across HMR / route changes
+    const MGR_KEY = '__NM_SCHEMA_MGR__';
+    let mgr = window[MGR_KEY];
+    if (!mgr) {
+        const mgrOpts = {
+            path: SOCKET_PATH,
+            transports: ['websocket'], // avoid polling aborts on nav
+            reconnection: true,
+            reconnectionAttempts: Infinity,
+            reconnectionDelay: 500,
+            reconnectionDelayMax: 4000,
+        };
+        mgr = new Manager(origin, mgrOpts);
+        window[MGR_KEY] = mgr;
+    }
+    if (!schemaSocket) {
+        const sockOpts = {
+            auth: { apiKey: process.env.NEXT_PUBLIC_NEXTMIN_API_KEY || '' }, // <-- auth goes here
+        };
+        schemaSocket = mgr.socket(NAMESPACE, sockOpts);
+    }
+    return schemaSocket;
+}

package/dist/lib/schemaUtils.d.ts

@@ -0,0 +1,4 @@
+import { Attribute, ArrayAttribute } from './types';
+export declare function isArrayAttr(attr: Attribute): attr is ArrayAttribute;
+export declare function isRef(attr: Attribute): boolean;
+export declare function inputTypeFor(attr: Attribute): 'text' | 'number' | 'checkbox' | 'textarea';

package/dist/lib/schemaUtils.js

@@ -0,0 +1,18 @@
+export function isArrayAttr(attr) {
+    return Array.isArray(attr);
+}
+export function isRef(attr) {
+    return isArrayAttr(attr) ? attr.some((a) => !!a.ref) : !!attr.ref;
+}
+export function inputTypeFor(attr) {
+    const a = isArrayAttr(attr) ? attr[0] : attr;
+    if (!a)
+        return 'text';
+    if (a.type === 'number')
+        return 'number';
+    if (a.type === 'boolean')
+        return 'checkbox';
+    if (a.longtext)
+        return 'textarea';
+    return 'text';
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,50 @@
+export type AttributeBase = {
+    type: string;
+    required?: boolean;
+    unique?: boolean;
+    private?: boolean;
+    ref?: string;
+    longtext?: boolean;
+    show?: string;
+};
+export type ArrayAttribute = AttributeBase[];
+export type Attribute = AttributeBase | ArrayAttribute;
+export type SchemaDef = {
+    modelName: string;
+    attributes: Record<string, Attribute>;
+    allowedMethods: {
+        create?: boolean;
+        read?: boolean;
+        update?: boolean;
+        delete?: boolean;
+    };
+};
+export type SchemasResponse = {
+    success: true;
+    data: SchemaDef[];
+};
+export type ApiListResponse<T> = {
+    success: boolean;
+    data: T[];
+    pagination?: {
+        totalRows: number;
+        page: number;
+        limit: number;
+    };
+    message?: string;
+};
+export type ApiItemResponse<T> = {
+    success: boolean;
+    data: T;
+    message?: string;
+};
+export type LatLng = {
+    lat: number;
+    lng: number;
+};
+export type AddressAttribute = Attribute & {
+    format?: 'address';
+    populate?: string;
+    countryCodes?: string[];
+    limit?: number;
+};

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};