@careflair/common 1.0.4 → 1.0.6

package/dist/schemas/availabilitySchemaValidation.js

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

@@ -1,6 +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;
+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

@@ -1,23 +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;
+"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

@@ -1,38 +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>;
+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

@@ -1,29 +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"],
-});
+"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/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;
+    confirmPassword: string;
+    firstName: string;
+    lastName: string;
+    password: string;
+    fingerPrint?: string | undefined;
+}, {
+    role: string;
+    username: string;
+    email: string;
+    confirmPassword: string;
+    firstName: string;
+    lastName: string;
+    password: string;
+    fingerPrint?: string | undefined;
+}>, {
+    role: string;
+    username: string;
+    email: string;
+    confirmPassword: string;
+    firstName: string;
+    lastName: string;
+    password: string;
+    fingerPrint?: string | undefined;
+}, {
+    role: string;
+    username: string;
+    email: string;
+    confirmPassword: string;
+    firstName: string;
+    lastName: string;
+    password: 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;
+}>;