@careflair/common 1.0.6 → 1.0.8

package/dist/schemas/userValiationSchema.d.ts

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

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

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

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

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

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