@careflair/common 1.0.0

package/dist/schemas/availabilitySchemaValidation.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailabilitiesSchemaZod = void 0;
+const zod_1 = require("zod");
+// Regular expression for both 12-hour (with AM/PM) and 24-hour format
+const timeRegex = /^(0?[1-9]|1[0-2]):([0-5][0-9]) (AM|PM)$/i; // 12-hour format with AM/PM
+const timeRegex24Hour = /^(2[0-3]|[01]?[0-9]):([0-5][0-9])$/; // 24-hour format (00:00 to 23:59)
+// Function to convert time string to minutes
+const convertToMinutes = (time) => {
+    let hours, minutes;
+    // Check if it's a 12-hour format with AM/PM
+    if (timeRegex.test(time)) {
+        const [timeString, period] = time.split(' ');
+        const [hour, minute] = timeString.split(':').map(Number);
+        hours = hour;
+        minutes = minute;
+        if (period.toLowerCase() === 'pm' && hours !== 12) {
+            hours += 12; // Convert PM to 24-hour format
+        }
+        else if (period.toLowerCase() === 'am' && hours === 12) {
+            hours = 0; // Handle 12 AM as 0 hours
+        }
+    }
+    else if (timeRegex24Hour.test(time)) {
+        // Handle 24-hour format (e.g., "14:00")
+        const [hour, minute] = time.split(':').map(Number);
+        hours = hour;
+        minutes = minute;
+    }
+    else {
+        throw new Error('Invalid time format');
+    }
+    return hours * 60 + minutes; // Convert to total minutes since midnight
+};
+// Shift schema with time validation
+const ShiftSchema = zod_1.z.object({
+    startTime: zod_1.z.string().refine(time => timeRegex.test(time) || timeRegex24Hour.test(time), 'Invalid start time format'),
+    endTime: zod_1.z.string().refine(time => timeRegex.test(time) || timeRegex24Hour.test(time), 'Invalid end time format'),
+}).refine((data) => {
+    // Convert times to minutes for comparison
+    const startInMinutes = convertToMinutes(data.startTime);
+    const endInMinutes = convertToMinutes(data.endTime);
+    return startInMinutes < endInMinutes; // Ensure start time is before end time
+}, {
+    message: 'Start time must be before end time',
+    path: ['startTime', 'endTime'],
+});
+// Availability schema with shift overlap validation
+const AvailabilitySchemaZod = zod_1.z.object({
+    day: zod_1.z.string(),
+    isEnabled: zod_1.z.boolean().default(true),
+    shifts: zod_1.z.array(ShiftSchema).refine(shifts => {
+        // Sort shifts by start time (in minutes)
+        const sortedShifts = shifts.sort((a, b) => {
+            const startA = convertToMinutes(a.startTime);
+            const startB = convertToMinutes(b.startTime);
+            return startA - startB;
+        });
+        // Ensure no overlapping shifts
+        for (let i = 0; i < sortedShifts.length - 1; i++) {
+            const endCurrent = convertToMinutes(sortedShifts[i].endTime);
+            const startNext = convertToMinutes(sortedShifts[i + 1].startTime);
+            if (endCurrent > startNext) {
+                return false;
+            }
+        }
+        return true;
+    }, {
+        message: 'Shifts cannot overlap',
+    }),
+});
+// Schema for the entire availability array (the list of availabilities)
+exports.AvailabilitiesSchemaZod = zod_1.z.array(AvailabilitySchemaZod).refine(availabilities => {
+    const days = availabilities.map(a => a.day);
+    const uniqueDays = new Set(days);
+    return days.length === uniqueDays.size; // Ensure no duplicate days
+}, {
+    message: 'There should be no duplicate days',
+});

package/dist/schemas/businessServicesValidation.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { CategoryEnum, SupportWorkerService } from '../enums';
+export declare const ServicesSchema: z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof CategoryEnum>, "many">>, CategoryEnum[] | undefined, CategoryEnum[] | undefined>;
+export declare const validateServices: (services?: string[]) => boolean;
+export declare const SupportWorkerServicesSchema: z.ZodEffects<z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof SupportWorkerService>, "many">>, SupportWorkerService[] | undefined, SupportWorkerService[] | undefined>;
+export declare const validateSupportWorkerServices: (services?: string[]) => boolean;

