@erdemtuna/doc-review 0.9.0 → 0.10.0

package/lib/positioning.js

@@ -0,0 +1,97 @@
+const GAP = 12;
+export function visibleViewport(win = window) {
+    const viewport = win.visualViewport;
+    return viewport
+        ? { left: viewport.offsetLeft, top: viewport.offsetTop, width: viewport.width, height: viewport.height }
+        : { left: 0, top: 0, width: win.innerWidth, height: win.innerHeight };
+}
+export function lastVisibleRect(rects) {
+    if (!Array.isArray(rects))
+        return null;
+    for (let index = rects.length - 1; index >= 0; index -= 1) {
+        const rect = rects[index];
+        if (rect && rect.width >= 0 && rect.height >= 0)
+            return rect;
+    }
+    return null;
+}
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+function frameRectToChrome(rect, frameRect) {
+    return {
+        left: frameRect.left + rect.left,
+        right: frameRect.left + rect.right,
+        top: frameRect.top + rect.top,
+        bottom: frameRect.top + rect.bottom,
+    };
+}
+export function placeContextualSurface(geometry, options) {
+    const { frameRect, viewport, surfaceWidth = 340, surfaceHeight = 220, narrow = false, toolbarHeight = 48, } = options;
+    const bottomSheet = () => ({
+        kind: "sheet",
+        left: viewport.left,
+        top: viewport.top + viewport.height - Math.min(surfaceHeight, viewport.height),
+        width: viewport.width,
+    });
+    if (!geometry || geometry.relation === "unavailable" || !geometry.clip)
+        return { kind: "hidden" };
+    if (narrow)
+        return bottomSheet();
+    const clip = frameRectToChrome(geometry.clip, frameRect);
+    const minLeft = viewport.left + GAP;
+    const maxLeft = viewport.left + viewport.width - surfaceWidth - GAP;
+    const viewportMinTop = viewport.top + toolbarHeight + GAP;
+    const minTop = Math.max(viewportMinTop, clip.top + GAP);
+    const maxTop = viewport.top + viewport.height - surfaceHeight - GAP;
+    const clipBottomTop = clip.bottom - surfaceHeight - GAP;
+    const horizontal = Number.isFinite(geometry.horizontal)
+        ? frameRect.left + geometry.horizontal
+        : clip.left;
+    const edgeLeft = clamp(horizontal + GAP, minLeft, maxLeft);
+    if (geometry.relation === "above") {
+        return { kind: "edge-top", left: edgeLeft, top: minTop, width: surfaceWidth };
+    }
+    if (geometry.relation === "below") {
+        return {
+            kind: "edge-bottom",
+            left: edgeLeft,
+            top: Math.max(viewportMinTop, Math.min(maxTop, clipBottomTop)),
+            width: surfaceWidth,
+        };
+    }
+    const target = lastVisibleRect(geometry.rects);
+    if (!target)
+        return { kind: "hidden" };
+    const rect = frameRectToChrome(target, frameRect);
+    const attachedMaxTop = Math.min(maxTop, clipBottomTop);
+    const clampTop = (top) => clamp(top, minTop, Math.max(minTop, attachedMaxTop));
+    const candidates = [
+        { left: rect.right + GAP, top: clampTop(rect.bottom - surfaceHeight) },
+        { left: rect.left - surfaceWidth - GAP, top: clampTop(rect.bottom - surfaceHeight) },
+        { left: clamp(rect.left, minLeft, maxLeft), top: rect.bottom + GAP },
+        { left: clamp(rect.left, minLeft, maxLeft), top: rect.top - surfaceHeight - GAP },
+    ];
+    const fit = candidates.find((candidate) => candidate.left >= minLeft &&
+        candidate.left <= maxLeft &&
+        candidate.top >= minTop &&
+        candidate.top <= attachedMaxTop &&
+        candidate.left + surfaceWidth <= Math.min(viewport.left + viewport.width - GAP, clip.right) &&
+        candidate.top + surfaceHeight <= clip.bottom);
+    const fallback = fit || {
+        left: clamp(rect.right + GAP, minLeft, maxLeft),
+        top: clampTop(rect.top),
+    };
+    return { kind: "attached", ...fallback, width: surfaceWidth };
+}
+export function alignedCardPosition(rects, { frameRect, viewport, width = 300, height = 180 }) {
+    const target = lastVisibleRect(rects);
+    if (!target)
+        return null;
+    const top = frameRect.top + target.top;
+    const right = frameRect.left + target.right;
+    if (top < frameRect.top || top > frameRect.bottom || right < frameRect.left || right > frameRect.right)
+        return null;
+    return {
+        left: Math.max(viewport.left + 12, Math.min(viewport.left + viewport.width - width - 12, right + 12)),
+        top: Math.max(viewport.top + 12, Math.min(viewport.top + viewport.height - height - 12, top)),
+    };
+}

package/lib/review-controller.js

