@careflair/common 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export { WorkHistoryInputValidation, WorkHistorySchema, } from "./schemas/workHi
 export { AvailabilitiesSchemaZod, AvailabilityZodInput, } from "./schemas/availabilitySchemaValidation";
 export { HourlyRateInputZod, HourlyRateInputZodType, } from "./schemas/hourlyRateSchemaValidation";
 export { ServicesSchema, validateServices, } from "./schemas/businessServicesValidation";
-export { detectVideoProvider, isValidCommunityVideoUrl, isValidYouTubeOrVimeoUrl, validateVideoLink, VideoProvider, VideoValidationResult, } from "./utils/videoValidation";
+export { VideoProvider, VideoValidationResult, detectVideoProvider, isValidCommunityVideoUrl, isValidYouTubeOrVimeoUrl, validateVideoLink, } from "./utils/videoValidation";

package/dist/interfaces/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/schemas/forms.d.ts

@@ -0,0 +1,210 @@
+import { z } from "zod";
+/**
+ * Registration form schema
+ */
+export declare const registrationFormSchema: z.ZodEffects<z.ZodObject<{
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    email: z.ZodString;
+    username: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+    role: z.ZodEffects<z.ZodString, string, string>;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+    fingerPrint: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    role: string;
+    username: string;
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    fingerPrint?: string | undefined;
+}, {
+    role: string;
+    username: string;
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    fingerPrint?: string | undefined;
+}>, {
+    role: string;
+    username: string;
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    fingerPrint?: string | undefined;
+}, {
+    role: string;
+    username: string;
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    confirmPassword: string;
+    fingerPrint?: string | undefined;
+}>;
+/**
+ * Participant location form schema
+ */
+export declare const participantLocationFormSchema: z.ZodObject<{
+    address: z.ZodEffects<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        label: string;
+    }, {
+        value: string;
+        label: string;
+    }>, {
+        value: string;
+        label: string;
+    }, {
+        value: string;
+        label: string;
+    }>;
+    state: z.ZodEffects<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        label: string;
+    }, {
+        value: string;
+        label: string;
+    }>, {
+        value: string;
+        label: string;
+    }, {
+        value: string;
+        label: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    state: {
+        value: string;
+        label: string;
+    };
+    address: {
+        value: string;
+        label: string;
+    };
+}, {
+    state: {
+        value: string;
+        label: string;
+    };
+    address: {
+        value: string;
+        label: string;
+    };
+}>;
+/**
+ * Contact details form schema
+ */
+export declare const ContactDetailsFormSchema: z.ZodObject<{
+    phone: z.ZodUnion<[z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>, z.ZodLiteral<"">]>;
+    email: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    website: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    enableSmsNotifications: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    email?: string | undefined;
+    phone?: string | undefined;
+    website?: string | undefined;
+    enableSmsNotifications?: boolean | undefined;
+}, {
+    email?: string | undefined;
+    phone?: string | undefined;
+    website?: string | undefined;
+    enableSmsNotifications?: boolean | undefined;
+}>;
+/**
+ * Education and training form schema
+ */
+export declare const EducationAndTrainingFormSchema: z.ZodObject<{
+    type: z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        label: string;
+    }, {
+        value: string;
+        label: string;
+    }>;
+    school: z.ZodString;
+    degree: z.ZodString;
+    startDate: z.ZodDate;
+    endDate: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
+    isCurrentlyStudying: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<false>]>>;
+}, "strip", z.ZodTypeAny, {
+    type: {
+        value: string;
+        label: string;
+    };
+    school: string;
+    degree: string;
+    startDate: Date;
+    endDate?: Date | null | undefined;
+    isCurrentlyStudying?: boolean | undefined;
+}, {
+    type: {
+        value: string;
+        label: string;
+    };
+    school: string;
+    degree: string;
+    startDate: Date;
+    endDate?: Date | null | undefined;
+    isCurrentlyStudying?: boolean | undefined;
+}>;
+/**
+ * Work history form schema
+ */
+export declare const WorkHistoryFormSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    jobTitle: z.ZodString;
+    organisation: z.ZodString;
+    startDate: z.ZodEffects<z.ZodString, string, string>;
+    endDate: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    isCurrentlyWorking: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    startDate: string;
+    jobTitle: string;
+    organisation: string;
+    endDate?: string | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}, {
+    startDate: string;
+    jobTitle: string;
+    organisation: string;
+    endDate?: string | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}>, {
+    startDate: string;
+    jobTitle: string;
+    organisation: string;
+    endDate?: string | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}, {
+    startDate: string;
+    jobTitle: string;
+    organisation: string;
+    endDate?: string | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}>, {
+    startDate: string;
+    jobTitle: string;
+    organisation: string;
+    endDate?: string | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}, {
+    startDate: string;
+    jobTitle: string;
+    organisation: string;
+    endDate?: string | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}>;

