@careflair/common 1.0.4 → 1.0.6

package/dist/schemas/workHistorySchema.js

@@ -1,28 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkHistorySchema = void 0;
-const zod_1 = require("zod");
-const limits_1 = require("../constants/limits");
-exports.WorkHistorySchema = 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 must be at most ${limits_1.WORK_HISTORY_TITLE_MAX_LENGTH} characters long`),
-    startDate: zod_1.z.date(),
-    endDate: zod_1.z.date().optional().nullable(),
-    organisation: zod_1.z
-        .string()
-        .min(1, "Organisation is required")
-        .max(limits_1.WORK_HISTORY_ORGANIZATION_MAX_LENGTH, `Organisation must be at most ${limits_1.WORK_HISTORY_ORGANIZATION_MAX_LENGTH} characters long`),
-    isCurrentlyWorking: zod_1.z.boolean().default(false),
-})
-    .refine((data) => {
-    if (data.endDate) {
-        return !data.isCurrentlyWorking;
-    }
-    return data.isCurrentlyWorking || data.endDate !== undefined;
-}, {
-    message: "If there is an endDate, is Currently Working must be false. If is Currently Working is false, endDate must be provided.",
-    path: ["endDate", "isCurrentlyWorking"],
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkHistorySchema = void 0;
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+exports.WorkHistorySchema = 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 must be at most ${limits_1.WORK_HISTORY_TITLE_MAX_LENGTH} characters long`),
+    startDate: zod_1.z.date(),
+    endDate: zod_1.z.date().optional().nullable(),
+    organisation: zod_1.z
+        .string()
+        .min(1, "Organisation is required")
+        .max(limits_1.WORK_HISTORY_ORGANIZATION_MAX_LENGTH, `Organisation must be at most ${limits_1.WORK_HISTORY_ORGANIZATION_MAX_LENGTH} characters long`),
+    isCurrentlyWorking: zod_1.z.boolean().default(false),
+})
+    .refine((data) => {
+    if (data.endDate) {
+        return !data.isCurrentlyWorking;
+    }
+    return data.isCurrentlyWorking || data.endDate !== undefined;
+}, {
+    message: "If there is an endDate, is Currently Working must be false. If is Currently Working is false, endDate must be provided.",
+    path: ["endDate", "isCurrentlyWorking"],
+});

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/utils.d.ts

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

package/dist/utils/utils.js

@@ -1,9 +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
-    }));
-}
+"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/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;