package/dist/schemas/businessServicesValidation.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSupportWorkerServices = exports.SupportWorkerServicesSchema = exports.validateServices = exports.ServicesSchema = void 0;
+const zod_1 = require("zod");
+const enums_1 = require("../enums");
+exports.ServicesSchema = zod_1.z
+    .array(zod_1.z.nativeEnum(enums_1.CategoryEnum))
+    .optional()
+    .refine((services) => !services || services.every((service) => Object.values(enums_1.CategoryEnum).includes(service)), { message: 'Invalid services provided.' });
+const validateServices = (services) => {
+    const result = exports.ServicesSchema.safeParse(services);
+    return result.success;
+};
+exports.validateServices = validateServices;
+exports.SupportWorkerServicesSchema = zod_1.z
+    .array(zod_1.z.nativeEnum(enums_1.SupportWorkerService))
+    .optional()
+    .refine((services) => !services || services.every((service) => Object.values(enums_1.SupportWorkerService).includes(service)), { message: 'Invalid services provided.' });
+const validateSupportWorkerServices = (services) => {
+    const result = exports.SupportWorkerServicesSchema.safeParse(services);
+    return result.success;
+};
+exports.validateSupportWorkerServices = validateSupportWorkerServices;

package/dist/schemas/educationSchemas.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const EducationAndTrainingSchema: z.ZodEffects<z.ZodObject<{
+    school: z.ZodString;
+    type: z.ZodString;
+    degree: z.ZodString;
+    startDate: z.ZodDate;
+    endDate: z.ZodOptional<z.ZodDate>;
+    isCurrentlyStudying: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    school: string;
+    degree: string;
+    startDate: Date;
+    isCurrentlyStudying: boolean;
+    endDate?: Date | undefined;
+}, {
+    type: string;
+    school: string;
+    degree: string;
+    startDate: Date;
+    endDate?: Date | undefined;
+    isCurrentlyStudying?: boolean | undefined;
+}>, {
+    type: string;
+    school: string;
+    degree: string;
+    startDate: Date;
+    isCurrentlyStudying: boolean;
+    endDate?: Date | undefined;
+}, {
+    type: string;
+    school: string;
+    degree: string;
+    startDate: Date;
+    endDate?: Date | undefined;
+    isCurrentlyStudying?: boolean | undefined;
+}>;
+export type EducationAndTrainingInputValidation = z.infer<typeof EducationAndTrainingSchema>;

package/dist/schemas/educationSchemas.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EducationAndTrainingSchema = void 0;
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+exports.EducationAndTrainingSchema = zod_1.z
+    .object({
+    school: zod_1.z
+        .string()
+        .min(1, "School is required")
+        .max(limits_1.EDUTRAINING_INSTITUTION_MAX_LENGTH, `School name must be at most ${limits_1.EDUTRAINING_INSTITUTION_MAX_LENGTH} characters long`),
+    type: zod_1.z.string().min(1, "Type of education is required"),
+    degree: zod_1.z
+        .string()
+        .min(1, "Degree is required")
+        .max(limits_1.EDUTRAINING_DEGREE_MAX_LENGTH, `Degree must be at most ${limits_1.EDUTRAINING_DEGREE_MAX_LENGTH} characters long`),
+    startDate: zod_1.z.date(),
+    endDate: zod_1.z.date().optional(),
+    isCurrentlyStudying: zod_1.z.boolean().default(false),
+})
+    .refine((data) => {
+    if (data.endDate) {
+        return !data.isCurrentlyStudying;
+    }
+    return data.isCurrentlyStudying || data.endDate !== undefined;
+}, {
+    message: "If there is an endDate, is Currently Studying must be false. If is Currently Studying is false, endDate must be provided.",
+    path: ["endDate", "isCurrentlyStudying"],
+});