package/dist/schemas/forms.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkHistoryFormSchema = exports.EducationAndTrainingFormSchema = exports.ContactDetailsFormSchema = exports.participantLocationFormSchema = exports.registrationFormSchema = void 0;
+const libphonenumber_js_1 = require("libphonenumber-js");
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+const enums_1 = require("../enums");
+const validation_1 = require("./validation");
+/**
+ * Registration form schema
+ */
+exports.registrationFormSchema = zod_1.z
+    .object({
+    firstName: zod_1.z
+        .string()
+        .min(1, "First name is required")
+        .min(limits_1.NAME_MIN_LENGTH, `First name must be at least ${limits_1.NAME_MIN_LENGTH} characters long`)
+        .max(limits_1.NAME_MAX_LENGTH, `First name must be under ${limits_1.NAME_MAX_LENGTH} characters`),
+    lastName: zod_1.z
+        .string()
+        .min(1, "Last name is required")
+        .min(limits_1.NAME_MIN_LENGTH, `Last name must be at least ${limits_1.NAME_MIN_LENGTH} characters long`)
+        .max(limits_1.NAME_MAX_LENGTH, `Last name must be under ${limits_1.NAME_MAX_LENGTH} characters`),
+    email: validation_1.emailSchema,
+    username: zod_1.z
+        .string()
+        .min(1, "Username is required")
+        .min(limits_1.USERNAME_MIN_LENGTH, `Username must be at least ${limits_1.USERNAME_MIN_LENGTH} characters long`)
+        .max(limits_1.USERNAME_MAX_LENGTH, `Username must be under ${limits_1.USERNAME_MAX_LENGTH} characters`)
+        .regex(/^[a-zA-Z0-9_]+$/, "Username can only contain letters, numbers, and underscores")
+        .refine((value) => !value.startsWith("_"), "Username cannot start with an underscore")
+        .refine((value) => !value.endsWith("_"), "Username cannot end with an underscore")
+        .refine((value) => !value.includes("__"), "Username cannot contain consecutive underscores"),
+    role: zod_1.z
+        .string()
+        .min(1, "Please select your role")
+        .refine((val) => Object.values(enums_1.UserRole).includes(val), {
+        message: "Please select a valid role",
+    }),
+    password: validation_1.passwordSchema,
+    confirmPassword: zod_1.z.string().min(1, "Confirm password is required"),
+    fingerPrint: zod_1.z.string().optional(),
+})
+    // Password match validation
+    .refine((data) => data.password === data.confirmPassword, {
+    message: "Passwords don't match",
+    path: ["confirmPassword"],
+});
+/**
+ * Participant location form schema
+ */
+exports.participantLocationFormSchema = zod_1.z.object({
+    address: zod_1.z
+        .object({
+        value: zod_1.z.string(),
+        label: zod_1.z.string(),
+    })
+        .refine((data) => data.value && data.label, {
+        message: "Address is required",
+        path: ["value"],
+    }),
+    state: zod_1.z
+        .object({
+        value: zod_1.z.string(),
+        label: zod_1.z.string(),
+    })
+        .refine((data) => data.value && data.label, {
+        message: "State is required",
+        path: ["value"],
+    }),
+});
+/**
+ * Contact details form schema
+ */
+exports.ContactDetailsFormSchema = zod_1.z.object({
+    phone: zod_1.z
+        .string()
+        .refine((value) => {
+        if (!value)
+            return true; // Allow empty
+        // Validate it's Australian and mobile
+        if (!(0, libphonenumber_js_1.isValidPhoneNumber)(value, "AU"))
+            return false;
+        const parsed = (0, libphonenumber_js_1.parsePhoneNumberFromString)(value, "AU");
+        if (!parsed || parsed.country !== "AU")
+            return false;
+        const type = parsed.getType();
+        return type === "MOBILE" || type === "FIXED_LINE_OR_MOBILE";
+    }, {
+        message: "Please enter a valid Australian mobile number (04XX XXX XXX)",
+    })
+        .optional()
+        .or(zod_1.z.literal("")),
+    email: zod_1.z
+        .string()
+        .email("Invalid email address")
+        .optional()
+        .or(zod_1.z.literal("")),
+    website: zod_1.z
+        .string()
+        .regex(/^(?:https?:\/\/)?[\w-]+(\.[\w-]+)+([\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])?$/, "Invalid URL")
+        .optional()
+        .or(zod_1.z.literal("")),
+    enableSmsNotifications: zod_1.z.boolean().optional(),
+});
+/**
+ * Education and training form schema
+ */
+exports.EducationAndTrainingFormSchema = zod_1.z.object({
+    type: zod_1.z.object({
+        label: zod_1.z.string(),
+        value: zod_1.z.string(),
+    }),
+    school: zod_1.z
+        .string()
+        .min(1, "School/Instituation is required")
+        .max(limits_1.EDUTRAINING_INSTITUTION_MAX_LENGTH, "Institution name is too long"),
+    degree: zod_1.z
+        .string()
+        .min(1, "Degree is required")
+        .max(limits_1.EDUTRAINING_DEGREE_MAX_LENGTH, "Degree is too long"),
+    startDate: zod_1.z.date({
+        required_error: "Start date is required",
+    }),
+    endDate: zod_1.z.date().optional().nullable(),
+    isCurrentlyStudying: zod_1.z.boolean().or(zod_1.z.literal(false)).optional(),
+});
+// Helper function to check if date is in the future
+const isDateInFuture = (date) => {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const compareDate = new Date(date);
+    return compareDate > today;
+};
+// Helper function to check if there's at least 1 month difference
+const isAtLeastOneMonthDifference = (startDate, endDate) => {
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    // Calculate difference in months
+    const diffInMonths = (end.getFullYear() - start.getFullYear()) * 12 +
+        (end.getMonth() - start.getMonth());
+    return diffInMonths >= 1;
+};
+/**
+ * Work history form schema
+ */
+exports.WorkHistoryFormSchema = zod_1.z
+    .object({
+    jobTitle: zod_1.z
+        .string()
+        .min(1, "Job title is required")
+        .max(limits_1.WORK_HISTORY_TITLE_MAX_LENGTH, "Job title is too long"),
+    organisation: zod_1.z
+        .string()
+        .min(1, "Organization is required")
+        .max(limits_1.WORK_HISTORY_ORGANIZATION_MAX_LENGTH, "Organization is too long"),
+    startDate: zod_1.z
+        .string()
+        .min(1, "Start date is required")
+        .refine((date) => !isDateInFuture(date), {
+        message: "Start date cannot be in the future",
+    }),
+    endDate: zod_1.z
+        .string()
+        .optional()
+        .refine((date) => !date || !isDateInFuture(date), {
+        message: "End date cannot be in the future",
+    }),
+    isCurrentlyWorking: zod_1.z.boolean().default(false).optional(),
+})
+    .refine((data) => {
+    // Skip validation if currently working or no end date
+    if (data.isCurrentlyWorking || !data.endDate)
+        return true;
+    // Check if end date is after start date
+    const startDate = new Date(data.startDate);
+    const endDate = new Date(data.endDate);
+    return endDate > startDate;
+}, {
+    message: "End date must be after start date",
+    path: ["endDate"],
+})
+    .refine((data) => {
+    // Skip validation if currently working or no end date
+    if (data.isCurrentlyWorking || !data.endDate)
+        return true;
+    // Check if there's at least 1 month difference
+    return isAtLeastOneMonthDifference(data.startDate, data.endDate);
+}, {
+    message: "There must be at least 1 month between start and end date",
+    path: ["endDate"],
+});

