app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

report.ts (12342B)


      1 import {
      2   productViewSnapshot,
      3   productViewPublisherProof,
      4   type ProductView
      5 } from '../catalog/product-view.ts';
      6 import { verifiedEnvelopeSnapshot } from '../nostr/verified-envelope.ts';
      7 import {
      8   inboxThreadSnapshot,
      9   inboxReplyOwnership,
     10   subscribeInboxView,
     11   type InboxView
     12 } from '../messaging/inbox-view.ts';
     13 
     14 declare const contextBrand: unique symbol, previewBrand: unique symbol;
     15 export type ReportContext = Readonly<{ [contextBrand]: true }>;
     16 export type ReportPreview = Readonly<{ [previewBrand]: true }>;
     17 export type ReportContextSnapshot = Readonly<
     18   | { kind: 'general' }
     19   | { kind: 'listing'; eventId: string; coordinate: string }
     20   | {
     21       kind: 'conversation';
     22       peer: string;
     23       messages: readonly Readonly<{
     24         id: string;
     25         content: string;
     26         createdAt: number;
     27       }>[];
     28     }
     29 >;
     30 type Selection = Readonly<{
     31   listingVersion: boolean;
     32   coordinate: boolean;
     33   peer: boolean;
     34   messages: readonly string[];
     35   notes: string;
     36   privateDisclosure: boolean;
     37 }>;
     38 type PreviewOwner = {
     39   text(): string | undefined;
     40   current(): boolean;
     41   retire(): void;
     42 };
     43 type ContextOwner = {
     44   read(): ReportContextSnapshot | undefined;
     45   close(deferNotification?: boolean): void;
     46   subscribe(listener: () => void): () => void;
     47   own(preview: PreviewOwner): () => void;
     48   retirePreviews(): void;
     49   listen(unsubscribe: () => void): void;
     50   notify(): void;
     51 };
     52 const contexts = new WeakMap<ReportContext, ContextOwner>();
     53 const previews = new WeakMap<ReportPreview, PreviewOwner>();
     54 
     55 function capture(read: () => ReportContextSnapshot | undefined): ReportContext {
     56   const token = Object.freeze({}) as ReportContext;
     57   let closed = false;
     58   let source = read;
     59   let unsubscribe = () => {};
     60   const listeners = new Map<symbol, () => void>();
     61   const retained = new Map<symbol, PreviewOwner>();
     62   const retirePreviews = () => {
     63     for (const previous of retained.values()) previous.retire();
     64   };
     65   const notify = () => {
     66     for (const listener of listeners.values()) listener();
     67   };
     68   const close = (deferNotification = false) => {
     69     if (closed) return;
     70     closed = true;
     71     source = () => undefined;
     72     unsubscribe();
     73     unsubscribe = () => {};
     74     retirePreviews();
     75     const pending = Array.from(listeners.values());
     76     listeners.clear();
     77     // Plaintext and authority retire synchronously. Only UI notification may
     78     // be deferred when a Svelte derivation discovers original-owner loss.
     79     const notifyClosed = () => {
     80       for (const listener of pending) listener();
     81     };
     82     if (deferNotification && pending.length) queueMicrotask(notifyClosed);
     83     else notifyClosed();
     84   };
     85   contexts.set(token, {
     86     read() {
     87       if (closed) return undefined;
     88       let snapshot: ReportContextSnapshot | undefined;
     89       try {
     90         snapshot = source();
     91       } catch {
     92         /* Original source unavailable. */
     93       }
     94       if (!snapshot) close(true);
     95       return snapshot;
     96     },
     97     close,
     98     subscribe(listener) {
     99       if (closed) return () => {};
    100       const id = Symbol();
    101       listeners.set(id, listener);
    102       return () => {
    103         listeners.delete(id);
    104       };
    105     },
    106     own(preview) {
    107       const id = Symbol();
    108       if (closed) preview.retire();
    109       else retained.set(id, preview);
    110       return () => {
    111         retained.delete(id);
    112       };
    113     },
    114     retirePreviews,
    115     listen(next) {
    116       if (closed) next();
    117       else unsubscribe = next;
    118     },
    119     notify
    120   });
    121   return token;
    122 }
    123 export function createGeneralReport(): ReportContext {
    124   return capture(() => ({ kind: 'general' }));
    125 }
    126 export function createListingReport(
    127   view: ProductView
    128 ): ReportContext | undefined {
    129   if (typeof window === 'undefined') return undefined;
    130   const proof = productViewPublisherProof(view);
    131   const event = proof && verifiedEnvelopeSnapshot(proof);
    132   if (!event || event.kind !== 30402) return undefined;
    133   try {
    134     const initial = productViewSnapshot(view);
    135     if (
    136       initial.eventId !== event.id ||
    137       initial.reference.pubkey !== event.pubkey
    138     )
    139       return undefined;
    140     const coordinate = `30402:${initial.reference.pubkey}:${initial.reference.identifier}`;
    141     return capture(() => {
    142       try {
    143         const current = productViewSnapshot(view);
    144         const currentProof = productViewPublisherProof(view);
    145         const signed = currentProof && verifiedEnvelopeSnapshot(currentProof);
    146         return current.eventId === event.id &&
    147           signed?.id === event.id &&
    148           `30402:${current.reference.pubkey}:${current.reference.identifier}` ===
    149             coordinate
    150           ? { kind: 'listing', eventId: event.id, coordinate }
    151           : undefined;
    152       } catch {
    153         return undefined;
    154       }
    155     });
    156   } catch {
    157     return undefined;
    158   }
    159 }
    160 export function createConversationReport(
    161   view: InboxView,
    162   id: string
    163 ): ReportContext | undefined {
    164   if (typeof window === 'undefined') return undefined;
    165   const initial = inboxThreadSnapshot(view, id);
    166   const first = initial.messages[0];
    167   const original = first && inboxReplyOwnership(view, id, first.data.rumorId);
    168   if (initial.status !== 'ready' || !original?.current()) return undefined;
    169   const peer = original.peer;
    170   const token = capture(() => {
    171     if (!original.current()) return undefined;
    172     const thread = inboxThreadSnapshot(view, id);
    173     if (thread.status !== 'ready') return undefined;
    174     if (
    175       thread.messages.some((row) => {
    176         const owned = inboxReplyOwnership(view, id, row.data.rumorId);
    177         return !owned?.current() || owned.peer !== peer;
    178       })
    179     )
    180       return undefined;
    181     const rows = thread.messages.map((row) => ({
    182       id: row.data.rumorId,
    183       content: row.data.content,
    184       createdAt: row.data.createdAt
    185     }));
    186     /* verified original rows only */
    187     return { kind: 'conversation', peer, messages: rows };
    188   });
    189   const owned = contexts.get(token)!;
    190   owned.listen(
    191     subscribeInboxView(view, () => {
    192       if (reportContextSnapshot(token)) owned.notify();
    193     })
    194   );
    195   return token;
    196 }
    197 export function reportContextSnapshot(
    198   token: ReportContext
    199 ): ReportContextSnapshot | undefined {
    200   return contexts.get(token)?.read();
    201 }
    202 export function subscribeReportContext(
    203   token: ReportContext,
    204   listener: () => void
    205 ): () => void {
    206   return contexts.get(token)?.subscribe(listener) ?? (() => {});
    207 }
    208 export function closeReportContext(token: ReportContext): void {
    209   contexts.get(token)?.close();
    210 }
    211 function selection(raw: unknown): Selection | undefined {
    212   if (
    213     typeof raw !== 'string' ||
    214     raw.length > 65536 ||
    215     !raw.isWellFormed() ||
    216     new TextEncoder().encode(raw).length > 65536
    217   )
    218     return undefined;
    219   try {
    220     const value: unknown = JSON.parse(raw);
    221     if (!value || typeof value !== 'object' || Array.isArray(value))
    222       return undefined;
    223     const row = value as Record<string, unknown>;
    224     let count = 0;
    225     for (const key in row) {
    226       if (
    227         ![
    228           'listingVersion',
    229           'coordinate',
    230           'peer',
    231           'messages',
    232           'notes',
    233           'privateDisclosure'
    234         ].includes(key)
    235       )
    236         return undefined;
    237       count++;
    238     }
    239     if (
    240       count !== 6 ||
    241       typeof row.listingVersion !== 'boolean' ||
    242       typeof row.coordinate !== 'boolean' ||
    243       typeof row.peer !== 'boolean' ||
    244       typeof row.privateDisclosure !== 'boolean' ||
    245       typeof row.notes !== 'string' ||
    246       !row.notes.isWellFormed() ||
    247       new TextEncoder().encode(row.notes).length > 4096 ||
    248       !Array.isArray(row.messages) ||
    249       row.messages.some(
    250         (value) => typeof value !== 'string' || !/^[0-9a-f]{64}$/.test(value)
    251       ) ||
    252       new Set(row.messages).size !== row.messages.length
    253     )
    254       return undefined;
    255     return {
    256       listingVersion: row.listingVersion,
    257       coordinate: row.coordinate,
    258       peer: row.peer,
    259       messages: row.messages as string[],
    260       notes: row.notes,
    261       privateDisclosure: row.privateDisclosure
    262     };
    263   } catch {
    264     return undefined;
    265   }
    266 }
    267 function selectedText(
    268   snapshot: ReportContextSnapshot,
    269   selected: Selection
    270 ): string | undefined {
    271   if (
    272     snapshot.kind !== 'listing' &&
    273     (selected.listingVersion || selected.coordinate)
    274   )
    275     return undefined;
    276   if (
    277     snapshot.kind !== 'conversation' &&
    278     (selected.peer || selected.messages.length)
    279   )
    280     return undefined;
    281   if (snapshot.kind === 'conversation') {
    282     if (
    283       (selected.peer || selected.messages.length || selected.notes) &&
    284       !selected.privateDisclosure
    285     )
    286       return undefined;
    287     if (
    288       selected.messages.some(
    289         (id) => !snapshot.messages.some((message) => message.id === id)
    290       )
    291     )
    292       return undefined;
    293   }
    294   const lines = [
    295     'HarvestCircle report',
    296     ...(snapshot.kind === 'listing' && selected.listingVersion
    297       ? ['Listing version: ' + snapshot.eventId]
    298       : []),
    299     ...(snapshot.kind === 'listing' && selected.coordinate
    300       ? ['Coordinate: ' + snapshot.coordinate]
    301       : []),
    302     ...(snapshot.kind === 'conversation' && selected.peer
    303       ? ['Authenticated peer: ' + snapshot.peer]
    304       : []),
    305     ...(snapshot.kind === 'conversation'
    306       ? snapshot.messages
    307           .filter((message) => selected.messages.includes(message.id))
    308           .map(
    309             (message) =>
    310               `Message: ${message.id}\nTime: ${message.createdAt}\n${message.content}`
    311           )
    312       : []),
    313     ...(selected.notes ? ['Notes:\n' + selected.notes] : [])
    314   ];
    315   if (lines.length === 1) return undefined;
    316   const text = lines.join('\n\n');
    317   // Conservative local-copy ceiling, not a message/transport quota. Refuse the
    318   // complete selection rather than silently truncating private report content.
    319   return new TextEncoder().encode(text).length <= 65536 ? text : undefined;
    320 }
    321 export function reviewReportPreview(
    322   token: ReportContext,
    323   raw: unknown,
    324   review: unknown
    325 ): ReportPreview | undefined {
    326   if (review !== 'reviewed_report_preview') return undefined;
    327   const owned = contexts.get(token),
    328     selected = selection(raw),
    329     snapshot = reportContextSnapshot(token);
    330   if (!owned || !selected || !snapshot) return undefined;
    331   const text = selectedText(snapshot, selected);
    332   if (!text) return undefined;
    333   // One current reviewed preview per context; obsolete selections do not form
    334   // a retained plaintext history and cannot remain copyable by stale handles.
    335   owned.retirePreviews();
    336   const preview = Object.freeze({}) as ReportPreview;
    337   let currentText: string | undefined = text;
    338   let chosen: Selection | undefined = selected;
    339   let forget = () => {};
    340   const record: PreviewOwner = {
    341     text: () => currentText,
    342     current() {
    343       const actual = reportContextSnapshot(token);
    344       return (
    345         !!actual &&
    346         chosen !== undefined &&
    347         currentText !== undefined &&
    348         selectedText(actual, chosen) === currentText
    349       );
    350     },
    351     retire() {
    352       currentText = undefined;
    353       chosen = undefined;
    354       forget();
    355       forget = () => {};
    356     }
    357   };
    358   forget = owned.own(record);
    359   previews.set(preview, record);
    360   return preview;
    361 }
    362 export function reportPreviewSnapshot(
    363   token: ReportPreview
    364 ): string | undefined {
    365   const record = previews.get(token);
    366   if (!record || !record.current()) {
    367     if (record) record.retire();
    368     return undefined;
    369   }
    370   return record.text();
    371 }
    372 export function closeReportPreview(token: ReportPreview): void {
    373   const record = previews.get(token);
    374   if (record) record.retire();
    375 }
    376 export async function copyReportPreview(
    377   token: ReportPreview,
    378   review: unknown
    379 ): Promise<'copied' | 'unavailable' | 'stopped'> {
    380   if (review !== 'reviewed_copy_report' || !previews.has(token))
    381     return 'unavailable';
    382   const text = reportPreviewSnapshot(token);
    383   if (text === undefined) return 'stopped';
    384   if (typeof window === 'undefined' || typeof navigator === 'undefined')
    385     return 'unavailable';
    386   try {
    387     const clipboard = navigator.clipboard,
    388       write =
    389         clipboard &&
    390         Reflect.get<Clipboard, 'writeText'>(clipboard, 'writeText');
    391     if (typeof write !== 'function') return 'unavailable';
    392     if (reportPreviewSnapshot(token) !== text) return 'stopped';
    393     await write.call(clipboard, text);
    394     return reportPreviewSnapshot(token) === text ? 'copied' : 'stopped';
    395   } catch {
    396     return reportPreviewSnapshot(token) === text ? 'unavailable' : 'stopped';
    397   }
    398 }