@bash-app/bash-common 30.275.0 → 30.276.0

package/src/competitionIdeas.ts

@@ -0,0 +1,429 @@
+import { CompetitionType, JudgingType } from "@prisma/client";
+
+export interface CompetitionIdea {
+  id: string;
+  title: string;
+  description: string;
+  competitionType: CompetitionType;
+  subtype: string;
+  judgingType: JudgingType;
+  tags?: string[];
+  suggestsParticipationTier?: boolean;
+  rulesSnippet?: string;
+}
+
+export const COMPETITION_IDEAS: CompetitionIdea[] = [
+  {
+    id: "art-contest",
+    title: "Art contest",
+    description: "Live or submitted artwork judged on creativity and skill.",
+    competitionType: CompetitionType.SKILL,
+    subtype: "Art contests (speed painting, live art)",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Skill", "Creative"],
+  },
+  {
+    id: "audience-favorite-dish",
+    title: "Audience favorite dish",
+    description: "Potluck or tasting event — guests vote for their favorite plate.",
+    competitionType: CompetitionType.AUDIENCE_VOTING,
+    subtype: "Best dish (potlucks)",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Food", "Vote"],
+  },
+  {
+    id: "barista-latte-art",
+    title: "Barista latte art contest",
+    description: "Baristas pour their best latte art for judges or crowd applause.",
+    competitionType: CompetitionType.FOOD_DRINK,
+    subtype: "Barista/latte art contest",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Food", "Skill"],
+  },
+  {
+    id: "best-booth-decor",
+    title: "Best booth decor",
+    description: "Vendors compete for the best-looking booth at the fair.",
+    competitionType: CompetitionType.VENDOR_BOOTH,
+    subtype: "Best booth decor",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Vendor", "Vote"],
+  },
+  {
+    id: "best-costume",
+    title: "Best costume contest",
+    description: "Show off creative costumes — judges or audience pick winners.",
+    competitionType: CompetitionType.SKILL,
+    subtype: "Costume contests",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Seasonal", "Fun"],
+  },
+  {
+    id: "best-dressed",
+    title: "Best dressed",
+    description: "Formal or themed event — who nailed the look?",
+    competitionType: CompetitionType.AUDIENCE_VOTING,
+    subtype: "Best dressed",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Vote", "Social"],
+  },
+  {
+    id: "bingo-night",
+    title: "Bingo night",
+    description: "Classic bingo rounds — host calls numbers and tracks winners.",
+    competitionType: CompetitionType.INTERACTIVE,
+    subtype: "Bingo",
+    judgingType: JudgingType.HOST_CHOOSES,
+    tags: ["Interactive", "All ages"],
+  },
+  {
+    id: "case-study-competition",
+    title: "Case study competition",
+    description: "Teams present solutions; panel scores on rubric.",
+    competitionType: CompetitionType.BUSINESS_PROFESSIONAL,
+    subtype: "Case study competitions",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Professional", "Teams"],
+  },
+  {
+    id: "check-in-contest",
+    title: "Check-in contest",
+    description: "First attendees to check in win a sponsor gift (host confirms).",
+    competitionType: CompetitionType.SOCIAL_MEDIA,
+    subtype: "Check-in contests (first X people get a prize)",
+    judgingType: JudgingType.FIRST_COME,
+    tags: ["Door", "Sponsor"],
+  },
+  {
+    id: "chili-cook-off",
+    title: "Chili cook-off",
+    description: "Cooks bring their best chili; judges score taste and presentation.",
+    competitionType: CompetitionType.FOOD_DRINK,
+    subtype: "Chili cook-off / BBQ contest",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Food", "Fundraiser"],
+  },
+  {
+    id: "coloring-contest",
+    title: "Coloring contest",
+    description: "Kids submit coloring pages; host picks winners by age group.",
+    competitionType: CompetitionType.KIDS_FAMILY,
+    subtype: "Coloring contests",
+    judgingType: JudgingType.HOST_CHOOSES,
+    tags: ["Kids", "Family"],
+  },
+  {
+    id: "cornhole-tournament",
+    title: "Cornhole tournament",
+    description: "Single-elimination bracket on the lawn.",
+    competitionType: CompetitionType.PHYSICAL,
+    subtype: "Cornhole tournaments",
+    judgingType: JudgingType.BRACKET_TOURNAMENT,
+    tags: ["Outdoor", "Bracket"],
+  },
+  {
+    id: "cupcake-decorating",
+    title: "Cupcake decorating contest",
+    description: "Decorate cupcakes on the spot; judges pick the most creative.",
+    competitionType: CompetitionType.FOOD_DRINK,
+    subtype: "Cupcake decorating",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Food", "Kids"],
+  },
+  {
+    id: "dance-off",
+    title: "Dance-off",
+    description: "Dancers battle in rounds; audience or judges advance winners.",
+    competitionType: CompetitionType.SKILL,
+    subtype: "Dance-offs",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Skill", "Performance"],
+  },
+  {
+    id: "design-sprint",
+    title: "Design sprint showcase",
+    description: "Teams demo prototypes; judges score on impact and polish.",
+    competitionType: CompetitionType.BUSINESS_PROFESSIONAL,
+    subtype: "Design sprints",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Professional", "Teams"],
+  },
+  {
+    id: "eating-contest",
+    title: "Eating contest",
+    description: "Timed eating challenge — fastest or most completed wins.",
+    competitionType: CompetitionType.FOOD_DRINK,
+    subtype: "Eating competitions (hot wings, donuts, pie, etc.)",
+    judgingType: JudgingType.METRICS,
+    tags: ["Food", "Fun"],
+  },
+  {
+    id: "fan-favorite-vendor",
+    title: "Fan favorite vendor",
+    description: "Attendees vote for their favorite vendor booth.",
+    competitionType: CompetitionType.VENDOR_BOOTH,
+    subtype: "Fan favorite vendor",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Vendor", "Vote"],
+  },
+  {
+    id: "gingerbread-houses",
+    title: "Gingerbread house competition",
+    description: "Teams build gingerbread houses; judges score creativity.",
+    competitionType: CompetitionType.SEASONAL_HOLIDAY,
+    subtype: "Gingerbread house competition",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Seasonal", "Family"],
+  },
+  {
+    id: "hackathon",
+    title: "Hackathon showcase",
+    description: "Teams demo builds; judges score on technical merit and UX.",
+    competitionType: CompetitionType.BUSINESS_PROFESSIONAL,
+    subtype: "Hackathons",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Professional", "Tech"],
+  },
+  {
+    id: "hashtag-photo-contest",
+    title: "Hashtag photo contest",
+    description: "Best photo posted with the event hashtag — host or crowd picks.",
+    competitionType: CompetitionType.SOCIAL_MEDIA,
+    subtype: "Best photo posted with event hashtag",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Social", "Marketing"],
+  },
+  {
+    id: "lego-build-off",
+    title: "LEGO build-off",
+    description: "Build teams compete on a theme within a time limit.",
+    competitionType: CompetitionType.KIDS_FAMILY,
+    subtype: "LEGO build-offs",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Kids", "Creative"],
+  },
+  {
+    id: "lip-sync-battle",
+    title: "Lip sync battle",
+    description: "Performers lip sync to tracks; audience votes for the best show.",
+    competitionType: CompetitionType.INTERACTIVE,
+    subtype: "Lip sync battles",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Performance", "Fun"],
+  },
+  {
+    id: "minute-to-win-it",
+    title: "Minute to Win It games",
+    description: "Quick challenge stations — host tracks fastest times.",
+    competitionType: CompetitionType.INTERACTIVE,
+    subtype: "Minute-to-Win-It style games",
+    judgingType: JudgingType.METRICS,
+    tags: ["Interactive", "All ages"],
+  },
+  {
+    id: "mixology-challenge",
+    title: "Mixology challenge",
+    description: "Bartenders craft signature drinks; judges score taste and presentation.",
+    competitionType: CompetitionType.FOOD_DRINK,
+    subtype: "Mixology or mocktail challenge",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Food", "21+"],
+  },
+  {
+    id: "most-interactive-booth",
+    title: "Most interactive booth",
+    description: "Which vendor booth engaged attendees the most?",
+    competitionType: CompetitionType.VENDOR_BOOTH,
+    subtype: "Most interactive booth",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Vendor", "Vote"],
+  },
+  {
+    id: "obstacle-course",
+    title: "Obstacle course race",
+    description: "Timed runs through obstacles — fastest time wins.",
+    competitionType: CompetitionType.PHYSICAL,
+    subtype: "Obstacle courses",
+    judgingType: JudgingType.METRICS,
+    tags: ["Outdoor", "Athletic"],
+  },
+  {
+    id: "photography-contest",
+    title: "Photography contest",
+    description: "Submit or display photos; judges score composition and story.",
+    competitionType: CompetitionType.SKILL,
+    subtype: "Photography contests",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Creative", "Skill"],
+  },
+  {
+    id: "pitch-competition",
+    title: "Pitch competition",
+    description: "Founders pitch ideas; panel scores and picks a winner.",
+    competitionType: CompetitionType.BUSINESS_PROFESSIONAL,
+    subtype: "Pitch competitions",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Professional", "Startup"],
+  },
+  {
+    id: "pumpkin-carving",
+    title: "Pumpkin carving contest",
+    description: "Carve on site; host or judges pick the best jack-o'-lantern.",
+    competitionType: CompetitionType.KIDS_FAMILY,
+    subtype: "Pumpkin carving",
+    judgingType: JudgingType.HOST_CHOOSES,
+    tags: ["Seasonal", "Family"],
+  },
+  {
+    id: "relay-race",
+    title: "Relay race",
+    description: "Team relay on the field — first team across wins.",
+    competitionType: CompetitionType.PHYSICAL,
+    subtype: "Relay races",
+    judgingType: JudgingType.METRICS,
+    tags: ["Outdoor", "Teams"],
+  },
+  {
+    id: "scavenger-hunt",
+    title: "Scavenger hunt",
+    description: "Teams find clues around the venue — first to finish wins.",
+    competitionType: CompetitionType.PHYSICAL,
+    subtype: "Scavenger hunts",
+    judgingType: JudgingType.METRICS,
+    tags: ["Outdoor", "Teams"],
+  },
+  {
+    id: "science-fair",
+    title: "Science fair expo",
+    description: "Projects on display; judges score on hypothesis and presentation.",
+    competitionType: CompetitionType.BUSINESS_PROFESSIONAL,
+    subtype: "Science fairs/expos",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Education", "Kids"],
+  },
+  {
+    id: "singing-battle",
+    title: "Singing or karaoke battle",
+    description: "Performers sing live; audience or judges pick favorites.",
+    competitionType: CompetitionType.SKILL,
+    subtype: "Singing or karaoke battles",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Performance", "Skill"],
+  },
+  {
+    id: "startup-demo-day",
+    title: "Startup demo day voting",
+    description: "Founders demo on stage; audience votes for fan favorite.",
+    competitionType: CompetitionType.BUSINESS_PROFESSIONAL,
+    subtype: "Startup demo day voting",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Professional", "Vote"],
+  },
+  {
+    id: "talent-show",
+    title: "Talent show",
+    description: "Open mic performances; judges or audience advance acts.",
+    competitionType: CompetitionType.SKILL,
+    subtype: "Talent shows",
+    judgingType: JudgingType.JUDGES,
+    tags: ["Performance", "All ages"],
+  },
+  {
+    id: "treasure-hunt",
+    title: "Treasure hunt",
+    description: "Follow clues to a hidden prize — host verifies first find.",
+    competitionType: CompetitionType.RANDOMIZED,
+    subtype: "Treasure hunts",
+    judgingType: JudgingType.METRICS,
+    tags: ["Interactive", "Outdoor"],
+  },
+  {
+    id: "trivia-night",
+    title: "Trivia night",
+    description: "Teams answer rounds of questions; highest score wins.",
+    competitionType: CompetitionType.SKILL,
+    subtype: "Trivia competitions",
+    judgingType: JudgingType.METRICS,
+    tags: ["Indoor", "Teams"],
+  },
+  {
+    id: "tug-of-war",
+    title: "Tug of war",
+    description: "Team bracket on the rope — last team standing wins.",
+    competitionType: CompetitionType.PHYSICAL,
+    subtype: "Tug of war",
+    judgingType: JudgingType.BRACKET_TOURNAMENT,
+    tags: ["Outdoor", "Teams"],
+  },
+  {
+    id: "ugly-sweater",
+    title: "Ugly sweater contest",
+    description: "Holiday sweaters judged for creativity and commitment.",
+    competitionType: CompetitionType.SEASONAL_HOLIDAY,
+    subtype: "Ugly sweater contest",
+    judgingType: JudgingType.AUDIENCE_VOTE,
+    tags: ["Seasonal", "Fun"],
+  },
+  {
+    id: "white-elephant",
+    title: "White elephant gift exchange",
+    description: "Participants bring wrapped gifts; steal-and-swap game run by the host.",
+    competitionType: CompetitionType.INTERACTIVE,
+    subtype: "White elephant / gift exchange",
+    judgingType: JudgingType.HOST_CHOOSES,
+    tags: ["Fundraiser", "Interactive"],
+    suggestsParticipationTier: true,
+    rulesSnippet:
+      "- Bring one wrapped gift\n- Must be present to play\n- Host runs steal/swap rounds\n- Prizes listed are sponsor donations, not cash values",
+  },
+];
+
+export function competitionIdeasSorted(): CompetitionIdea[] {
+  return [...COMPETITION_IDEAS].sort((a, b) =>
+    a.title.localeCompare(b.title, undefined, { sensitivity: "base" })
+  );
+}
+
+export function competitionIdeasByLetter(): Map<string, CompetitionIdea[]> {
+  const sorted = competitionIdeasSorted();
+  const map = new Map<string, CompetitionIdea[]>();
+  for (const idea of sorted) {
+    const first = idea.title.trim().charAt(0).toUpperCase();
+    const letter = /[A-Z]/.test(first) ? first : "#";
+    const list = map.get(letter) ?? [];
+    list.push(idea);
+    map.set(letter, list);
+  }
+  return map;
+}
+
+/** Unique subtype labels per competition type (for host subtype dropdown). */
+export function competitionSubtypesByType(): Record<
+  CompetitionType,
+  string[]
+> {
+  const out = {} as Record<CompetitionType, string[]>;
+  for (const idea of COMPETITION_IDEAS) {
+    const existing = out[idea.competitionType] ?? [];
+    if (!existing.includes(idea.subtype)) {
+      existing.push(idea.subtype);
+    }
+    out[idea.competitionType] = existing;
+  }
+  for (const key of Object.keys(out) as CompetitionType[]) {
+    out[key].sort((a, b) => a.localeCompare(b));
+  }
+  return out;
+}
+
+export function filterCompetitionIdeas(query: string): CompetitionIdea[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return competitionIdeasSorted();
+  return competitionIdeasSorted().filter(
+    (idea) =>
+      idea.title.toLowerCase().includes(q) ||
+      idea.description.toLowerCase().includes(q) ||
+      idea.subtype.toLowerCase().includes(q) ||
+      (idea.tags?.some((t) => t.toLowerCase().includes(q)) ?? false)
+  );
+}