package/dist/schemas/hourlyRateSchemaValidation.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const HourlyRateInputZod: z.ZodObject<{
+    service: z.ZodString;
+    dayRates: z.ZodEffects<z.ZodArray<z.ZodObject<{
+        day: z.ZodString;
+        price: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        day: string;
+        price: number;
+    }, {
+        day: string;
+        price: number;
+    }>, "many">, {
+        day: string;
+        price: number;
+    }[], {
+        day: string;
+        price: number;
+    }[]>;
+    isNegotiable: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    service: string;
+    dayRates: {
+        day: string;
+        price: number;
+    }[];
+    isNegotiable?: boolean | undefined;
+}, {
+    service: string;
+    dayRates: {
+        day: string;
+        price: number;
+    }[];
+    isNegotiable?: boolean | undefined;
+}>;
+export type HourlyRateInputZodType = z.infer<typeof HourlyRateInputZod>;

package/dist/schemas/hourlyRateSchemaValidation.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HourlyRateInputZod = void 0;
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+// DayRateInput validation: Check for duplicate days in the input
+const DayRateInputZod = zod_1.z.object({
+    day: zod_1.z.string(),
+    price: zod_1.z
+        .number()
+        .min(limits_1.MIN_HOURLY_RATE, `Hourly rate must be at least $${limits_1.MIN_HOURLY_RATE}`)
+        .max(limits_1.MAX_HOURLY_RATE, `Hourly rate must be at most $${limits_1.MAX_HOURLY_RATE}`),
+});
+// HourlyRateInput validation: Validate dayRates for duplicates
+exports.HourlyRateInputZod = zod_1.z.object({
+    service: zod_1.z.string(),
+    dayRates: zod_1.z.array(DayRateInputZod).refine((data) => {
+        const days = data.map((dayRate) => dayRate.day);
+        const uniqueDays = new Set(days);
+        return days.length === uniqueDays.size; // Ensure no duplicate days
+    }, {
+        message: "There should be no duplicate days in dayRates",
+    }),
+    isNegotiable: zod_1.z.boolean().optional(),
+});

package/dist/schemas/index.d.ts

@@ -0,0 +1,6 @@
+export { UserRegistrationSchema, UserRegistrationInput } from './userValiationSchema';
+export { EducationAndTrainingSchema, EducationAndTrainingInputValidation } from './educationSchemas';
+export { WorkHistorySchema, WorkHistoryInputValidation } from './workHistorySchema';
+export { AvailabilitiesSchemaZod, AvailabilityZodInput } from './availabilitySchemaValidation';
+export { HourlyRateInputZod, HourlyRateInputZodType } from './hourlyRateSchemaValidation';
+export { validateServices, ServicesSchema, SupportWorkerServicesSchema, validateSupportWorkerServices } from './businessServicesValidation';

package/dist/schemas/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSupportWorkerServices = exports.SupportWorkerServicesSchema = exports.ServicesSchema = exports.validateServices = exports.HourlyRateInputZod = exports.AvailabilitiesSchemaZod = exports.WorkHistorySchema = exports.EducationAndTrainingSchema = exports.UserRegistrationSchema = void 0;
+var userValiationSchema_1 = require("./userValiationSchema");
+Object.defineProperty(exports, "UserRegistrationSchema", { enumerable: true, get: function () { return userValiationSchema_1.UserRegistrationSchema; } });
+var educationSchemas_1 = require("./educationSchemas");
+Object.defineProperty(exports, "EducationAndTrainingSchema", { enumerable: true, get: function () { return educationSchemas_1.EducationAndTrainingSchema; } });
+var workHistorySchema_1 = require("./workHistorySchema");
+Object.defineProperty(exports, "WorkHistorySchema", { enumerable: true, get: function () { return workHistorySchema_1.WorkHistorySchema; } });
+var availabilitySchemaValidation_1 = require("./availabilitySchemaValidation");
+Object.defineProperty(exports, "AvailabilitiesSchemaZod", { enumerable: true, get: function () { return availabilitySchemaValidation_1.AvailabilitiesSchemaZod; } });
+var hourlyRateSchemaValidation_1 = require("./hourlyRateSchemaValidation");
+Object.defineProperty(exports, "HourlyRateInputZod", { enumerable: true, get: function () { return hourlyRateSchemaValidation_1.HourlyRateInputZod; } });
+var businessServicesValidation_1 = require("./businessServicesValidation");
+Object.defineProperty(exports, "validateServices", { enumerable: true, get: function () { return businessServicesValidation_1.validateServices; } });
+Object.defineProperty(exports, "ServicesSchema", { enumerable: true, get: function () { return businessServicesValidation_1.ServicesSchema; } });
+Object.defineProperty(exports, "SupportWorkerServicesSchema", { enumerable: true, get: function () { return businessServicesValidation_1.SupportWorkerServicesSchema; } });
+Object.defineProperty(exports, "validateSupportWorkerServices", { enumerable: true, get: function () { return businessServicesValidation_1.validateSupportWorkerServices; } });

