@sincpro/mobile-ui 0.1.2 → 0.1.4

package/lib/utils/date.js

@@ -0,0 +1,126 @@
+import dayjs from "dayjs";
+import timezone from "dayjs/plugin/timezone";
+import utc from "dayjs/plugin/utc";
+import { getLocales } from "expo-localization";
+const DEFAULT_TIMEZONE = "America/Costa_Rica";
+const DEFAULT_LOCALE = "es-CR";
+dayjs.extend(utc);
+dayjs.extend(timezone);
+/**
+ * Formatea una fecha en la zona horaria indicada respetando la granularidad de la entrada.
+ *
+ * Reglas de detección:
+ * 1. Si `input` es un string 'YYYY-MM-DD' (solo fecha) => se interpreta como medianoche (00:00:00)
+ *    en la zona horaria destino y se devuelve SOLO la parte de fecha (sin hora).
+ * 2. Si `input` incluye componente de tiempo (ISO completo o Date) => se convierte a la zona destino
+ *    y se muestra fecha + hora (HH:MM) salvo que se fuerce lo contrario mediante `options.showTime`.
+ * 3. Cuando `options.showTime` es `true` o `false` se sobre‑escribe la auto‑detección.
+ * 4. Si `timezone` es null/undefined o inválido se retorna la cadena "Error de formateo".
+ *
+ * Localización:
+ * - Usa el primer locale del dispositivo (`expo-localization`) como predeterminado.
+ * - Puedes forzar uno diferente con `options.locale` (ej: 'es-CR', 'en-US').
+ *
+ * Seguridad de zona horaria:
+ * - El parse de una fecha sin hora NO se hace en la zona local del dispositivo para luego convertir,
+ *   sino directamente en la zona destino para evitar corrimientos de día.
+ *
+ * Ejemplos:
+ * ```ts
+ * formatDate('2025-09-02', 'America/Costa_Rica');
+ * // => "2 de septiembre de 2025"
+ *
+ * formatDate('2025-09-02T18:30:00Z', 'America/Costa_Rica');
+ * // => "2 de septiembre de 2025, 12:30 p. m." (dependiendo del locale real)
+ *
+ * formatDate(new Date('2025-09-02T23:15:00Z'), 'Europe/Madrid');
+ * // => "3 de septiembre de 2025, 01:15" (cambio de día por zona +02)
+ *
+ * formatDate('2025-09-02', 'America/Costa_Rica', { showTime: true });
+ * // => "2 de septiembre de 2025, 12:00 a. m." (fuerza hora)
+ * ```
+ *
+ * @param input      Fecha (string ISO, 'YYYY-MM-DD' o instancia Date)
+ * @param timezone   Zona horaria IANA (ej: 'America/Costa_Rica', 'Asia/Tokyo'). Si es null/undefined usa Costa Rica
+ * @param options    Opcional: locale forzado y/o bandera para mostrar hora
+ * @returns          Cadena localizada o "Error de formateo" si no se puede procesar
+ */
+export function formatDate(input, timezone, options) {
+    // Usar timezone por defecto si no se proporciona
+    const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
+    const fallbackLocale = DEFAULT_LOCALE.split("-")[0]; // "es" from "es-CR"
+    const deviceLocale = getLocales()?.[0]?.languageTag ?? fallbackLocale;
+    const usedLocale = options?.locale ?? deviceLocale;
+    try {
+        const rawStr = typeof input === "string" ? input : input.toISOString();
+        const isDateOnly = /^\d{4}-\d{2}-\d{2}$/.test(rawStr);
+        // Auto-detect showTime si no se pasa explicitamente
+        const effectiveShowTime = options?.showTime !== undefined
+            ? options.showTime
+            : !isDateOnly && /T\d{2}:\d{2}/.test(rawStr); // tiene componente hora
+        const dateInstance = isDateOnly
+            ? dayjs.tz(`${rawStr}T00:00:00`, effectiveTimezone)
+            : dayjs.utc(rawStr).tz(effectiveTimezone);
+        const dateInZone = dateInstance.toDate();
+        const formatOptions = {
+            year: "numeric",
+            month: "long",
+            day: "numeric",
+            timeZone: effectiveTimezone,
+        };
+        if (effectiveShowTime) {
+            formatOptions.hour = "2-digit";
+            formatOptions.minute = "2-digit";
+        }
+        return new Intl.DateTimeFormat(usedLocale, formatOptions).format(dateInZone);
+    }
+    catch (error) {
+        console.warn("Error formateando fecha:", error);
+        return "Error de formateo";
+    }
+}
+/**
+ * Formatea una fecha usando automáticamente el timezone por defecto (Costa Rica).
+ * Útil para casos donde no se tiene acceso al timezone del usuario.
+ *
+ * @param input      Fecha (string ISO, 'YYYY-MM-DD' o instancia Date)
+ * @param options    Opcional: locale forzado y/o bandera para mostrar hora
+ * @returns          Cadena localizada en timezone de Costa Rica
+ */
+export function formatDateWithDefaultTimezone(input, options) {
+    return formatDate(input, DEFAULT_TIMEZONE, options);
+}
+/**
+ * Obtiene la fecha actual en formato YYYY-MM-DD en el timezone especificado.
+ * Útil para crear fechas de programación que respeten el timezone del usuario.
+ *
+ * @param timezone Zona horaria IANA. Si es null/undefined usa Costa Rica
+ * @returns Fecha actual en formato YYYY-MM-DD en el timezone especificado
+ */
+export function getCurrentDateInTimezone(timezone) {
+    const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
+    try {
+        return dayjs().tz(effectiveTimezone).format("YYYY-MM-DD");
+    }
+    catch (error) {
+        console.warn("Error obteniendo fecha actual en timezone:", error);
+        return dayjs().format("YYYY-MM-DD"); // Fallback to local
+    }
+}
+/**
+ * Obtiene la fecha y hora actual en formato ISO en el timezone especificado.
+ * Útil para timestamps que necesiten reflejar el timezone del usuario.
+ *
+ * @param timezone Zona horaria IANA. Si es null/undefined usa Costa Rica
+ * @returns Fecha actual en formato ISO en el timezone especificado
+ */
+export function getCurrentDateTimeInTimezone(timezone) {
+    const effectiveTimezone = timezone || DEFAULT_TIMEZONE;
+    try {
+        return dayjs().tz(effectiveTimezone).toISOString();
+    }
+    catch (error) {
+        console.warn("Error obteniendo fecha/hora actual en timezone:", error);
+        return dayjs().toISOString(); // Fallback to local
+    }
+}