package/dist/schemas/validation.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+/**
+ * Reusable email validation schema
+ */
+export declare const emailSchema: z.ZodString;
+/**
+ * Reusable password validation schema
+ */
+export declare const passwordSchema: z.ZodString;
+/**
+ * Reusable password change schema
+ */
+export declare const passwordChangeSchema: z.ZodEffects<z.ZodObject<{
+    currentPassword: z.ZodString;
+    newPassword: z.ZodString;
+    confirmPassword: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}, {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}>, {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}, {
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+}>;

package/dist/schemas/validation.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.passwordChangeSchema = exports.passwordSchema = exports.emailSchema = void 0;
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+/**
+ * Reusable email validation schema
+ */
+exports.emailSchema = zod_1.z
+    .string()
+    .min(1, "Email is required")
+    .max(limits_1.EMAIL_MAX_LENGTH, "Email is too long")
+    .email("Invalid email")
+    .regex(/^[^+]+@/, "Email aliasing is not allowed");
+/**
+ * Reusable password validation schema
+ */
+exports.passwordSchema = zod_1.z
+    .string()
+    .min(1, "Password is required")
+    .min(limits_1.PASSWORD_MIN_LENGTH, `Password must be at least ${limits_1.PASSWORD_MIN_LENGTH} characters long`)
+    .max(limits_1.PASSWORD_MAX_LENGTH, `Password must be at most ${limits_1.PASSWORD_MAX_LENGTH} characters long`);
+/**
+ * Reusable password change schema
+ */
+exports.passwordChangeSchema = zod_1.z
+    .object({
+    currentPassword: zod_1.z.string().min(1, "Current password is required"),
+    newPassword: exports.passwordSchema,
+    confirmPassword: zod_1.z
+        .string()
+        .min(1, "Confirm password is required")
+        .max(limits_1.PASSWORD_MAX_LENGTH, "Confirm password is too long"),
+})
+    .refine((data) => data.newPassword === data.confirmPassword, {
+    message: "Passwords don't match",
+    path: ["confirmPassword"],
+});

