feat: add gallery state and reference to photo lexicon; update photo and gallery functions to support gallery items

__generated__/lexicons.ts

···
             ref: 'lex:social.grain.photo.defs#exifView',
             description: 'EXIF metadata for the photo, if available.',
           },
+          gallery: {
+            type: 'ref',
+            ref: 'lex:social.grain.photo.defs#galleryState',
+          },
         },
       },
       exifView: {
···
           },
           model: {
             type: 'string',
+          },
+        },
+      },
+      galleryState: {
+        type: 'object',
+        description:
+          "Metadata about the photo's relationship with the subject content. Only has meaningful content when photo is attached to a gallery.",
+        properties: {
+          item: {
+            type: 'string',
+            format: 'at-uri',
           },
         },
       },

__generated__/types/social/grain/photo/defs.ts

···
   alt: string
   aspectRatio?: SocialGrainDefs.AspectRatio
   exif?: ExifView
+  gallery?: GalleryState
 }
 
 const hashPhotoView = 'photoView'
···
 export function validateExifView<V>(v: V) {
   return validate<ExifView & V>(v, id, hashExifView)
 }
+
+/** Metadata about the photo's relationship with the subject content. Only has meaningful content when photo is attached to a gallery. */
+export interface GalleryState {
+  $type?: 'social.grain.photo.defs#galleryState'
+  item?: string
+}
+
+const hashGalleryState = 'galleryState'
+
+export function isGalleryState<V>(v: V) {
+  return is$typed(v, id, hashGalleryState)
+}
+
+export function validateGalleryState<V>(v: V) {
+  return validate<GalleryState & V>(v, id, hashGalleryState)
+}

lexicons/social/grain/photo/defs.json

···
           "type": "ref",
           "ref": "social.grain.photo.defs#exifView",
           "description": "EXIF metadata for the photo, if available."
-        }
+        },
+        "gallery": { "type": "ref", "ref": "#galleryState" }
       }
     },
     "exifView": {
···
         "lensModel": { "type": "string" },
         "make": { "type": "string" },
         "model": { "type": "string" }
+      }
+    },
+    "galleryState": {
+      "type": "object",
+      "description": "Metadata about the photo's relationship with the subject content. Only has meaningful content when photo is attached to a gallery.",
+      "properties": {
+        "item": { "type": "string", "format": "at-uri" }
       }
     }
   }

src/lib/gallery.ts

···
 import { getActorProfile, getActorProfilesBulk } from "./actor.ts";
 import { photoToView } from "./photo.ts";
 
-type PhotoWithExif = WithBffMeta<Photo> & {
+type PhotoWithMeta = WithBffMeta<Photo> & {
+  galleryItemUri?: string;
   exif?: WithBffMeta<PhotoExif>;
 };
 
 export function getGalleryItemsAndPhotos(
   ctx: BffContext,
   galleries: WithBffMeta<Gallery>[],
-): Map<string, PhotoWithExif[]> {
+): Map<string, PhotoWithMeta[]> {
   const galleryUris = galleries.map(
     (gallery) =>
       `at://${gallery.did}/social.grain.gallery/${new AtUri(gallery.uri).rkey}`,
···
     },
   );
 
-  const photosMap = new Map<string, PhotoWithExif>();
+  const photosMap = new Map<string, PhotoWithMeta>();
   const exifMap = new Map<string, WithBffMeta<PhotoExif>>();
   for (const exif of photosExif) {
     exifMap.set(exif.photo, exif);
···
     photosMap.set(photo.uri, exif ? { ...photo, exif } : photo);
   }
 
-  const galleryPhotosMap = new Map<string, PhotoWithExif[]>();
+  const galleryPhotosMap = new Map<string, PhotoWithMeta[]>();
   for (const item of galleryItems) {
     const galleryUri = item.gallery;
     const photo = photosMap.get(item.item);
···
     }
 
     if (photo) {
-      galleryPhotosMap.get(galleryUri)?.push(photo);
+      // Attach the galleryItem uri as itemUri
+      galleryPhotosMap.get(galleryUri)?.push({
+        ...photo,
+        galleryItemUri: item.uri,
+      });
     }
   }
 
···
 }: {
   record: WithBffMeta<Gallery>;
   creator: Un$Typed<ProfileView>;
-  items: PhotoWithExif[];
+  items: PhotoWithMeta[];
   labels: Label[];
   favCount?: number;
   commentCount?: number;
···
 function itemToView(
   did: string,
   item:
-    | PhotoWithExif
+    | PhotoWithMeta
     | {
       $type: string;
     },
 ): Un$Typed<PhotoView> | undefined {
   if (isPhoto(item)) {
-    return photoToView(did, item, item.exif);
+    return photoToView(did, item, item.exif, item.galleryItemUri);
   }
   return undefined;
 }
 
 export function getGalleryCameras(
-  items: Array<PhotoWithExif | PhotoView>,
+  items: Array<PhotoWithMeta | PhotoView>,
 ): string[] {
   const cameras = new Set<string>();
   if (!Array.isArray(items)) return [];
···
       where: [{ field: "photo", in: photoUris }],
     },
   );
-  const photosMap = new Map<string, PhotoWithExif>();
   const exifMap = new Map<string, WithBffMeta<PhotoExif>>();
   for (const exif of photosExif) {
     exifMap.set(exif.photo, exif);
-  }
-  for (const photo of photos) {
-    const exif = exifMap.get(photo.uri);
-    photosMap.set(photo.uri, exif ? { ...photo, exif } : photo);
   }
   // Get the gallery DID from the URI
   const did = (() => {

src/lib/photo.ts

···
   did: string,
   photo: WithBffMeta<Photo>,
   exif?: WithBffMeta<PhotoExif>,
+  galleryItemUri?: string,
 ): $Typed<PhotoView> {
   return {
     $type: "social.grain.photo.defs#photoView",
···
     alt: photo.alt,
     aspectRatio: photo.aspectRatio,
     exif: exif ? exifToView(exif) : undefined,
+    gallery: galleryItemUri ? { item: galleryItemUri } : undefined,
   };
 }