tricu

export-app.ts (4856B)

---

 import { treeFormat } from './tree-export.js';
 import type { BundleHash } from './bundle.js';
 import type { ClientMessage, WorkerMessage } from './protocol.js';
 type Exported = Extract<WorkerMessage, { type: 'exported' }>;
 type Request = Extract<ClientMessage, { type: 'export' }>;
 function el<T extends HTMLElement = HTMLElement>(id: string): T {
   const element = document.getElementById(id); if (!element) throw new Error(`Missing element ${id}`); return element as T;
 }
 // Presentation owns its output and invalidation; the package controller owns the
 // shared selection and worker. No arguments or execution settings enter exports.
 export function createTreeExport(request: (message: Request) => void, select: (name: string) => void, stop: () => void) {
   const definition = el<HTMLSelectElement>('tree-definition'), format = el<HTMLSelectElement>('tree-format');
   const button = el<HTMLButtonElement>('export-tree'), cancel = el<HTMLButtonElement>('stop-tree');
   const copy = el<HTMLButtonElement>('copy-tree'), download = el<HTMLButtonElement>('download-tree');
   const preview = el('tree-preview'), status = el('tree-provenance'), empty = el('tree-empty');
   let exported: Exported | undefined, pending = false;
   const descriptions = {
     ternary: 'A single line: 0 is Leaf, 1 introduces a Stem, and 2 introduces a Fork. Shared branches are repeated.',
     tricu: 'A fully parenthesized tree expression using t. This is generated tree structure, not the original source.',
     triangle: 'A fully parenthesized tree expression using △. Shared branches are repeated.',
     dag: 'Shared △ applications with a fixed export named tree. Choose DAG when an expanded tree would be too large.',
   };
   function clear(): void {
     exported = undefined; pending = false; preview.textContent = ''; preview.hidden = true; empty.hidden = false;
     status.textContent = 'Export the selected stored definition.'; status.classList.remove('error');
     copy.disabled = true; download.disabled = true;
   }
   function help(): void { el('tree-format-help').textContent = descriptions[treeFormat(format.value)]; }
   function begin(): void { clear(); pending = true; status.textContent = 'Preparing definition export…'; }
   function fail(message: string): void { clear(); status.textContent = message; status.classList.add('error'); }
   format.onchange = () => { clear(); help(); };
   definition.onchange = () => { clear(); select(definition.value); };
   button.onclick = () => {
     try { begin(); request({ type: 'export', export: definition.value, format: treeFormat(format.value) }); }
     catch (error) { fail(error instanceof Error ? error.message : String(error)); }
   };
   cancel.onclick = stop;
   copy.onclick = async () => {
     const value = exported; if (!value) return;
     try {
       await navigator.clipboard.writeText(value.file.text);
       if (exported === value) status.textContent += ' · Copied complete tree.';
     } catch { if (exported === value) status.textContent += ' · Clipboard unavailable. Use Download tree.'; }
   };
   download.onclick = () => {
     if (!exported) return;
     const url = URL.createObjectURL(new Blob([exported.file.text], { type: 'text/plain;charset=utf-8' }));
     const anchor = document.createElement('a'); anchor.href = url;
     const name = exported.export.replace(/[^a-zA-Z0-9_-]/gu, '-').slice(0, 64) || 'tree';
     anchor.download = `${name}-${exported.hash.slice(0, 12)}.${exported.file.extension}`;
     document.body.append(anchor); anchor.click(); anchor.remove();
     setTimeout(() => URL.revokeObjectURL(url), 1000);
   };
   help();
   return {
     clear, begin, fail,
     get pending(): boolean { return pending; },
     selection(input: HTMLSelectElement): void {
       definition.replaceChildren(...[...input.options].map(option => option.cloneNode(true)));
       definition.value = input.value;
     },
     controls(busy: boolean, loaded: boolean): void {
       button.disabled = format.disabled = definition.disabled = busy || !loaded;
       cancel.disabled = !busy; copy.disabled = download.disabled = busy || !exported;
     },
     receive(data: Exported, hash: BundleHash | undefined, name: string): boolean {
       if (data.hash !== hash || data.export !== name || data.format !== format.value) return false;
       exported = data; pending = false;
       preview.textContent = data.file.text.slice(0, 16_384); preview.hidden = false; empty.hidden = true;
       status.classList.remove('error');
       status.textContent = `SHA-256 ${data.hash} · definition ${data.export} · ${data.file.bytes.toLocaleString()} UTF-8 bytes · ${data.file.storedNodes.toLocaleString()} stored nodes` +
         (preview.textContent.length < data.file.text.length ? ' · Preview: first 16,384 characters. Copy and Download contain the complete tree.' : ' · Complete tree.');
       return true;
     },
   };
 }