giggle-guard

🛡️ Giggle Guard

3000+ hilarious validation messages that make your users smile instead of rage-quit when they mess up forms. Because who says error messages have to be boring?

🎯 Why Giggle Guard?

• 🚫 Users hate boring error messages → Make them laugh instead of cry 😭
• 🎭 Generic validation is forgettable → Stand out like a glitter bomb in a library
• 📋 Copy-paste ready messages → Say goodbye to "Field is required." Forever. 🔥
• 📈 Boost user engagement → Happy users fill forms. Sad users click away.
• 🌟 Open source humor → Fueled by developer memes and community chuckles

📦 Installation

npm install giggle-guard

yarn add giggle-guard

pnpm add giggle-guard

🚀 Quick Start

One-liner Usage

import { getMessage } from "giggle-guard";

const message = getMessage({
  fieldType: "email",
  errorType: "required",
});
console.log(message); // "Even my spam folder has higher standards"

Instance Usage

import { GiggleGuard } from "giggle-guard";

const guard = new GiggleGuard({
  defaultTone: "sarcastic",
  trackUsedMessages: true,
});

const funnyMessage = guard.getMessage({
  fieldType: "password",
  errorType: "tooWeak",
  tone: "funny",
});

Multiple Messages

import { getMessages } from "giggle-guard";

const messages = getMessages(
  {
    fieldType: "email",
    errorType: "invalid",
  },
  3
);

🎭 Available Tones

📋 Supported Field Types

❌ Error Types

🎪 Hilarious Message Samples by Tone

😂 Funny Tone - Classic Comedy Gold

🙄 Sarcastic Tone - Passive Aggressive Perfection

💅 GenZ Tone - Internet Culture Supreme

🖤 Dark Tone - Existential Dread Meets Forms

🤓 Nerdy Tone - 404: Humor Not Found

🎭 Dramatic Tone - Shakespeare Meets Silicon Valley

🥑 Millennial Tone - Peak 2010s Nostalgia

💪 Motivational Tone - Tony Robbins Meets Tech Support

🛠️ All Available Methods

Core Methods

import { getMessage, getMessages, GiggleGuard } from "giggle-guard";

// Get a single message
const message = getMessage({
  fieldType: "email",
  errorType: "required",
  tone: "funny", // optional
  excludeUsed: true, // optional
});

// Get multiple messages
const messages = getMessages(
  {
    fieldType: "password",
    errorType: "tooWeak",
  },
  3
);

// Using the class instance
const guard = new GiggleGuard();

Instance Methods

const guard = new GiggleGuard();

// Core methods
guard.getMessage(options)
guard.getMessages(options, count)

// Lookup methods
guard.getMessageById(id)
guard.getMessagesByField(fieldType)
guard.getMessagesByTone(tone)

// Utility methods
guard.resetUsedMessages()
guard.getStats()
guard.updateConfig({ ... })

Validation Helper

import { validateFieldErrorCombo } from "giggle-guard";

const { valid, allowedErrors } = validateFieldErrorCombo("email", "required");
console.log(valid); // true
console.log(allowedErrors); // ["required", "invalid", "tooShort", ...]

⚙️ Configuration Options

Giggle Guard comes with sensible defaults out of the box. Here's the configuration it uses internally unless you override it:

{
  defaultTone: "random",       // Use a random tone unless specified
  trackUsedMessages: true,     // Avoid repeating the same message
  fallbackToGeneric: true,     // Fallback to generic messages if none match
  strictValidation: false      // Log a warning instead of throwing an error
}

⚛️ Framework Integration Examples

React Hook Form

import { useForm } from "react-hook-form";
import { getMessage } from "giggle-guard";

function MyForm() {
  const {
    register,
    handleSubmit,
    formState: { errors },
  } = useForm();

  const getErrorMessage = (fieldType: string, errorType: string) => {
    return getMessage({ fieldType, errorType, tone: "millennial" });
  };

  return (
    <form onSubmit={handleSubmit(() => {})}>
      <input {...register("email", { required: true })} type="email" />
      {errors.email && <p>{getErrorMessage("email", "required")}</p>}
    </form>
  );
}

Formik

import { Formik, Form, Field, ErrorMessage } from "formik";
import { getMessage } from "giggle-guard";

