@blocksdiy/react-common 1.70.2 → 1.71.0

package/dist/comments/pins.js

@@ -0,0 +1,125 @@
+import { useMemo } from "react";
+import { checkText, findAnchorItemElement, resolveAnchor } from "./anchor.js";
+import { clipRectsOf, toRect, usePageLayoutTick, visiblePart } from "./layout.js";
+/**
+ * Where each thread's pin goes on the page as it is now. Never stored: worked out from the anchor
+ * every time the page moves, so a pin follows its element across screen sizes, re-sorted lists and
+ * scrolling.
+ */
+/** How far a pin keeps from the viewport's edges. */
+export const PIN_EDGE_MARGIN = 12;
+/**
+ * The pin's point, in viewport coordinates.
+ * - A quote: the end of its last line.
+ * - An element: where it was clicked, scaled to the element's box now; else its top-right corner.
+ */
+export const pinPoint = (target) => {
+    if (target.kind === "quote") {
+        return { x: target.lastLine.right, y: (target.lastLine.top + target.lastLine.bottom) / 2 };
+    }
+    const { rect, point } = target;
+    if (!point) {
+        return { x: rect.right, y: rect.top };
+    }
+    return {
+        x: rect.left + point.x * (rect.right - rect.left),
+        y: rect.top + point.y * (rect.bottom - rect.top),
+    };
+};
+/** `point` kept `margin` inside the viewport. */
+export const keepInViewport = (point, viewport, margin = PIN_EDGE_MARGIN) => ({
+    x: Math.min(Math.max(point.x, margin), Math.max(margin, viewport.width - margin)),
+    y: Math.min(Math.max(point.y, margin), Math.max(margin, viewport.height - margin)),
+});
+/** Pins on the same element become one group, at the first one's point (items in input order). */
+export const groupPins = (pins) => {
+    const groups = new Map();
+    for (const pin of pins) {
+        const group = groups.get(pin.key);
+        if (group) {
+            group.items.push(pin.item);
+        }
+        else {
+            groups.set(pin.key, { key: pin.key, point: pin.point, items: [pin.item] });
+        }
+    }
+    return [...groups.values()];
+};
+const HIDDEN = { point: null, groupKey: null };
+/**
+ * The comments' own layer (pins, threads) marks its root with this attribute: what it draws over an
+ * element doesn't hide the element. Other ignored UI (the agent chat's panel) does.
+ */
+export const COMMENTS_LAYER_ATTRIBUTE = "data-blocks-comments-layer";
+/** Whether the element can be seen at `visible`'s centre, or only the comments' own layer is over it. */
+const isUncovered = (element, visible) => {
+    const hit = document.elementFromPoint((visible.left + visible.right) / 2, (visible.top + visible.bottom) / 2);
+    return !hit || element.contains(hit) || hit.closest(`[${COMMENTS_LAYER_ATTRIBUTE}]`) !== null;
+};
+const elementKeys = new WeakMap();
+let nextElementKey = 0;
+const keyOf = (element) => {
+    let key = elementKeys.get(element);
+    if (!key) {
+        key = `el-${++nextElementKey}`;
+        elementKeys.set(element, key);
+    }
+    return key;
+};
+/** Lays out one anchor whose element is known. */
+export const layoutAnchor = (anchor, resolved) => {
+    const { element, state, range, currentText } = resolved;
+    if (!element) {
+        return { state, element: null, currentText, ...HIDDEN };
+    }
+    const box = toRect(element.getBoundingClientRect());
+    const visible = visiblePart(box, clipRectsOf(element));
+    if (!visible || !isUncovered(element, visible)) {
+        return { state, element, currentText, ...HIDDEN };
+    }
+    const lines = range ? Array.from(range.getClientRects()).filter((rect) => rect.width > 0 || rect.height > 0) : [];
+    const lastLine = lines.at(-1);
+    const point = lastLine
+        ? pinPoint({ kind: "quote", lastLine: toRect(lastLine) })
+        : pinPoint({ kind: "element", rect: box, point: anchor.point });
+    return {
+        state,
+        element,
+        currentText,
+        point: keepInViewport(point, { width: window.innerWidth, height: window.innerHeight }),
+        groupKey: keyOf(element),
+    };
+};
+/** The element each anchor was last found at: an anchor's object stays the same while its thread is unchanged. */
+const foundByAnchor = new WeakMap();
+/** Finds an anchor again, re-checking only its text while its element is still in the page and still in the same row. */
+const resolveCached = (anchor) => {
+    const known = foundByAnchor.get(anchor);
+    const stillThere = known?.isConnected && (!anchor.item || findAnchorItemElement(anchor)?.contains(known) === true);
+    const resolved = stillThere ? checkText(anchor, known) : resolveAnchor(anchor);
+    if (resolved.element) {
+        foundByAnchor.set(anchor, resolved.element);
+    }
+    else {
+        foundByAnchor.delete(anchor);
+    }
+    return resolved;
+};
+/** Where each thread is on the page now, re-measured at most once per frame while `isActive`. */
+export const useCommentPins = (anchors, isActive) => {
+    // Not for the React Compiler (app-render compiles this module): the memo's input is the page's
+    // layout, read through `tick`, which the compiler would drop from the deps as unused.
+    "use no memo";
+    const tick = usePageLayoutTick(isActive);
+    return useMemo(() => {
+        void tick;
+        const layouts = new Map();
+        if (!isActive || typeof document === "undefined") {
+            return layouts;
+        }
+        for (const { id, anchor } of anchors) {
+            layouts.set(id, layoutAnchor(anchor, resolveCached(anchor)));
+        }
+        return layouts;
+    }, [anchors, isActive, tick]);
+};

