@airoom/nextmin-react 0.1.0

package/LICENSE

@@ -0,0 +1,49 @@
+Nextmin Proprietary License v1.0
+
+Copyright (c) 2025 GSCodes
+All rights reserved.
+
+1. Definitions
+“Software” means the package and all accompanying files under the package name(s) @airoom/nextmin-react and @airoom/nextmin-node, including any updates provided by Licensor.
+“Licensor” means GSCodes.
+“Licensee” means the person or entity that obtains the Software.
+
+2. Grant of License
+Subject to full compliance with this License, Licensor grants Licensee a limited, non-exclusive, non-transferable, non-sublicensable license to:
+  a) install and use the Software internally, solely for evaluating or running Licensee’s own applications; and
+  b) make a reasonable number of copies solely for internal backup and archival purposes.
+
+3. Restrictions
+Except as expressly permitted in Section 2, Licensee must NOT:
+  a) copy, publish, distribute, sell, rent, lease, lend, sublicense, or otherwise make the Software available to any third party;
+  b) modify, translate, adapt, create derivative works of, or merge the Software with other software;
+  c) reverse engineer, decompile, disassemble, or otherwise attempt to derive source code or underlying ideas, except to the extent such restrictions are expressly prohibited by applicable law;
+  d) remove, obscure, or alter any proprietary notices or markings; or
+  e) use the Software to train, fine-tune, or improve any artificial intelligence or machine learning model.
+
+4. Ownership
+The Software is licensed, not sold. Licensor retains all right, title, and interest in and to the Software, including all intellectual property rights and all copies.
+
+5. Confidentiality
+The Software and any non-public information provided by Licensor shall be treated as confidential and not disclosed to any third party without Licensor’s prior written consent, except as required by law.
+
+6. Term and Termination
+This License is effective until terminated. Licensor may terminate this License immediately upon notice if Licensee breaches any term. Upon termination, Licensee must cease all use and destroy all copies of the Software. Sections 3–10 survive termination.
+
+7. Updates; No Support Obligation
+Licensor may, but is not obligated to, provide updates, bug fixes, or support. Any updates are governed by this License unless accompanied by a different license.
+
+8. No Warranty
+THE SOFTWARE IS PROVIDED “AS IS” AND “AS AVAILABLE,” WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT. USE IS AT LICENSEE’S SOLE RISK.
+
+9. Limitation of Liability
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL LICENSOR BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES, OR FOR ANY LOSS OF PROFITS, REVENUE, DATA, GOODWILL, OR BUSINESS INTERRUPTION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. LICENSOR’S TOTAL LIABILITY FOR ALL CLAIMS SHALL NOT EXCEED THE AMOUNT PAID BY LICENSEE FOR THE SOFTWARE (IF ANY) IN THE TWELVE (12) MONTHS PRECEDING THE CLAIM.
+
+10. Governing Law; Venue
+This License is governed by the laws of State of California, USA, without regard to its conflict of laws principles. The parties submit to the exclusive jurisdiction and venue of the courts located in San Francisco County, California, USA.
+
+11. Commercial Licensing
+For commercial use, redistribution, or other rights not expressly granted, contact: tareqaziz0065@gmail.com.
+
+12. Entire Agreement
+This License constitutes the entire agreement with respect to the Software and supersedes all prior or contemporaneous agreements or understandings on the subject matter.

package/README.md

