app

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

dispose.ts (3273B)


      1 import {
      2   privateSessionOwnership,
      3   privateSessionCleanupRequired,
      4   subscribePrivateSessionClose,
      5   closePrivateSession,
      6   type PrivateSession
      7 } from './private-session.ts';
      8 declare const visibilityBrand: unique symbol;
      9 export type PrivateVisibilityScope = Readonly<{ [visibilityBrand]: true }>;
     10 type Snapshot = Readonly<{ active: boolean; cleanupRequired: boolean }>;
     11 type Controller = { snapshot(): Snapshot; close(): boolean };
     12 const scopes = new WeakMap<PrivateVisibilityScope, Controller>();
     13 const sessions = new WeakMap<PrivateSession, PrivateVisibilityScope>();
     14 
     15 // Explicit internal Messages lifetime; no automatic unlock, fetch, decrypt,
     16 // provider request or hidden notification. Later Messages activation owns the
     17 // call and route disposal. Visibility returning does not revive a closed scope.
     18 export function getPrivateVisibilityScope(
     19   session: PrivateSession
     20 ): PrivateVisibilityScope | undefined {
     21   if (typeof window === 'undefined' || typeof document === 'undefined')
     22     return undefined;
     23   const observed = privateSessionOwnership(session);
     24   if (!observed) throw new Error('private_session_invalid');
     25   const capture = observed;
     26   const prior = sessions.get(session);
     27   if (prior) return prior;
     28   const token = Object.freeze({}) as PrivateVisibilityScope;
     29   let closed = false,
     30     registered = false;
     31   let off = () => {};
     32   function cleanupVisibility() {
     33     closed = true;
     34     if (registered) {
     35       document.removeEventListener('visibilitychange', onVisibility);
     36       registered = false;
     37     }
     38     off();
     39   }
     40   function close() {
     41     // Session closure drains all caches and sockets even if one cleanup fails.
     42     const cleaned = closePrivateSession(session);
     43     try {
     44       cleanupVisibility();
     45     } catch {
     46       return false;
     47     }
     48     if (!cleaned) return false;
     49     scopes.set(token, {
     50       snapshot: () => ({ active: false, cleanupRequired: false }),
     51       close: () => true
     52     });
     53     return true;
     54   }
     55   function onVisibility() {
     56     if (document.visibilityState !== 'visible') close();
     57   }
     58   scopes.set(token, {
     59     snapshot: () => ({
     60       active:
     61         !closed && capture.current() && document.visibilityState === 'visible',
     62       cleanupRequired:
     63         closed && (registered || privateSessionCleanupRequired(session))
     64     }),
     65     close
     66   });
     67   sessions.set(session, token);
     68   off = subscribePrivateSessionClose(session, cleanupVisibility);
     69   if (!closed && capture.current() && document.visibilityState === 'visible') {
     70     // Own the registration before its synchronous host call can reenter.
     71     registered = true;
     72     try {
     73       document.addEventListener('visibilitychange', onVisibility);
     74     } catch {
     75       close();
     76       throw new Error('private_visibility_unavailable');
     77     }
     78   }
     79   if (!capture.current() || document.visibilityState !== 'visible') close();
     80   return token;
     81 }
     82 function controller(token: PrivateVisibilityScope): Controller {
     83   const state = scopes.get(token);
     84   if (!state) throw new Error('private_visibility_invalid');
     85   return state;
     86 }
     87 export function privateVisibilitySnapshot(
     88   token: PrivateVisibilityScope
     89 ): Snapshot {
     90   return controller(token).snapshot();
     91 }
     92 export function closePrivateVisibilityScope(
     93   token: PrivateVisibilityScope
     94 ): boolean {
     95   return controller(token).close();
     96 }