package/dist/schemas/userValiationSchema.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const UserRegistrationSchema: z.ZodObject<{
+    email: z.ZodEffects<z.ZodString, string, string>;
+    username: z.ZodString;
+    password: z.ZodString;
+    role: z.ZodEnum<["business", "provider", "participant", "support_person", "support_worker"]>;
+    fingerPrint: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    isSmallProvider: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    role: "business" | "provider" | "participant" | "support_person" | "support_worker";
+    username: string;
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    isSmallProvider: boolean;
+    fingerPrint?: string | undefined;
+}, {
+    role: "business" | "provider" | "participant" | "support_person" | "support_worker";
+    username: string;
+    email: string;
+    password: string;
+    firstName: string;
+    lastName: string;
+    fingerPrint?: string | undefined;
+    isSmallProvider?: boolean | undefined;
+}>;
+export type UserRegistrationInput = z.infer<typeof UserRegistrationSchema>;

package/dist/schemas/userValiationSchema.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserRegistrationSchema = void 0;
+const zod_1 = require("zod");
+const limits_1 = require("../constants/limits");
+exports.UserRegistrationSchema = zod_1.z.object({
+    email: zod_1.z
+        .string()
+        .email()
+        .max(limits_1.EMAIL_MAX_LENGTH, `Email must be at most ${limits_1.EMAIL_MAX_LENGTH} characters long`)
+        .refine((email) => !email.includes("+"), {
+        message: "Email aliasing with '+' is not allowed",
+    }),
+    username: zod_1.z
+        .string()
+        .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 at most ${limits_1.USERNAME_MAX_LENGTH} characters long`),
+    password: zod_1.z
+        .string()
+        .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`),
+    role: zod_1.z.enum(["business", "provider", "participant", "support_person", "support_worker"], {
+        message: "Role must be one of: business, provider, participant, support_person, support_worker",
+    }),
+    fingerPrint: zod_1.z.string().optional(),
+    firstName: zod_1.z
+        .string()
+        .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 at most ${limits_1.NAME_MAX_LENGTH} characters long`),
+    lastName: zod_1.z
+        .string()
+        .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 at most ${limits_1.NAME_MAX_LENGTH} characters long`),
+    isSmallProvider: zod_1.z.boolean().optional().default(false),
+    // businessName: z.string().optional(),
+    // entityTypeCode: z.string().optional(),
+    // abn: z.string().optional(),
+});

package/dist/schemas/workHistorySchema.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const WorkHistorySchema: z.ZodEffects<z.ZodObject<{
+    jobTitle: z.ZodString;
+    startDate: z.ZodDate;
+    endDate: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
+    organisation: z.ZodString;
+    isCurrentlyWorking: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    startDate: Date;
+    jobTitle: string;
+    organisation: string;
+    isCurrentlyWorking: boolean;
+    endDate?: Date | null | undefined;
+}, {
+    startDate: Date;
+    jobTitle: string;
+    organisation: string;
+    endDate?: Date | null | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}>, {
+    startDate: Date;
+    jobTitle: string;
+    organisation: string;
+    isCurrentlyWorking: boolean;
+    endDate?: Date | null | undefined;
+}, {
+    startDate: Date;
+    jobTitle: string;
+    organisation: string;
+    endDate?: Date | null | undefined;
+    isCurrentlyWorking?: boolean | undefined;
+}>;
+export type WorkHistoryInputValidation = z.infer<typeof WorkHistorySchema>;