package/lib/utils/icon.d.ts

@@ -0,0 +1 @@
+export type IconType = "ionicons" | "fontawesome" | "material" | "fontawesome5" | "simplelineicons" | "antdesign" | "custom" | "feather" | "MaterialCommunityIcons";

package/lib/utils/icon.js

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

package/lib/utils/monetary.d.ts

@@ -0,0 +1,3 @@
+export declare function parseToMonetaryNumber(input?: string | number | null): number;
+export declare function formatTwoDecimals(value?: number | string | null): string;
+export declare function calculateDiscountedTotal(total: number, discount: number): number;

package/lib/utils/monetary.js

@@ -0,0 +1,31 @@
+import { Big } from "big.js";
+export function parseToMonetaryNumber(input) {
+    if (input == null)
+        return 0;
+    const s = String(input).trim();
+    if (!/[0-9]/.test(s))
+        return 0;
+    const cleaned = s.replace(/[^0-9.-]+/g, "");
+    try {
+        return Number(new Big(cleaned).toString());
+    }
+    catch {
+        return 0;
+    }
+}
+export function formatTwoDecimals(value) {
+    const raw = parseToMonetaryNumber(value);
+    const rounded = new Big(raw).toFixed(2);
+    const num = Number(rounded);
+    return new Intl.NumberFormat("de-DE", {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    }).format(num);
+}
+export function calculateDiscountedTotal(total, discount) {
+    if (discount === 0) {
+        return 0;
+    }
+    const result = (parseToMonetaryNumber(total) * discount) / 100;
+    return parseToMonetaryNumber(result);
+}

package/lib/utils/quantity.d.ts

