@memberjunction/ng-whiteboard 0.0.1 → 5.41.0

package/dist/lib/whiteboard-srcdoc.pipe.d.ts

@@ -0,0 +1,60 @@
+import { PipeTransform } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+/**
+ * `wbWidgetSrcdoc` — builds the sandboxed iframe `srcdoc` document for one HTML widget,
+ * with a lifecycle that guarantees BOTH halves of the widget rendering contract:
+ *
+ *  1. **Widget documents are rebuilt per MOUNT.** A pure pipe is instantiated per
+ *     binding-in-view, so every time a widget frame is (re)created — page switch away and
+ *     back, the viewport-lazy `@if` toggling, panel collapse/expand, whole-board
+ *     re-creation — the NEW embedded view gets a NEW pipe instance and therefore a fresh
+ *     `SafeHtml` whose first binding pass always writes `srcdoc` onto the new iframe.
+ *     No component-level cache can hand a re-mounted frame a stale instance.
+ *  2. **Still-mounted widgets never reload on unrelated board activity.** While the view
+ *     stays alive, Angular re-invokes a pure pipe only when the INPUT VALUE changes, and
+ *     the per-instance memo below additionally pins the returned `SafeHtml` identity for
+ *     an unchanged source. Whole-scene `'replace'` journal ops (undo / redo / page rename
+ *     / `LoadFromJSON` restores) that re-create the item OBJECT but not its `Html` string
+ *     therefore cause NO `srcdoc` rewrite and NO iframe reload — widget runtime state
+ *     survives. Only an actual `Html` edit (rich editor Apply, `Whiteboard_UpdateContent`)
+ *     produces a new document and reloads the frame.
+ *
+ * History: the board previously memoized `SafeHtml` per item ID in a component-level map
+ * invalidated from journal ops (`'remove'` / `'replace'`). That decoupled the cached
+ * document's lifetime from the iframe element's lifetime — unmount paths that journal
+ * nothing (the viewport-lazy toggle) left stale entries behind, and every `'replace'`
+ * (page switch, rename, undo) nuked the cache and force-reloaded widgets that never
+ * changed. Tying the memo to the VIEW (this pipe) removes the entire invalidation
+ * problem: mount ⇒ fresh document, unchanged source ⇒ stable identity, changed source ⇒
+ * new document.
+ *
+ * SECURITY — why `bypassSecurityTrustHtml` is correct here: Angular's sanitizer would
+ * strip the scripts/styles/SVG that make a widget useful, but the payload NEVER touches
+ * the app's DOM — it only becomes the `srcdoc` of an iframe whose `sandbox` attribute is
+ * `allow-scripts` ONLY. Without `allow-same-origin` the frame runs in a unique opaque
+ * origin: its scripts cannot reach the parent document, the MJ session, cookies, or any
+ * storage, and adding `allow-same-origin` (which would let the frame script remove its
+ * own sandbox) is deliberately ruled out. By design there is NO DOM sanitization inside
+ * the sandbox — the sandbox IS the boundary.
+ *
+ * Every produced document gets the `MJWhiteboard.submit` input-bridge helper prepended
+ * exactly once (idempotent — see {@link InjectWhiteboardSubmitHelper}), so the explicit
+ * submit path and the ambient interaction recorder work on every mount.
+ */
+export declare class WhiteboardWidgetSrcdocPipe implements PipeTransform {
+    private sanitizer;
+    /** Last source transformed by THIS instance (one instance per mounted frame). */
+    private lastHtml;
+    /** The pinned `SafeHtml` for {@link lastHtml} — identity-stable while mounted. */
+    private lastSafe;
+    /**
+     * The widget's iframe `srcdoc`: the helper-injected source wrapped as trusted HTML.
+     * Identity-stable for an unchanged `html` on the same instance (no iframe reload);
+     * a changed `html` — or a fresh instance on a re-mounted frame — builds a new document.
+     */
+    transform(html: string): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WhiteboardWidgetSrcdocPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<WhiteboardWidgetSrcdocPipe, "wbWidgetSrcdoc", true>;
+}
+//# sourceMappingURL=whiteboard-srcdoc.pipe.d.ts.map

package/dist/lib/whiteboard-srcdoc.pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whiteboard-srcdoc.pipe.d.ts","sourceRoot":"","sources":["../../src/lib/whiteboard-srcdoc.pipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,aAAa,EAAU,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAgB,QAAQ,EAAE,MAAM,2BAA2B,CAAC;;AAGnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBACa,0BAA2B,YAAW,aAAa;IAC9D,OAAO,CAAC,SAAS,CAAwB;IAEzC,iFAAiF;IACjF,OAAO,CAAC,QAAQ,CAAuB;IACvC,kFAAkF;IAClF,OAAO,CAAC,QAAQ,CAAyB;IAEzC;;;;OAIG;IACI,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ;yCAb7B,0BAA0B;uCAA1B,0BAA0B;CAsBtC"}

package/dist/lib/whiteboard-srcdoc.pipe.js