package/dist/utils/date.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Format a date to display relative time (e.g., "2 hours ago", "Yesterday")
+ */
+export declare const formatPostDate: (createdAt: Date) => string;
+/**
+ * Format time difference between two dates (e.g., "2h ago", "3d ago")
+ */
+export declare const formatTimeDifference: (startDate: Date, endDate?: Date) => string;
+/**
+ * Formats date like WhatsApp:
+ * - For today: shows time (e.g., "2:30 PM")
+ * - For yesterday: shows "Yesterday"
+ * - For this week: shows day name (e.g., "Monday", "Tuesday")
+ * - For same year: shows day and month (e.g., "24 Jan")
+ * - For different year: shows day, month, and year (e.g., "24 Jan 2022")
+ */
+export declare const formatWhatsAppStyle: (date: Date | string) => string;
+/**
+ * Format job posting date consistently across the application
+ * Handles timezone conversion from UTC to user's local timezone
+ */
+export declare const formatJobPostDate: (createdAt: string | Date) => string;
+/**
+ * Format job posting date for absolute display (e.g., "Dec 15")
+ * Handles timezone conversion from UTC to user's local timezone
+ */
+export declare const formatJobPostDateAbsolute: (createdAt: string | Date) => string;
+/**
+ * Format a date/time to display in a user-friendly format
+ */
+export declare const formatDateTime: (dateTime: string | Date) => string;
+/**
+ * Format a date to display in a user-friendly format
+ */
+export declare const formatDate: (dateTime: string | Date) => string;