@@ -0,0 +1,93 @@
+import { decodePage, record } from "./chrome-api.js";
+export function createReviewController(options) {
+    let source = null;
+    let revision = 0;
+    let navigationRevision = 0;
+    let disposed = false;
+    const cleanup = new Set();
+    const invalidate = () => { revision++; };
+    const report = (error) => { if (!disposed)
+        options.failed(error); };
+    async function refresh() {
+        const started = ++revision;
+        const key = options.key();
+        const generation = options.generation();
+        options.beforeRefresh();
+        const page = await options.request(`/api/page/${key}?session=${encodeURIComponent(options.sessionId)}`);
+        if (disposed || started !== revision || key !== options.key() || generation !== options.generation())
+            return;
+        options.refreshPage(decodePage(page), true);
+    }
+    function connect() {
+        if (disposed || source)
+            return;
+        source = (options.eventSource || ((url) => new EventSource(url)))(`/events/${options.sessionId}`);
+        source.addEventListener("ended", () => { if (!disposed)
+            options.ended(); });
+        source.addEventListener("reload", () => {
+            if (disposed)
+                return;
+            invalidate();
+            void options.reload().catch(report);
+        });
+        source.addEventListener("history", () => { if (!disposed)
+            void options.history().catch(report); });
+        source.addEventListener("agent", (event) => {
+            if (disposed)
+                return;
+            try {
+                const value = record(JSON.parse(event.data));
+                if (typeof value.state !== "string")
+                    throw new Error("Invalid agent state event.");
+                options.agent(value.state);
+            }
+            catch (error) {
+                report(error);
+            }
+        });
+        source.addEventListener("refresh", () => { if (!disposed)
+            void refresh().catch(report); });
+        // EventSource owns reconnect/backoff; reconnect errors are not failed mutations.
+        source.onerror = () => { };
+    }
+    async function navigate(body) {
+        if (disposed)
+            throw new Error("Review ended");
+        if (options.hasDrafts())
+            throw new Error("Save or cancel open comment drafts before changing pages");
+        const started = ++navigationRevision;
+        invalidate();
+        const key = options.key();
+        const generation = options.generation();
+        await options.save();
+        if (disposed || started !== navigationRevision || key !== options.key() || generation !== options.generation()) {
+            throw new Error("The page changed before navigating. Retry on the current page.");
+        }
+        if ("key" in body)
+            options.suspend();
+        const result = record(await options.request(`/api/session/${options.sessionId}/${"key" in body ? "goto" : "navigate"}`, { method: "POST", body: JSON.stringify(body) }));
+        // A source reload does not undo a navigation already accepted by the server.
+        if (disposed || started !== navigationRevision)
+            return;
+        const next = "key" in body ? body.key : result.key;
+        if (typeof next !== "string")
+            throw new Error("The server returned an invalid navigation target.");
+        await options.load(next);
+    }
+    return {
+        connect, refresh, navigate, invalidate,
+        own(stop) { cleanup.add(stop); return stop; },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            revision++;
+            navigationRevision++;
+            source?.close();
+            source = null;
+            for (const stop of cleanup)
+                stop();
+            cleanup.clear();
+        },
+    };
+}

package/lib/review-mode.js

@@ -0,0 +1,66 @@
+export const REVIEW_MODES = Object.freeze(["view", "edit"]);
+export function normalizeReviewMode(mode) {
+    return mode === "edit" ? "edit" : "view";
+}
+export function savePolicyForPage(page) {
+    return page && ((typeof page === "object" || typeof page === "function") &&
+        (("savePolicy" in page && page.savePolicy === "feedback-only") ||
+            ("kind" in page && page.kind === "url") ||
+            ("markdown" in page && page.markdown) || ("feedbackOnly" in page && page.feedbackOnly)))
+        ? "feedback-only"
+        : "writable";
+}
+export function reviewConfiguration(page, mode) {
+    return {
+        mode: normalizeReviewMode(mode),
+        savePolicy: savePolicyForPage(page),
+    };
+}
+export function applyBodyReviewMode(body, mode) {
+    const normalized = normalizeReviewMode(mode);
+    if (normalized === "edit") {
+        if (body.getAttribute("contenteditable") !== "true")
+            body.setAttribute("contenteditable", "true");
+        if (body.getAttribute("spellcheck") !== "false")
+            body.setAttribute("spellcheck", "false");
+    }
+    else {
+        if (body.hasAttribute("contenteditable"))
+            body.removeAttribute("contenteditable");
+        if (body.hasAttribute("spellcheck"))
+            body.removeAttribute("spellcheck");
+    }
+    return normalized;
+}
+/** Keep the active mode intact when an application hydrates and rewrites body attributes. */
+export function keepBodyInReviewMode(body, initialMode = "view") {
+    let mode = normalizeReviewMode(initialMode);
+    let applying = false;
+    const enforce = () => {
+        if (applying)
+            return;
+        applying = true;
+        applyBodyReviewMode(body, mode);
+        applying = false;
+    };
+    const view = body.ownerDocument.defaultView;
+    if (!view)
+        throw new TypeError("The review body must belong to a window.");
+    const Observer = view.MutationObserver;
+    const observer = new Observer(enforce);
+    observer.observe(body, { attributes: true, attributeFilter: ["contenteditable", "spellcheck"] });
+    enforce();
+    return {
+        get mode() {
+            return mode;
+        },
+        setMode(nextMode) {
+            mode = normalizeReviewMode(nextMode);
+            enforce();
+            return mode;
+        },
+        disconnect() {
+            observer.disconnect();
+        },
+    };
+}