package/src/competitionValidation.ts

@@ -0,0 +1,42 @@
+import { JudgingType } from "@prisma/client";
+
+/** Judging modes disallowed for new competitions (lottery / auction-adjacent). */
+export const DISALLOWED_JUDGING_TYPES_FOR_NEW: ReadonlySet<JudgingType> = new Set([
+  JudgingType.RANDOM_DRAW,
+  JudgingType.HIGHEST_BID,
+]);
+
+export const DISALLOWED_JUDGING_TYPE_MESSAGE =
+  "Random draw and highest-bid judging are not supported on Bash. Use host choice, skill judging, audience vote, metrics, first come, or tournament bracket.";
+
+export function isDisallowedJudgingTypeForNew(
+  judgingType: JudgingType | null | undefined
+): boolean {
+  if (!judgingType) return false;
+  return DISALLOWED_JUDGING_TYPES_FOR_NEW.has(judgingType);
+}
+
+export function assertAllowedJudgingTypeForNew(
+  judgingType: JudgingType | null | undefined
+): void {
+  if (isDisallowedJudgingTypeForNew(judgingType)) {
+    throw new Error(DISALLOWED_JUDGING_TYPE_MESSAGE);
+  }
+}
+
+/** Default judging type for new competitions. */
+export const DEFAULT_COMPETITION_JUDGING_TYPE: JudgingType =
+  JudgingType.HOST_CHOOSES;
+
+export function normalizeJudgingTypeForSave(
+  judgingType: JudgingType | null | undefined,
+  isExistingLegacy: boolean
+): JudgingType {
+  if (!judgingType) {
+    return isExistingLegacy ? JudgingType.RANDOM_DRAW : DEFAULT_COMPETITION_JUDGING_TYPE;
+  }
+  if (!isExistingLegacy && isDisallowedJudgingTypeForNew(judgingType)) {
+    throw new Error(DISALLOWED_JUDGING_TYPE_MESSAGE);
+  }
+  return judgingType;
+}

