@atmo-dev/events-ui 0.1.0

package/dist/event-view/InviteShareFlow.svelte

@@ -0,0 +1,177 @@
+<script lang="ts">
+	import { Button, Checkbox, Input, Label, Modal } from '@foxui/core';
+	import DateTimePicker from '../DateTimePicker.svelte';
+	import ShareModal from '../ShareModal.svelte';
+	import { datetimeLocalToISO } from '../date-format.js';
+	import type { HostProfile } from '../contrail.js';
+	import type { EditorAdapter, EditorViewer } from '../editor/adapter.js';
+
+	let {
+		spaceUri,
+		spaceKey,
+		did,
+		rkey,
+		eventName,
+		hostProfile,
+		adapter,
+		viewer
+	}: {
+		spaceUri: string;
+		spaceKey: string;
+		did: string;
+		rkey: string;
+		eventName: string;
+		hostProfile: HostProfile | null | undefined;
+		adapter: EditorAdapter;
+		viewer: EditorViewer;
+	} = $props();
+
+	let inviteUrl: string | null = $state(null);
+	let inviteBusy = $state(false);
+	let inviteError: string | null = $state(null);
+	let showInviteModal = $state(false);
+
+	// Invite-options dialog (shown before the share modal) — owner picks
+	// whether to allow anonymous reads, max uses, and expiry.
+	let showInviteForm = $state(false);
+	let inviteAllowAnonRead = $state(true);
+	let inviteMaxUsesText = $state('');
+	let inviteHasExpiry = $state(false);
+	let inviteExpiresAt = $state('');
+	const inviteTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+	function openInviteForm() {
+		inviteError = null;
+		inviteAllowAnonRead = true;
+		inviteMaxUsesText = '';
+		inviteHasExpiry = false;
+		showInviteForm = true;
+	}
+
+	async function submitInviteForm() {
+		if (inviteBusy) return;
+		inviteBusy = true;
+		inviteError = null;
+		try {
+			let maxUses: number | undefined;
+			if (inviteMaxUsesText.trim()) {
+				const n = Number(inviteMaxUsesText);
+				if (!Number.isInteger(n) || n < 1) {
+					throw new Error('Max uses must be a positive integer.');
+				}
+				maxUses = n;
+			}
+
+			let expiresAt: number | undefined;
+			if (inviteHasExpiry && inviteExpiresAt.trim()) {
+				const iso = datetimeLocalToISO(inviteExpiresAt, inviteTimezone);
+				const ts = new Date(iso).getTime();
+				if (!Number.isFinite(ts)) throw new Error('Invalid expiry date.');
+				if (ts <= Date.now()) throw new Error('Expiry must be in the future.');
+				expiresAt = ts;
+			}
+
+			if (!adapter.createSpaceInvite) {
+				throw new Error('createSpaceInvite not supported by this adapter');
+			}
+			const result = await adapter.createSpaceInvite({
+				spaceUri,
+				kind: inviteAllowAnonRead ? 'read-join' : 'join',
+				...(maxUses != null ? { maxUses } : {}),
+				...(expiresAt != null ? { expiresAt } : {})
+			});
+			inviteUrl = `${window.location.origin}/p/${hostProfile?.handle || did}/e/${rkey}/s/${spaceKey}?invite=${result.token}`;
+			showInviteForm = false;
+			showInviteModal = true;
+		} catch (e) {
+			inviteError = e instanceof Error ? e.message : String(e);
+		} finally {
+			inviteBusy = false;
+		}
+	}
+</script>
+
+<Button variant="secondary" class="mt-3 w-full" onclick={openInviteForm}>
+	Share invite link
+</Button>
+
+<Modal bind:open={showInviteForm} interactOutsideBehavior={inviteBusy ? 'ignore' : 'close'}>
+	<h2 class="mb-4 text-lg font-semibold">Create invite link</h2>
+
+	<form
+		class="space-y-4"
+		onsubmit={(e) => {
+			e.preventDefault();
+			submitInviteForm();
+		}}
+	>
+		<div class="flex items-start gap-2">
+			<Checkbox id="invite-allow-anon" bind:checked={inviteAllowAnonRead} disabled={inviteBusy} />
+			<div>
+				<Label for="invite-allow-anon">Allow viewing event without being logged in</Label>
+				<p class="text-base-500 dark:text-base-400 mt-0.5 text-xs">
+					Anyone with this link can read the event details. Signed-in users can still join with the
+					same link.
+				</p>
+			</div>
+		</div>
+
+		<div>
+			<Label for="invite-max-uses">Max uses</Label>
+			<Input
+				id="invite-max-uses"
+				type="number"
+				min="1"
+				bind:value={inviteMaxUsesText}
+				placeholder="Unlimited"
+				disabled={inviteBusy}
+			/>
+			<p class="text-base-500 dark:text-base-400 mt-1 text-xs">
+				Caps how many people can join — anonymous reads are always unlimited. Leave empty for no
+				limit.
+			</p>
+		</div>
+
+		<div>
+			<div class="mb-1 flex items-center gap-2">
+				<Checkbox id="invite-has-expiry" bind:checked={inviteHasExpiry} disabled={inviteBusy} />
+				<Label for="invite-has-expiry">Set an expiry</Label>
+			</div>
+			{#if inviteHasExpiry}
+				<DateTimePicker bind:value={inviteExpiresAt} />
+			{:else}
+				<p class="text-base-500 dark:text-base-400 text-xs">Link never expires.</p>
+			{/if}
+		</div>
+
+		{#if inviteError}
+			<p class="text-sm text-red-600 dark:text-red-400">{inviteError}</p>
+		{/if}
+
+		<div class="flex justify-end gap-2 pt-2">
+			<Button
+				type="button"
+				variant="secondary"
+				onclick={() => (showInviteForm = false)}
+				disabled={inviteBusy}
+			>
+				Cancel
+			</Button>
+			<Button type="submit" disabled={inviteBusy}>
+				{inviteBusy ? 'Creating…' : 'Create invite'}
+			</Button>
+		</div>
+	</form>
+</Modal>
+
+{#if inviteUrl}
+	<ShareModal
+		bind:open={showInviteModal}
+		url={inviteUrl}
+		title="Invite link"
+		shareText={`You're invited to "${eventName}".\n\n${inviteUrl}`}
+		{eventName}
+		{adapter}
+		{viewer}
+	/>
+{/if}

package/dist/event-view/InviteShareFlow.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { HostProfile } from '../contrail.js';
+import type { EditorAdapter, EditorViewer } from '../editor/adapter.js';
+type $$ComponentProps = {
+    spaceUri: string;
+    spaceKey: string;
+    did: string;
+    rkey: string;
+    eventName: string;
+    hostProfile: HostProfile | null | undefined;
+    adapter: EditorAdapter;
+    viewer: EditorViewer;
+};
+declare const InviteShareFlow: import("svelte").Component<$$ComponentProps, {}, "">;
+type InviteShareFlow = ReturnType<typeof InviteShareFlow>;
+export default InviteShareFlow;

package/dist/event-view/StreamPlacePlayer.svelte

@@ -0,0 +1,222 @@
+<script lang="ts">
+	import { onMount } from 'svelte';
+	import 'plyr/dist/plyr.css';
+	import type PlyrType from 'plyr';
+
+	let {
+		handle,
+		title
+	}: {
+		handle: string;
+		title: string;
+	} = $props();
+
+	let videoEl: HTMLVideoElement | undefined = $state();
+	let overlayEl: HTMLAnchorElement | undefined = $state();
+	let error = $state(false);
+	let controlsVisible = $state(true);
+
+	let pc: RTCPeerConnection | null = null;
+	let plyr: PlyrType | null = null;
+
+	const posterUrl = $derived(
+		`https://stream.place/api/playback/${encodeURIComponent(handle)}/stream.jpg`
+	);
+
+	onMount(() => {
+		init();
+		return () => {
+			if (pc) {
+				pc.close();
+				pc = null;
+			}
+			if (videoEl) {
+				videoEl.srcObject = null;
+			}
+			plyr?.destroy();
+		};
+	});
+
+	function waitForIceGathering(peer: RTCPeerConnection, timeoutMs = 2000): Promise<void> {
+		return new Promise((resolve) => {
+			if (peer.iceGatheringState === 'complete') {
+				resolve();
+				return;
+			}
+
+			let done = false;
+			const finish = () => {
+				if (done) return;
+				done = true;
+				peer.removeEventListener('icegatheringstatechange', onStateChange);
+				clearTimeout(timer);
+				resolve();
+			};
+
+			const onStateChange = () => {
+				if (peer.iceGatheringState === 'complete') {
+					finish();
+				}
+			};
+
+			peer.addEventListener('icegatheringstatechange', onStateChange);
+			const timer = setTimeout(finish, timeoutMs);
+		});
+	}
+
+	async function init() {
+		if (!videoEl) return;
+
+		try {
+			pc = new RTCPeerConnection({
+				iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+				bundlePolicy: 'max-bundle'
+			});
+
+			pc.addTransceiver('video', { direction: 'recvonly' });
+			pc.addTransceiver('audio', { direction: 'recvonly' });
+
+			pc.addEventListener('track', (event) => {
+				if (!videoEl) return;
+				if (event.streams && event.streams[0]) {
+					videoEl.srcObject = event.streams[0];
+				} else {
+					let stream = videoEl.srcObject as MediaStream | null;
+					if (!stream) {
+						stream = new MediaStream();
+						videoEl.srcObject = stream;
+					}
+					stream.addTrack(event.track);
+				}
+			});
+
+			const offer = await pc.createOffer();
+			await pc.setLocalDescription(offer);
+			await waitForIceGathering(pc, 2000);
+
+			const sdp = pc.localDescription?.sdp;
+			if (!sdp) {
+				error = true;
+				pc.close();
+				pc = null;
+				return;
+			}
+
+			const response = await fetch(
+				`https://stream.place/api/playback/${encodeURIComponent(handle)}/webrtc?rendition=source`,
+				{
+					method: 'POST',
+					headers: { 'Content-Type': 'application/sdp' },
+					body: sdp
+				}
+			);
+
+			if (!response.ok) {
+				error = true;
+				pc.close();
+				pc = null;
+				return;
+			}
+
+			const answerSdp = await response.text();
+			await pc.setRemoteDescription({ type: 'answer', sdp: answerSdp });
+
+			const { default: Plyr } = await import('plyr');
+
+			plyr = new Plyr(videoEl, {
+				controls: ['play', 'mute', 'volume', 'fullscreen'],
+				settings: [],
+				ratio: '16:9'
+			});
+
+			plyr.on('controlshidden', () => {
+				controlsVisible = false;
+			});
+			plyr.on('controlsshown', () => {
+				controlsVisible = true;
+			});
+
+			// Move the overlay link inside Plyr's container so mousemove over the
+			// button bubbles into Plyr's activity tracker — otherwise hovering it
+			// hides the controls, which hides the button, which reactivates Plyr
+			// (a flicker loop).
+			const plyrEl = videoEl.closest('.plyr');
+			if (plyrEl && overlayEl) plyrEl.appendChild(overlayEl);
+		} catch {
+			error = true;
+			if (pc) {
+				pc.close();
+				pc = null;
+			}
+		}
+	}
+</script>
+
+{#snippet watchOnStreamPlace(hidden = false)}
+	<a
+		bind:this={overlayEl}
+		href="https://stream.place/{handle}"
+		target="_blank"
+		rel="noopener noreferrer"
+		onclick={() => plyr?.pause()}
+		class="absolute top-3 right-3 z-10 inline-flex items-center gap-1.5 rounded-full bg-black/55 px-2.5 py-1 text-xs font-medium text-white backdrop-blur-sm transition-opacity duration-200 hover:bg-black/75 {hidden
+			? 'pointer-events-none opacity-0'
+			: 'opacity-100'}"
+	>
+		Watch on stream.place
+		<svg
+			xmlns="http://www.w3.org/2000/svg"
+			viewBox="0 0 20 20"
+			fill="currentColor"
+			class="size-3"
+			aria-hidden="true"
+		>
+			<path
+				fill-rule="evenodd"
+				d="M4.25 5.5a.75.75 0 0 0-.75.75v8.5c0 .414.336.75.75.75h8.5a.75.75 0 0 0 .75-.75v-4a.75.75 0 0 1 1.5 0v4A2.25 2.25 0 0 1 12.75 17h-8.5A2.25 2.25 0 0 1 2 14.75v-8.5A2.25 2.25 0 0 1 4.25 4h5a.75.75 0 0 1 0 1.5h-5Z"
+				clip-rule="evenodd"
+			/>
+			<path
+				fill-rule="evenodd"
+				d="M6.194 12.753a.75.75 0 0 0 1.06.053L16.5 4.44v2.81a.75.75 0 0 0 1.5 0v-4.5a.75.75 0 0 0-.75-.75h-4.5a.75.75 0 0 0 0 1.5h2.553l-9.056 8.194a.75.75 0 0 0-.053 1.06Z"
+				clip-rule="evenodd"
+			/>
+		</svg>
+	</a>
+{/snippet}
+
+{#if error}
+	<div
+		class="bg-base-100 dark:bg-base-900 border-base-200 dark:border-base-800 relative flex aspect-video w-full items-center justify-center overflow-hidden rounded-xl border"
+	>
+		<div
+			class="absolute inset-0 bg-cover bg-center"
+			style="background-image: url({posterUrl});"
+		></div>
+		<div class="absolute inset-0 bg-black/60"></div>
+		{@render watchOnStreamPlace()}
+		<p class="text-base-100 relative text-sm">Stream is offline</p>
+	</div>
+{:else}
+	<div
+		class="border-base-300 dark:border-base-400/40 relative aspect-video w-full max-w-full overflow-hidden rounded-xl border"
+	>
+		{@render watchOnStreamPlace(!controlsVisible)}
+		<video
+			bind:this={videoEl}
+			class="h-full w-full"
+			aria-label={title}
+			poster={posterUrl}
+			autoplay
+			playsinline
+			muted
+			crossorigin="anonymous"
+		></video>
+	</div>
+{/if}
+
+<style>
+	* {
+		--plyr-color-main: var(--color-accent-500);
+	}
+</style>

package/dist/event-view/StreamPlacePlayer.svelte.d.ts

@@ -0,0 +1,8 @@
+import 'plyr/dist/plyr.css';
+type $$ComponentProps = {
+    handle: string;
+    title: string;
+};
+declare const StreamPlacePlayer: import("svelte").Component<$$ComponentProps, {}, "">;
+type StreamPlacePlayer = ReturnType<typeof StreamPlacePlayer>;
+export default StreamPlacePlayer;

package/dist/event-view/format.d.ts

@@ -0,0 +1,26 @@
+import type { FlatEventRecord } from '../contrail.js';
+export declare function formatMonth(date: Date): string;
+export declare function formatDay(date: Date): number;
+export declare function formatWeekday(date: Date): string;
+export declare function formatFullDate(date: Date): string;
+export declare function formatTime(date: Date): string;
+export declare function getModeLabel(mode: string): string;
+/** Foxui accent-color class — applied alongside `variant="primary"` on a Badge
+ *  to override its `--accent-*` CSS variables (see @foxui/core/dist/theme.css). */
+export declare function getModeColor(mode: string): string;
+export type LocationData = {
+    name?: string;
+    shortAddress: string;
+    fullAddress: string;
+    fullString: string;
+    googleMapsUrl: string;
+};
+export declare function getLocationData(locations: FlatEventRecord['locations']): LocationData | null;
+export type GeoLocation = {
+    lat: number;
+    lng: number;
+    googleMapsUrl: string;
+    osmUrl: string;
+};
+export declare function resolveGeoLocation(locations: FlatEventRecord['locations'], locationData: LocationData | null): Promise<GeoLocation | null>;
+export declare function buildDescriptionHtml(description: string | undefined, facets: unknown): string | null;

package/dist/event-view/format.js

@@ -0,0 +1,145 @@
+import { marked } from 'marked';
+import { sanitize } from '../cal/sanitize.js';
+import { getProfileUrl } from '../profile-url.js';
+export function formatMonth(date) {
+    return date.toLocaleDateString('en-US', { month: 'short' }).toUpperCase();
+}
+export function formatDay(date) {
+    return date.getDate();
+}
+export function formatWeekday(date) {
+    return date.toLocaleDateString('en-US', { weekday: 'long' });
+}
+export function formatFullDate(date) {
+    const options = { month: 'long', day: 'numeric' };
+    if (date.getFullYear() !== new Date().getFullYear()) {
+        options.year = 'numeric';
+    }
+    return date.toLocaleDateString('en-US', options);
+}
+export function formatTime(date) {
+    return date.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' });
+}
+export function getModeLabel(mode) {
+    if (mode.includes('virtual'))
+        return 'Virtual';
+    if (mode.includes('hybrid'))
+        return 'Hybrid';
+    if (mode.includes('inperson'))
+        return 'In-Person';
+    return 'Event';
+}
+/** Foxui accent-color class — applied alongside `variant="primary"` on a Badge
+ *  to override its `--accent-*` CSS variables (see @foxui/core/dist/theme.css). */
+export function getModeColor(mode) {
+    if (mode.includes('virtual'))
+        return 'cyan';
+    if (mode.includes('hybrid'))
+        return 'purple';
+    if (mode.includes('inperson'))
+        return 'amber';
+    return '';
+}
+export function getLocationData(locations) {
+    if (!locations?.length)
+        return null;
+    const loc = locations.find((v) => v.$type === 'community.lexicon.location.address');
+    if (!loc)
+        return null;
+    const shortParts = [loc.street, loc.locality].filter(Boolean);
+    const fullParts = [loc.street, loc.locality, loc.region, loc.country].filter(Boolean);
+    if (fullParts.length === 0)
+        return null;
+    const shortAddress = shortParts.join(', ');
+    const fullAddress = fullParts.join(', ');
+    const displayName = loc.name || undefined;
+    const fullString = displayName ? `${displayName}, ${fullAddress}` : fullAddress;
+    const googleMapsUrl = `https://www.google.com/maps/search/?api=1&query=${encodeURIComponent(fullString)}`;
+    return { name: displayName, shortAddress, fullAddress, fullString, googleMapsUrl };
+}
+function geoUrls(lat, lng, osmType, osmId) {
+    return {
+        googleMapsUrl: `https://www.google.com/maps/search/?api=1&query=${lat},${lng}`,
+        osmUrl: osmType && osmId
+            ? `https://www.openstreetmap.org/${osmType}/${osmId}`
+            : `https://www.openstreetmap.org/?mlat=${lat}&mlon=${lng}#map=17/${lat}/${lng}`
+    };
+}
+export async function resolveGeoLocation(locations, locationData) {
+    if (!locations?.length)
+        return null;
+    const geo = locations.find((v) => v.$type === 'community.lexicon.location.geo');
+    if (geo?.latitude && geo?.longitude) {
+        const lat = parseFloat(geo.latitude);
+        const lng = parseFloat(geo.longitude);
+        if (!isNaN(lat) && !isNaN(lng))
+            return { lat, lng, ...geoUrls(lat, lng) };
+    }
+    if (!locationData?.fullAddress)
+        return null;
+    try {
+        const r = await fetch(`/api/geocoding?q=${encodeURIComponent(locationData.fullAddress)}`);
+        if (!r.ok)
+            return null;
+        const data = (await r.json());
+        if (!data?.lat || !data?.lon)
+            return null;
+        const lat = parseFloat(data.lat);
+        const lng = parseFloat(data.lon);
+        if (isNaN(lat) || isNaN(lng))
+            return null;
+        return { lat, lng, ...geoUrls(lat, lng, data.osm_type, data.osm_id) };
+    }
+    catch {
+        return null;
+    }
+}
+const renderer = new marked.Renderer();
+renderer.link = ({ href, text }) => `<a target="_blank" rel="noopener noreferrer nofollow" href="${href}" class="text-accent-600 dark:text-accent-400 hover:underline">${text}</a>`;
+function renderDescription(text, facets) {
+    let result = text;
+    if (facets && facets.length > 0) {
+        const encoded = new TextEncoder().encode(text);
+        const decoder = new TextDecoder();
+        const sorted = [...facets].sort((a, b) => a.index.byteStart - b.index.byteStart);
+        const parts = [];
+        let cursor = 0;
+        for (const facet of sorted) {
+            const feature = facet.features?.[0];
+            if (!feature)
+                continue;
+            if (facet.index.byteStart < cursor)
+                continue;
+            const segmentText = decoder.decode(encoded.slice(facet.index.byteStart, facet.index.byteEnd));
+            let mdLink = null;
+            switch (feature.$type) {
+                case 'app.bsky.richtext.facet#mention': {
+                    const handle = segmentText.startsWith('@') ? segmentText.slice(1) : segmentText;
+                    mdLink = `[${segmentText}](${getProfileUrl(handle || feature.did || '')})`;
+                    break;
+                }
+                case 'app.bsky.richtext.facet#link':
+                    mdLink = `[${segmentText}](${feature.uri})`;
+                    break;
+                case 'app.bsky.richtext.facet#tag':
+                    mdLink = `[${segmentText}](https://bsky.app/hashtag/${feature.tag})`;
+                    break;
+            }
+            if (mdLink) {
+                parts.push(decoder.decode(encoded.slice(cursor, facet.index.byteStart)));
+                parts.push(mdLink);
+                cursor = facet.index.byteEnd;
+            }
+        }
+        parts.push(decoder.decode(encoded.slice(cursor)));
+        result = parts.join('');
+    }
+    return marked.parse(result, { renderer });
+}
+export function buildDescriptionHtml(description, facets) {
+    if (!description)
+        return null;
+    return sanitize(renderDescription(description, facets), {
+        ADD_ATTR: ['target']
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { default as EventView } from './EventView.svelte';
+export { default as EventEditor } from './EventEditor.svelte';
+export { default as EventCard } from './EventCard.svelte';
+export { default as EventRsvp } from './EventRsvp.svelte';
+export { default as EventComments } from './EventComments.svelte';
+export { default as EventAttendees } from './EventAttendees.svelte';
+export { default as VodPlayer } from './VodPlayer.svelte';
+export { default as VodTranscript } from './VodTranscript.svelte';
+export type { EditorAdapter, EditorBlobRef, EditorViewer } from './editor/adapter.js';
+export type { EventEditorPrefill } from './editor/types.js';
+export type { FlatEventRecord, HostProfile, AttendeeInfo } from './contrail.js';
+export type { EventData, EventLexiconMain, EventLocationVariant, EventStatus, EventMode as EventLexiconMode } from './event-types.js';
+export type { EventTheme } from './theme.js';
+export { defaultTheme, themeBackgrounds, randomAccentColor, accentColors } from './theme.js';
+export { eventUrl, isEventOngoing, RSVP_GOING, RSVP_INTERESTED } from './contrail.js';
+export { getCDNImageBlobUrl, compressImage } from './atproto-helpers.js';
+export { getProfileUrl } from './profile-url.js';
+export { datetimeLocalToISO, isoToDatetimeLocalInTz, formatInTz, partsInTz } from './date-format.js';

package/dist/index.js

@@ -0,0 +1,18 @@
+// Components
+export { default as EventView } from './EventView.svelte';
+export { default as EventEditor } from './EventEditor.svelte';
+export { default as EventCard } from './EventCard.svelte';
+export { default as EventRsvp } from './EventRsvp.svelte';
+export { default as EventComments } from './EventComments.svelte';
+export { default as EventAttendees } from './EventAttendees.svelte';
+export { default as VodPlayer } from './VodPlayer.svelte';
+export { default as VodTranscript } from './VodTranscript.svelte';
+// Theme values
+export { defaultTheme, themeBackgrounds, randomAccentColor, accentColors } from './theme.js';
+// Event helpers
+export { eventUrl, isEventOngoing, RSVP_GOING, RSVP_INTERESTED } from './contrail.js';
+// Atproto helpers (browser-safe, no client/session state)
+export { getCDNImageBlobUrl, compressImage } from './atproto-helpers.js';
+export { getProfileUrl } from './profile-url.js';
+// Date/time helpers
+export { datetimeLocalToISO, isoToDatetimeLocalInTz, formatInTz, partsInTz } from './date-format.js';

package/dist/profile-url.d.ts

@@ -0,0 +1 @@
+export declare function getProfileUrl(handleOrDid: string): string;

package/dist/profile-url.js

@@ -0,0 +1,7 @@
+export function getProfileUrl(handleOrDid) {
+    const lower = handleOrDid.toLowerCase();
+    if (lower.endsWith('.blacksky.team') || lower.endsWith('.blacksky.app')) {
+        return `https://blacksky.community/profile/${handleOrDid}`;
+    }
+    return `https://bsky.app/profile/${handleOrDid}`;
+}

package/dist/theme.d.ts

@@ -0,0 +1,9 @@
+export interface EventTheme {
+    name: string;
+    accentColor: string;
+    baseColor: string;
+}
+export declare const accentColors: readonly ["red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose"];
+export declare const defaultTheme: EventTheme;
+export declare function randomAccentColor(): string;
+export declare const themeBackgrounds: Record<string, string>;

package/dist/theme.js

@@ -0,0 +1,22 @@
+export const accentColors = [
+    'red', 'orange', 'amber', 'yellow', 'lime', 'green', 'emerald',
+    'teal', 'cyan', 'sky', 'blue', 'indigo', 'violet', 'purple',
+    'fuchsia', 'pink', 'rose'
+];
+export const defaultTheme = {
+    name: 'minimal',
+    accentColor: 'cyan',
+    baseColor: 'mist'
+};
+export function randomAccentColor() {
+    return accentColors[Math.floor(Math.random() * accentColors.length)];
+}
+export const themeBackgrounds = {
+    minimal: 'Minimal',
+    blobs: 'Blobs',
+    warp: 'Stars',
+    matrix: 'Matrix',
+    fireflies: 'Fireflies',
+    butterflies: 'Butterflies',
+    kaleidoscope: 'Kaleidoscope'
+};