@@ -0,0 +1,75 @@
+import { Pipe, inject } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { InjectWhiteboardSubmitHelper } from './whiteboard-widget-bridge';
+import * as i0 from "@angular/core";
+/**
+ * `wbWidgetSrcdoc` — builds the sandboxed iframe `srcdoc` document for one HTML widget,
+ * with a lifecycle that guarantees BOTH halves of the widget rendering contract:
+ *
+ *  1. **Widget documents are rebuilt per MOUNT.** A pure pipe is instantiated per
+ *     binding-in-view, so every time a widget frame is (re)created — page switch away and
+ *     back, the viewport-lazy `@if` toggling, panel collapse/expand, whole-board
+ *     re-creation — the NEW embedded view gets a NEW pipe instance and therefore a fresh
+ *     `SafeHtml` whose first binding pass always writes `srcdoc` onto the new iframe.
+ *     No component-level cache can hand a re-mounted frame a stale instance.
+ *  2. **Still-mounted widgets never reload on unrelated board activity.** While the view
+ *     stays alive, Angular re-invokes a pure pipe only when the INPUT VALUE changes, and
+ *     the per-instance memo below additionally pins the returned `SafeHtml` identity for
+ *     an unchanged source. Whole-scene `'replace'` journal ops (undo / redo / page rename
+ *     / `LoadFromJSON` restores) that re-create the item OBJECT but not its `Html` string
+ *     therefore cause NO `srcdoc` rewrite and NO iframe reload — widget runtime state
+ *     survives. Only an actual `Html` edit (rich editor Apply, `Whiteboard_UpdateContent`)
+ *     produces a new document and reloads the frame.
+ *
+ * History: the board previously memoized `SafeHtml` per item ID in a component-level map
+ * invalidated from journal ops (`'remove'` / `'replace'`). That decoupled the cached
+ * document's lifetime from the iframe element's lifetime — unmount paths that journal
+ * nothing (the viewport-lazy toggle) left stale entries behind, and every `'replace'`
+ * (page switch, rename, undo) nuked the cache and force-reloaded widgets that never
+ * changed. Tying the memo to the VIEW (this pipe) removes the entire invalidation
+ * problem: mount ⇒ fresh document, unchanged source ⇒ stable identity, changed source ⇒
+ * new document.
+ *
+ * SECURITY — why `bypassSecurityTrustHtml` is correct here: Angular's sanitizer would
+ * strip the scripts/styles/SVG that make a widget useful, but the payload NEVER touches
+ * the app's DOM — it only becomes the `srcdoc` of an iframe whose `sandbox` attribute is
+ * `allow-scripts` ONLY. Without `allow-same-origin` the frame runs in a unique opaque
+ * origin: its scripts cannot reach the parent document, the MJ session, cookies, or any
+ * storage, and adding `allow-same-origin` (which would let the frame script remove its
+ * own sandbox) is deliberately ruled out. By design there is NO DOM sanitization inside
+ * the sandbox — the sandbox IS the boundary.
+ *
+ * Every produced document gets the `MJWhiteboard.submit` input-bridge helper prepended
+ * exactly once (idempotent — see {@link InjectWhiteboardSubmitHelper}), so the explicit
+ * submit path and the ambient interaction recorder work on every mount.
+ */
+export class WhiteboardWidgetSrcdocPipe {
+    constructor() {
+        this.sanitizer = inject(DomSanitizer);
+        /** Last source transformed by THIS instance (one instance per mounted frame). */
+        this.lastHtml = null;
+        /** The pinned `SafeHtml` for {@link lastHtml} — identity-stable while mounted. */
+        this.lastSafe = null;
+    }
+    /**
+     * The widget's iframe `srcdoc`: the helper-injected source wrapped as trusted HTML.
+     * Identity-stable for an unchanged `html` on the same instance (no iframe reload);
+     * a changed `html` — or a fresh instance on a re-mounted frame — builds a new document.
+     */
+    transform(html) {
+        if (this.lastSafe !== null && this.lastHtml === html) {
+            return this.lastSafe;
+        }
+        const safe = this.sanitizer.bypassSecurityTrustHtml(InjectWhiteboardSubmitHelper(html));
+        this.lastHtml = html;
+        this.lastSafe = safe;
+        return safe;
+    }
+    static { this.ɵfac = function WhiteboardWidgetSrcdocPipe_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || WhiteboardWidgetSrcdocPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "wbWidgetSrcdoc", type: WhiteboardWidgetSrcdocPipe, pure: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(WhiteboardWidgetSrcdocPipe, [{
+        type: Pipe,
+        args: [{ name: 'wbWidgetSrcdoc', standalone: true, pure: true }]
+    }], null, null); })();
+//# sourceMappingURL=whiteboard-srcdoc.pipe.js.map