@@ -0,0 +1,133 @@
+# @airoom/nextmin-react
+
+Plug‑and‑play React Admin Panel that connects to a `@airoom/nextmin-node` backend. Render an authenticated dashboard with lists, forms, file uploads, settings, and live updates — generated from your JSON schemas.
+
+- “From JSON schema to REST API + Admin”
+- 1 month → 1 hour
+- Works out of the box with Next.js (App Router and Pages Router)
+
+## Features
+
+- `<NextMinProvider>`: initializes store, loads schemas, and opens a live socket
+- `<AdminApp>`: full admin shell with auth, sidebar, dashboard, list/create/edit, profile, settings
+- Built‑in router: `<NextMinRouter>` and `<AdminRouteNormalizer>` for admin routes
+- Components: Sidebar, SchemaForm, FileUploader, reference selectors, phone/password inputs, table & filters
+- Hooks/utils: Google address autocomplete, list data helpers, formatters
+- Styling included; no extra CSS import needed
+
+## Installation
+
+```bash
+# npm
+npm install @airoom/nextmin-react
+
+# yarn
+yarn add @airoom/nextmin-react
+
+# pnpm
+pnpm add @airoom/nextmin-react
+```
+
+## Configure environment
+
+Create or update your frontend env file (e.g., `.env.local`) with the server base URL and client API key:
+
+```env
+NEXT_PUBLIC_NEXTMIN_API_URL=http://localhost:8081/rest
+# IMPORTANT: Use the API key stored in your database → Settings.apiKey
+NEXT_PUBLIC_NEXTMIN_API_KEY=your_api_key_here
+```
+
+Notes
+
+- `NEXT_PUBLIC_NEXTMIN_API_URL` should point to your nextmin-node REST base (e.g., http://host:port/rest)
+- `NEXT_PUBLIC_NEXTMIN_API_KEY` must match the value in your backend DB Settings document’s `apiKey` field
+
+Where to find the API key
+
+- Start your nextmin-node server once
+- Open the database and locate the Settings collection/table
+- Copy the first Settings document’s `apiKey` value and paste it here
+
+## Next.js setup (App Router)
+
+Wrap only the admin area with the provider and render the AdminApp. Mark these files as client components.
+
+```tsx
+// app/admin/layout.tsx
+'use client'
+import { NextMinProvider } from '@airoom/nextmin-react';
+
+export default function AdminLayout({ children }: { children: React.ReactNode }) {
+  return <NextMinProvider>{children}</NextMinProvider>;
+}
+```
+
+```tsx
+// app/admin/page.tsx
+'use client'
+import { AdminApp } from '@airoom/nextmin-react';
+export default function AdminIndex() {
+  return <AdminApp />;
+}
+```
+
+```tsx
+// app/admin/[...slug]/page.tsx
+'use client'
+import { AdminApp } from '@airoom/nextmin-react';
+export default function AdminCatchAll() {
+  return <AdminApp />;
+}
+```
+
+Behavior
+
+- Unauthenticated users are redirected to `/admin/auth/sign-in`
+- Authenticated users visiting `/admin/auth/*` are redirected to `/admin/dashboard`
+- Sidebar and pages are rendered according to the schemas loaded from your backend
+
+Pages Router (alternative)
+
+```tsx
+// pages/admin.tsx
+import dynamic from 'next/dynamic';
+const Admin = dynamic(() => import('@airoom/nextmin-react').then(m => m.AdminApp), { ssr: false });
+export default Admin;
+```
+
+Wrap with `<NextMinProvider>` at a top level where appropriate (e.g., `_app.tsx`) and ensure it runs on the client.
+
+## Default admin credentials (after setup)
+
+After completing the backend setup, sign in with the default super user and change the password immediately:
+
+- Email: super@example.com
+- Username: superadmin
+- Password: supersecurepassword
+
+## Usage notes
+
+- No extra CSS import required; the package bundles its styles
+- Backend auth/paths are configured via env vars (see above)
+- Add custom links to routes like `/admin/<model>/create` or `/admin/<model>/<id>`
+- The first Settings document (model name "Settings") controls site name, logo, and Google Maps key for address autocomplete
+
+## TypeScript
+
+Types are bundled with the package.
+
+```ts
+import type { ApiItemResponse } from '@airoom/nextmin-react/types';
+```
+
+## Troubleshooting
+
+- 401 Unauthorized: ensure `NEXT_PUBLIC_NEXTMIN_API_KEY` matches your DB `Settings.apiKey`
+- Cannot load schemas: verify `NEXT_PUBLIC_NEXTMIN_API_URL` points to `/rest` and the backend is reachable
+- Address autocomplete: set `NEXT_PUBLIC_GOOGLE_MAPS_KEY` in your environment and in the Settings document if applicable
+- Blank page on Next.js: ensure admin files are client components (`'use client'`) and dynamic imports have `ssr: false` where necessary
+
+## License
+
+Licensed under the Nextmin Proprietary License. © 2025 GSCodes. For commercial licensing or extended rights, contact: tareqaziz0065@gmail.com.

package/dist/auth/AuthPage.d.ts

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

package/dist/auth/AuthPage.js

@@ -0,0 +1,23 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { usePathname, useRouter } from 'next/navigation';
+import { useSelector } from 'react-redux';
+import { SignInForm } from './SignInForm';
+import { ForgotPasswordForm } from './ForgotPasswordForm';
+export function AuthPage() {
+    const pathname = usePathname();
+    const router = useRouter();
+    const token = useSelector((s) => s?.session?.token ?? null);
+    // If already authenticated on /admin/auth/* → go to dashboard
+    useEffect(() => {
+        if (token && pathname?.startsWith('/admin/auth')) {
+            router.replace('/admin/dashboard');
+        }
+    }, [token, pathname, router]);
+    if (pathname?.startsWith('/admin/auth/forgot-password')) {
+        return _jsx(ForgotPasswordForm, {});
+    }
+    // Default = Sign in; SignInForm already stores token+user and updates Redux.
+    return _jsx(SignInForm, { onSuccess: () => router.replace('/admin/dashboard') });
+}

package/dist/auth/ForgotPasswordForm.d.ts

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

package/dist/auth/ForgotPasswordForm.js

@@ -0,0 +1,28 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Card, CardHeader, CardBody, Input, Button, Link, Form, } from '@heroui/react';
+import { requestPasswordReset } from '../lib/auth';
+export function ForgotPasswordForm() {
+    const [loading, setLoading] = useState(false);
+    const [msg, setMsg] = useState(null);
+    const [err, setErr] = useState(null);
+    async function submit(formData) {
+        setErr(null);
+        setMsg(null);
+        setLoading(true);
+        try {
+            await requestPasswordReset(String(formData.get('email') || ''));
+            setMsg('If an account exists, reset instructions have been sent.');
+        }
+        catch (e) {
+            setErr(e?.message || 'Request failed');
+        }
+        finally {
+            setLoading(false);
+        }
+    }
+    return (_jsx("div", { className: "min-h-[100dvh] grid place-items-center p-6 bg-default-50", children: _jsxs(Card, { className: "w-full max-w-md rounded-2xl shadow-lg border border-default-200", children: [_jsxs(CardHeader, { className: "flex flex-col items-center text-center gap-1 pt-6 pb-0", children: [_jsx("h1", { className: "text-3xl font-bold tracking-tight", children: "Reset password" }), _jsx("p", { className: "text-small text-foreground/60", children: "Enter your email to receive a reset link" })] }), _jsx(CardBody, { className: "gap-5 mt-4", children: _jsxs(Form, { className: "flex flex-col gap-4", 
+                        // @ts-ignore
+                        onSubmit: submit, validationBehavior: "native", children: [_jsx(Input, { variant: "bordered", name: "email", type: "email", label: "Email", labelPlacement: "outside", placeholder: "name@example.com", isRequired: true, autoComplete: "email" }), msg && _jsx("p", { className: "text-sm text-success", children: msg }), err && _jsx("p", { className: "text-sm text-danger", children: err }), _jsx(Button, { type: "submit", isLoading: loading, className: "w-full bg-[#0a35ff] text-white", children: "Send reset link" }), _jsx("p", { className: "text-sm text-center text-foreground/70", children: _jsx(Link, { href: "/admin/auth/sign-in", children: "Back to sign in" }) })] }) })] }) }));
+}

