@sincpro/mobile-ui 0.1.2 → 0.1.3

package/lib/theme/typography.js

@@ -0,0 +1,234 @@
+import { Montserrat_300Light, Montserrat_400Regular, Montserrat_500Medium, Montserrat_600SemiBold, Montserrat_800ExtraBold, useFonts, } from "@expo-google-fonts/montserrat";
+/* -------------------- Font Families & Weights -------------------- */
+export const fontFamilies = {
+    light: "Montserrat_300Light",
+    regular: "Montserrat_400Regular",
+    medium: "Montserrat_500Medium",
+    semiBold: "Montserrat_600SemiBold",
+    extraBold: "Montserrat_800ExtraBold",
+};
+export const fontWeights = {
+    light: "300",
+    regular: "400",
+    medium: "500",
+    semiBold: "600",
+    extraBold: "800",
+};
+/* -------------------- Font Sizes -------------------- */
+export const fontSizes = {
+    xs: 10,
+    sm: 13,
+    base: 14,
+    lg: 16,
+    xl: 18,
+    "2xl": 20,
+    "3xl": 24,
+    "4xl": 28,
+    "5xl": 32,
+    "6xl": 36,
+    "7xl": 48,
+    "8xl": 64,
+};
+/* -------------------- Line Heights -------------------- */
+export const lineHeights = {
+    none: 1,
+    tight: 1.25,
+    snug: 1.375,
+    normal: 1.5,
+    relaxed: 1.625,
+    loose: 2,
+};
+/* -------------------- Letter Spacing -------------------- */
+export const letterSpacing = {
+    tighter: -0.5,
+    tight: -0.25,
+    normal: 0,
+    wide: 0.25,
+    wider: 0.5,
+    widest: 1,
+};
+/* -------------------- Typography Variants -------------------- */
+export const typographyVariants = {
+    // Display
+    display: {
+        fontSize: fontSizes["7xl"],
+        fontFamily: fontFamilies.extraBold,
+        fontWeight: fontWeights.extraBold,
+        lineHeight: fontSizes["7xl"] * lineHeights.tight,
+        letterSpacing: letterSpacing.tight,
+    },
+    // Headings
+    h1: {
+        fontSize: fontSizes["5xl"],
+        fontFamily: fontFamilies.extraBold,
+        fontWeight: fontWeights.extraBold,
+        lineHeight: fontSizes["5xl"] * lineHeights.tight,
+        letterSpacing: letterSpacing.tight,
+    },
+    h2: {
+        fontSize: fontSizes["4xl"],
+        fontFamily: fontFamilies.semiBold,
+        fontWeight: fontWeights.semiBold,
+        lineHeight: fontSizes["4xl"] * lineHeights.snug,
+        letterSpacing: letterSpacing.normal,
+    },
+    h3: {
+        fontSize: fontSizes["3xl"],
+        fontFamily: fontFamilies.semiBold,
+        fontWeight: fontWeights.semiBold,
+        lineHeight: fontSizes["3xl"] * lineHeights.snug,
+        letterSpacing: letterSpacing.normal,
+    },
+    h4: {
+        fontSize: fontSizes["2xl"],
+        fontFamily: fontFamilies.medium,
+        fontWeight: fontWeights.medium,
+        lineHeight: fontSizes["2xl"] * lineHeights.normal,
+        letterSpacing: letterSpacing.normal,
+    },
+    h5: {
+        fontSize: fontSizes.xl,
+        fontFamily: fontFamilies.medium,
+        fontWeight: fontWeights.medium,
+        lineHeight: fontSizes.xl * lineHeights.normal,
+        letterSpacing: letterSpacing.normal,
+    },
+    h6: {
+        fontSize: fontSizes.lg,
+        fontFamily: fontFamilies.medium,
+        fontWeight: fontWeights.medium,
+        lineHeight: fontSizes.lg * lineHeights.normal,
+        letterSpacing: letterSpacing.normal,
+    },
+    // Body
+    bodyLarge: {
+        fontSize: fontSizes.lg,
+        fontFamily: fontFamilies.regular,
+        fontWeight: fontWeights.regular,
+        lineHeight: fontSizes.lg * lineHeights.relaxed,
+        letterSpacing: letterSpacing.normal,
+    },
+    body: {
+        fontSize: fontSizes.base,
+        fontFamily: fontFamilies.regular,
+        fontWeight: fontWeights.regular,
+        lineHeight: fontSizes.base * lineHeights.relaxed,
+        letterSpacing: letterSpacing.normal,
+    },
+    bodySmall: {
+        fontSize: fontSizes.sm,
+        fontFamily: fontFamilies.regular,
+        fontWeight: fontWeights.regular,
+        lineHeight: fontSizes.sm * lineHeights.normal,
+        letterSpacing: letterSpacing.normal,
+    },
+    // Label
+    label: {
+        fontSize: fontSizes.base,
+        fontFamily: fontFamilies.medium,
+        fontWeight: fontWeights.medium,
+        lineHeight: fontSizes.base * lineHeights.normal,
+        letterSpacing: letterSpacing.wide,
+    },
+    labelSmall: {
+        fontSize: fontSizes.sm,
+        fontFamily: fontFamilies.medium,
+        fontWeight: fontWeights.medium,
+        lineHeight: fontSizes.sm * lineHeights.normal,
+        letterSpacing: letterSpacing.wide,
+    },
+    // Caption
+    caption: {
+        fontSize: fontSizes.sm,
+        fontFamily: fontFamilies.regular,
+        fontWeight: fontWeights.regular,
+        lineHeight: fontSizes.sm * lineHeights.normal,
+        letterSpacing: letterSpacing.normal,
+    },
+    captionSmall: {
+        fontSize: fontSizes.xs,
+        fontFamily: fontFamilies.regular,
+        fontWeight: fontWeights.regular,
+        lineHeight: fontSizes.xs * lineHeights.normal,
+        letterSpacing: letterSpacing.normal,
+    },
+    // Buttons
+    button: {
+        fontSize: fontSizes.base,
+        fontFamily: fontFamilies.semiBold,
+        fontWeight: fontWeights.semiBold,
+        lineHeight: fontSizes.base * lineHeights.none,
+        letterSpacing: letterSpacing.wide,
+    },
+    buttonSmall: {
+        fontSize: fontSizes.sm,
+        fontFamily: fontFamilies.semiBold,
+        fontWeight: fontWeights.semiBold,
+        lineHeight: fontSizes.sm * lineHeights.none,
+        letterSpacing: letterSpacing.wide,
+    },
+    buttonLarge: {
+        fontSize: fontSizes.lg,
+        fontFamily: fontFamilies.semiBold,
+        fontWeight: fontWeights.semiBold,
+        lineHeight: fontSizes.lg * lineHeights.none,
+        letterSpacing: letterSpacing.wide,
+    },
+    // Legacy
+    title: {
+        fontSize: fontSizes.xl,
+        fontFamily: fontFamilies.semiBold,
+        fontWeight: fontWeights.semiBold,
+        lineHeight: fontSizes.xl * lineHeights.snug,
+        letterSpacing: letterSpacing.normal,
+    },
+    subtitle: {
+        fontSize: fontSizes.lg,
+        fontFamily: fontFamilies.medium,
+        fontWeight: fontWeights.medium,
+        lineHeight: fontSizes.lg * lineHeights.normal,
+        letterSpacing: letterSpacing.normal,
+    },
+};
+/* -------------------- Utility Functions -------------------- */
+export const createTextStyle = (variant, overrides) => ({
+    ...typographyVariants[variant],
+    ...overrides,
+});
+export const createCustomTextStyle = (fontSize, fontFamily, options) => {
+    const size = fontSizes[fontSize];
+    const line = options?.lineHeight ? lineHeights[options.lineHeight] : lineHeights.normal;
+    const spacing = options?.letterSpacing ?? "normal";
+    return {
+        fontSize: size,
+        fontFamily: fontFamilies[fontFamily],
+        fontWeight: fontWeights[fontFamily],
+        lineHeight: size * line,
+        letterSpacing: letterSpacing[spacing],
+        ...(options?.color && { color: options.color }),
+    };
+};
+/* -------------------- Font Loader -------------------- */
+export const useAppFonts = () => {
+    const [loaded] = useFonts({
+        Montserrat_300Light,
+        Montserrat_400Regular,
+        Montserrat_500Medium,
+        Montserrat_600SemiBold,
+        Montserrat_800ExtraBold,
+    });
+    return loaded;
+};
+/* -------------------- Typography Object -------------------- */
+export const Typography = {
+    fontFamilies,
+    fontWeights,
+    fontSizes,
+    lineHeights,
+    letterSpacing,
+    variants: typographyVariants,
+    createTextStyle,
+    createCustomTextStyle,
+    useAppFonts,
+};
+export default Typography;

package/lib/theme/useTheme.d.ts

@@ -0,0 +1 @@
+export declare const theme: import("./types").ThemeTokens;

package/lib/theme/useTheme.js

@@ -0,0 +1,2 @@
+import { getActiveTheme } from "../theme/active";
+export const theme = getActiveTheme();

package/lib/utils/date.d.ts

@@ -0,0 +1,70 @@
+interface FormatDateOptions {
+    locale?: string | null;
+    showTime?: boolean;
+}
+/**
+ * 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 declare function formatDate(input: string | Date, timezone: string | null | undefined, options?: FormatDateOptions): string;
+/**
+ * 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 declare function formatDateWithDefaultTimezone(input: string | Date, options?: FormatDateOptions): string;
+/**
+ * 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 declare function getCurrentDateInTimezone(timezone?: string | null): string;
+/**
+ * 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 declare function getCurrentDateTimeInTimezone(timezone?: string | null): string;
+export {};

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,9 @@
+import { ReactNode } from "react";
+interface AuthFormProps {
+    title?: string;
+    description?: string;
+    onBack?: () => void;
+    FormNode: ReactNode;
+}
+declare function AuthFormView({ title, description, 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 "react/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, 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" }), 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 {};