package/dist/comments/text-pick.d.ts

@@ -0,0 +1,59 @@
+import { type Rect } from "./layout.js";
+/**
+ * Pointing at part of a text, as the picker does over text: the caret position under the pointer,
+ * the word around it, and the range a drag covers — clamped to the row it started in, so a quote
+ * never spans two records. The geometry is the browser's; what can be computed without it is pure
+ * (word bounds, hit tests, ordering) and tested on its own.
+ */
+/** A position in a text node: before the character at `offset`. */
+export interface TextPoint {
+    node: Text;
+    offset: number;
+}
+/** A position between nodes or characters, as a Range's boundary takes it. */
+export interface Boundary {
+    node: Node;
+    offset: number;
+}
+/** How far the pointer moves from a press on text before it is a drag, not a click. */
+export declare const DRAG_THRESHOLD_PX = 4;
+/**
+ * The word around `offset` in `text` — the one it is in, else the one ending right before it —
+ * as `[start, end)`; null over spaces and punctuation. Words in any script (`Intl.Segmenter`), a
+ * whitespace split where it is missing.
+ */
+export declare const wordBoundsAt: (text: string, offset: number, locale?: string) => {
+    start: number;
+    end: number;
+} | null;
+/** Whether `(x, y)` is on one of `rects`, with `slop` px around each. */
+export declare const isPointInRects: (x: number, y: number, rects: readonly Rect[], slop?: number) => boolean;
+/** Whether `a` comes after `b` in the document. */
+export declare const isAfter: (a: Boundary, b: Boundary) => boolean;
+/** The range between two positions, in document order. */
+export declare const rangeBetween: (doc: Document, a: Boundary, b: Boundary) => Range;
+/**
+ * What a drag that starts at `node` may cover: the record it is in (the nearest `itemAnchorProps`
+ * element), else the element a click there would pick. A quote never leaves it.
+ */
+export declare const dragRootOf: (node: Node) => Element | null;
+/** `point` kept inside `root`: a position past its end is its end, one before its start is its start. */
+export declare const clampToRoot: (root: Element, point: Boundary) => Boundary;
+/** The caret position the browser puts under `(x, y)`, when it is in a text node. */
+export declare const caretFromPoint: (doc: Document, x: number, y: number) => TextPoint | null;
+/**
+ * The text position under the pointer, only when the pointer is ON the text: the browser answers
+ * with the nearest text from anywhere in an element, so the characters beside the caret decide
+ * (a space between words counts, so the cursor doesn't flicker along a line). Null over empty
+ * space, in ignored UI or an editable field.
+ */
+export declare const textPointAt: (doc: Document, x: number, y: number) => TextPoint | null;
+/** The word under a text position, as a range: what the hover tints. */
+export declare const wordRangeAt: (doc: Document, point: TextPoint) => Range | null;
+/** Where the caret bar goes for a text position: the edge of the character beside it. */
+export declare const caretRectAt: (doc: Document, point: TextPoint) => {
+    x: number;
+    top: number;
+    bottom: number;
+} | null;
+//# sourceMappingURL=text-pick.d.ts.map