@@ -0,0 +1,11 @@
+/** Redondea a la precisión indicada usando round half up */
+export declare function roundTo(value: number, precision: number): number;
+/** Normaliza la cantidad al múltiplo más cercano del incremento mínimo */
+export declare function normalizeQuantity(value: number, minIncrement: number, precision: number): number;
+/** Convierte un valor a entero escalado según precisión para cálculos seguros */
+export declare function toScaledInt(value: number, precision: number): number;
+export declare function fromScaledInt(scaled: number, precision: number): number;
+/** Multiplicación segura evitando errores binarios típicos */
+export declare function safeMul(a: number, b: number, precision: number): number;
+/** Valida si un valor es múltiplo del incremento mínimo dentro de la precisión */
+export declare function isMultipleOfIncrement(value: number, minIncrement: number, precision: number): boolean;

package/lib/utils/quantity.js

@@ -0,0 +1,44 @@
+import { Big } from "big.js";
+/** Redondea a la precisión indicada usando round half up */
+export function roundTo(value, precision) {
+    if (isNaN(value))
+        return 0;
+    const factor = new Big(10).pow(precision);
+    return Number(new Big(value).times(factor).round(0, 1).div(factor).toString());
+}
+/** Normaliza la cantidad al múltiplo más cercano del incremento mínimo */
+export function normalizeQuantity(value, minIncrement, precision) {
+    if (!isFinite(value))
+        return 0;
+    if (value < 0)
+        value = 0;
+    if (minIncrement <= 0)
+        return roundTo(value, precision);
+    const steps = Math.round(value / minIncrement);
+    const normalized = steps * minIncrement;
+    return roundTo(normalized, precision);
+}
+/** Convierte un valor a entero escalado según precisión para cálculos seguros */
+export function toScaledInt(value, precision) {
+    if (!isFinite(value))
+        return 0;
+    const factor = Math.pow(10, precision);
+    return Math.round(value * factor);
+}
+export function fromScaledInt(scaled, precision) {
+    const factor = Math.pow(10, precision);
+    return scaled / factor;
+}
+/** Multiplicación segura evitando errores binarios típicos */
+export function safeMul(a, b, precision) {
+    const factor = Math.pow(10, precision);
+    return (Math.round(a * factor) * Math.round(b * factor)) / (factor * factor);
+}
+/** Valida si un valor es múltiplo del incremento mínimo dentro de la precisión */
+export function isMultipleOfIncrement(value, minIncrement, precision) {
+    if (minIncrement <= 0)
+        return true;
+    const scaledValue = toScaledInt(value, precision + 3); // extra precisión para reducir error
+    const scaledInc = toScaledInt(minIncrement, precision + 3);
+    return scaledValue % scaledInc === 0;
+}

package/lib/utils/serializer.d.ts

@@ -0,0 +1,2 @@
+export declare function safeJsonStringify(obj: any, pretty?: boolean): string;
+export declare function safeJsonParse(json: string): any;

package/lib/utils/serializer.js

@@ -0,0 +1,44 @@
+export function safeJsonStringify(obj, pretty = false) {
+    const seen = new WeakSet();
+    if (pretty) {
+        return JSON.stringify(obj, (key, value) => {
+            if (key.startsWith("_")) {
+                return undefined;
+            }
+            if (value instanceof Map) {
+                return Object.fromEntries(value);
+            }
+            if (value instanceof Set) {
+                return Array.from(value);
+            }
+            if (typeof value === "object" && value !== null) {
+                if (seen.has(value)) {
+                    return "[Circular]";
+                }
+                seen.add(value);
+            }
+            return value;
+        }, 2);
+    }
+    return JSON.stringify(obj, (key, value) => {
+        if (key.startsWith("_")) {
+            return undefined;
+        }
+        if (value instanceof Map) {
+            return Object.fromEntries(value);
+        }
+        if (value instanceof Set) {
+            return Array.from(value);
+        }
+        if (typeof value === "object" && value !== null) {
+            if (seen.has(value)) {
+                return "[Circular]";
+            }
+            seen.add(value);
+        }
+        return value;
+    });
+}
+export function safeJsonParse(json) {
+    return JSON.parse(json);
+}

package/lib/utils/timezone.d.ts

@@ -0,0 +1,4 @@
+export interface TimezoneLocale {
+    timezone: string;
+    locale: string;
+}

package/lib/utils/timezone.js

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