package/dist/auth/SignInForm.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type SignInFormProps = {
+    onSuccess?: (token: string, user: any) => void;
+};
+export declare function SignInForm({ onSuccess }: SignInFormProps): React.ReactElement;
+export {};

package/dist/auth/SignInForm.js

@@ -0,0 +1,38 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Card, CardHeader, CardBody, Input, Button, Link, Form, } from '@heroui/react';
+import { useDispatch } from 'react-redux';
+import { setSession } from '../state/sessionSlice';
+import { login as loginApi } from '../lib/auth';
+export function SignInForm({ onSuccess }) {
+    const [loading, setLoading] = useState(false);
+    const [err, setErr] = useState(null);
+    const dispatch = useDispatch();
+    async function doLogin(email, password) {
+        return loginApi({ email, password });
+    }
+    return (_jsx("div", { className: "min-h-[100dvh] grid place-items-center p-6 bg-default-50", children: _jsxs(Card, { className: "w-full max-w-md rounded-2xl shadow-lg border border-default-200", children: [_jsxs(CardHeader, { className: "flex flex-col items-center text-center gap-1 pt-6 pb-0", children: [_jsx("h1", { className: "text-3xl font-bold tracking-tight", children: "Welcome back" }), _jsx("p", { className: "text-small text-foreground/60", children: "Sign in to your account" })] }), _jsx(CardBody, { className: "gap-5 mt-4", children: _jsxs(Form, { className: "flex flex-col gap-4", validationBehavior: "native", onSubmit: async (e) => {
+                            e.preventDefault();
+                            setErr(null);
+                            setLoading(true);
+                            const form = new FormData(e.currentTarget);
+                            const email = String(form.get('email') ?? '');
+                            const password = String(form.get('password') ?? '');
+                            try {
+                                const { token, user } = await doLogin(email, password);
+                                // persist + redux
+                                localStorage.setItem('nextmin.token', token);
+                                localStorage.setItem('nextmin.user', JSON.stringify(user));
+                                dispatch(setSession({ token, user }));
+                                // optional callback
+                                onSuccess?.(token, user);
+                            }
+                            catch (er) {
+                                setErr(er?.message || 'Invalid credentials');
+                            }
+                            finally {
+                                setLoading(false);
+                            }
+                        }, children: [_jsx(Input, { isRequired: true, variant: "bordered", label: "Email", labelPlacement: "outside", name: "email", placeholder: "Email", type: "email", autoComplete: "email" }), _jsx(Input, { isRequired: true, variant: "bordered", label: "Password", labelPlacement: "outside", name: "password", placeholder: "Password", type: "password", autoComplete: "current-password" }), err && _jsx("p", { className: "text-sm text-danger", children: err }), _jsx("div", { className: "flex items-center justify-start", children: _jsx(Link, { href: "/admin/auth/forgot-password", className: "text-sm", children: "Forgot Password?" }) }), _jsx(Button, { type: "submit", isLoading: loading, className: "w-full bg-[#0a35ff] text-white", children: "Continue" })] }) })] }) }));
+}

