app

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

dirty-navigation.ts (3880B)


      1 import {
      2   privateComposerSnapshot,
      3   discardPrivateComposer,
      4   type PrivateComposer
      5 } from '../messaging/composer-state.ts';
      6 declare const navigationBrand: unique symbol;
      7 export type DirtyNavigation = Readonly<{ [navigationBrand]: true }>;
      8 type Result =
      9   'allowed' | 'confirmation_required' | 'review_required' | 'invalid';
     10 type Controller = {
     11   request(): Result;
     12   discard(review: unknown): Result;
     13   keep(): boolean;
     14   snapshot():
     15     | Readonly<{
     16         state: 'idle' | 'confirmation_required';
     17         copy: string;
     18         defaultAction: 'Keep editing';
     19         discardAction: 'Discard draft';
     20       }>
     21     | undefined;
     22   dirty(): boolean;
     23 };
     24 const navigations = new WeakMap<DirtyNavigation, Controller>();
     25 // Shared route interception contract, with no URL/body/persistence/effect sink.
     26 // Same-page validation and gates do not call this close contract. Mounted
     27 // consumers own focus return and inline controls; native unload uses its own
     28 // browser-provided confirmation, never an asynchronous save attempt.
     29 export function captureDirtyNavigation(
     30   composer: PrivateComposer
     31 ): DirtyNavigation | undefined {
     32   if (typeof window === 'undefined' || !privateComposerSnapshot(composer))
     33     return undefined;
     34   let requestedRevision: number | undefined;
     35   function request(): Result {
     36     const value = privateComposerSnapshot(composer);
     37     if (!value) return 'invalid';
     38     if (!value.dirty) {
     39       requestedRevision = undefined;
     40       return 'allowed';
     41     }
     42     requestedRevision = value.revision;
     43     return 'confirmation_required';
     44   }
     45   function discard(review: unknown): Result {
     46     if (
     47       review !== 'reviewed_discard_private_text' ||
     48       requestedRevision === undefined
     49     )
     50       return 'invalid';
     51     const value = privateComposerSnapshot(composer),
     52       revision = requestedRevision;
     53     requestedRevision = undefined;
     54     if (!value) return 'invalid';
     55     if (value.revision !== revision) return 'review_required';
     56     return discardPrivateComposer(composer, revision, review)
     57       ? 'allowed'
     58       : 'invalid';
     59   }
     60   function keep() {
     61     if (!privateComposerSnapshot(composer)) return false;
     62     requestedRevision = undefined;
     63     return true;
     64   }
     65   function snapshot() {
     66     if (!privateComposerSnapshot(composer)) return undefined;
     67     return {
     68       state:
     69         requestedRevision === undefined
     70           ? ('idle' as const)
     71           : ('confirmation_required' as const),
     72       copy:
     73         requestedRevision === undefined
     74           ? ''
     75           : 'Discard unsaved private text? Keep editing to preserve it. An outstanding extension call remains pending until it settles.',
     76       defaultAction: 'Keep editing' as const,
     77       discardAction: 'Discard draft' as const
     78     };
     79   }
     80   const token = Object.freeze({}) as DirtyNavigation;
     81   navigations.set(token, {
     82     request,
     83     discard,
     84     keep,
     85     snapshot,
     86     dirty: () => privateComposerSnapshot(composer)?.dirty ?? false
     87   });
     88   return token;
     89 }
     90 export function requestPrivateNavigation(token: DirtyNavigation) {
     91   return navigations.get(token)?.request() ?? 'invalid';
     92 }
     93 export function confirmDiscardNavigation(
     94   token: DirtyNavigation,
     95   review: unknown
     96 ) {
     97   return navigations.get(token)?.discard(review) ?? 'invalid';
     98 }
     99 export function keepPrivateEditing(token: DirtyNavigation) {
    100   return navigations.get(token)?.keep() ?? false;
    101 }
    102 export function dirtyNavigationSnapshot(token: DirtyNavigation) {
    103   return navigations.get(token)?.snapshot();
    104 }
    105 export function privateNavigationBeforeUnload(
    106   token: DirtyNavigation,
    107   event: BeforeUnloadEvent
    108 ): boolean {
    109   const controller = navigations.get(token);
    110   if (typeof window === 'undefined' || !controller?.dirty()) return false;
    111   event.preventDefault();
    112   // The mounted consumer owns event registration and legacy returnValue.
    113   // This contract never receives or emits the private body or a destination.
    114   return true;
    115 }