package/lib/views/AuthFormView.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from "react";
+import { type ImageSourcePropType } from "react-native";
+interface AuthFormProps {
+    title?: string;
+    description?: string;
+    logoSource?: ImageSourcePropType;
+    onBack?: () => void;
+    FormNode: ReactNode;
+}
+declare function AuthFormView({ title, description, logoSource, onBack, FormNode }: AuthFormProps): import("react/jsx-runtime").JSX.Element;
+export default AuthFormView;

package/lib/views/AuthFormView.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "nativewind/jsx-runtime";
+import { Display } from "../Display";
+import AuthContainer from "../layouts/AuthContainer";
+import { Typography } from "../Typography";
+import { View } from "react-native";
+const Logo = Display.Logo;
+const Text = Typography.Text;
+function AuthFormView({ title, description, logoSource, onBack, FormNode }) {
+    const renderTitle = () => {
+        if (!title)
+            return null;
+        return (_jsx(Text, { semibold: true, variant: "h4", children: title }));
+    };
+    const renderDescription = () => {
+        if (!description)
+            return null;
+        return _jsx(Text, { variant: "body", children: description });
+    };
+    return (_jsx(AuthContainer, { header: _jsx(Logo, { size: "large", source: logoSource }), onBackPress: onBack, children: _jsxs(View, { className: "m-4", children: [_jsxs(View, { className: "mb-5", children: [renderTitle(), renderDescription()] }), FormNode] }) }));
+}
+export default AuthFormView;