<Formik
  initialValues={{ email: "" }}
  validate={(values) => {
    const errors: any = {};
    if (!values.email) {
      errors.email = getMessage({ fieldType: "email", errorType: "required" });
    }
    return errors;
  }}
  onSubmit={() => {}}
>
  <Form>
    <Field name="email" type="email" />
    <ErrorMessage name="email" component="div" />
  </Form>
</Formik>;

Vue + Vuelidate

<script setup>
import { ref } from "vue";
import { useVuelidate } from "@vuelidate/core";
import { required, email } from "@vuelidate/validators";
import { getMessage } from "giggle-guard";

const form = ref({ email: "" });
const rules = { email: { required, email } };
const $v = useVuelidate(rules, form);

const getEmailError = () => {
  if (!$v.value.email.required)
    return getMessage({ fieldType: "email", errorType: "required" });
  if (!$v.value.email.email)
    return getMessage({ fieldType: "email", errorType: "invalid" });
};
</script>

Angular

import { FormBuilder, Validators } from '@angular/forms';
import { getMessage } from 'giggle-guard';

constructor(private fb: FormBuilder) {}

form = this.fb.group({
  email: ['', [Validators.required, Validators.email]]
});

getEmailError() {
  const control = this.form.get('email');
  if (control?.hasError('required')) return getMessage({ fieldType: 'email', errorType: 'required' });
  if (control?.hasError('email')) return getMessage({ fieldType: 'email', errorType: 'invalid' });
  return '';
}

🔌 Integrations & Plugins

Validation Libraries

// Yup
import * as yup from "yup";
import { getMessage } from "giggle-guard";

const schema = yup.object({
  email: yup
    .string()
    .required(() => getMessage({ fieldType: "email", errorType: "required" }))
    .email(() => getMessage({ fieldType: "email", errorType: "invalid" })),
});

// Zod
import { z } from "zod";
import { getMessage } from "giggle-guard";

const schema = z.object({
  email: z
    .string({
      required_error: getMessage({ fieldType: "email", errorType: "required" }),
    })
    .email(getMessage({ fieldType: "email", errorType: "invalid" })),
});

// Joi
import Joi from "joi";
import { getMessage } from "giggle-guard";

const schema = Joi.object({
  email: Joi.string()
    .required()
    .messages({
      "any.required": getMessage({ fieldType: "email", errorType: "required" }),
      "string.email": getMessage({ fieldType: "email", errorType: "invalid" }),
    }),
});

📊 Statistics & Analytics

const guard = new GiggleGuard();
const stats = guard.getStats();

console.log(stats);
// {
//   total: 3000,
//   byFieldType: {
//     email: 150,
//     password: 200,
//     name: 100,
//     ...
//   },
//   byTone: {
//     funny: 400,
//     sarcastic: 350,
//     professional: 300,
//     ...
//   },
//   byErrorType: {
//     required: 500,
//     invalid: 400,
//     tooShort: 300,
//     ...
//   }
// }

❓ FAQ

Q: Will these messages offend my users?
A: All messages are carefully curated to be playful, not offensive.

Q: Can I use this in a professional/corporate environment?
A: Absolutely! Use the professional tone for safer but still friendly humor.

Q: Can I contribute my own funny messages?
A: Yes! Fork the repo and submit a pull request.

Q: Does this work with server-side validation?
A: Yes! Works with browser, Node.js, and even edge functions.

Q: Will the same messages keep repeating?
A: Nope. trackUsedMessages prevents repetition unless you reset.

Q: Can I get message usage stats?
A: Yup! Use getStats() for field/tone/error type analytics.

Q: Can I change tones dynamically?
A: Yes! You can override the tone per message call.

Q: Is it production-ready?
A: Yes! Used in live apps, tested with 3000+ messages.

🤝 Contributing

• Add messages under /src/messages/[fieldType].ts
• Write new tests under /tests
• Keep humor universal, light, and accessible
• Avoid slang that won't age well

📝 License

MIT – Use it anywhere, laugh everywhere.

⭐ Star us on GitHub

If Giggle Guard made you (or your users) smile, give us a ⭐ and spread the laughs!

Made with ❤️ by Pratik Shikhaliya — who's tired of boring error messages.

Remember: Life's too short for "This field is required"