package/dist/comments/text-pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-pick.d.ts","sourceRoot":"","sources":["../../src/comments/text-pick.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAU,MAAM,UAAU,CAAC;AAE7C;;;;;GAKG;AAEH,mEAAmE;AACnE,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,8EAA8E;AAC9E,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,uFAAuF;AACvF,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAgBnC;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,EAAE,SAAS,MAAM,KAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAoC7G,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,cAAc,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,SAAS,IAAI,EAAE,EAAE,aAAQ,KAAG,OAGrF,CAAC;AAEJ,mDAAmD;AACnD,eAAO,MAAM,OAAO,GAAI,GAAG,QAAQ,EAAE,GAAG,QAAQ,KAAG,OAMlD,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,YAAY,GAAI,KAAK,QAAQ,EAAE,GAAG,QAAQ,EAAE,GAAG,QAAQ,KAAG,KAMtE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,IAAI,KAAG,OAAO,GAAG,IAGjD,CAAC;AAEF,yGAAyG;AACzG,eAAO,MAAM,WAAW,GAAI,MAAM,OAAO,EAAE,OAAO,QAAQ,KAAG,QAM5D,CAAC;AAOF,qFAAqF;AACrF,eAAO,MAAM,cAAc,GAAI,KAAK,QAAQ,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,SAAS,GAAG,IAchF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,QAAQ,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,SAAS,GAAG,IAgB7E,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,WAAW,GAAI,KAAK,QAAQ,EAAE,OAAO,SAAS,KAAG,KAAK,GAAG,IASrE,CAAC;AAEF,yFAAyF;AACzF,eAAO,MAAM,WAAW,GAAI,KAAK,QAAQ,EAAE,OAAO,SAAS,KAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAmB1G,CAAC"}

package/dist/comments/text-pick.js

