svelte-firekit 0.0.14 → 0.0.16

package/dist/components/ui/sonner/sonner.svelte

@@ -1,20 +0,0 @@
-<script lang="ts">
-	import { Toaster as Sonner, type ToasterProps as SonnerProps } from "svelte-sonner";
-	import { mode } from "mode-watcher";
-
-	let restProps: SonnerProps = $props();
-</script>
-
-<Sonner
-	theme={$mode}
-	class="toaster group"
-	toastOptions={{
-		classes: {
-			toast: "group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg",
-			description: "group-[.toast]:text-muted-foreground",
-			actionButton: "group-[.toast]:bg-primary group-[.toast]:text-primary-foreground",
-			cancelButton: "group-[.toast]:bg-muted group-[.toast]:text-muted-foreground",
-		},
-	}}
-	{...restProps}
-/>

package/dist/components/ui/sonner/sonner.svelte.d.ts

@@ -1,3 +0,0 @@
-import { Toaster as Sonner, type ToasterProps as SonnerProps } from "svelte-sonner";
-declare const Sonner: import("svelte").Component<SonnerProps, {}, "">;
-export default Sonner;

package/dist/components/ui/tooltip/index.js

@@ -1,8 +0,0 @@
-import { Tooltip as TooltipPrimitive } from "bits-ui";
-import Content from "./tooltip-content.svelte";
-const Root = TooltipPrimitive.Root;
-const Trigger = TooltipPrimitive.Trigger;
-const Provider = TooltipPrimitive.Provider;
-export { Root, Trigger, Content, Provider, 
-//
-Root as Tooltip, Content as TooltipContent, Trigger as TooltipTrigger, Provider as TooltipProvider, };

package/dist/components/ui/tooltip/tooltip-content.svelte

@@ -1,21 +0,0 @@
-<script lang="ts">
-	import { Tooltip as TooltipPrimitive } from "bits-ui";
-	import { cn } from "../../../utils.js";
-
-	let {
-		ref = $bindable(null),
-		class: className,
-		sideOffset = 4,
-		...restProps
-	}: TooltipPrimitive.ContentProps = $props();
-</script>
-
-<TooltipPrimitive.Content
-	bind:ref
-	{sideOffset}
-	class={cn(
-		"bg-primary text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 overflow-hidden rounded-md px-3 py-1.5 text-xs",
-		className
-	)}
-	{...restProps}
-/>

package/dist/components/ui/tooltip/tooltip-content.svelte.d.ts

@@ -1,3 +0,0 @@
-import { Tooltip as TooltipPrimitive } from "bits-ui";
-declare const TooltipContent: import("svelte").Component<TooltipPrimitive.ContentProps, {}, "ref">;
-export default TooltipContent;

package/dist/firebase/auth/auth-manager.svelte.d.ts