package/dist/auth/SignUpForm.d.ts

@@ -0,0 +1,3 @@
+export declare function SignUpForm({ onSuccess }: {
+    onSuccess?: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/auth/SignUpForm.js

@@ -0,0 +1,30 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Card, CardHeader, CardBody, Input, Button, Checkbox, Link, Form, } from '@heroui/react';
+import { register } from '../lib/auth';
+export function SignUpForm({ onSuccess }) {
+    const [loading, setLoading] = useState(false);
+    const [err, setErr] = useState(null);
+    async function submit(formData) {
+        setErr(null);
+        setLoading(true);
+        try {
+            await register({
+                name: String(formData.get('name') || ''),
+                email: String(formData.get('email') || ''),
+                password: String(formData.get('password') || ''),
+            });
+            onSuccess?.();
+        }
+        catch (e) {
+            setErr(e?.message || 'Registration failed');
+        }
+        finally {
+            setLoading(false);
+        }
+    }
+    return (_jsx("div", { className: "min-h-[100dvh] grid place-items-center p-6", children: _jsxs(Card, { className: "w-full max-w-md", children: [_jsxs(CardHeader, { className: "pb-0", children: [_jsx("h1", { className: "text-2xl font-semibold", children: "Create account" }), _jsx("p", { className: "text-sm text-foreground/70", children: "Start your journey" })] }), _jsx(CardBody, { className: "gap-4 mt-4", children: _jsxs(Form, { className: "flex flex-col gap-4", 
+                        // @ts-ignore
+                        onSubmit: submit, validationBehavior: "native", children: [_jsx(Input, { variant: "bordered", name: "name", label: "Full Name", isRequired: true, autoComplete: "name" }), _jsx(Input, { variant: "bordered", name: "email", type: "email", label: "Email", isRequired: true, autoComplete: "email" }), _jsx(Input, { variant: "bordered", name: "password", type: "password", label: "Password", isRequired: true, autoComplete: "new-password" }), err && _jsx("p", { className: "text-sm text-danger", children: err }), _jsxs(Checkbox, { required: true, children: ["I agree to the", ' ', _jsx(Link, { href: "/legal/terms", target: "_blank", children: "Terms" }), ' ', "\u00A0and\u00A0", _jsx(Link, { href: "/legal/privacy", target: "_blank", children: "Privacy Policy" })] }), _jsx(Button, { type: "submit", color: "primary", isLoading: loading, children: "Create account" }), _jsxs("p", { className: "text-sm text-center text-foreground/70", children: ["Already have an account? ", _jsx(Link, { href: "/auth/sign-in", children: "Sign in" })] })] }) })] }) }));
+}

package/dist/components/AddressAutocomplete.d.ts

@@ -0,0 +1,21 @@
+export type LatLng = {
+    lat: number;
+    lng: number;
+};
+export type AddressAutocompleteGoogleProps = {
+    name: string;
+    label?: string;
+    description?: string;
+    value: string;
+    onChange: (address: string, latlng?: LatLng) => void;
+    disabled?: boolean;
+    required?: boolean;
+    className?: string;
+    classNames?: {
+        inputWrapper?: string;
+    };
+    countryCodes?: string[];
+    limit?: number;
+    apiKey?: string;
+};
+export default function AddressAutocompleteGoogle({ name, label, description, value, onChange, disabled, required, className, classNames, countryCodes, limit, apiKey, }: AddressAutocompleteGoogleProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/AddressAutocomplete.js

@@ -0,0 +1,182 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { Autocomplete, AutocompleteItem } from '@heroui/react';
+import { loadGoogleMaps } from '../lib/googleLoader';
+function deriveStableKey(s) {
+    const pid = s?.placePrediction?.placeId ??
+        s?.placePrediction?.id ??
+        s?.place_id ??
+        s?.id ??
+        null;
+    const label = s?.placePrediction?.text?.toString?.();
+    return pid ? String(pid) : label ? String(label) : null;
+}
+export default function AddressAutocompleteGoogle({ name, label, description, value, onChange, disabled, required, className, classNames, countryCodes, limit = 8, apiKey, }) {
+    // Controlled input
+    const [q, setQ] = useState(value ?? '');
+    useEffect(() => {
+        if ((value ?? '') !== q)
+            setQ(value ?? '');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [value]);
+    const [items, setItems] = useState([]);
+    const [keyMissing, setKeyMissing] = useState(false);
+    // Google + guards
+    const tokenRef = useRef(null);
+    const suppressFetchRef = useRef(false);
+    const fetchGenRef = useRef(0);
+    // Clears
+    const manualClearRef = useRef(false);
+    const locationRestriction = useMemo(() => {
+        const cc = (countryCodes?.[0] ?? '').toLowerCase();
+        if (cc === 'bd' || !cc)
+            return { west: 88.008, south: 20.67, east: 92.68, north: 26.634 };
+        return undefined;
+    }, [countryCodes]);
+    // Load Google once (and on key change)
+    useEffect(() => {
+        (async () => {
+            try {
+                const g = await loadGoogleMaps(apiKey);
+                tokenRef.current = new g.maps.places.AutocompleteSessionToken();
+                setKeyMissing(false);
+            }
+            catch {
+                setKeyMissing(true);
+            }
+        })();
+    }, [apiKey]);
+    if (!apiKey || !apiKey.trim()) {
+        return (_jsxs("div", { className: "text-danger text-xs", children: ["Google Maps API key is missing. Set ", _jsx("b", { children: "system.googleMapsKey" }), " or define ", _jsx("b", { children: "NEXT_PUBLIC_GOOGLE_MAPS_KEY" }), "."] }));
+    }
+    if (keyMissing) {
+        return (_jsxs("div", { className: "text-danger text-xs", children: ["Google Maps API key is missing or invalid. Set", ' ', _jsx("b", { children: "system.googleMapsKey" }), " or ", _jsx("b", { children: "NEXT_PUBLIC_GOOGLE_MAPS_KEY" }), "."] }));
+    }
+    // Debounced suggestions fetch (Places API New)
+    useEffect(() => {
+        if (suppressFetchRef.current)
+            return;
+        const trimmed = (q ?? '').trim();
+        if (!trimmed || trimmed.length < 3) {
+            setItems([]);
+            return;
+        }
+        let cancelled = false;
+        const myGen = ++fetchGenRef.current;
+        const run = async () => {
+            try {
+                const g = await loadGoogleMaps(apiKey);
+                const req = {
+                    input: trimmed,
+                    sessionToken: tokenRef.current,
+                    language: 'en',
+                    region: (countryCodes?.[0] ?? 'bd').toLowerCase(),
+                };
+                if (locationRestriction)
+                    req.locationRestriction = locationRestriction;
+                const { suggestions } = await g.maps.places.AutocompleteSuggestion.fetchAutocompleteSuggestions(req);
+                if (cancelled || myGen !== fetchGenRef.current)
+                    return;
+                const list = (suggestions ??
+                    []);
+                const mapped = list
+                    .slice(0, Math.max(1, limit))
+                    .map((s) => {
+                    const key = deriveStableKey(s);
+                    const label = s.placePrediction?.text?.toString?.() ?? '';
+                    return key && label ? { key, label, raw: s } : null;
+                })
+                    .filter((r) => !!r);
+                setItems(mapped);
+            }
+            catch {
+                setItems([]);
+            }
+        };
+        const t = setTimeout(run, 250);
+        return () => {
+            cancelled = true;
+            clearTimeout(t);
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [q, apiKey, countryCodes, locationRestriction, limit]);
+    const getLatLng = (loc) => {
+        if (!loc)
+            return null;
+        if (typeof loc.lat === 'function' && typeof loc.lng === 'function')
+            return { lat: loc.lat(), lng: loc.lng() };
+        if (typeof loc.lat === 'number' && typeof loc.lng === 'number')
+            return { lat: loc.lat, lng: loc.lng };
+        return null;
+    };
+    // Resolve and commit
+    const resolveByKey = async (key) => {
+        const rec = items.find((r) => r.key === key);
+        if (!rec)
+            return;
+        suppressFetchRef.current = true;
+        // Show EXACT suggestion text immediately, and keep it
+        const label = rec.label;
+        setQ(label);
+        setItems([]);
+        try {
+            const g = await loadGoogleMaps(apiKey);
+            const pp = rec.raw.placePrediction;
+            if (!pp)
+                return;
+            const place = pp.toPlace();
+            await place.fetchFields({
+                fields: ['location'], // we only need lat/lng; do NOT fetch formattedAddress
+                sessionToken: tokenRef.current ?? undefined,
+            });
+            const ll = getLatLng(place.location);
+            // Always commit the SUGGESTION TEXT to the form; populate latLng when available
+            onChange(label, ll ?? undefined);
+            // fresh session
+            tokenRef.current = new g.maps.places.AutocompleteSessionToken();
+        }
+        finally {
+            suppressFetchRef.current = false;
+        }
+    };
+    // Normalize HeroUI selection payload
+    function extractKey(sel) {
+        if (sel === null || sel === undefined || sel === 'all')
+            return null;
+        if (sel instanceof Set) {
+            const first = sel.values().next().value;
+            return first != null ? String(first) : null;
+        }
+        return String(sel);
+    }
+    return (_jsx("div", { className: className, children: _jsx(Autocomplete, { "aria-label": label ?? name, label: label, labelPlacement: "outside", placeholder: "Type address", name: name, isRequired: required, description: description, variant: "bordered", classNames: classNames, isDisabled: disabled, items: items, inputValue: q, isClearable: true, onClear: () => {
+                manualClearRef.current = true;
+                setQ('');
+                setItems([]);
+                onChange('', undefined);
+            }, onKeyDown: (e) => {
+                if ((e.key === 'Backspace' || e.key === 'Delete') && q.length <= 1) {
+                    manualClearRef.current = true;
+                }
+            }, onInputChange: (text) => {
+                if (text == null)
+                    return;
+                const trimmed = text.trim();
+                // Ignore blur-initiated clears unless it was a real manual clear
+                if (trimmed === '' && !manualClearRef.current)
+                    return;
+                if (trimmed === '' && manualClearRef.current) {
+                    manualClearRef.current = false;
+                    setQ('');
+                    setItems([]);
+                    return;
+                }
+                if (text !== q)
+                    setQ(text);
+            }, onSelectionChange: (sel) => {
+                const key = extractKey(sel);
+                if (key)
+                    void resolveByKey(key);
+            }, children: (item) => (_jsx(AutocompleteItem, { textValue: item.label, children: item.label }, item.key)) }) }));
+}

package/dist/components/AdminApp.d.ts

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