package/dist/utils/date.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDate = exports.formatDateTime = exports.formatJobPostDateAbsolute = exports.formatJobPostDate = exports.formatWhatsAppStyle = exports.formatTimeDifference = exports.formatPostDate = void 0;
+const date_fns_1 = require("date-fns");
+/**
+ * Format a date to display relative time (e.g., "2 hours ago", "Yesterday")
+ */
+const formatPostDate = (createdAt) => {
+    const now = new Date();
+    const minutesAgo = (0, date_fns_1.differenceInMinutes)(now, createdAt);
+    const hoursAgo = (0, date_fns_1.differenceInHours)(now, createdAt);
+    const daysAgo = (0, date_fns_1.differenceInDays)(now, createdAt);
+    if (minutesAgo < 1) {
+        return "Just now";
+    }
+    if (minutesAgo < 60) {
+        return `${minutesAgo} minute${minutesAgo > 1 ? "s" : ""} ago`;
+    }
+    if (hoursAgo < 24) {
+        return `${hoursAgo} hour${hoursAgo > 1 ? "s" : ""} ago`;
+    }
+    if (daysAgo === 1) {
+        return "Yesterday";
+    }
+    if (daysAgo <= 7) {
+        return `${daysAgo} day${daysAgo > 1 ? "s" : ""} ago`;
+    }
+    // For older posts, show a formatted date
+    return (0, date_fns_1.format)(createdAt, "MMMM d, yyyy h:mm a"); // For example: "January 15, 2023 2:45 PM"
+};
+exports.formatPostDate = formatPostDate;
+/**
+ * Format time difference between two dates (e.g., "2h ago", "3d ago")
+ */
+const formatTimeDifference = (startDate, endDate = new Date()) => {
+    const duration = (0, date_fns_1.intervalToDuration)({ start: startDate, end: endDate });
+    const minutesDifference = (0, date_fns_1.differenceInMinutes)(endDate, startDate);
+    // Return "just now" if less than 2 minutes
+    if (minutesDifference < 2) {
+        return "just now";
+    }
+    if (duration.years && duration.years >= 1) {
+        return `${duration.years}y ago`;
+    }
+    if (duration.weeks && duration.weeks >= 1) {
+        return `${duration.weeks}w ago`;
+    }
+    if (duration.days && duration.days >= 1) {
+        return `${duration.days}d ago`;
+    }
+    if (duration.hours && duration.hours >= 1) {
+        return `${duration.hours}h ago`;
+    }
+    if (duration.minutes && duration.minutes >= 1) {
+        return `${duration.minutes}m ago`;
+    }
+    return "just now"; // fallback if less than 1 minute
+};
+exports.formatTimeDifference = formatTimeDifference;
+/**
+ * Formats date like WhatsApp:
+ * - For today: shows time (e.g., "2:30 PM")
+ * - For yesterday: shows "Yesterday"
+ * - For this week: shows day name (e.g., "Monday", "Tuesday")
+ * - For same year: shows day and month (e.g., "24 Jan")
+ * - For different year: shows day, month, and year (e.g., "24 Jan 2022")
+ */
+const formatWhatsAppStyle = (date) => {
+    if (!date)
+        return "";
+    const messageDate = typeof date === "string" ? new Date(date) : date;
+    const now = new Date();
+    // Invalid date
+    if (isNaN(messageDate.getTime()))
+        return "";
+    // Today: show time (e.g., "2:30 PM")
+    if ((0, date_fns_1.isToday)(messageDate)) {
+        return (0, date_fns_1.format)(messageDate, "h:mm a");
+    }
+    // Yesterday: show "Yesterday"
+    if ((0, date_fns_1.isYesterday)(messageDate)) {
+        return "Yesterday";
+    }
+    // This week (but not today or yesterday): show day name (e.g., "Monday")
+    if ((0, date_fns_1.isSameWeek)(messageDate, now)) {
+        return (0, date_fns_1.format)(messageDate, "EEEE"); // Full day name
+    }
+    // Same year: show date without year (e.g., "24 Jan")
+    if ((0, date_fns_1.isSameYear)(messageDate, now)) {
+        return (0, date_fns_1.format)(messageDate, "d MMM");
+    }
+    // Different year: show date with year (e.g., "24 Jan 2022")
+    return (0, date_fns_1.format)(messageDate, "d MMM yyyy");
+};
+exports.formatWhatsAppStyle = formatWhatsAppStyle;
+/**
+ * Format job posting date consistently across the application
+ * Handles timezone conversion from UTC to user's local timezone
+ */
+const formatJobPostDate = (createdAt) => {
+    if (!createdAt)
+        return "";
+    const postDate = typeof createdAt === "string" ? new Date(createdAt) : createdAt;
+    const now = new Date();
+    // Invalid date
+    if (isNaN(postDate.getTime()))
+        return "";
+    const minutesAgo = (0, date_fns_1.differenceInMinutes)(now, postDate);
+    const hoursAgo = (0, date_fns_1.differenceInHours)(now, postDate);
+    const daysAgo = (0, date_fns_1.differenceInDays)(now, postDate);
+    if (minutesAgo < 1) {
+        return "Just now";
+    }
+    if (minutesAgo < 60) {
+        return `${minutesAgo} minute${minutesAgo > 1 ? "s" : ""} ago`;
+    }
+    if (hoursAgo < 24) {
+        return `${hoursAgo} hour${hoursAgo > 1 ? "s" : ""} ago`;
+    }
+    if (daysAgo === 1) {
+        return "Yesterday";
+    }
+    if (daysAgo <= 7) {
+        return `${daysAgo} day${daysAgo > 1 ? "s" : ""} ago`;
+    }
+    // For older posts, show formatted date in user's timezone
+    return (0, date_fns_1.format)(postDate, "MMM d");
+};
+exports.formatJobPostDate = formatJobPostDate;
+/**
+ * Format job posting date for absolute display (e.g., "Dec 15")
+ * Handles timezone conversion from UTC to user's local timezone
+ */
+const formatJobPostDateAbsolute = (createdAt) => {
+    if (!createdAt)
+        return "";
+    const postDate = typeof createdAt === "string" ? new Date(createdAt) : createdAt;
+    // Invalid date
+    if (isNaN(postDate.getTime()))
+        return "";
+    // Format date in user's local timezone
+    return (0, date_fns_1.format)(postDate, "MMM d");
+};
+exports.formatJobPostDateAbsolute = formatJobPostDateAbsolute;
+/**
+ * Format a date/time to display in a user-friendly format
+ */
+const formatDateTime = (dateTime) => {
+    return new Date(dateTime).toLocaleTimeString("en-US", {
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true,
+    });
+};
+exports.formatDateTime = formatDateTime;
+/**
+ * Format a date to display in a user-friendly format
+ */
+const formatDate = (dateTime) => {
+    return new Date(dateTime).toLocaleDateString("en-US", {
+        weekday: "long",
+        month: "short",
+        day: "numeric",
+    });
+};
+exports.formatDate = formatDate;

package/dist/utils/debounce.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Creates a debounced version of a function
+ * Platform-agnostic implementation that works in both browser and Node.js
+ * @param func - The function to debounce
+ * @param delay - The delay in milliseconds
+ * @returns A debounced function
+ */
+export declare function debounce<T extends (...args: any[]) => void>(func: T, delay: number): (...args: Parameters<T>) => void;

package/dist/utils/debounce.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = debounce;
+/**
+ * Creates a debounced version of a function
+ * Platform-agnostic implementation that works in both browser and Node.js
+ * @param func - The function to debounce
+ * @param delay - The delay in milliseconds
+ * @returns A debounced function
+ */
+function debounce(func, delay) {
+    let timer;
+    return (...args) => {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+        timer = setTimeout(() => {
+            func(...args);
+            timer = undefined;
+        }, delay);
+    };
+}

package/dist/utils/enum.d.ts

