@blocksdiy/react-common 1.70.2 → 1.71.1

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,+FAA+F;AAC/F,eAAO,MAAM,cAAc,MAAM,CAAC;AA6IlC;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,QAAQ,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,SAAS,GAAG,IAYhF,CAAC;AAkBF;;;;;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,307 @@
+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 most characters a lookup measures to correct the browser's answer before keeping it. */
+export const CARET_SCAN_MAX = 256;
+let graphemes;
+const graphemeSegmenter = () => {
+    if (graphemes === undefined) {
+        graphemes =
+            typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"
+                ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+                : null;
+    }
+    return graphemes;
+};
+const clustersByNode = new WeakMap();
+/**
+ * Where each character of `node`'s text starts as a reader sees it (a grapheme cluster: an emoji,
+ * a letter with its marks), then the text's end. Without `Intl.Segmenter`, code points. Kept per
+ * node while its text is the same.
+ */
+const clusterBounds = (node) => {
+    const data = node.data;
+    const known = clustersByNode.get(node);
+    if (known?.data === data) {
+        return known.bounds;
+    }
+    const bounds = [];
+    const segmenter = graphemeSegmenter();
+    if (segmenter) {
+        for (const segment of segmenter.segment(data)) {
+            bounds.push(segment.index);
+        }
+    }
+    else {
+        for (let index = 0; index < data.length; index += data.codePointAt(index) > 0xffff ? 2 : 1) {
+            bounds.push(index);
+        }
+    }
+    bounds.push(data.length);
+    clustersByNode.set(node, { data, bounds });
+    return bounds;
+};
+/** The character `offset` is in or starts (its index in `bounds`); the count of them at the end. */
+const clusterAt = (bounds, offset) => {
+    let low = 0;
+    let high = bounds.length - 1;
+    while (low < high) {
+        const middle = (low + high + 1) >> 1;
+        if (bounds[middle] <= offset) {
+            low = middle;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return low;
+};
+/** The box of character `index` (as `clusterBounds` counts them), if it has one with width. */
+const clusterRect = (doc, node, bounds, index) => {
+    if (index < 0 || index >= bounds.length - 1) {
+        return null;
+    }
+    const range = doc.createRange();
+    range.setStart(node, bounds[index]);
+    range.setEnd(node, bounds[index + 1]);
+    const rects = Array.from(range.getClientRects());
+    return rects.find((rect) => rect.right > rect.left) ?? null;
+};
+const holds = (rect, x, y) => !!rect && x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+/**
+ * Whether character `index` (its box `rect`) is in a run read left to right: from a neighbour
+ * touching it on its line, else from its element's direction.
+ */
+const readsLeftToRight = (doc, node, bounds, index, rect) => {
+    for (const neighbour of [index + 1, index - 1]) {
+        const box = clusterRect(doc, node, bounds, neighbour);
+        if (!box || Math.abs(box.top - rect.top) > 1) {
+            continue;
+        }
+        if (Math.abs(box.left - rect.right) < 1) {
+            return neighbour > index;
+        }
+        if (Math.abs(box.right - rect.left) < 1) {
+            return neighbour < index;
+        }
+    }
+    const element = node.parentElement;
+    return !element || doc.defaultView?.getComputedStyle(element).direction !== "rtl";
+};
+/**
+ * The caret position at `(x, y)` from the boxes of `node`'s characters, looked for outward from
+ * the browser's answer (`near`, its character index): before the character under it when on its
+ * leading half, else after it. Null when the pointer isn't on `node`'s text, or no character
+ * within `CARET_SCAN_MAX` of the answer is under it.
+ */
+const caretOnCharacters = (doc, node, bounds, near, x, y) => {
+    const whole = doc.createRange();
+    whole.selectNodeContents(node);
+    if (!isPointInRects(x, y, Array.from(whole.getClientRects(), toRect), 0)) {
+        return null;
+    }
+    const count = bounds.length - 1;
+    let measured = 0;
+    for (let distance = 0; measured < CARET_SCAN_MAX; distance += 1) {
+        const after = near + distance;
+        const before = near - distance - 1;
+        if (after >= count && before < 0) {
+            return null;
+        }
+        for (const index of [after, before]) {
+            if (index < 0 || index >= count || measured >= CARET_SCAN_MAX) {
+                continue;
+            }
+            measured += 1;
+            const rect = clusterRect(doc, node, bounds, index);
+            if (rect && holds(rect, x, y)) {
+                const isLeading = x < (rect.left + rect.right) / 2 === readsLeftToRight(doc, node, bounds, index, rect);
+                return { node, offset: bounds[isLeading ? index : index + 1] };
+            }
+        }
+    }
+    return null;
+};
+/**
+ * The caret position the browser puts under `(x, y)`, when it is in a text node. Where a run reads
+ * the other way than its line (Latin words on a right-to-left page), the browser can answer at a
+ * run's edge with a position beside other characters, far from the pointer (Chrome: the line's
+ * end for the left half of the run's first letter, the run's start for the right half of its
+ * last): when neither character beside its answer is under the pointer, the one that is decides,
+ * found near the answer (`CARET_SCAN_MAX`), else the answer stands. Characters are what a reader
+ * sees as one (an emoji, a letter with its marks): a corrected position is never inside one.
+ */
+export const caretFromPoint = (doc, x, y) => {
+    const point = browserCaretAt(doc, x, y);
+    if (!point) {
+        return null;
+    }
+    const bounds = clusterBounds(point.node);
+    const index = clusterAt(bounds, point.offset);
+    const beside = bounds[index] === point.offset ? [index - 1, index] : [index];
+    if (beside.some((at) => holds(clusterRect(doc, point.node, bounds, at), x, y))) {
+        return point;
+    }
+    return caretOnCharacters(doc, point.node, bounds, index, x, y) ?? point;
+};
+const browserCaretAt = (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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"}