@bash-app/bash-common 30.51.0 → 30.53.0

package/src/utils/blogUtils.ts

@@ -0,0 +1,134 @@
+import { generateSlug } from './slugUtils';
+import { BLOG_DETAIL_URL, BLOG_EXCERPT_LENGTH, DEFAULT_BLOG_IMAGE, SITE_NAME } from '../definitions';
+
+// Blog URL generation
+export function generateBlogDetailUrl(blogId: string, slug?: string): string {
+  if (slug) {
+    return `${BLOG_DETAIL_URL}/${blogId}-${slug}`;
+  }
+  return `${BLOG_DETAIL_URL}/${blogId}`;
+}
+
+export function getBlogDetailUrl(blogId: string, slug?: string, title?: string): string {
+  if (slug) {
+    return generateBlogDetailUrl(blogId, slug);
+  } else if (title) {
+    // Generate a temporary slug from title for URLs (not saved to DB)
+    const tempSlug = generateSlug(title);
+    return generateBlogDetailUrl(blogId, tempSlug);
+  } else {
+    // Ultimate fallback - use just the ID (backward compatible)
+    return `${BLOG_DETAIL_URL}/${blogId}`;
+  }
+}
+
+// Parse blog URL parameters
+export function parseBlogUrlParams(blogIdSlug: string): { id: string; slug?: string } | null {
+  if (!blogIdSlug) return null;
+  
+  // Check if it contains a hyphen (ID-slug format)
+  const hyphenIndex = blogIdSlug.indexOf('-');
+  
+  if (hyphenIndex === -1) {
+    // No hyphen found, treat as just an ID
+    return { id: blogIdSlug };
+  }
+  
+  // Split at the first hyphen
+  const id = blogIdSlug.substring(0, hyphenIndex);
+  const slug = blogIdSlug.substring(hyphenIndex + 1);
+  
+  return { id, slug };
+}
+
+// Content processing
+export function generateExcerpt(content: string, length: number = BLOG_EXCERPT_LENGTH): string {
+  // Strip HTML tags
+  const textContent = content.replace(/<[^>]*>/g, '');
+  
+  if (textContent.length <= length) {
+    return textContent;
+  }
+  
+  // Find the last complete word within the length limit
+  const truncated = textContent.substring(0, length);
+  const lastSpace = truncated.lastIndexOf(' ');
+  
+  return lastSpace > 0 
+    ? truncated.substring(0, lastSpace) + '...'
+    : truncated + '...';
+}
+
+// Calculate estimated reading time
+export function calculateReadingTime(content: string): number {
+  const wordsPerMinute = 200;
+  const textContent = content.replace(/<[^>]*>/g, '');
+  const wordCount = textContent.split(/\s+/).length;
+  return Math.ceil(wordCount / wordsPerMinute);
+}
+
+// Blog image handling
+export function getBlogImageUrl(imageUrl?: string | null): string {
+  return imageUrl || DEFAULT_BLOG_IMAGE;
+}
+
+// SEO helpers
+export function generateMetaTitle(title: string, siteName: string = 'Bash'): string {
+  return `${title} | ${siteName}`;
+}
+
+export function generateMetaDescription(content: string, title: string): string {
+  const excerpt = generateExcerpt(content, 155);
+  return excerpt || `Read about ${title} on ${SITE_NAME}`;
+}
+
+// Content validation
+export function validateBlogContent(title: string, content: string): { isValid: boolean; errors: string[] } {
+  const errors: string[] = [];
+  
+  if (!title || title.trim().length === 0) {
+    errors.push('Title is required');
+  } else if (title.length > 200) {
+    errors.push('Title must be less than 200 characters');
+  }
+  
+  if (!content || content.trim().length === 0) {
+    errors.push('Content is required');
+  } else if (content.length < 100) {
+    errors.push('Content must be at least 100 characters');
+  }
+  
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
+// Tag processing
+export function processTags(tagString: string): string[] {
+  if (!tagString) return [];
+  
+  return tagString
+    .split(',')
+    .map(tag => tag.trim().toLowerCase())
+    .filter(tag => tag.length > 0)
+    .slice(0, 10); // Limit to 10 tags
+}
+
+// Search helpers
+export function highlightSearchTerms(text: string, searchTerm: string): string {
+  if (!searchTerm) return text;
+  
+  const regex = new RegExp(`(${searchTerm})`, 'gi');
+  return text.replace(regex, '<mark>$1</mark>');
+}
+
+// Format publication date
+export function formatPublishDate(date: Date | string): string {
+  const publishDate = typeof date === 'string' ? new Date(date) : date;
+  return publishDate.toLocaleDateString('en-US', {
+    year: 'numeric',
+    month: 'long',
+    day: 'numeric'
+  });
+} 

package/src/utils/qrCodeUtils.ts

@@ -1,12 +1,14 @@
 import QRCode from "qrcode";
 import { TICKET_DETAILS } from "../definitions";
+import { generateBashDetailUrl } from "./slugUtils";
 
 export function bashEventPrismaCheckoutQrCodeUrl(bashEventId: string | undefined | null, prismaCheckoutId: string | undefined | null): string {
   return `${TICKET_DETAILS}/${bashEventId}/${prismaCheckoutId}`;
 }
 
-export function bashEventQrCodeUrl(bashEventId: string | undefined | null, ticketTierId?: string | undefined | null, ticketId?: string | undefined | null): string {
-  const baseUrl = `${TICKET_DETAILS}/${bashEventId}`;
+export function bashEventQrCodeUrl(bashEventId: string | undefined | null, ticketTierId?: string | undefined | null, ticketId?: string | undefined | null, slug?: string | undefined | null): string {
+  const baseUrl = slug ? generateBashDetailUrl(bashEventId!, slug).replace('/bash/', '/ticket-details/') : `${TICKET_DETAILS}/${bashEventId}`;
+  
   if (ticketId) {
     return `${baseUrl}/ticket/${ticketId}`;
   }

package/src/utils/slugUtils.ts

@@ -0,0 +1,60 @@
+import slugify from 'slugify';
+
+export function generateSlug(title: string): string {
+  return slugify(title, { 
+    lower: true, 
+    strict: true, 
+    remove: /[*+~.()'"!:@]/g 
+  });
+}
+
+export async function generateUniqueSlug(
+  title: string, 
+  checkSlugExists: (slug: string, excludeId?: string) => Promise<boolean>,
+  excludeId?: string
+): Promise<string> {
+  const baseSlug = generateSlug(title);
+  let slug = baseSlug;
+  let counter = 1;
+
+  while (true) {
+    const exists = await checkSlugExists(slug, excludeId);
+    if (!exists) {
+      return slug;
+    }
+    slug = `${baseSlug}-${counter}`;
+    counter++;
+  }
+}
+
+export function generateBashDetailUrl(bashEventId: string, slug: string): string {
+  return `/bash/${bashEventId}-${slug}`;
+}
+
+export function parseBashUrlParams(param: string): { id: string; slug: string | null } | null {
+  // Expected format: "id-slug" where id is first part before first dash
+  const dashIndex = param.indexOf('-');
+  
+  if (dashIndex === -1) {
+    // Old format: just the ID
+    if (param && param.length > 0) {
+      return { id: param, slug: null };
+    }
+    return null;
+  }
+  
+  const id = param.substring(0, dashIndex);
+  const slug = param.substring(dashIndex + 1);
+  
+  if (!id) {
+    return null;
+  }
+  
+  // New format: id-slug
+  return { id, slug: slug || null };
+}
+
+export function validateSlug(slug: string): boolean {
+  // Check if slug only contains lowercase letters, numbers, and hyphens
+  return /^[a-z0-9-]+$/.test(slug);
+} 

package/src/utils/ticketListUtils.ts

@@ -1,10 +1,10 @@
 import { DateTime } from "luxon";
 import {
-    NumberOfTicketsForDate,
-    URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM,
-    URL_PARAMS_TICKET_LIST_DELIM,
-    URL_PARAMS_TICKET_TIER_ID_NUMBER_OF_TICKETS_DATE_DELIM,
-    URL_PARAMS_TICKETS_DATE_DELIM
+  NumberOfTicketsForDate,
+  URL_PARAMS_NUMBER_OF_TICKETS_TICKETS_DATE_DELIM,
+  URL_PARAMS_TICKET_LIST_DELIM,
+  URL_PARAMS_TICKET_TIER_ID_NUMBER_OF_TICKETS_DATE_DELIM,
+  URL_PARAMS_TICKETS_DATE_DELIM
 } from "../definitions";
 import { DATETIME_FORMAT_ISO_LIKE } from "./dateTimeUtils";
 
@@ -22,8 +22,26 @@ export function ticketListToString(ticketList: Map<string, NumberOfTicketsForDat
     for (const ticketNumAndDates of ticketListArgs) {
       if (ticketNumAndDates.numberOfTickets > 0) {
         ticketsExist = true;
+        
+        // Ensure ticketDateTime is in ISO format
+        let dateTimeStr = ticketNumAndDates.ticketDateTime;
+        if (dateTimeStr) {
+          // If it's already a string, try to parse it as DateTime and convert to ISO
+          const dateTime = typeof dateTimeStr === 'string' 
+            ? DateTime.fromFormat(dateTimeStr, DATETIME_FORMAT_ISO_LIKE).isValid 
+              ? DateTime.fromFormat(dateTimeStr, DATETIME_FORMAT_ISO_LIKE)
+              : DateTime.fromISO(dateTimeStr).isValid
+                ? DateTime.fromISO(dateTimeStr)
+                : DateTime.fromJSDate(new Date(dateTimeStr))
+            : DateTime.fromJSDate(dateTimeStr as any);
+          
+          if (dateTime.isValid) {
+            dateTimeStr = dateTime.toISO() || dateTimeStr;
+          }
+        }
+        
         ticketArgs.push(
-          `${ticketNumAndDates.numberOfTickets}${URL_PARAMS_TICKETS_DATE_DELIM}${ticketNumAndDates.ticketDateTime}`);
+          `${ticketNumAndDates.numberOfTickets}${URL_PARAMS_TICKETS_DATE_DELIM}${dateTimeStr}`);
       }
       else {
         ticketsExist = false;