app

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

product-enquiry.ts (6256B)


      1 import { mount, unmount, tick } from 'svelte';
      2 import Panel from './product-enquiry-panel.svelte';
      3 import { renderFixture as renderThread } from './conversation-thread.ts';
      4 import { validateRelayPolicy } from '../../../src/lib/config/relays.ts';
      5 import {
      6   createPublicRuntimeContext,
      7   mountPublicRuntime,
      8   createPublicView,
      9   closePublicRuntime
     10 } from '../../../src/lib/runtime/public-runtime.ts';
     11 import {
     12   createProductView,
     13   productViewSnapshot,
     14   closeProductView,
     15   type ProductViewSnapshot
     16 } from '../../../src/lib/catalog/product-view.ts';
     17 import { encodeProductReference } from '../../../src/lib/nostr/references.ts';
     18 import { getPublicKey } from 'applesauce-core/helpers';
     19 import {
     20   captureProductEnquiry,
     21   productEnquirySnapshot,
     22   productEnquiryMessage,
     23   updateProductEnquiry,
     24   reuseProductEnquiryConversation,
     25   closeProductEnquiry,
     26   type ProductEnquiry
     27 } from '../../../src/lib/messaging/product-enquiry.ts';
     28 import type { InboxView } from '../../../src/lib/messaging/inbox-view.ts';
     29 export { beforeNavigate, goto } from './conversation-thread.ts';
     30 
     31 export async function renderFixture(existing = false) {
     32   const thread = existing ? await renderThread('inbound') : undefined;
     33   if (thread) {
     34     await thread.checkSetup();
     35     if (!(await thread.unlock())) throw Error('original pair unavailable');
     36   }
     37   const preparationCounts = thread?.delta() ?? {
     38     decrypts: 0,
     39     signs: 0,
     40     encrypts: 0
     41   };
     42   const policy = validateRelayPolicy(
     43     JSON.stringify({
     44       schemaVersion: 1,
     45       public: [
     46         {
     47           origin: 'wss://discovery.example.org',
     48           read: true,
     49           write: false,
     50           nip50: false
     51         }
     52       ],
     53       inbox: [],
     54       postingEnabled: false,
     55       messagingEnabled: false,
     56       operatorDenylist: []
     57     })
     58   );
     59   if (!policy) throw Error('invalid fixed test policy');
     60   const context = createPublicRuntimeContext();
     61   let offset = 0;
     62   const runtime = mountPublicRuntime(context, policy, {
     63     now: () => performance.now() + offset,
     64     schedule(callback, delay) {
     65       const timer = setTimeout(callback, delay);
     66       return () => clearTimeout(timer);
     67     }
     68   });
     69   if (!runtime) throw Error('original runtime unavailable');
     70   const reference = encodeProductReference({
     71     kind: 30402,
     72     pubkey: getPublicKey(new Uint8Array(32).fill(84)),
     73     identifier: 'carrots'
     74   });
     75   if (!reference) throw Error('invalid public coordinate');
     76   const observers = new Set<(value: ProductViewSnapshot) => void>();
     77   const view = createProductView(
     78     createPublicView(runtime),
     79     reference,
     80     { nowSeconds: () => 1700000200 },
     81     (value) => {
     82       for (const callback of observers) callback(value);
     83     }
     84   );
     85   const target = document.createElement('div');
     86   document.body.append(target);
     87   let draft: ProductEnquiry | undefined;
     88   const mounted = mount(Panel, {
     89     target,
     90     props: {
     91       view,
     92       observe(callback: (value: ProductViewSnapshot) => void) {
     93         observers.add(callback);
     94         callback(productViewSnapshot(view));
     95         return () => {
     96           observers.delete(callback);
     97         };
     98       },
     99       capture(value: ProductEnquiry) {
    100         draft = value;
    101       }
    102     }
    103   });
    104   function capture(review: unknown = 'reviewed_product_enquiry') {
    105     const captured = captureProductEnquiry(view, review);
    106     if (captured) {
    107       if (draft) closeProductEnquiry(draft);
    108       draft = captured;
    109     }
    110     return !!captured;
    111   }
    112   let closed = false;
    113   return {
    114     viewSnapshot: () => productViewSnapshot(view),
    115     capture,
    116     snapshot: () => draft && productEnquirySnapshot(draft),
    117     message: () => draft && productEnquiryMessage(draft),
    118     update: (text: string) =>
    119       !!draft &&
    120       updateProductEnquiry(draft, text, 'reviewed_product_enquiry_edit'),
    121     native: () =>
    122       thread
    123         ? thread.native()
    124         : Promise.resolve({ received: [], pairs: [], sends: [] }),
    125     delta: () => {
    126       const actual = thread?.delta() ?? { decrypts: 0, signs: 0, encrypts: 0 };
    127       return {
    128         decrypts: actual.decrypts - preparationCounts.decrypts,
    129         signs: actual.signs - preparationCounts.signs,
    130         encrypts: actual.encrypts - preparationCounts.encrypts
    131       };
    132     },
    133     knownPath: () => (thread ? '/messages/' + thread.knownId : undefined),
    134     existingThread: () => thread?.thread(),
    135     resolveExistingThread: () => thread?.resolve(thread.knownId),
    136     reuse: () =>
    137       draft && thread
    138         ? reuseProductEnquiryConversation(
    139             draft,
    140             thread.controller,
    141             'reviewed_product_enquiry_conversation'
    142           )
    143         : Promise.resolve(undefined),
    144     async copied() {
    145       const fake = {} as ProductEnquiry;
    146       return {
    147         view: !!captureProductEnquiry({ ...view }, 'reviewed_product_enquiry'),
    148         snapshot: productEnquirySnapshot(fake),
    149         message: productEnquiryMessage(fake),
    150         update: updateProductEnquiry(
    151           fake,
    152           'forged',
    153           'reviewed_product_enquiry_edit'
    154         ),
    155         reuse:
    156           draft &&
    157           (await reuseProductEnquiryConversation(
    158             draft,
    159             {} as InboxView,
    160             'reviewed_product_enquiry_conversation'
    161           ))
    162       };
    163     },
    164     async unreviewed() {
    165       return {
    166         capture: !!captureProductEnquiry(view, undefined),
    167         update: !!draft && updateProductEnquiry(draft, 'unreviewed', undefined),
    168         reuse:
    169           draft &&
    170           thread &&
    171           (await reuseProductEnquiryConversation(
    172             draft,
    173             thread.controller,
    174             undefined
    175           ))
    176       };
    177     },
    178     async persistentText() {
    179       const native = thread ? await thread.native() : undefined;
    180       return JSON.stringify({
    181         url: location.href,
    182         local: { ...localStorage },
    183         session: { ...sessionStorage },
    184         native
    185       });
    186     },
    187     advance() {
    188       offset += 15001;
    189     },
    190     async closeView() {
    191       closeProductView(view);
    192       await tick();
    193     },
    194     async close() {
    195       if (closed) return;
    196       closed = true;
    197       if (draft) closeProductEnquiry(draft);
    198       closeProductView(view);
    199       closePublicRuntime(context);
    200       await unmount(mounted);
    201       target.remove();
    202       await thread?.close();
    203     }
    204   };
    205 }