@@ -1,85 +0,0 @@
-import { type DocumentData } from "firebase/firestore";
-type UserClaims = Record<string, any>;
-interface UserData extends DocumentData {
-    displayName?: string;
-    email?: string;
-    photoURL?: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-    isProfileComplete?: boolean;
-    role?: string;
-    settings?: Record<string, any>;
-    [key: string]: any;
-}
-interface GuardConfig {
-    authRequired?: boolean;
-    redirectTo?: string;
-    requiredClaims?: string[];
-    requiredData?: (data: DocumentData | null) => boolean;
-    allowIf?: (manager: FirekitAuthManager) => boolean;
-    redirectParams?: Record<string, string>;
-}
-export declare class FirekitAuthManager {
-    private static instance;
-    private readonly SESSION_TIMEOUT;
-    private activityInterval;
-    private _initPromise;
-    private _user;
-    private _userData;
-    private _claims;
-    private _initialized;
-    private _loading;
-    private _error;
-    private _currentSession;
-    private _lastValidationTime;
-    readonly isLoggedIn: boolean;
-    readonly uid: string | undefined;
-    readonly email: string | null | undefined;
-    readonly displayName: string | null | undefined;
-    readonly photoURL: string | null | undefined;
-    readonly emailVerified: boolean | undefined;
-    readonly claims: UserClaims;
-    readonly data: UserData | null;
-    readonly initialized: boolean;
-    readonly loading: boolean;
-    readonly error: Error | null;
-    readonly sessionActive: boolean;
-    private constructor();
-    static getInstance(): FirekitAuthManager;
-    private initialize;
-    waitForInit(): Promise<void>;
-    private handleAuthStateChange;
-    private loadUserData;
-    private loadUserClaims;
-    private setupActivityTracking;
-    private initializeSession;
-    private updateLastActivity;
-    private checkSession;
-    private handleSessionTimeout;
-    private clearSession;
-    private handleError;
-    private generateDeviceId;
-    private getPlatformInfo;
-    private validateClaims;
-    handleRedirect(redirectTo: string, params?: Record<string, string>): Promise<void>;
-    validateAuth({ authRequired, redirectTo, requiredClaims, requiredData, allowIf, redirectParams, }?: GuardConfig): Promise<boolean>;
-    updateEmailUser(email: string): Promise<void>;
-    updatePassword(password: string): Promise<void>;
-    updateProfileInfo({ displayName, photoURL, }: {
-        displayName?: string;
-        photoURL?: string;
-    }): Promise<void>;
-    updateUserData(data: Partial<UserData>): Promise<void>;
-    saveUserData(data: UserData): Promise<void>;
-    sendVerificationEmail(): Promise<void>;
-    refreshUserData(): Promise<void>;
-    hasRequiredClaims(requiredClaims: string[]): boolean;
-    isAdmin(): boolean;
-    isPremium(): boolean;
-    requireClaims(claims: string[], redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
-    requireData(validator: (data: DocumentData | null) => boolean, redirectTo?: string, redirectParams?: Record<string, string>): Promise<boolean>;
-    logOut(): Promise<void>;
-    destroy(): void;
-}
-export declare const firekitAuthManager: FirekitAuthManager;
-export {};

package/dist/firebase/auth/auth-manager.svelte.js

@@ -1,386 +0,0 @@
-import { browser } from "$app/environment";
-import { goto } from "$app/navigation";
-import { firebaseService } from "../firebase.js";
-import { toast } from "svelte-sonner";
-import { onAuthStateChanged, updateEmail, updatePassword, updateProfile, sendEmailVerification, } from "firebase/auth";
-import { doc, getDoc, setDoc, updateDoc, } from "firebase/firestore";
-class AuthError extends Error {
-    code;
-    originalError;
-    constructor(message, code = 'unknown', originalError) {
-        super(message);
-        this.code = code;
-        this.originalError = originalError;
-        this.name = 'AuthError';
-    }
-}
-export class FirekitAuthManager {
-    static instance;
-    SESSION_TIMEOUT = 30 * 60 * 1000; // 30 minutes
-    activityInterval = null;
-    _initPromise = null;
-    // State using Svelte 5 runes
-    _user = $state();
-    _userData = $state(null);
-    _claims = $state({});
-    _initialized = $state(false);
-    _loading = $state(true);
-    _error = $state(null);
-    _currentSession = $state(null);
-    _lastValidationTime = $state(0);
-    // Derived state
-    isLoggedIn = $derived(Boolean(this._user));
-    uid = $derived(this._user?.uid);
-    email = $derived(this._user?.email);
-    displayName = $derived(this._user?.displayName);
-    photoURL = $derived(this._user?.photoURL);
-    emailVerified = $derived(this._user?.emailVerified);
-    claims = $derived(this._claims);
-    data = $derived(this._userData);
-    initialized = $derived(this._initialized);
-    loading = $derived(this._loading);
-    error = $derived(this._error);
-    sessionActive = $derived(Boolean(this._currentSession));
-    constructor() {
-        if (browser) {
-            this.initialize();
-            this.setupActivityTracking();
-        }
-    }
-    static getInstance() {
-        if (!FirekitAuthManager.instance) {
-            FirekitAuthManager.instance = new FirekitAuthManager();
-        }
-        return FirekitAuthManager.instance;
-    }
-    async initialize() {
-        if (this._initialized)
-            return;
-        this._initPromise = new Promise((resolve) => {
-            const auth = firebaseService.getAuthInstance();
-            if (!auth)
-                throw new AuthError('Firebase Auth not initialized', 'init_failed');
-            onAuthStateChanged(auth, async (user) => {
-                await this.handleAuthStateChange(user);
-                resolve();
-            });
-        });
-    }
-    async waitForInit() {
-        if (this._initialized)
-            return;
-        return this._initPromise || Promise.resolve();
-    }
-    async handleAuthStateChange(user) {
-        this._loading = true;
-        try {
-            if (user) {
-                this._user = user;
-                await Promise.all([
-                    this.loadUserData(user.uid),
-                    this.loadUserClaims(user)
-                ]);
-                this.initializeSession();
-            }
-            else {
-                this._user = null;
-                this._userData = null;
-                this._claims = {};
-                this.clearSession();
-            }
-            this._initialized = true;
-            this._error = null;
-        }
-        catch (error) {
-            this.handleError(error);
-        }
-        finally {
-            this._loading = false;
-        }
-    }
-    async loadUserData(uid) {
-        const docRef = doc(firebaseService.getDb(), "users", uid);
-        const docSnap = await getDoc(docRef);
-        if (docSnap.exists()) {
-            this._userData = docSnap.data();
-        }
-        else {
-            const initialData = {
-                displayName: this._user?.displayName || "",
-                email: this._user?.email || "",
-                photoURL: this._user?.photoURL || "",
-                createdAt: new Date(),
-                updatedAt: new Date(),
-                isProfileComplete: false,
-            };
-            await this.saveUserData(initialData);
-        }
-    }
-    async loadUserClaims(user) {
-        const tokenResult = await user.getIdTokenResult();
-        this._claims = tokenResult.claims;
-    }
-    setupActivityTracking() {
-        if (browser) {
-            ['mousedown', 'keydown', 'scroll', 'touchstart'].forEach(eventName => {
-                window.addEventListener(eventName, () => this.updateLastActivity());
-            });
-            this.activityInterval = setInterval(() => this.checkSession(), 60000);
-        }
-    }
-    initializeSession() {
-        this._currentSession = {
-            lastActivity: Date.now(),
-            deviceId: this.generateDeviceId(),
-            platform: this.getPlatformInfo()
-        };
-    }
-    updateLastActivity() {
-        if (this._currentSession) {
-            this._currentSession.lastActivity = Date.now();
-        }
-    }
-    async checkSession() {
-        if (!this._currentSession)
-            return;
-        const inactiveTime = Date.now() - this._currentSession.lastActivity;
-        if (inactiveTime > this.SESSION_TIMEOUT) {
-            await this.handleSessionTimeout();
-        }
-    }
-    async handleSessionTimeout() {
-        toast.warning('Session expired due to inactivity', {
-            description: 'Please log in again to continue.',
-            duration: 5000
-        });
-        await this.logOut();
-    }
-    clearSession() {
-        this._currentSession = null;
-        if (this.activityInterval) {
-            clearInterval(this.activityInterval);
-            this.activityInterval = null;
-        }
-    }
-    handleError(error) {
-        const authError = error instanceof AuthError
-            ? error
-            : new AuthError(error instanceof Error ? error.message : 'An unknown error occurred', 'unknown', error instanceof Error ? error : undefined);
-        this._error = authError;
-        this._loading = false;
-        console.error('[FirekitAuthManager]', authError);
-    }
-    generateDeviceId() {
-        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    getPlatformInfo() {
-        if (!browser)
-            return 'server';
-        return `${navigator.platform} - ${navigator.userAgent}`;
-    }
-    validateClaims(requiredClaims, userClaims) {
-        return requiredClaims.every(claim => userClaims[claim]);
-    }
-    async handleRedirect(redirectTo, params) {
-        const url = new URL(redirectTo, window.location.origin);
-        if (params) {
-            Object.entries(params).forEach(([key, value]) => {
-                url.searchParams.append(key, value);
-            });
-        }
-        await goto(url.toString());
-    }
-    // Public Methods
-    async validateAuth({ authRequired = true, redirectTo = "/login", requiredClaims = [], requiredData, allowIf, redirectParams, } = {}) {
-        if (!browser)
-            return true;
-        const now = Date.now();
-        if (now - this._lastValidationTime < 1000)
-            return false;
-        this._lastValidationTime = now;
-        try {
-            this._loading = true;
-            this._error = null;
-            await this.waitForInit();
-            // Basic auth validation
-            if (authRequired && !this._user) {
-                await this.handleRedirect(redirectTo, {
-                    ...redirectParams,
-                    returnTo: window.location.pathname,
-                });
-                return false;
-            }
-            if (!authRequired && this._user) {
-                await this.handleRedirect(redirectTo, redirectParams);
-                return false;
-            }
-            // Custom conditions
-            if (allowIf && !allowIf(this)) {
-                await this.handleRedirect(redirectTo, redirectParams);
-                return false;
-            }
-            // Claims validation
-            if (requiredClaims.length > 0 && !this.validateClaims(requiredClaims, this._claims)) {
-                await this.handleRedirect(redirectTo, redirectParams);
-                return false;
-            }
-            // Data validation
-            if (requiredData && !requiredData(this._userData)) {
-                await this.handleRedirect(redirectTo, redirectParams);
-                return false;
-            }
-            return true;
-        }
-        catch (error) {
-            this.handleError(error);
-            return false;
-        }
-        finally {
-            this._loading = false;
-        }
-    }
-    async updateEmailUser(email) {
-        if (!this._user)
-            throw new AuthError("No authenticated user", "no_user");
-        try {
-            await updateEmail(this._user, email);
-            await this.updateUserData({ email });
-            toast.success("Email updated successfully!", {
-                description: "Please note that you will be logged out, and you will need to log in again using your new email address.",
-            });
-            setTimeout(async () => {
-                await this.logOut();
-            }, 4500);
-        }
-        catch (error) {
-            this.handleError(error);
-            throw error;
-        }
-    }
-    async updatePassword(password) {
-        if (!this._user)
-            throw new AuthError("No authenticated user", "no_user");
-        try {
-            await updatePassword(this._user, password);
-        }
-        catch (error) {
-            this.handleError(error);
-            throw error;
-        }
-    }
-    async updateProfileInfo({ displayName, photoURL, }) {
-        if (!this._user)
-            throw new AuthError("No authenticated user", "no_user");
-        if (!displayName && !photoURL)
-            return;
-        try {
-            if (displayName)
-                await updateProfile(this._user, { displayName });
-            if (photoURL)
-                await updateProfile(this._user, { photoURL });
-            await this.updateUserData({ displayName, photoURL });
-        }
-        catch (error) {
-            this.handleError(error);
-            throw error;
-        }
-    }
-    async updateUserData(data) {
-        if (!this._user?.uid)
-            throw new AuthError("No authenticated user", "no_user");
-        try {
-            const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
-            const updateData = { ...data, updatedAt: new Date() };
-            await updateDoc(docRef, updateData);
-            await this.loadUserData(this._user.uid);
-        }
-        catch (error) {
-            this.handleError(error);
-            throw error;
-        }
-    }
-    async saveUserData(data) {
-        if (!this._user?.uid)
-            throw new AuthError("No authenticated user", "no_user");
-        try {
-            const docRef = doc(firebaseService.getDb(), "users", this._user.uid);
-            const saveData = {
-                ...data,
-                createdAt: data.createdAt || new Date(),
-                updatedAt: new Date(),
-            };
-            await setDoc(docRef, saveData);
-            await this.loadUserData(this._user.uid);
-        }
-        catch (error) {
-            this.handleError(error);
-            throw error;
-        }
-    }
-    async sendVerificationEmail() {
-        if (!this._user)
-            throw new AuthError('No authenticated user', 'no_user');
-        try {
-            await sendEmailVerification(this._user);
-            toast.success('Verification email sent!');
-        }
-        catch (error) {
-            this.handleError(error);
-            throw error;
-        }
-    }
-    async refreshUserData() {
-        if (!this._user)
-            return;
-        try {
-            await Promise.all([
-                this.loadUserData(this._user.uid),
-                this.loadUserClaims(this._user)
-            ]);
-        }
-        catch (error) {
-            this.handleError(error);
-            throw error;
-        }
-    }
-    // Helper methods
-    hasRequiredClaims(requiredClaims) {
-        return requiredClaims.every((claim) => this._claims[claim]);
-    }
-    isAdmin() {
-        return Boolean(this._claims.admin);
-    }
-    isPremium() {
-        return Boolean(this._claims.premium);
-    }
-    async requireClaims(claims, redirectTo = "/login", redirectParams) {
-        return this.validateAuth({
-            requiredClaims: claims,
-            redirectTo,
-            redirectParams,
-        });
-    }
-    async requireData(validator, redirectTo = "/login", redirectParams) {
-        return this.validateAuth({
-            requiredData: validator,
-            redirectTo,
-            redirectParams,
-        });
-    }
-    async logOut() {
-        try {
-            await firebaseService.getAuthInstance().signOut();
-            this.clearSession();
-        }
-        catch (error) {
-            this.handleError(error);
-            throw error;
-        }
-    }
-    // Cleanup
-    destroy() {
-        this.clearSession();
-        // Additional cleanup if needed
-    }
-}
-export const firekitAuthManager = FirekitAuthManager.getInstance();

package/dist/firebase/config.d.ts

@@ -1,2 +0,0 @@
-import type { FirebaseOptions } from 'firebase/app';
-export declare const firebaseConfig: FirebaseOptions;

package/dist/firebase/config.js

@@ -1,44 +0,0 @@
-import { PUBLIC_FIREBASE_API_KEY, PUBLIC_FIREBASE_AUTH_DOMAIN, PUBLIC_FIREBASE_PROJECT_ID, PUBLIC_FIREBASE_STORAGE_BUCKET, PUBLIC_FIREBASE_MESSAGING_SENDER_ID, PUBLIC_FIREBASE_APP_ID, PUBLIC_FIREBASE_MEASUREMENT_ID } from '$env/static/public';
-class FirebaseConfig {
-    static instance;
-    config;
-    constructor() {
-        const missingVars = this.getMissingFirebaseConfigVars();
-        if (missingVars.length > 0) {
-            throw Error(`The following Firebase configuration variables are missing: ${missingVars.join(', ')}`);
-        }
-        this.config = {
-            apiKey: PUBLIC_FIREBASE_API_KEY,
-            authDomain: PUBLIC_FIREBASE_AUTH_DOMAIN,
-            projectId: PUBLIC_FIREBASE_PROJECT_ID,
-            storageBucket: PUBLIC_FIREBASE_STORAGE_BUCKET,
-            messagingSenderId: PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
-            appId: PUBLIC_FIREBASE_APP_ID,
-            measurementId: PUBLIC_FIREBASE_MEASUREMENT_ID
-        };
-    }
-    getMissingFirebaseConfigVars() {
-        const requiredVars = {
-            'PUBLIC_FIREBASE_API_KEY': PUBLIC_FIREBASE_API_KEY,
-            'PUBLIC_FIREBASE_AUTH_DOMAIN': PUBLIC_FIREBASE_AUTH_DOMAIN,
-            'PUBLIC_FIREBASE_PROJECT_ID': PUBLIC_FIREBASE_PROJECT_ID,
-            'PUBLIC_FIREBASE_STORAGE_BUCKET': PUBLIC_FIREBASE_STORAGE_BUCKET,
-            'PUBLIC_FIREBASE_MESSAGING_SENDER_ID': PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
-            'PUBLIC_FIREBASE_APP_ID': PUBLIC_FIREBASE_APP_ID,
-            'PUBLIC_FIREBASE_MEASUREMENT_ID': PUBLIC_FIREBASE_MEASUREMENT_ID
-        };
-        return Object.entries(requiredVars)
-            .filter(([_, value]) => !value)
-            .map(([key]) => key);
-    }
-    static getInstance() {
-        if (!FirebaseConfig.instance) {
-            FirebaseConfig.instance = new FirebaseConfig();
-        }
-        return FirebaseConfig.instance;
-    }
-    getConfig() {
-        return this.config;
-    }
-}
-export const firebaseConfig = FirebaseConfig.getInstance().getConfig();

package/dist/hooks/is-mobile.svelte.d.ts

@@ -1,5 +0,0 @@
-export declare class IsMobile {
-    #private;
-    constructor();
-    get current(): boolean;
-}

package/dist/hooks/is-mobile.svelte.js

@@ -1,23 +0,0 @@
-import { untrack } from "svelte";
-const MOBILE_BREAKPOINT = 768;
-export class IsMobile {
-    #current = $state(false);
-    constructor() {
-        $effect(() => {
-            return untrack(() => {
-                const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
-                const onChange = () => {
-                    this.#current = window.innerWidth < MOBILE_BREAKPOINT;
-                };
-                mql.addEventListener("change", onChange);
-                onChange();
-                return () => {
-                    mql.removeEventListener("change", onChange);
-                };
-            });
-        });
-    }
-    get current() {
-        return this.#current;
-    }
-}

package/dist/schemas/reset-password.d.ts

@@ -1,4 +0,0 @@
-import * as v from 'valibot';
-export declare const resetPasswordSchema: v.ObjectSchema<{
-    readonly email: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your email.">, v.EmailAction<string, "The email address is badly formatted.">]>;
-}, undefined>;

package/dist/schemas/reset-password.js

@@ -1,4 +0,0 @@
-import * as v from 'valibot';
-export const resetPasswordSchema = v.object({
-    email: v.pipe(v.string(), v.nonEmpty('Please enter your email.'), v.email('The email address is badly formatted.')),
-});

package/dist/schemas/sign-in.d.ts

@@ -1,5 +0,0 @@
-import * as v from 'valibot';
-export declare const signInSchema: v.ObjectSchema<{
-    readonly email: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your email.">, v.EmailAction<string, "The email address is badly formatted.">]>;
-    readonly password: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your password.">, v.MinLengthAction<string, 8, "Your password must have 8 characters or more.">]>;
-}, undefined>;

package/dist/schemas/sign-in.js

@@ -1,5 +0,0 @@
-import * as v from 'valibot';
-export const signInSchema = v.object({
-    email: v.pipe(v.string(), v.nonEmpty('Please enter your email.'), v.email('The email address is badly formatted.')),
-    password: v.pipe(v.string(), v.nonEmpty('Please enter your password.'), v.minLength(8, 'Your password must have 8 characters or more.')),
-});

package/dist/schemas/sign-up.d.ts

@@ -1,8 +0,0 @@
-import * as v from 'valibot';
-export declare const signUpSchema: v.ObjectSchema<{
-    readonly firstName: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your first name.">]>;
-    readonly lastName: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your last name.">]>;
-    readonly email: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your email.">, v.EmailAction<string, "The email address is badly formatted.">]>;
-    readonly password: v.SchemaWithPipe<[v.StringSchema<undefined>, v.NonEmptyAction<string, "Please enter your password.">, v.MinLengthAction<string, 8, "Your password must have 8 characters or more.">]>;
-    readonly agreeToTerms: v.SchemaWithPipe<[v.BooleanSchema<undefined>, v.CustomSchema<boolean, "You must agree to the terms and conditions.">]>;
-}, undefined>;

package/dist/schemas/sign-up.js

@@ -1,8 +0,0 @@
-import * as v from 'valibot';
-export const signUpSchema = v.object({
-    firstName: v.pipe(v.string(), v.nonEmpty('Please enter your first name.')),
-    lastName: v.pipe(v.string(), v.nonEmpty('Please enter your last name.')),
-    email: v.pipe(v.string(), v.nonEmpty('Please enter your email.'), v.email('The email address is badly formatted.')),
-    password: v.pipe(v.string(), v.nonEmpty('Please enter your password.'), v.minLength(8, 'Your password must have 8 characters or more.')),
-    agreeToTerms: v.pipe(v.boolean(), v.custom((value) => value === true, 'You must agree to the terms and conditions.'))
-});