@blocksdiy/react-common 1.70.2 → 1.71.1

package/dist/comments/comment-mode.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Comment mode: whether the app shows its comments right now. The platform turns it on and off
+ * (its Comment button, over the iframe bridge: app-render calls `setCommentMode`); the app's
+ * comments surface (the registry `comments` item) reads it and can turn it off itself (Esc), which
+ * the platform hears through `onCommentModeExit`. Host and app share this module: it is a UMD
+ * external app-render provides, so no window global is needed.
+ *
+ * Turning it on is a handshake: it resolves `true` once a surface is mounted, waiting a little for
+ * one (the bundle may still be loading). An app without the comments component never answers, so
+ * the platform learns it can't show comments and the mode stays off.
+ *
+ * The app can also open one thread itself (a comment's link in the agent chat): `openCommentThread`
+ * asks the host for comment mode, as its Comment button would, and the surface goes to the thread.
+ * Only where the platform offers comments (`CommentOptions.isOffered`): not in its builder.
+ */
+/**
+ * What the app's comments show, as the platform's Comment button sets it. `mentionableAgents`: the
+ * block names of the agents this person may mention (their roles' agent mini-apps); all of the
+ * app's agents when absent (the platform hasn't sent its options).
+ */
+export interface CommentOptions {
+    /** Pins of resolved threads and outdated ones (their text changed) show too. */
+    showResolved: boolean;
+    mentionableAgents?: readonly string[];
+    /**
+     * Whether the platform offers comments here (its `app-comments` flag on, the app having the
+     * comments component, and not in its builder): when `false` no thread opens from inside the app,
+     * so its links back to one hide. Absent means offered: a platform from before the field sends
+     * none, and an app-render from before it ignores it.
+     */
+    isOffered?: boolean;
+}
+export declare const DEFAULT_COMMENT_OPTIONS: CommentOptions;
+/** A thread to open in the app: on its page, scrolled to, open. */
+export interface CommentThreadOpenRequest {
+    threadId: number;
+    /** The page the thread is on (`CommentThreadSummaryDto.routePath`). */
+    routePath: string;
+}
+/** How long turning comment mode on waits for a comments surface to mount. */
+export declare const COMMENT_MODE_CLAIM_TIMEOUT_MS = 5000;
+export interface CommentModeTimers {
+    setTimeout(callback: () => void, ms: number): ReturnType<typeof setTimeout>;
+    clearTimeout(id: ReturnType<typeof setTimeout>): void;
+}
+export interface CommentModeStore {
+    /** The host: turn comment mode on or off. On resolves false when no surface mounted in time. */
+    set(isOn: boolean): Promise<boolean>;
+    isOn(): boolean;
+    subscribe(listener: () => void): () => void;
+    /** The app: a comments surface is mounted while the returned function hasn't been called. */
+    registerSurface(): () => void;
+    /** The app: the surface turned comment mode off itself (Esc). The host hears it. */
+    exit(): void;
+    /** The host: hears when the app turned comment mode off itself. */
+    onExit(listener: () => void): () => void;
+    /** The host: what the comments show (resolved and outdated pins, agents to mention) and if they're offered. */
+    setOptions(options: CommentOptions): void;
+    options(): CommentOptions;
+    /** The app's surface: opens the threads asked for while the returned function hasn't been called. */
+    handleOpenThread(handler: (request: CommentThreadOpenRequest) => void): () => void;
+    /** The host: hears the app ask for comment mode (to show a thread it opens). */
+    onRequestOn(listener: () => void): () => void;
+    /**
+     * Whether a thread can be opened from inside the app: the host offers comments here (the options'
+     * `isOffered` isn't `false`), listens, and a surface opens it.
+     */
+    canOpenThread(): boolean;
+    /** The app: asks the host for comment mode and the surface for the thread. False when it can't here. */
+    openThread(request: CommentThreadOpenRequest): boolean;
+}
+export declare const createCommentModeStore: (timers?: CommentModeTimers) => CommentModeStore;
+/** The one store the host and the app share. */
+export declare const commentMode: CommentModeStore;
+/** The host: turn comment mode on or off (resolves false when the app has no comments surface). */
+export declare const setCommentMode: (isOn: boolean) => Promise<boolean>;
+/** The host: hears when the app turned comment mode off itself. Returns the unsubscribe. */
+export declare const onCommentModeExit: (listener: () => void) => (() => void);
+/** The host: what the app's comments show (the Comment button's options), and whether they're offered. */
+export declare const setCommentOptions: (next: CommentOptions) => void;
+/** The host: hears the app ask for comment mode. Returns the unsubscribe. */
+export declare const onCommentModeRequest: (listener: () => void) => (() => void);
+/**
+ * The app (the agent chat's comment message): opens a thread — its page, comment mode on, the
+ * thread open. False when it can't here: outside the platform, where it doesn't offer comments (its
+ * builder), or without the comments component.
+ */
+export declare const openCommentThread: (request: CommentThreadOpenRequest, store?: CommentModeStore) => boolean;
+/** Whether `openCommentThread` can open a thread here: the link back to it shows only then. */
+export declare const canOpenCommentThread: (store?: CommentModeStore) => boolean;
+/**
+ * `canOpenCommentThread`, kept current: the link back to a thread re-renders when the host stops
+ * offering comments (its builder) or offers them again, rather than staying until something else
+ * renders it.
+ */
+export declare const useCanOpenCommentThread: (store?: CommentModeStore) => boolean;
+export interface UseCommentsSurfaceOptions {
+    /**
+     * Opens a thread `openCommentThread` asked for: navigate to its page with the thread's link
+     * (`?comment=<id>`), which the comments then open.
+     */
+    onOpenThread?: (request: CommentThreadOpenRequest) => void;
+    store?: CommentModeStore;
+}
+/**
+ * The app's comments surface: registers itself while mounted and reads the mode. `exit` turns it off
+ * from inside the app and tells the host. It opens the threads the app asks for (a comment's link in
+ * the agent chat) and reads the host's options.
+ */
+export declare const useCommentsSurface: ({ onOpenThread, store }?: UseCommentsSurfaceOptions) => {
+    isCommentMode: boolean;
+    options: CommentOptions;
+    exit: () => void;
+};
+//# sourceMappingURL=comment-mode.d.ts.map

package/dist/comments/comment-mode.d.ts.map

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

package/dist/comments/comment-mode.js

@@ -0,0 +1,176 @@
+import { useCallback, useEffect, useRef, useSyncExternalStore } from "react";
+export const DEFAULT_COMMENT_OPTIONS = { showResolved: false };
+const sameOptions = (a, b) => a.showResolved === b.showResolved &&
+    a.mentionableAgents?.join("\n") === b.mentionableAgents?.join("\n") &&
+    a.isOffered === b.isOffered;
+/** How long turning comment mode on waits for a comments surface to mount. */
+export const COMMENT_MODE_CLAIM_TIMEOUT_MS = 5000;
+const defaultTimers = {
+    setTimeout: (callback, ms) => setTimeout(callback, ms),
+    clearTimeout: (id) => clearTimeout(id),
+};
+export const createCommentModeStore = (timers = defaultTimers) => {
+    let on = false;
+    let surfaces = 0;
+    let pending = null;
+    const listeners = new Set();
+    const exitListeners = new Set();
+    let options = DEFAULT_COMMENT_OPTIONS;
+    let openThreadHandler = null;
+    const requestOnListeners = new Set();
+    const emit = () => listeners.forEach((listener) => listener());
+    const canOpenThread = () => options.isOffered !== false && requestOnListeners.size > 0 && openThreadHandler !== null;
+    const settlePending = (claimed) => {
+        if (pending) {
+            timers.clearTimeout(pending.timer);
+            pending.resolve(claimed);
+            pending = null;
+        }
+    };
+    const turnOn = () => {
+        if (!on) {
+            on = true;
+            emit();
+        }
+    };
+    const turnOff = () => {
+        if (on) {
+            on = false;
+            emit();
+        }
+    };
+    return {
+        set(isOn) {
+            // A newer request supersedes one still waiting for a surface.
+            settlePending(false);
+            if (!isOn) {
+                turnOff();
+                return Promise.resolve(true);
+            }
+            if (surfaces > 0) {
+                turnOn();
+                return Promise.resolve(true);
+            }
+            return new Promise((resolve) => {
+                pending = {
+                    resolve,
+                    timer: timers.setTimeout(() => {
+                        pending = null;
+                        resolve(false);
+                    }, COMMENT_MODE_CLAIM_TIMEOUT_MS),
+                };
+            });
+        },
+        isOn: () => on,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        registerSurface() {
+            surfaces += 1;
+            if (pending) {
+                turnOn();
+                settlePending(true);
+            }
+            let registered = true;
+            return () => {
+                if (!registered) {
+                    return;
+                }
+                registered = false;
+                surfaces -= 1;
+                if (surfaces === 0) {
+                    turnOff();
+                }
+            };
+        },
+        exit() {
+            if (on) {
+                turnOff();
+                exitListeners.forEach((listener) => listener());
+            }
+        },
+        onExit(listener) {
+            exitListeners.add(listener);
+            return () => exitListeners.delete(listener);
+        },
+        setOptions(next) {
+            if (!sameOptions(next, options)) {
+                options = next;
+                emit();
+            }
+        },
+        options: () => options,
+        // Both decide `canOpenThread`: its subscribers hear each change.
+        handleOpenThread(handler) {
+            openThreadHandler = handler;
+            emit();
+            return () => {
+                if (openThreadHandler === handler) {
+                    openThreadHandler = null;
+                    emit();
+                }
+            };
+        },
+        onRequestOn(listener) {
+            requestOnListeners.add(listener);
+            emit();
+            return () => {
+                if (requestOnListeners.delete(listener)) {
+                    emit();
+                }
+            };
+        },
+        canOpenThread,
+        openThread(request) {
+            if (!canOpenThread()) {
+                return false;
+            }
+            requestOnListeners.forEach((listener) => listener());
+            openThreadHandler?.(request);
+            return true;
+        },
+    };
+};
+/** The one store the host and the app share. */
+export const commentMode = createCommentModeStore();
+/** The host: turn comment mode on or off (resolves false when the app has no comments surface). */
+export const setCommentMode = (isOn) => commentMode.set(isOn);
+/** The host: hears when the app turned comment mode off itself. Returns the unsubscribe. */
+export const onCommentModeExit = (listener) => commentMode.onExit(listener);
+/** The host: what the app's comments show (the Comment button's options), and whether they're offered. */
+export const setCommentOptions = (next) => commentMode.setOptions(next);
+/** The host: hears the app ask for comment mode. Returns the unsubscribe. */
+export const onCommentModeRequest = (listener) => commentMode.onRequestOn(listener);
+/**
+ * The app (the agent chat's comment message): opens a thread — its page, comment mode on, the
+ * thread open. False when it can't here: outside the platform, where it doesn't offer comments (its
+ * builder), or without the comments component.
+ */
+export const openCommentThread = (request, store = commentMode) => store.openThread(request);
+/** Whether `openCommentThread` can open a thread here: the link back to it shows only then. */
+export const canOpenCommentThread = (store = commentMode) => store.canOpenThread();
+/**
+ * `canOpenCommentThread`, kept current: the link back to a thread re-renders when the host stops
+ * offering comments (its builder) or offers them again, rather than staying until something else
+ * renders it.
+ */
+export const useCanOpenCommentThread = (store = commentMode) => useSyncExternalStore(store.subscribe, store.canOpenThread, () => false);
+/**
+ * The app's comments surface: registers itself while mounted and reads the mode. `exit` turns it off
+ * from inside the app and tells the host. It opens the threads the app asks for (a comment's link in
+ * the agent chat) and reads the host's options.
+ */
+export const useCommentsSurface = ({ onOpenThread, store = commentMode } = {}) => {
+    useEffect(() => store.registerSurface(), [store]);
+    const latestOpenThread = useRef(onOpenThread);
+    useEffect(() => {
+        latestOpenThread.current = onOpenThread;
+    });
+    const isHandlingOpenThread = !!onOpenThread;
+    useEffect(() => (isHandlingOpenThread ? store.handleOpenThread((request) => latestOpenThread.current?.(request)) : undefined), [isHandlingOpenThread, store]);
+    const isCommentMode = useSyncExternalStore(store.subscribe, store.isOn, () => false);
+    const options = useSyncExternalStore(store.subscribe, store.options, () => DEFAULT_COMMENT_OPTIONS);
+    const exit = useCallback(() => store.exit(), [store]);
+    return { isCommentMode, options, exit };
+};

package/dist/comments/composer.d.ts

@@ -0,0 +1,133 @@
+import { type RefObject } from "react";
+import { type Mention } from "./mentions.js";
+import type { MentionableUserDto } from "./types.js";
+/**
+ * The comment composer's logic, headless: the text, the mentions in it, the `@` menu, the "Send to"
+ * agent line, and the body to store. The registry's composer only draws it.
+ *
+ * Each mention is a range of the text (`@Name`, exactly) tied to who it names, so two people with
+ * the same name stay apart and a typed `@Dana` is not a mention until picked. Every edit moves the
+ * ranges: an edit before one shifts it, an edit inside one turns it back into plain text, and
+ * Backspace right after one removes it whole.
+ */
+export interface ComposerMention {
+    start: number;
+    /** Exclusive: `text.slice(start, end)` is `@` + the mention's name. */
+    end: number;
+    mention: Mention;
+}
+export interface ComposerState {
+    text: string;
+    /** In text order, never overlapping. */
+    mentions: ComposerMention[];
+}
+export type ComposerSegment = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "mention";
+    text: string;
+    mention: Mention;
+};
+export declare const EMPTY_COMPOSER: ComposerState;
+/**
+ * The text after an edit, with its mentions moved. `caret` is where the caret is after the edit:
+ * what follows it is taken as unchanged, which places a typed or pasted run, or a deletion, exactly
+ * (a plain diff can't tell which of two equal letters was typed).
+ */
+export declare const applyEdit: (state: ComposerState, text: string, caret?: number) => ComposerState;
+/** Picks a mention for the `@query` typed at `[queryStart, caret)`: `@Name ` in its place. */
+export declare const insertMention: (state: ComposerState, queryStart: number, caret: number, mention: Mention) => {
+    state: ComposerState;
+    caret: number;
+};
+/** Backspace with the caret right after a mention: the whole mention goes. Null when it isn't one. */
+export declare const deleteMentionBefore: (state: ComposerState, caret: number) => {
+    state: ComposerState;
+    caret: number;
+} | null;
+/** Whether the text mentions this agent. */
+export declare const mentionsAgent: (state: ComposerState, agentId: string) => boolean;
+/** Mentions an agent at the start of the text (the "Send to" line), unless the text already does. */
+export declare const addAgentMention: (state: ComposerState, agent: {
+    agentId: string;
+    name: string;
+}) => ComposerState;
+/** Removes every mention of an agent, with the space after each. */
+export declare const removeAgentMention: (state: ComposerState, agentId: string) => ComposerState;
+/** The text in runs — plain text, and mentions — for the highlight drawn behind the text. */
+export declare const composerSegments: (state: ComposerState) => ComposerSegment[];
+/** The body to store: each mention as its token (`@[42]`, `@[agent:Name]`), the rest as typed. */
+export declare const composerBody: (state: ComposerState) => string;
+/** An agent the composer can mention: one of the app's floating-chat agents. */
+export interface ComposerAgent {
+    id: string;
+    name: string;
+    photoUrl?: string | null;
+}
+export type ComposerOption = Mention & {
+    photoUrl?: string | null;
+};
+/**
+ * How well a name matches what was typed after `@`: 0 when the name starts with it, 1 when one of
+ * its words does, 2 for any other match (inside a word, an email). The menu lists better matches
+ * first, so "@ol" puts Olive before Marina Sokolov.
+ */
+export declare const mentionRank: (name: string, query: string) => number;
+/**
+ * The `@` menu for what was typed: the app's agents first, then people (never yourself), each group
+ * ranked by `mentionRank` and capped (3 agents, 5 people). `separatorBefore` is the index of the
+ * first person when both groups have matches, where the menu draws its divider.
+ */
+export declare const mentionOptions: ({ people, agents, currentUserId, query, }: {
+    people: readonly MentionableUserDto[];
+    agents: readonly ComposerAgent[];
+    currentUserId: number | null;
+    query: string;
+}) => {
+    options: ComposerOption[];
+    separatorBefore: number | null;
+};
+export interface UseMentionComposerOptions {
+    people: readonly MentionableUserDto[];
+    agents: readonly ComposerAgent[];
+    /** Left out of the `@` menu: nobody mentions themselves. */
+    currentUserId: number | null;
+    textareaRef: RefObject<HTMLTextAreaElement | null>;
+}
+export interface MentionComposer {
+    text: string;
+    segments: ComposerSegment[];
+    /** What to store; empty when there's nothing to send. */
+    body: string;
+    /** The `@` menu's options (agents, then people), while an `@query` is being typed. */
+    options: ComposerOption[];
+    /** The index of the first person when agents and people both match: draw a divider before it. */
+    separatorBefore: number | null;
+    highlighted: number;
+    setHighlighted: (index: number) => void;
+    /** Arrow keys in the menu. */
+    moveHighlight: (step: 1 | -1) => void;
+    pick: (option: ComposerOption) => void;
+    /** Esc in the menu. */
+    closeMenu: () => void;
+    isMenuOpen: boolean;
+    /** The textarea's change: its new value and caret. */
+    onChange: (text: string, caret: number) => void;
+    /**
+     * Backspace, before the browser acts on it: right after a mention, selects the whole mention so
+     * the key deletes it (undoably). The caller lets the key go on.
+     */
+    onBackspace: (selectionStart: number, selectionEnd: number) => void;
+    /** The "Send to" line: the agent it shows — the first one mentioned, else the first agent. */
+    sendToAgent: ComposerAgent | null;
+    isSendingToAgent: boolean;
+    /** Checks or unchecks "Send to": mentions the agent, or removes its mentions. */
+    setSendingToAgent: (isOn: boolean) => void;
+    /** Swaps the "Send to" agent; a mention of the old one becomes one of the new one. */
+    chooseSendToAgent: (agentId: string) => void;
+    reset: () => void;
+}
+/** The composer's state and actions; see the module comment. */
+export declare const useMentionComposer: ({ people, agents, currentUserId, textareaRef, }: UseMentionComposerOptions) => MentionComposer;
+//# sourceMappingURL=composer.d.ts.map

package/dist/comments/composer.d.ts.map

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