package/dist/schemas/workHistorySchema.js

@@ -0,0 +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"],
+});

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

@@ -0,0 +1,31 @@
+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
+ * @param url - The video URL
+ * @returns VideoProvider or null if not detected
+ */
+export declare function detectVideoProvider(url: string): VideoProvider | null;
+/**
+ * Convenience function for YouTube and Vimeo only (commonly used)
+ * @param url - The video URL to validate
+ * @returns boolean
+ */
+export declare function isValidYouTubeOrVimeoUrl(url: string): boolean;
+/**
+ * Convenience function for community posts (all providers)
+ * @param url - The video URL to validate
+ * @returns boolean
+ */
+export declare function isValidCommunityVideoUrl(url: string): boolean;

package/dist/utils/videoValidation.js

@@ -0,0 +1,119 @@
+"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
+ * @param url - The video URL
+ * @returns VideoProvider or null if not detected
+ */
+function detectVideoProvider(url) {
+    const normalizedUrl = url.toLowerCase();
+    // YouTube detection
+    if (normalizedUrl.includes("youtube.com") ||
+        normalizedUrl.includes("youtu.be")) {
+        const youtubeRegex = /^(https?:\/\/)?(www\.)?(youtube\.com|youtu\.be)\/.+/;
+        if (youtubeRegex.test(url)) {
+            return "youtube";
+        }
+    }
+    // Vimeo detection
+    if (normalizedUrl.includes("vimeo.com")) {
+        const vimeoRegex = /^(https?:\/\/)?(www\.)?(vimeo\.com)\/.+/;
+        if (vimeoRegex.test(url)) {
+            return "vimeo";
+        }
+    }
+    // Loom detection
+    if (normalizedUrl.includes("loom.com")) {
+        const loomRegex = /^(https?:\/\/)?(www\.)?(loom\.com)\/share\/([a-zA-Z0-9]+)(\S+)?$/;
+        if (loomRegex.test(url)) {
+            return "loom";
+        }
+    }
+    // TikTok detection
+    if (normalizedUrl.includes("tiktok.com")) {
+        const tiktokRegex1 = /^(https?:\/\/)?(www\.)?(tiktok\.com)\/@([a-zA-Z0-9_.]+)\/video\/([0-9]+)(\S+)?$/;
+        const tiktokRegex2 = /^(https?:\/\/)?(vm\.)?(tiktok\.com)\/([a-zA-Z0-9]+)(\S+)?$/;
+        if (tiktokRegex1.test(url) || tiktokRegex2.test(url)) {
+            return "tiktok";
+        }
+    }
+    return null;
+}
+/**
+ * Basic URL validation
+ * @param url - The URL to validate
+ * @returns boolean
+ */
+function isValidURL(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        // Try with protocol prefix
+        try {
+            new URL(`https://${url}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+/**
+ * Convenience function for YouTube and Vimeo only (commonly used)
+ * @param url - The video URL to validate
+ * @returns boolean
+ */
+function isValidYouTubeOrVimeoUrl(url) {
+    const result = validateVideoLink(url, ["youtube", "vimeo"]);
+    return result.isValid;
+}
+/**
+ * Convenience function for community posts (all providers)
+ * @param url - The video URL to validate
+ * @returns boolean
+ */
+function isValidCommunityVideoUrl(url) {
+    const result = validateVideoLink(url, [
+        "youtube",
+        "vimeo",
+        "loom",
+        "tiktok",
+    ]);
+    return result.isValid;
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@careflair/common",
+  "version": "1.0.0",
+  "description": "A package containing multiple Zod-based validation schemas for CareFlair.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.4"
+  },
+  "keywords": [
+    "pnp-zod"
+  ],
+  "author": "Farhan Hossain",
+  "license": "ISC",
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
+  "files": [
+    "dist"
+  ]
+}