package/dist/lib/whiteboard-srcdoc.pipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"whiteboard-srcdoc.pipe.js","sourceRoot":"","sources":["../../src/lib/whiteboard-srcdoc.pipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAiB,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAY,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,MAAM,OAAO,0BAA0B;IADvC;QAEU,cAAS,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QAEzC,iFAAiF;QACzE,aAAQ,GAAkB,IAAI,CAAC;QACvC,kFAAkF;QAC1E,aAAQ,GAAoB,IAAI,CAAC;KAgB1C;IAdC;;;;OAIG;IACI,SAAS,CAAC,IAAY;QAC3B,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;YACrD,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC,4BAA4B,CAAC,IAAI,CAAC,CAAC,CAAC;QACxF,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,OAAO,IAAI,CAAC;IACd,CAAC;2HArBU,0BAA0B;wFAA1B,0BAA0B;;iFAA1B,0BAA0B;cADtC,IAAI;eAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE","sourcesContent":["import { Pipe, PipeTransform, inject } from '@angular/core';\nimport { DomSanitizer, SafeHtml } from '@angular/platform-browser';\nimport { InjectWhiteboardSubmitHelper } from './whiteboard-widget-bridge';\n\n/**\n * `wbWidgetSrcdoc` — builds the sandboxed iframe `srcdoc` document for one HTML widget,\n * with a lifecycle that guarantees BOTH halves of the widget rendering contract:\n *\n *  1. **Widget documents are rebuilt per MOUNT.** A pure pipe is instantiated per\n *     binding-in-view, so every time a widget frame is (re)created — page switch away and\n *     back, the viewport-lazy `@if` toggling, panel collapse/expand, whole-board\n *     re-creation — the NEW embedded view gets a NEW pipe instance and therefore a fresh\n *     `SafeHtml` whose first binding pass always writes `srcdoc` onto the new iframe.\n *     No component-level cache can hand a re-mounted frame a stale instance.\n *  2. **Still-mounted widgets never reload on unrelated board activity.** While the view\n *     stays alive, Angular re-invokes a pure pipe only when the INPUT VALUE changes, and\n *     the per-instance memo below additionally pins the returned `SafeHtml` identity for\n *     an unchanged source. Whole-scene `'replace'` journal ops (undo / redo / page rename\n *     / `LoadFromJSON` restores) that re-create the item OBJECT but not its `Html` string\n *     therefore cause NO `srcdoc` rewrite and NO iframe reload — widget runtime state\n *     survives. Only an actual `Html` edit (rich editor Apply, `Whiteboard_UpdateContent`)\n *     produces a new document and reloads the frame.\n *\n * History: the board previously memoized `SafeHtml` per item ID in a component-level map\n * invalidated from journal ops (`'remove'` / `'replace'`). That decoupled the cached\n * document's lifetime from the iframe element's lifetime — unmount paths that journal\n * nothing (the viewport-lazy toggle) left stale entries behind, and every `'replace'`\n * (page switch, rename, undo) nuked the cache and force-reloaded widgets that never\n * changed. Tying the memo to the VIEW (this pipe) removes the entire invalidation\n * problem: mount ⇒ fresh document, unchanged source ⇒ stable identity, changed source ⇒\n * new document.\n *\n * SECURITY — why `bypassSecurityTrustHtml` is correct here: Angular's sanitizer would\n * strip the scripts/styles/SVG that make a widget useful, but the payload NEVER touches\n * the app's DOM — it only becomes the `srcdoc` of an iframe whose `sandbox` attribute is\n * `allow-scripts` ONLY. Without `allow-same-origin` the frame runs in a unique opaque\n * origin: its scripts cannot reach the parent document, the MJ session, cookies, or any\n * storage, and adding `allow-same-origin` (which would let the frame script remove its\n * own sandbox) is deliberately ruled out. By design there is NO DOM sanitization inside\n * the sandbox — the sandbox IS the boundary.\n *\n * Every produced document gets the `MJWhiteboard.submit` input-bridge helper prepended\n * exactly once (idempotent — see {@link InjectWhiteboardSubmitHelper}), so the explicit\n * submit path and the ambient interaction recorder work on every mount.\n */\n@Pipe({ name: 'wbWidgetSrcdoc', standalone: true, pure: true })\nexport class WhiteboardWidgetSrcdocPipe implements PipeTransform {\n  private sanitizer = inject(DomSanitizer);\n\n  /** Last source transformed by THIS instance (one instance per mounted frame). */\n  private lastHtml: string | null = null;\n  /** The pinned `SafeHtml` for {@link lastHtml} — identity-stable while mounted. */\n  private lastSafe: SafeHtml | null = null;\n\n  /**\n   * The widget's iframe `srcdoc`: the helper-injected source wrapped as trusted HTML.\n   * Identity-stable for an unchanged `html` on the same instance (no iframe reload);\n   * a changed `html` — or a fresh instance on a re-mounted frame — builds a new document.\n   */\n  public transform(html: string): SafeHtml {\n    if (this.lastSafe !== null && this.lastHtml === html) {\n      return this.lastSafe;\n    }\n    const safe = this.sanitizer.bypassSecurityTrustHtml(InjectWhiteboardSubmitHelper(html));\n    this.lastHtml = html;\n    this.lastSafe = safe;\n    return safe;\n  }\n}\n"]}