Function bodies 43 total

class SidebarState {
	readonly props: SidebarStateProps;
	open = $derived.by(() => this.props.open());
	openMobile = $state(false);
	setOpen: SidebarStateProps['setOpen'];
	#isMobile: IsMobile;
	state = $derived.by(() => (this.open ? 'expanded' : 'collapsed'));

	constructor(props: SidebarStateProps) {
		this.setOpen = props.setOpen;
		this.#isMobile = new IsMobile();
		this.props = props;
	}

	// Convenience getter for checking if the sidebar is mobile
	// without this, we would need to use `sidebar.isMobile.current` everywhere
	get isMobile() {
		return this.#isMobile.current;
	}

	// Event handler to apply to the `<svelte:window>`
	handleShortcutKeydown = (e: KeyboardEvent) => {
		if (e.key === SIDEBAR_KEYBOARD_SHORTCUT && (e.metaKey || e.ctrlKey)) {
			e.preventDefault();
			this.toggle();
		}
	};

	setOpenMobile = (value: boolean) => {
		this.openMobile = value;
	};

	toggle = () => {
		return this.#isMobile.current ? (this.openMobile = !this.openMobile) : this.setOpen(!this.open)

	constructor(props: SidebarStateProps) {
		this.setOpen = props.setOpen;
		this.#isMobile = new IsMobile();
		this.props = props;
	}

export function setSidebar(props: SidebarStateProps): SidebarState {
	return setContext(Symbol.for(SYMBOL_KEY), new SidebarState(props));
}

export function useSidebar(): SidebarState {
	return getContext(Symbol.for(SYMBOL_KEY));
}

export class IsMobile extends MediaQuery {
	constructor(breakpoint: number = DEFAULT_MOBILE_BREAKPOINT) {
		super(`max-width: ${breakpoint - 1}px`);
	}
}

	constructor(breakpoint: number = DEFAULT_MOBILE_BREAKPOINT) {
		super(`max-width: ${breakpoint - 1}px`);
	}

export async function logActivity(params: {
	organizationId: string;
	clientId?: string | null;
	entityType: EntityType;
	entityId: string;
	action: ActivityAction;
	description: string;
	performedById: string;
	metadata?: Record<string, unknown>;
}) {
	await db.insert(activity).values({
		organizationId: params.organizationId,
		clientId: params.clientId ?? null,
		entityType: params.entityType,
		entityId: params.entityId,
		action: params.action,
		description: params.description,
		performedById: params.performedById,
		metadata: params.metadata ?? null
	});
}

function createResendSender(): SendFn {
	return async (message) => {
		const { Resend } = await import('resend');
		const resend = new Resend(RESEND_API_KEY);
		await resend.emails.send({
			from: EMAIL_FROM,
			to: message.to,
			subject: message.subject,
			html: message.html,
			text: message.text
		});
	};
}

function createSendGridSender(): SendFn {
	return async (message) => {
		const sgMail = await import('@sendgrid/mail');
		sgMail.default.setApiKey(SENDGRID_API_KEY);
		await sgMail.default.send({
			from: EMAIL_FROM,
			to: message.to,
			subject: message.subject,
			html: message.html,
			text: message.text
		});
	};
}

function createSmtpSender(): SendFn {
	return async (message) => {
		const nodemailer = await import('nodemailer');
		const transport = nodemailer.default.createTransport({
			host: SMTP_HOST,
			port: Number(SMTP_PORT) || 587,
			auth: { user: SMTP_USER, pass: SMTP_PASS }
		});
		await transport.sendMail({
			from: EMAIL_FROM,
			to: message.to,
			subject: message.subject,
			html: message.html,
			text: message.text
		});
	};
}

function createConsoleSender(): SendFn {
	return async (message) => {
		console.log(`[DEV EMAIL] To: ${message.to}`);
		console.log(`[DEV EMAIL] Subject: ${message.subject}`);
		console.log(`[DEV EMAIL] Body: ${message.text ?? message.html}`);
	};
}

function getSender(): SendFn {
	switch (EMAIL_PROVIDER) {
		case 'resend':
			return createResendSender();
		case 'sendgrid':
			return createSendGridSender();
		case 'smtp':
			return createSmtpSender();
		default:
			return createConsoleSender();
	}
}

export async function sendEmail(message: EmailMessage): Promise<void> {
	try {
		await sender(message);
	} catch (error) {
		console.error('[EMAIL] Failed to send:', error);
	}
}

function sanitizeFileName(fileName: string): string {
	const baseName = basename(fileName).replace(/[^\w.-]/g, '_');
	return baseName || 'upload';
}

function isWithinUploadDir(filePath: string): boolean {
	const relativePath = relative(UPLOAD_DIR, resolve(filePath));
	return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
}

export async function saveUploadedFile(
	orgId: string,
	file: File
): Promise<{ storagePath: string; fileName: string; mimeType: string; size: number }> {

export async function deleteFile(storagePath: string): Promise<void> {
	if (!isWithinUploadDir(storagePath)) {
		console.error('[FILES] Refusing to delete file outside upload directory:', storagePath);
		return;
	}

	try {
		await unlink(resolve(storagePath));
	} catch {
		// File may already be deleted
	}
}

export function normalizeOrganizationSlug(input: string): string {
	return input
		.trim()
		.toLowerCase()
		.replace(/['’]/g, '')
		.replace(/[^a-z0-9]+/g, '-')
		.replace(/^-+|-+$/g, '');
}

export async function getOrganizationAccessContext(
	requestHeaders: Headers,
	session: Session['session'] | null
): Promise<{
	activeOrganizationId: string | null;
	organizations: ListedOrganization[];
}> {

export async function claimOrphanOrganizationForUser(slug: string, userId: string) {
	return db.transaction(async (tx) => {
		await tx.execute(sql`select pg_advisory_xact_lock(hashtext(${`claim-org:${slug}`}))`);

		const [existingOrganization] = await tx
			.select({
				id: organization.id,
				name: organization.name,
				slug: organization.slug,
				logo: organization.logo,
				createdAt: organization.createdAt,
				metadata: organization.metadata
			})
			.from(organization)
			.where(eq(organization.slug, slug))
			.limit(1);

		if (!existingOrganization) {
			return null;
		}

		const [existingUserMembership] = await tx
			.select({ id: member.id })
			.from(member)
			.where(and(eq(member.organizationId, existingOrganization.id), eq(member.userId, userId)))
			.limit(1);

		if (existingUserMembership) {
			return existingOrganization;
		}

		const [existingMember] = await tx
			.select({ id: member.id })
			.from(member)
			.where(eq(member.organizationId, existingOrganization.

export async function resolveOrgMemberUserId(
	orgId: string,
	requestedUserId: string | null | undefined
): Promise<string | null> {
	const userId = requestedUserId?.trim();
	if (!userId) return null;

	const [orgMember] = await db
		.select({ userId: member.userId })
		.from(member)
		.where(and(eq(member.organizationId, orgId), eq(member.userId, userId)))
		.limit(1);

	return orgMember?.userId ?? null;
}

export async function filterVisibleTagIds(
	orgId: string,
	requestedTagIds: string[]
): Promise<string[]> {
	const tagIds = Array.from(new Set(requestedTagIds.map((id) => id.trim()).filter(Boolean)));
	if (tagIds.length === 0) return [];

	const visibleTags = await db
		.select({ id: tag.id })
		.from(tag)
		.where(and(inArray(tag.id, tagIds), or(eq(tag.organizationId, orgId), eq(tag.isSystem, true))));

	return visibleTags.map(({ id }) => id);
}

export async function seedSystemTags() {
	if (seeded) return;
	if (seedingPromise) {
		await seedingPromise;
		return;
	}

	seedingPromise = (async () => {
		const existing = await db.select({ name: tag.name }).from(tag).where(eq(tag.isSystem, true));
		const existingNames = new Set(existing.map((t) => t.name));

		const missing = SYSTEM_TAGS.filter((name) => !existingNames.has(name));
		if (missing.length > 0) {
			await db
				.insert(tag)
				.values(missing.map((name) => ({ name, isSystem: true, organizationId: null })));
		}

		seeded = true;
	})();

	try {
		await seedingPromise;
	} catch (error) {
		seedingPromise = null;
		throw error;
	}

	seedingPromise = null;
}

export function formatDate(d: string | Date | null | undefined): string {
	if (!d) return '\u2014';
	const date = typeof d === 'string' ? new Date(d) : d;
	return date.toLocaleDateString('en-ZA', { year: 'numeric', month: 'short', day: 'numeric' });
}

export function currentGreeting(now: Date = new Date()): string {
	const hour = now.getHours();
	if (hour < 12) return 'Good morning';
	if (hour < 17) return 'Good afternoon';
	return 'Good evening';
}

export function daysUntilDate(d: string | Date | null | undefined): number {
	if (!d) return Infinity;

	const endDate = typeof d === 'string' ? new Date(d) : new Date(d.getTime());
	if (isNaN(endDate.getTime())) return Infinity;

	endDate.setHours(0, 0, 0, 0);

	const today = new Date();
	today.setHours(0, 0, 0, 0);

	return Math.ceil((endDate.getTime() - today.getTime()) / (1000 * 60 * 60 * 24));
}

export function isOverdueDate(d: string | Date | null | undefined, status?: string): boolean {
	if (!d || status === 'done') return false;

	const dueTime = typeof d === 'string' ? Date.parse(d) : d.getTime();
	return !Number.isNaN(dueTime) && dueTime < Date.now();
}

export function formatCurrency(v: string | number | null | undefined): string {
	if (v == null || v === '') return '\u2014';
	const num = typeof v === 'string' ? parseFloat(v) : v;
	if (isNaN(num)) return '\u2014';
	return new Intl.NumberFormat('en-ZA', { style: 'currency', currency: 'ZAR' }).format(num);
}

export function timeAgo(d: string | Date | null | undefined): string {
	if (!d) return '';
	const date = typeof d === 'string' ? new Date(d) : d;
	const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
	if (seconds < 60) return 'just now';
	const minutes = Math.floor(seconds / 60);
	if (minutes < 60) return `${minutes}m ago`;
	const hours = Math.floor(minutes / 60);
	if (hours < 24) return `${hours}h ago`;
	const days = Math.floor(hours / 24);
	if (days < 30) return `${days}d ago`;
	return formatDate(d);
}

export function formatFileSize(bytes: number): string {
	if (bytes < 1024) return `${bytes} B`;
	if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)} KB`;
	return `${(bytes / 1048576).toFixed(1)} MB`;
}

export function policyTypeLabel(t: string): string {
	const labels: Record<string, string> = {
		motor: 'Motor',
		property: 'Property',
		liability: 'Liability',
		commercial: 'Commercial',
		life: 'Life',
		other: 'Other'
	};
	return labels[t] ?? t;
}

export function claimStatusVariant(s: string): 'default' | 'secondary' | 'destructive' | 'outline' {
	const map: Record<string, 'default' | 'secondary' | 'destructive' | 'outline'> = {
		open: 'default',
		in_progress: 'default',
		settled: 'secondary',
		rejected: 'destructive',
		closed: 'outline'
	};
	return map[s] ?? 'outline';
}

export function claimStatusLabel(s: string): string {
	const labels: Record<string, string> = {
		open: 'Open',
		in_progress: 'In Progress',
		settled: 'Settled',
		rejected: 'Rejected',
		closed: 'Closed'
	};
	return labels[s] ?? s;
}

export function policyStatusVariant(
	s: string
): 'default' | 'secondary' | 'destructive' | 'outline' {
	const map: Record<string, 'default' | 'secondary' | 'destructive' | 'outline'> = {
		active: 'default',
		pending: 'outline',
		lapsed: 'destructive',
		cancelled: 'secondary'
	};
	return map[s] ?? 'outline';
}

export function policyStatusLabel(s: string): string {
	const labels: Record<string, string> = {
		active: 'Active',
		pending: 'Pending',
		lapsed: 'Lapsed',
		cancelled: 'Cancelled'
	};
	return labels[s] ?? s;
}

export function buildRelativeUrl(
	pathname: string,
	search: string,
	updates: Record<string, string | null | undefined>
): string {
	const params = new URLSearchParams(search);

	for (const [key, value] of Object.entries(updates)) {
		if (!value) {
			params.delete(key);
			continue;
		}

		params.set(key, value);
	}

	const query = params.toString();
	return query ? `${pathname}?${query}` : pathname;
}

export function cn(...inputs: ClassValue[]) {
	return twMerge(clsx(inputs));
}

export function isOneOf<T extends readonly string[]>(
	value: string,
	allowed: T
): value is T[number] {
	return allowed.includes(value as T[number]);
}

async function findClientPolicy(orgId: string, clientId: string, policyId: string) {
	const [existingPolicy] = await db
		.select()
		.from(policy)
		.where(
			and(eq(policy.id, policyId), eq(policy.clientId, clientId), eq(policy.organizationId, orgId))
		);

	return existingPolicy;
}

async function findClientClaim(orgId: string, clientId: string, claimId: string) {
	const [existingClaim] = await db
		.select()
		.from(claim)
		.where(
			and(eq(claim.id, claimId), eq(claim.clientId, clientId), eq(claim.organizationId, orgId))
		);

	return existingClaim;
}

async function findClientNote(orgId: string, clientId: string, noteId: string) {
	const [existingNote] = await db
		.select()
		.from(note)
		.where(and(eq(note.id, noteId), eq(note.clientId, clientId), eq(note.organizationId, orgId)));

	return existingNote;
}

async function findClientDocument(orgId: string, clientId: string, documentId: string) {
	const [existingDocument] = await db
		.select()
		.from(document)
		.where(
			and(
				eq(document.id, documentId),
				eq(document.clientId, clientId),
				eq(document.organizationId, orgId)
			)
		);

	return existingDocument;
}

function getAuthErrorMessage(error: unknown): string {
	if (
		typeof error === 'object' &&
		error &&
		'body' in error &&
		typeof error.body === 'object' &&
		error.body &&
		'message' in error.body &&
		typeof error.body.message === 'string'
	) {
		return error.body.message;
	}

	if (error instanceof Error && error.message) {
		return error.message;
	}

	return 'Something went wrong while updating the organization.';
}