package/src/definitions.ts

@@ -749,6 +749,8 @@ export interface LinkedInAuthData {
 export interface NumberOfTicketsForDate {
   numberOfTickets: number;
   ticketDateTime: DateTimeArgType;
+  /** Pay-what-you-can tier: buyer-chosen unit price in cents (min = tier.price). */
+  unitPriceCents?: number;
 }
 
 export interface TicketTierAvailability {
@@ -942,6 +944,9 @@ export interface StripeCreateBashEventTicketsCheckoutSessionArgs extends UtmFiel
 
   /** Required when the event has `waiverRequired` — buyer attested to host waiver/terms */
   waiverAccepted?: boolean;
+
+  /** EventGroup id when purchasing a group package for the crew */
+  groupId?: string;
 }
 
 export interface StripeCreateBashEventDonationCheckoutSessionArgs extends UtmFields {

package/src/extendedSchemas.ts

@@ -14,6 +14,7 @@ import {
     Checkout,
     Competition,
     CompetitionParticipant,
+    CompetitionSponsor,
     CompetitionVote,
     Contact,
     Coordinates,
@@ -249,12 +250,43 @@ export interface SponsoredEventExt extends SponsoredEvent {}
 
 export interface PrizeExt extends Prize {
   winner?: PublicUser | null;
+  contributor?: PublicUser | null;
+  sourceService?: {
+    id: string;
+    serviceName: string | null;
+    coverPhoto: string | null;
+  } | null;
+}
+
+export interface CompetitionPrizeOfferExt {
+  id: string;
+  competitionId: string;
+  offeredByUserId: string;
+  status: string;
+  name: string;
+  description: string;
+  imageUrl?: string | null;
+  sponsorLabel?: string | null;
+  sourceServiceId?: string | null;
+  sourceSku?: string | null;
+  hostNote?: string | null;
+  createdAt: Date | string;
+  respondedAt?: Date | string | null;
+  offeredBy?: PublicUser;
+  sourceService?: {
+    id: string;
+    serviceName: string | null;
+    coverPhoto: string | null;
+  } | null;
 }
 
 export interface CompetitionExt extends Competition {
   prizes: PrizeExt[];
   participants?: CompetitionParticipant[];
   votes?: CompetitionVote[];
+  entryTicketTier?: TicketTier | null;
+  sponsor?: CompetitionSponsor[];
+  prizeOffers?: CompetitionPrizeOfferExt[];
 }
 
 /** One row in BashEvent.merchandiseItems (host wizard; informational catalog) */
@@ -456,11 +488,26 @@ export const BASH_EVENT_DATA_TO_INCLUDE = {
   invitations: true,
   competitions: {
     include: {
+      entryTicketTier: {
+        select: {
+          id: true,
+          title: true,
+          price: true,
+          isDonationTier: true,
+        },
+      },
+      sponsor: true,
       prizes: {
         include: {
           winner: {
             select: FRONT_END_USER_DATA_TO_SELECT,
           },
+          contributor: {
+            select: FRONT_END_USER_DATA_TO_SELECT,
+          },
+          sourceService: {
+            select: { id: true, serviceName: true, coverPhoto: true },
+          },
         },
       },
       participants: {

package/src/groupTicketUtils.ts

@@ -0,0 +1,101 @@
+import type { TicketTier } from "@prisma/client";
+
+/** Minimum seats per group package tier. */
+export const MIN_GROUP_TICKET_SEAT_COUNT = 2;
+
+/** Maximum seats per group package tier (v1). */
+export const MAX_GROUP_TICKET_SEAT_COUNT = 20;
+
+export type GroupTicketTierFields = Pick<
+  TicketTier,
+  "isGroupTicket" | "groupTicketSeatCount" | "pricingType" | "isDonationTier" | "isWaitlistTier"
+>;
+
+export function isGroupTicketTier(
+  tier: Pick<TicketTier, "isGroupTicket" | "groupTicketSeatCount">
+): boolean {
+  return (
+    tier.isGroupTicket === true &&
+    tier.groupTicketSeatCount != null &&
+    tier.groupTicketSeatCount >= MIN_GROUP_TICKET_SEAT_COUNT
+  );
+}
+
+export function validateGroupTicketTierInput(
+  tier: GroupTicketTierFields
+): { ok: true } | { ok: false; message: string } {
+  if (!tier.isGroupTicket) {
+    return { ok: true };
+  }
+  const seats = tier.groupTicketSeatCount;
+  if (seats == null || Number.isNaN(seats)) {
+    return {
+      ok: false,
+      message: "Group package tiers need a seat count (how many people are included).",
+    };
+  }
+  if (seats < MIN_GROUP_TICKET_SEAT_COUNT) {
+    return {
+      ok: false,
+      message: `Group packages need at least ${MIN_GROUP_TICKET_SEAT_COUNT} people.`,
+    };
+  }
+  if (seats > MAX_GROUP_TICKET_SEAT_COUNT) {
+    return {
+      ok: false,
+      message: `Group packages can include up to ${MAX_GROUP_TICKET_SEAT_COUNT} people.`,
+    };
+  }
+  if (tier.isDonationTier === true) {
+    return {
+      ok: false,
+      message: "Donation tiers cannot be group packages.",
+    };
+  }
+  if (tier.isWaitlistTier === true) {
+    return {
+      ok: false,
+      message: "Waitlist tiers cannot be group packages.",
+    };
+  }
+  if (tier.pricingType === "BASHPOINTS") {
+    return {
+      ok: false,
+      message: "BashPoints tiers cannot be group packages yet.",
+    };
+  }
+  return { ok: true };
+}
+
+/** Sold ticket rows → packages consumed (for inventory caps). */
+export function packagesSoldFromTicketCount(
+  ticketRowCount: number,
+  seatCount: number
+): number {
+  if (seatCount < 1) {
+    return ticketRowCount;
+  }
+  return Math.ceil(ticketRowCount / seatCount);
+}
+
+/** Per-person share in cents for Venmo hints (integer division). */
+export function groupPackageShareCents(
+  packagePriceCents: number,
+  seatCount: number
+): number {
+  if (seatCount < 1) {
+    return packagePriceCents;
+  }
+  return Math.floor(packagePriceCents / seatCount);
+}
+
+export function formatGroupPackagePerPersonUsd(
+  packagePriceCents: number,
+  seatCount: number
+): string {
+  const dollars = groupPackageShareCents(packagePriceCents, seatCount) / 100;
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+  }).format(dollars);
+}

package/src/index.ts

@@ -6,6 +6,10 @@ export * from "./utmAttribution.js";
 export * from "./venueLoyaltyRedemption.js";
 export * from "./stripeListingSubscriptionMessages.js";
 export * from "./extendedSchemas.js";
+export * from "./competitionIdeas.js";
+export * from "./competitionValidation.js";
+export * from "./groupTicketUtils.js";
+export * from "./utils/groupTicketCartUtils.js";
 export * from "./partnerStoreTypes.js";
 export * from "./bashFeedTypes.js";
 export * from "./membershipDefinitions.js";