@@ -0,0 +1,6 @@
+type Option = {
+    label: string;
+    value: string;
+};
+export declare function enumToOptions<T extends Record<string, string>>(enumObj: T): Option[];
+export {};

package/dist/utils/enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumToOptions = enumToOptions;
+function enumToOptions(enumObj) {
+    return Object.values(enumObj).map((value) => ({
+        label: value, // Use the enum value for the label
+        value: value, // Use the enum value for the value
+    }));
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./phone";
+export * from "./date";
+export * from "./time";
+export * from "./debounce";
+export * from "./enum";
+export * from "./video";

package/dist/utils/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Phone validation utilities
+__exportStar(require("./phone"), exports);
+// Date formatting utilities
+__exportStar(require("./date"), exports);
+// Time/shift utilities
+__exportStar(require("./time"), exports);
+// Functional utilities
+__exportStar(require("./debounce"), exports);
+// Enum utilities
+__exportStar(require("./enum"), exports);
+// Video validation utilities
+__exportStar(require("./video"), exports);

package/dist/utils/phone.d.ts

@@ -0,0 +1,9 @@
+export type PhoneValidationResult = {
+    isValid: boolean;
+    error?: string;
+    formattedNumber?: string;
+};
+/**
+ * Validates an Australian phone number (mobile only)
+ */
+export declare function validateAustralianPhoneNumber(phoneNumber: string): PhoneValidationResult;

package/dist/utils/phone.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAustralianPhoneNumber = validateAustralianPhoneNumber;
+const libphonenumber_js_1 = require("libphonenumber-js");
+/**
+ * Validates an Australian phone number (mobile only)
+ */
+function validateAustralianPhoneNumber(phoneNumber) {
+    try {
+        // Trim whitespace
+        const trimmedNumber = phoneNumber.trim();
+        // Check if empty
+        if (!trimmedNumber) {
+            return {
+                isValid: false,
+                error: "Phone number cannot be empty",
+            };
+        }
+        // Check if it's a valid Australian mobile number
+        if (!(0, libphonenumber_js_1.isValidPhoneNumber)(trimmedNumber, "AU")) {
+            return {
+                isValid: false,
+                error: "Please enter a valid Australian phone number",
+            };
+        }
+        const parsedNumber = (0, libphonenumber_js_1.parsePhoneNumberFromString)(trimmedNumber, "AU");
+        if (!parsedNumber || parsedNumber.country !== "AU") {
+            return {
+                isValid: false,
+                error: "Please enter a valid Australian phone number",
+            };
+        }
+        // Check if it's a mobile number (landlines not allowed)
+        const numberType = parsedNumber.getType();
+        if (numberType !== "MOBILE" && numberType !== "FIXED_LINE_OR_MOBILE") {
+            return {
+                isValid: false,
+                error: "Only Australian mobile numbers are allowed",
+            };
+        }
+        // Just return valid - no formatting needed
+        return {
+            isValid: true,
+        };
+    }
+    catch {
+        return {
+            isValid: false,
+            error: "Please enter a valid Australian phone number",
+        };
+    }
+}

package/dist/utils/time.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Parse time string to minutes for comparison
+ */
+export declare const parseTimeToMinutes: (timeStr: string) => number;
+/**
+ * Get shift duration in minutes
+ */
+export declare const getShiftDurationMinutes: (startTime: string, endTime: string) => number;
+/**
+ * Get shift duration in hours
+ */
+export declare const getShiftDurationHours: (startTime: string, endTime: string) => number;
+/**
+ * Check if two shifts overlap
+ */
+export declare const areShiftsOverlapping: (shift1: {
+    startTime: string;
+    endTime: string;
+}, shift2: {
+    startTime: string;
+    endTime: string;
+}) => boolean;
+/**
+ * Check if shifts overlap for a given day
+ */
+export declare const checkForOverlappingShifts: (shifts: {
+    startTime: string;
+    endTime: string;
+}[]) => boolean;
+/**
+ * Check if a shift is too short (less than minimum minutes)
+ */
+export declare const isShiftTooShort: (shift: {
+    startTime: string;
+    endTime: string;
+}, minimumMinutes?: number) => boolean;
+/**
+ * Validate a single shift
+ */
+export declare const validateShift: (shift: {
+    startTime: string;
+    endTime: string;
+}, allShifts: {
+    startTime: string;
+    endTime: string;
+}[], shiftIndex: number) => {
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * Generate a new shift time based on the last shift
+ */
+export declare const generateNewShiftTime: (lastShift?: {
+    startTime: string;
+    endTime: string;
+}) => {
+    startTime: string;
+    endTime: string;
+};
+/**
+ * Convert time string to ISO format
+ */
+export declare const timeStringToISO: (timeString: string) => string;

package/dist/utils/time.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeStringToISO = exports.generateNewShiftTime = exports.validateShift = exports.isShiftTooShort = exports.checkForOverlappingShifts = exports.areShiftsOverlapping = exports.getShiftDurationHours = exports.getShiftDurationMinutes = exports.parseTimeToMinutes = void 0;
+const date_fns_1 = require("date-fns");
+/**
+ * Parse time string to minutes for comparison
+ */
+const parseTimeToMinutes = (timeStr) => {
+    const [hours, minutes] = timeStr.split(":").map(Number);
+    return hours * 60 + minutes;
+};
+exports.parseTimeToMinutes = parseTimeToMinutes;
+/**
+ * Get shift duration in minutes
+ */
+const getShiftDurationMinutes = (startTime, endTime) => {
+    return (0, exports.parseTimeToMinutes)(endTime) - (0, exports.parseTimeToMinutes)(startTime);
+};
+exports.getShiftDurationMinutes = getShiftDurationMinutes;
+/**
+ * Get shift duration in hours
+ */
+const getShiftDurationHours = (startTime, endTime) => {
+    return (0, exports.getShiftDurationMinutes)(startTime, endTime) / 60;
+};
+exports.getShiftDurationHours = getShiftDurationHours;
+/**
+ * Check if two shifts overlap
+ */
+const areShiftsOverlapping = (shift1, shift2) => {
+    const start1 = (0, exports.parseTimeToMinutes)(shift1.startTime);
+    const end1 = (0, exports.parseTimeToMinutes)(shift1.endTime);
+    const start2 = (0, exports.parseTimeToMinutes)(shift2.startTime);
+    const end2 = (0, exports.parseTimeToMinutes)(shift2.endTime);
+    return start1 < end2 && start2 < end1;
+};
+exports.areShiftsOverlapping = areShiftsOverlapping;
+/**
+ * Check if shifts overlap for a given day
+ */
+const checkForOverlappingShifts = (shifts) => {
+    if (shifts.length <= 1)
+        return false;
+    // Sort shifts by start time
+    const sortedShifts = [...shifts].sort((a, b) => {
+        return (new Date(`2023-01-01T${a.startTime}`).getTime() -
+            new Date(`2023-01-01T${b.startTime}`).getTime());
+    });
+    // Check for overlaps
+    for (let i = 0; i < sortedShifts.length - 1; i++) {
+        const currentShiftEnd = new Date(`2023-01-01T${sortedShifts[i].endTime}`);
+        const nextShiftStart = new Date(`2023-01-01T${sortedShifts[i + 1].startTime}`);
+        if (currentShiftEnd > nextShiftStart) {
+            return true; // Found an overlap
+        }
+    }
+    return false;
+};
+exports.checkForOverlappingShifts = checkForOverlappingShifts;
+/**
+ * Check if a shift is too short (less than minimum minutes)
+ */
+const isShiftTooShort = (shift, minimumMinutes = 60) => {
+    const startTime = new Date(`2023-01-01T${shift.startTime}`);
+    const endTime = new Date(`2023-01-01T${shift.endTime}`);
+    // Calculate difference in minutes
+    const diffMinutes = (endTime.getTime() - startTime.getTime()) / (1000 * 60);
+    return diffMinutes < minimumMinutes;
+};
+exports.isShiftTooShort = isShiftTooShort;
+/**
+ * Validate a single shift
+ */
+const validateShift = (shift, allShifts, shiftIndex) => {
+    const errors = [];
+    const warnings = [];
+    // 1. Check if times are provided
+    if (!shift.startTime || !shift.endTime) {
+        errors.push("Both start and end times are required");
+        return { errors, warnings };
+    }
+    // 2. End time after start time
+    if ((0, exports.parseTimeToMinutes)(shift.endTime) <= (0, exports.parseTimeToMinutes)(shift.startTime)) {
+        errors.push("End time must be after start time");
+    }
+    else {
+        // 3. Minimum shift duration (1 hour)
+        const durationHours = (0, exports.getShiftDurationHours)(shift.startTime, shift.endTime);
+        if (durationHours < 1) {
+            errors.push("Shift must be at least 1 hour");
+        }
+        // 4. Maximum shift duration (12 hours)
+        if (durationHours > 12) {
+            errors.push("Shift must be at most 12 hours");
+        }
+    }
+    // 5. Check for overlapping shifts
+    const otherShifts = [...allShifts];
+    otherShifts.splice(shiftIndex, 1); // Remove current shift from array
+    for (let i = 0; i < otherShifts.length; i++) {
+        if ((0, exports.areShiftsOverlapping)(shift, otherShifts[i])) {
+            errors.push("Shifts cannot overlap");
+            break;
+        }
+    }
+    return { errors, warnings };
+};
+exports.validateShift = validateShift;
+/**
+ * Generate a new shift time based on the last shift
+ */
+const generateNewShiftTime = (lastShift) => {
+    let newStartTime = "09:00";
+    let newEndTime = "10:00";
+    if (lastShift) {
+        // Start the new shift right after the last shift ends (no gap)
+        const lastEndTime = new Date(`2023-01-01T${lastShift.endTime}`);
+        // Format the new start time
+        newStartTime = (0, date_fns_1.format)(lastEndTime, "HH:mm");
+        // Set end time 1 hour after start time
+        const newEnd = new Date(lastEndTime);
+        newEnd.setHours(newEnd.getHours() + 1);
+        newEndTime = (0, date_fns_1.format)(newEnd, "HH:mm");
+    }
+    return { startTime: newStartTime, endTime: newEndTime };
+};
+exports.generateNewShiftTime = generateNewShiftTime;
+/**
+ * Convert time string to ISO format
+ */
+const timeStringToISO = (timeString) => {
+    return new Date(`2023-01-01T${timeString}`).toISOString();
+};
+exports.timeStringToISO = timeStringToISO;

package/dist/utils/video.d.ts

@@ -0,0 +1,25 @@
+export type VideoProvider = "youtube" | "vimeo" | "loom" | "tiktok";
+export interface VideoValidationResult {
+    isValid: boolean;
+    provider?: VideoProvider;
+    error?: string;
+}
+/**
+ * Unified video link validation function
+ * @param url - The video URL to validate
+ * @param allowedProviders - Array of allowed video providers
+ * @returns VideoValidationResult object
+ */
+export declare function validateVideoLink(url: string, allowedProviders: VideoProvider[]): VideoValidationResult;
+/**
+ * Detect video provider from URL
+ */
+export declare function detectVideoProvider(url: string): VideoProvider | null;
+/**
+ * Check if URL is valid YouTube or Vimeo URL
+ */
+export declare function isValidYouTubeOrVimeoUrl(url: string): boolean;
+/**
+ * Check if URL is valid community video URL (YouTube, Vimeo, Loom, TikTok)
+ */
+export declare function isValidCommunityVideoUrl(url: string): boolean;

package/dist/utils/video.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateVideoLink = validateVideoLink;
+exports.detectVideoProvider = detectVideoProvider;
+exports.isValidYouTubeOrVimeoUrl = isValidYouTubeOrVimeoUrl;
+exports.isValidCommunityVideoUrl = isValidCommunityVideoUrl;
+/**
+ * Unified video link validation function
+ * @param url - The video URL to validate
+ * @param allowedProviders - Array of allowed video providers
+ * @returns VideoValidationResult object
+ */
+function validateVideoLink(url, allowedProviders) {
+    if (!url || url.trim() === "") {
+        return { isValid: true }; // Empty URL is valid (optional field)
+    }
+    const trimmedUrl = url.trim();
+    // Validate URL format
+    if (!isValidURL(trimmedUrl)) {
+        return { isValid: false, error: "Invalid URL format" };
+    }
+    const provider = detectVideoProvider(trimmedUrl);
+    if (!provider) {
+        return {
+            isValid: false,
+            error: `Unsupported video provider. Supported: ${allowedProviders.join(", ")}`,
+        };
+    }
+    if (!allowedProviders.includes(provider)) {
+        return {
+            isValid: false,
+            error: `${provider} is not allowed. Supported: ${allowedProviders.join(", ")}`,
+        };
+    }
+    return { isValid: true, provider };
+}
+/**
+ * Detect video provider from URL
+ */
+function detectVideoProvider(url) {
+    const trimmedUrl = url.trim().toLowerCase();
+    if (trimmedUrl.includes("youtube.com") || trimmedUrl.includes("youtu.be")) {
+        return "youtube";
+    }
+    if (trimmedUrl.includes("vimeo.com")) {
+        return "vimeo";
+    }
+    if (trimmedUrl.includes("loom.com")) {
+        return "loom";
+    }
+    if (trimmedUrl.includes("tiktok.com")) {
+        return "tiktok";
+    }
+    return null;
+}
+/**
+ * Check if URL is valid YouTube or Vimeo URL
+ */
+function isValidYouTubeOrVimeoUrl(url) {
+    const provider = detectVideoProvider(url);
+    return provider === "youtube" || provider === "vimeo";
+}
+/**
+ * Check if URL is valid community video URL (YouTube, Vimeo, Loom, TikTok)
+ */
+function isValidCommunityVideoUrl(url) {
+    return detectVideoProvider(url) !== null;
+}
+/**
+ * Basic URL validation
+ */
+function isValidURL(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@careflair/common",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Shared assets for CareFlair",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,8 @@
   "author": "Farhan Hossain",
   "license": "ISC",
   "dependencies": {
+    "date-fns": "^4.1.0",
+    "libphonenumber-js": "^1.12.25",
     "zod": "^3.23.8"
   },
   "files": [