package/lib/views/FormViewV2.context.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from "react";
+interface FormViewContextValue<T> {
+    name: string;
+    description?: string;
+    item: T | null;
+    isLoading: boolean;
+    isEmpty: boolean;
+    hasError: boolean;
+    errorMessage?: string;
+    readonly: boolean;
+    showRefreshing: boolean;
+    setShowRefreshing: (value: boolean) => void;
+    onRefresh?: () => Promise<void>;
+    onRetry?: () => void;
+    onBack?: () => void;
+}
+export declare function FormViewProvider<T>({ name, description, item, isLoading, isEmpty, hasError, errorMessage, readonly, onRefresh, onRetry, onBack, children, }: {
+    name: string;
+    description?: string;
+    item: T | null;
+    isLoading?: boolean;
+    isEmpty?: boolean;
+    hasError?: boolean;
+    errorMessage?: string;
+    readonly?: boolean;
+    onRefresh?: () => Promise<void>;
+    onRetry?: () => void;
+    onBack?: () => void;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useFormView<T>(): FormViewContextValue<T>;
+export {};

package/lib/views/FormViewV2.context.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "nativewind/jsx-runtime";
+import { createContext, useContext, useState } from "react";
+const Context = createContext(null);
+export function FormViewProvider({ name, description, item, isLoading = false, isEmpty = false, hasError = false, errorMessage, readonly = false, onRefresh, onRetry, onBack, children, }) {
+    const [showRefreshing, setShowRefreshing] = useState(false);
+    return (_jsx(Context.Provider, { value: {
+            name,
+            description,
+            item,
+            isLoading,
+            isEmpty,
+            hasError,
+            errorMessage,
+            readonly,
+            showRefreshing,
+            setShowRefreshing,
+            onRefresh,
+            onRetry,
+            onBack,
+        }, children: children }));
+}
+export function useFormView() {
+    const context = useContext(Context);
+    if (!context) {
+        throw new Error("useFormView must be used within FormViewV2");
+    }
+    return context;
+}

package/lib/views/FormViewV2.d.ts

@@ -0,0 +1,62 @@
+import { EVariantScreenHeader } from "../widgets/ScreenHeader";
+import { ReactNode } from "react";
+import { type ImageSourcePropType } from "react-native";
+interface FormViewProps<T> {
+    name: string;
+    description?: string;
+    item: T | null;
+    isLoading?: boolean;
+    isEmpty?: boolean;
+    hasError?: boolean;
+    errorMessage?: string;
+    readonly?: boolean;
+    onRefresh?: () => Promise<void>;
+    onRetry?: () => void;
+    onBack?: () => void;
+    withContainer?: boolean;
+    children: ReactNode;
+}
+declare function FormViewRoot<T>({ name, description, item, isLoading, isEmpty, hasError, errorMessage, readonly, onRefresh, onRetry, onBack, withContainer, children, }: FormViewProps<T>): import("react/jsx-runtime").JSX.Element;
+declare function Header({ variant, logoSource, children, }: {
+    variant?: EVariantScreenHeader;
+    logoSource?: ImageSourcePropType;
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function HeaderActions({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function HeaderActionsBar({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function Content({ withMargin, children, }: {
+    withMargin?: boolean;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function Form({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+declare function Groups({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare function Group({ children, withMargin, elevation, }: {
+    children: ReactNode;
+    withMargin?: boolean;
+    elevation?: "sm" | "md" | "lg";
+}): import("react/jsx-runtime").JSX.Element;
+declare function Footer({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare const FormViewV2: {
+    Root: typeof FormViewRoot;
+    Header: typeof Header & {
+        Actions: typeof HeaderActions;
+        ActionsBar: typeof HeaderActionsBar;
+    };
+    Content: typeof Content & {
+        Form: typeof Form;
+        Groups: typeof Groups;
+        Group: typeof Group;
+    };
+    Footer: typeof Footer;
+};
+export default FormViewV2;

package/lib/views/FormViewV2.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx, Fragment as _Fragment } from "nativewind/jsx-runtime";
+import { ErrorBoundary, Feedback } from "../Feedback";
+import Container from "../layouts/Container";
+import { theme } from "../theme";
+import { FormViewProvider, useFormView } from "../views/FormViewV2.context";
+import ScreenHeader from "../widgets/ScreenHeader";
+import React from "react";
+import { RefreshControl, View } from "react-native";
+import { KeyboardAwareScrollView } from "react-native-keyboard-controller";
+function FormViewRoot({ name, description, item, isLoading = false, isEmpty = false, hasError = false, errorMessage, readonly = false, onRefresh, onRetry, onBack, withContainer = true, children, }) {
+    const Wrapper = withContainer ? Container : View;
+    const wrapperProps = withContainer ? {} : { style: { flex: 1 } };
+    return (_jsx(FormViewProvider, { description: description, errorMessage: errorMessage, hasError: hasError, isEmpty: isEmpty, isLoading: isLoading, item: item, name: name, onBack: onBack, onRefresh: onRefresh, onRetry: onRetry, readonly: readonly, children: _jsx(ErrorBoundary, { children: _jsx(Wrapper, { ...wrapperProps, children: children }) }) }));
+}
+function Header({ variant = "FLAT_HEADER" /* EVariantScreenHeader.FLAT_HEADER */, logoSource, children, }) {
+    const { name, description, onBack } = useFormView();
+    return (_jsx(_Fragment, { children: _jsx(ScreenHeader, { logoSource: logoSource, onBack: onBack, subtitle: description ? description : `Seleccionar ${name}`, title: name, variant: variant, children: children }) }));
+}
+function HeaderActions({ children }) {
+    return (_jsx(View, { className: "flex-row px-4 my-4 items-center justify-between flex-1 gap-2", children: children }));
+}
+function HeaderActionsBar({ children }) {
+    return (_jsx(View, { className: "bg-bg-card px-4 py-3 border-b border-border-default flex-row gap-2", children: children }));
+}
+function Content({ withMargin = false, children, }) {
+    const { name, isLoading, isEmpty, hasError, errorMessage, item, onRefresh, onRetry, onBack, showRefreshing, setShowRefreshing, } = useFormView();
+    const handleRefresh = React.useCallback(async () => {
+        setShowRefreshing(true);
+        if (onRefresh) {
+            await onRefresh();
+        }
+        setShowRefreshing(false);
+    }, [onRefresh, setShowRefreshing]);
+    const isCenteredContent = isLoading || isEmpty || !item || hasError;
+    return (_jsx(KeyboardAwareScrollView, { bottomOffset: 20, contentContainerStyle: {
+            flexGrow: 1,
+            justifyContent: isCenteredContent ? "center" : "flex-start",
+            alignItems: isCenteredContent ? "center" : "stretch",
+        }, keyboardShouldPersistTaps: "handled", refreshControl: _jsx(RefreshControl, { colors: [theme.primary], onRefresh: handleRefresh, refreshing: showRefreshing }), style: { flex: 1 }, children: isCenteredContent ? (_jsx(_Fragment, { children: isLoading ? (_jsx(Feedback.Loading, { message: `Cargando ${name}...` })) : hasError ? (_jsx(Feedback.Error, { message: errorMessage, onBack: onBack, onRetry: onRetry })) : (_jsx(Feedback.Empty, {})) })) : (_jsx(View, { style: withMargin ? { paddingHorizontal: 16 } : undefined, children: children })) }));
+}
+function Form({ children }) {
+    const { isEmpty, item } = useFormView();
+    if (isEmpty || !item) {
+        return _jsx(Feedback.Empty, {});
+    }
+    return _jsx(_Fragment, { children: children });
+}
+function Groups({ children }) {
+    const { isEmpty } = useFormView();
+    if (isEmpty) {
+        return null;
+    }
+    return _jsx(_Fragment, { children: children });
+}
+function Group({ children, withMargin = true, elevation = "md", }) {
+    const groupClass = withMargin
+        ? "bg-bg-card mx-4 my-1 p-1 rounded-lg border border-border-light"
+        : "bg-bg-card p-1 rounded-lg border border-border-light";
+    return (_jsx(View, { className: groupClass, style: theme.shadow[elevation], children: children }));
+}
+function Footer({ children }) {
+    const { isEmpty, isLoading } = useFormView();
+    if (isEmpty || isLoading) {
+        return null;
+    }
+    return (_jsx(View, { className: "bg-bg-card px-4 py-3 border-t border-border-default", style: theme.shadow.sm, children: children }));
+}
+// Nested Header components
+const HeaderWithSubComponents = Object.assign(Header, {
+    Actions: HeaderActions,
+    ActionsBar: HeaderActionsBar,
+});
+// Nested Content components
+const ContentWithSubComponents = Object.assign(Content, {
+    Form,
+    Groups,
+    Group,
+});
+export const FormViewV2 = {
+    Root: FormViewRoot,
+    Header: HeaderWithSubComponents,
+    Content: ContentWithSubComponents,
+    Footer,
+};
+export default FormViewV2;

package/lib/views/ListViewV2.context.d.ts

@@ -0,0 +1,36 @@
+import { ReactNode } from "react";
+interface ListViewContextValue<T> {
+    name: string;
+    description?: string;
+    items: T[];
+    isLoading: boolean;
+    hasError: boolean;
+    errorMessage?: string;
+    readonly: boolean;
+    showRefreshing: boolean;
+    setShowRefreshing: (value: boolean) => void;
+    onRefresh?: () => Promise<void>;
+    onRetry?: () => void;
+    onPressItem?: (item: T) => void;
+    onDeleteItem?: (item: T) => void;
+    onSearch?: (query: string) => void;
+    onBack?: () => void;
+}
+export declare function ListViewProvider<T>({ name, description, items, isLoading, hasError, errorMessage, readonly, onRefresh, onRetry, onPressItem, onDeleteItem, onSearch, onBack, children, }: {
+    name: string;
+    description?: string;
+    items: T[];
+    isLoading?: boolean;
+    hasError?: boolean;
+    errorMessage?: string;
+    readonly?: boolean;
+    onRefresh?: () => Promise<void>;
+    onRetry?: () => void;
+    onPressItem?: (item: T) => void;
+    onDeleteItem?: (item: T) => void;
+    onSearch?: (query: string) => void;
+    onBack?: () => void;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useListView<T>(): ListViewContextValue<T>;
+export {};

package/lib/views/ListViewV2.context.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "nativewind/jsx-runtime";
+import { createContext, useContext, useState } from "react";
+const Context = createContext(null);
+export function ListViewProvider({ name, description, items, isLoading = false, hasError = false, errorMessage, readonly = false, onRefresh, onRetry, onPressItem, onDeleteItem, onSearch, onBack, children, }) {
+    const [showRefreshing, setShowRefreshing] = useState(false);
+    return (_jsx(Context.Provider, { value: {
+            name,
+            description,
+            items,
+            isLoading,
+            hasError,
+            errorMessage,
+            readonly,
+            showRefreshing,
+            setShowRefreshing,
+            onRefresh,
+            onRetry,
+            onPressItem,
+            onDeleteItem,
+            onSearch,
+            onBack,
+        }, children: children }));
+}
+export function useListView() {
+    const context = useContext(Context);
+    if (!context) {
+        throw new Error("useListView must be used within ListViewV2");
+    }
+    return context;
+}