@@ -0,0 +1,165 @@
+import { isPickIgnored, ITEM_ATTRIBUTE, pickTarget } from "./anchor.js";
+import { toRect } from "./layout.js";
+/** How far the pointer moves from a press on text before it is a drag, not a click. */
+export const DRAG_THRESHOLD_PX = 4;
+const segmenters = new Map();
+const wordSegmenter = (locale) => {
+    if (typeof Intl === "undefined" || typeof Intl.Segmenter !== "function") {
+        return null;
+    }
+    const key = locale ?? "";
+    let segmenter = segmenters.get(key);
+    if (!segmenter) {
+        segmenter = new Intl.Segmenter(locale, { granularity: "word" });
+        segmenters.set(key, segmenter);
+    }
+    return segmenter;
+};
+/**
+ * The word around `offset` in `text` — the one it is in, else the one ending right before it —
+ * as `[start, end)`; null over spaces and punctuation. Words in any script (`Intl.Segmenter`), a
+ * whitespace split where it is missing.
+ */
+export const wordBoundsAt = (text, offset, locale) => {
+    if (!text) {
+        return null;
+    }
+    const at = Math.max(0, Math.min(offset, text.length));
+    const segmenter = wordSegmenter(locale);
+    if (segmenter) {
+        let before = null;
+        for (const segment of segmenter.segment(text)) {
+            const start = segment.index;
+            const end = start + segment.segment.length;
+            if (!segment.isWordLike) {
+                continue;
+            }
+            if (at >= start && at < end) {
+                return { start, end };
+            }
+            if (end === at) {
+                before = { start, end };
+            }
+        }
+        return before;
+    }
+    const isWordChar = (char) => !!char && !/[\s.,;:!?()[\]{}"'«»“”‘’…-]/.test(char);
+    let start = isWordChar(text[at]) ? at : isWordChar(text[at - 1]) ? at - 1 : -1;
+    if (start < 0) {
+        return null;
+    }
+    let end = start;
+    while (start > 0 && isWordChar(text[start - 1])) {
+        start -= 1;
+    }
+    while (end < text.length && isWordChar(text[end])) {
+        end += 1;
+    }
+    return { start, end };
+};
+/** Whether `(x, y)` is on one of `rects`, with `slop` px around each. */
+export const isPointInRects = (x, y, rects, slop = 1) => rects.some((rect) => x >= rect.left - slop && x <= rect.right + slop && y >= rect.top - slop && y <= rect.bottom + slop);
+/** Whether `a` comes after `b` in the document. */
+export const isAfter = (a, b) => {
+    const doc = b.node.ownerDocument ?? b.node;
+    const at = doc.createRange();
+    at.setStart(b.node, b.offset);
+    at.collapse(true);
+    return at.comparePoint(a.node, a.offset) > 0;
+};
+/** The range between two positions, in document order. */
+export const rangeBetween = (doc, a, b) => {
+    const [start, end] = isAfter(a, b) ? [b, a] : [a, b];
+    const range = doc.createRange();
+    range.setStart(start.node, start.offset);
+    range.setEnd(end.node, end.offset);
+    return range;
+};
+/**
+ * What a drag that starts at `node` may cover: the record it is in (the nearest `itemAnchorProps`
+ * element), else the element a click there would pick. A quote never leaves it.
+ */
+export const dragRootOf = (node) => {
+    const element = node instanceof Element ? node : node.parentElement;
+    return element?.closest(`[${ITEM_ATTRIBUTE}]`) ?? pickTarget(node);
+};
+/** `point` kept inside `root`: a position past its end is its end, one before its start is its start. */
+export const clampToRoot = (root, point) => {
+    if (root.contains(point.node)) {
+        return point;
+    }
+    const end = { node: root, offset: root.childNodes.length };
+    return isAfter(point, end) ? end : { node: root, offset: 0 };
+};
+/** The caret position the browser puts under `(x, y)`, when it is in a text node. */
+export const caretFromPoint = (doc, x, y) => {
+    const caretDoc = doc;
+    let node = null;
+    let offset = 0;
+    if (typeof caretDoc.caretPositionFromPoint === "function") {
+        const position = caretDoc.caretPositionFromPoint(x, y);
+        node = position?.offsetNode ?? null;
+        offset = position?.offset ?? 0;
+    }
+    else if (typeof caretDoc.caretRangeFromPoint === "function") {
+        const range = caretDoc.caretRangeFromPoint(x, y);
+        node = range?.startContainer ?? null;
+        offset = range?.startOffset ?? 0;
+    }
+    return node && node.nodeType === Node.TEXT_NODE ? { node: node, offset } : null;
+};
+/**
+ * The text position under the pointer, only when the pointer is ON the text: the browser answers
+ * with the nearest text from anywhere in an element, so the characters beside the caret decide
+ * (a space between words counts, so the cursor doesn't flicker along a line). Null over empty
+ * space, in ignored UI or an editable field.
+ */
+export const textPointAt = (doc, x, y) => {
+    const point = caretFromPoint(doc, x, y);
+    if (!point || isPickIgnored(point.node)) {
+        return null;
+    }
+    if (point.node.parentElement?.closest("input, textarea, [contenteditable]")) {
+        return null;
+    }
+    const length = point.node.data.length;
+    if (length === 0) {
+        return null;
+    }
+    const range = doc.createRange();
+    range.setStart(point.node, Math.max(0, Math.min(point.offset, length) - 1));
+    range.setEnd(point.node, Math.min(length, point.offset + 1));
+    return isPointInRects(x, y, Array.from(range.getClientRects(), toRect)) ? point : null;
+};
+/** The word under a text position, as a range: what the hover tints. */
+export const wordRangeAt = (doc, point) => {
+    const word = wordBoundsAt(point.node.data, point.offset, doc.documentElement.lang || undefined);
+    if (!word) {
+        return null;
+    }
+    const range = doc.createRange();
+    range.setStart(point.node, word.start);
+    range.setEnd(point.node, word.end);
+    return range;
+};
+/** Where the caret bar goes for a text position: the edge of the character beside it. */
+export const caretRectAt = (doc, point) => {
+    const range = doc.createRange();
+    const length = point.node.data.length;
+    if (length === 0) {
+        return null;
+    }
+    const after = point.offset < length;
+    range.setStart(point.node, after ? point.offset : point.offset - 1);
+    range.setEnd(point.node, after ? point.offset + 1 : point.offset);
+    const rect = range.getClientRects()[0];
+    if (!rect) {
+        return null;
+    }
+    const isRtl = point.node.parentElement
+        ? doc.defaultView?.getComputedStyle(point.node.parentElement).direction === "rtl"
+        : false;
+    // Before a character: its leading edge; after the last one: its trailing edge.
+    const x = after !== isRtl ? rect.left : rect.right;
+    return { x, top: rect.top, bottom: rect.bottom };
+};

package/dist/comments/threads-store.d.ts

@@ -0,0 +1,119 @@
+import { type CommentsApi } from "./api.js";
+import { type CommentAnchor, type CommentsChangedPayload, type CommentThreadDto, type CommentThreadSummaryDto, type MentionableUserDto } from "./types.js";
+/**
+ * The comment threads of one page of an app, kept current: the page's threads, the open thread's
+ * comments, and the people who can be mentioned. Every change another tab makes, and every step of
+ * an agent's reply (this tab's mention included), arrives as an ids-only `COMMENTS_CHANGED` ping,
+ * and the store refetches that thread by id, which applies who may see it (a 404 removes it).
+ * Writes return the thread as the server saved it; either way a thread is replaced by id, and an
+ * answer that crossed a newer one is read again rather than set the thread back.
+ */
+/** A page with more threads than this shows the newest ones. */
+export declare const MAX_THREADS_PER_PAGE = 500;
+/** Pings arriving together are refetched together. */
+export declare const LIVE_BATCH_MS = 150;
+/**
+ * Where opening a thread stands while its comments aren't in: `loading`, `not_found` (it was
+ * deleted, or the reader may not see it: a 404) or `failed` (a request that may work again).
+ */
+export type CommentThreadLoadState = "loading" | "not_found" | "failed";
+export interface CommentThreadsSnapshot {
+    status: "idle" | "loading" | "ready" | "error";
+    /** Newest activity first. */
+    threads: CommentThreadSummaryDto[];
+    /** The threads whose comments were loaded, by id. */
+    details: ReadonlyMap<number, CommentThreadDto>;
+    /** Threads asked for whose comments aren't in (none once they are), by id. */
+    threadLoads: ReadonlyMap<number, CommentThreadLoadState>;
+    mentionableUsers: MentionableUserDto[];
+}
+/** Subscribes to the app channel's comment pings; returns the unsubscribe. */
+export type SubscribeToCommentPings = (onPing: (payload: CommentsChangedPayload) => void) => () => void;
+export interface CommentThreadsStoreOptions {
+    api: CommentsApi;
+    appId: string;
+    subscribe: SubscribeToCommentPings;
+    setTimer?: (callback: () => void, ms: number) => ReturnType<typeof setTimeout>;
+    clearTimer?: (id: ReturnType<typeof setTimeout>) => void;
+}
+export declare class CommentThreadsStore {
+    private readonly options;
+    private snapshot;
+    private readonly listeners;
+    private routePath;
+    /** Bumps on every route change: an answer for an older route is dropped. */
+    private generation;
+    private stopPings;
+    private pendingIds;
+    private batchTimer;
+    /** Answers taken in so far; `takenAt` holds the count as of each thread's latest one. */
+    private taken;
+    private readonly takenAt;
+    private readonly setTimer;
+    private readonly clearTimer;
+    constructor(options: CommentThreadsStoreOptions);
+    getSnapshot: () => CommentThreadsSnapshot;
+    subscribe: (listener: () => void) => (() => void);
+    /** Shows the threads of `routePath` (null: none, and stop listening). */
+    setRoute(routePath: string | null): Promise<void>;
+    /**
+     * Loads a thread's comments (when it is opened). Until they are in, `threadLoads` says where it
+     * stands; a thread already loaded stays shown while it is read again.
+     */
+    loadThread(threadId: number): Promise<CommentThreadDto | null>;
+    createThread(anchor: CommentAnchor, body: string): Promise<CommentThreadDto>;
+    addComment(threadId: number, body: string): Promise<CommentThreadDto>;
+    updateComment(commentId: number, body: string): Promise<CommentThreadDto>;
+    /**
+     * Deletes one of the reader's comments. Null when it was the thread's last (no person's or agent's
+     * left): the thread is gone, and goes from the store as a 404 takes it (`not_found`).
+     */
+    deleteComment(commentId: number): Promise<CommentThreadDto | null>;
+    setResolved(threadId: number, resolved: boolean): Promise<CommentThreadDto>;
+    dispose(): void;
+    private loadAll;
+    private onPing;
+    private cancelBatch;
+    /** Whether the thread took an answer after a request sent at `sentAt` (a count of answers taken). */
+    private isCrossed;
+    /**
+     * Reads a thread and takes in the answer, by the rule above (`mayRetry` false: this is the read
+     * again, taken as it is). A 404 removes the thread. Returns the thread as the store has it now.
+     */
+    private refetch;
+    /**
+     * Sends a write and takes in its answer, by the rule above. Should reading the thread again fail,
+     * the write's answer is taken all the same, unless the thread is gone: the person's own change
+     * must show, and their tab gets no ping for it.
+     */
+    private write;
+    /** Takes in a thread as the server returned it. A thread of another page is kept out of the list. */
+    private apply;
+    private setLoad;
+    private remove;
+    private set;
+}
+/** Subscribes through the SDK's websocket connection (the app channel the app already joined). */
+export declare const subscribeWithWebsockets: (service: {
+    listen(event: string, callback: (data: unknown) => Promise<void>, options?: {
+        filter?: Record<string, unknown>;
+    }): void;
+    unlisten(event: string, callback: (data: unknown) => Promise<void>): void;
+}) => ((appId: string) => SubscribeToCommentPings);
+/** The app's comment pings, on the websocket connection the SDK opened for the app. */
+export declare const commentPingsFor: (appId: string) => SubscribeToCommentPings;
+/**
+ * The threads of the current page while `isActive` (comment mode on): nothing is loaded and nothing
+ * listened to otherwise.
+ */
+export declare const useCommentThreads: ({ api, appId, subscribe, routePath, isActive, }: {
+    api: CommentsApi;
+    appId: string;
+    subscribe: SubscribeToCommentPings;
+    routePath: string;
+    isActive: boolean;
+}) => {
+    store: CommentThreadsStore;
+    snapshot: CommentThreadsSnapshot;
+};
+//# sourceMappingURL=threads-store.d.ts.map

package/dist/comments/threads-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threads-store.d.ts","sourceRoot":"","sources":["../../src/comments/threads-store.ts"],"names":[],"mappings":"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"}