@intentface/chat 0.1.0

package/dist/composer/segments.d.ts

@@ -0,0 +1,108 @@
+import { type ChipData, type ChipSegment } from "../chip-markdown.js";
+export type Segment = {
+    type: "text";
+    text: string;
+} | {
+    type: "chip";
+    id: string;
+    chip: ChipData;
+};
+export type SegmentDoc = Segment[];
+export type TextChange = {
+    rangeStart: number;
+    rangeEnd: number;
+    insertedLength: number;
+};
+export declare const nextChipId: () => string;
+export declare const documentLength: (doc: SegmentDoc) => number;
+/** Chips contribute nothing — the getText()/onValueChange contract. */
+export declare const getPlainText: (doc: SegmentDoc) => string;
+/** Chips as the sentinel char — positions stay 1:1 for diffing. */
+export declare const toFlatText: (doc: SegmentDoc) => string;
+/**
+ * Chips as a single space — positions stay 1:1 for prefix detection, and the
+ * whitespace guarantees an active token can never span a chip.
+ */
+export declare const toScanText: (doc: SegmentDoc) => string;
+export declare const chipRangesOf: (doc: SegmentDoc) => Array<{
+    id: string;
+    start: number;
+    end: number;
+}>;
+/** The "\n"-delimited line around a position in scan text. */
+export declare const lineBoundsAt: (scanText: string, position: number) => {
+    lineStart: number;
+    lineEnd: number;
+};
+export declare const segmentsFromText: (text: string) => SegmentDoc;
+export declare const segmentsFromChipSegments: (segments: readonly ChipSegment[], makeId?: () => string) => SegmentDoc;
+/**
+ * The {text} submit payload — text as-is, chips as chip-markdown tokens.
+ * Byte-identical to the legacy serializeDocument for equivalent content.
+ */
+export declare const serializeSegments: (doc: SegmentDoc) => {
+    text: string;
+};
+/**
+ * Replace the logical range [from, to) with the inserted segments. A chip is
+ * atomic: it is removed iff its position falls inside the range (range edges
+ * never split it).
+ */
+export declare const spliceSegments: (doc: SegmentDoc, from: number, to: number, insert: SegmentDoc) => SegmentDoc;
+/** Extract [from, to) as a sub-document. Chips are included iff fully inside. */
+export declare const sliceSegments: (doc: SegmentDoc, from: number, to: number) => SegmentDoc;
+/**
+ * Fit segments into `room` logical units for maxLength: text is sliced at the
+ * boundary; a chip that doesn't fit whole is dropped entirely.
+ */
+export declare const truncateToFit: (insert: SegmentDoc, room: number) => SegmentDoc;
+export declare const mapPositionResult: (position: number, change: TextChange, bias: -1 | 1) => {
+    position: number;
+    deleted: boolean;
+};
+export declare const mapPosition: (position: number, change: TextChange, bias: -1 | 1) => number;
+export declare const diffFlatText: (oldFlat: string, newFlat: string, caretHint?: number) => TextChange | null;
+export type BeforeInputPlan = {
+    kind: "native";
+} | {
+    kind: "block";
+} | {
+    kind: "splice";
+    from: number;
+    to: number;
+    insert: SegmentDoc;
+    caret: number;
+};
+export declare const planBeforeInput: (args: {
+    inputType: string;
+    data: string | null;
+    /** The event's first target range in logical positions; null when unavailable. */
+    targetRange: {
+        start: number;
+        end: number;
+    } | null;
+    doc: SegmentDoc;
+    caret: {
+        start: number;
+        end: number;
+    };
+    maxLength?: number;
+}) => BeforeInputPlan;
+export type SnapshotInlineNode = {
+    type: "text";
+    text: string;
+} | {
+    type: "mentionChip";
+    attrs: {
+        prefix: string;
+        value: string;
+        label: string;
+        icon?: string;
+    };
+};
+export type SnapshotParagraphNode = {
+    type: "paragraph";
+    content?: SnapshotInlineNode[];
+};
+export declare const segmentsToParagraphJSON: (doc: SegmentDoc) => SnapshotParagraphNode[];
+export declare const segmentsFromParagraphJSON: (paragraphs: readonly SnapshotParagraphNode[], makeId?: () => string) => SegmentDoc;

package/dist/composer/segments.js

@@ -0,0 +1,366 @@
+// Segments — the editor engine's pure document kernel. The document is a flat
+// inline sequence: text segments (soft breaks ride inline as "\n") and atomic
+// chips of logical length 1. Everything here is pure and position-based —
+// logical positions count one per text character and one per chip — so the
+// DOM layer, the trigger tracker, and the tests all speak the same integers.
+//
+// Projections: the same document reads three ways depending on the consumer —
+// getPlainText (chips vanish; the getText/onValueChange contract),
+// toFlatText (chips as ""; input diffing needs 1:1 positions),
+// toScanText (chips as " "; prefix detection needs word boundaries and the
+// guarantee that a token can never span a chip).
+import { encodeChipMarkdown } from "../chip-markdown.js";
+// The character standing in for a chip in the diff projection. Object
+// Replacement Character — never produced by real typing.
+const CHIP_SENTINEL = "";
+// ---------------------------------------------------------------------------
+// Chip ids — monotonically increasing per module load. Deterministic (no
+// randomness), unique within a session, and test-friendly.
+// ---------------------------------------------------------------------------
+let chipIdCounter = 0;
+export const nextChipId = () => `chip-${++chipIdCounter}`;
+// ---------------------------------------------------------------------------
+// Projections & measurements
+// ---------------------------------------------------------------------------
+export const documentLength = (doc) => doc.reduce((length, segment) => length + (segment.type === "text" ? segment.text.length : 1), 0);
+/** Chips contribute nothing — the getText()/onValueChange contract. */
+export const getPlainText = (doc) => doc.reduce((text, segment) => (segment.type === "text" ? text + segment.text : text), "");
+/** Chips as the sentinel char — positions stay 1:1 for diffing. */
+export const toFlatText = (doc) => doc.reduce((text, segment) => text + (segment.type === "text" ? segment.text : CHIP_SENTINEL), "");
+/**
+ * Chips as a single space — positions stay 1:1 for prefix detection, and the
+ * whitespace guarantees an active token can never span a chip.
+ */
+export const toScanText = (doc) => doc.reduce((text, segment) => text + (segment.type === "text" ? segment.text : " "), "");
+export const chipRangesOf = (doc) => {
+    const ranges = [];
+    let offset = 0;
+    for (const segment of doc) {
+        if (segment.type === "chip") {
+            ranges.push({ id: segment.id, start: offset, end: offset + 1 });
+            offset += 1;
+        }
+        else {
+            offset += segment.text.length;
+        }
+    }
+    return ranges;
+};
+/** The "\n"-delimited line around a position in scan text. */
+export const lineBoundsAt = (scanText, position) => {
+    const lineStart = scanText.lastIndexOf("\n", Math.max(0, position - 1)) + 1;
+    const newlineAfter = scanText.indexOf("\n", position);
+    return { lineStart, lineEnd: newlineAfter === -1 ? scanText.length : newlineAfter };
+};
+// ---------------------------------------------------------------------------
+// Construction & serialization
+// ---------------------------------------------------------------------------
+export const segmentsFromText = (text) => text.length === 0 ? [] : [{ type: "text", text }];
+export const segmentsFromChipSegments = (segments, makeId = nextChipId) => normalizeSegments(segments.map((segment) => segment.type === "text"
+    ? { type: "text", text: segment.text }
+    : {
+        type: "chip",
+        id: makeId(),
+        chip: {
+            prefix: segment.prefix,
+            value: segment.value,
+            label: segment.label,
+            ...(segment.icon ? { icon: segment.icon } : {}),
+        },
+    }));
+/**
+ * The {text} submit payload — text as-is, chips as chip-markdown tokens.
+ * Byte-identical to the legacy serializeDocument for equivalent content.
+ */
+export const serializeSegments = (doc) => ({
+    text: doc.reduce((text, segment) => text + (segment.type === "text" ? segment.text : encodeChipMarkdown(segment.chip)), ""),
+});
+// ---------------------------------------------------------------------------
+// Splice & slice — all document surgery goes through these, so text merging
+// and empty-segment dropping happen in exactly one place.
+// ---------------------------------------------------------------------------
+/** Merge adjacent text segments and drop empty ones. */
+const normalizeSegments = (doc) => {
+    const normalized = [];
+    for (const segment of doc) {
+        if (segment.type === "text" && segment.text.length === 0)
+            continue;
+        const previous = normalized.at(-1);
+        if (segment.type === "text" && previous?.type === "text") {
+            normalized[normalized.length - 1] = { type: "text", text: previous.text + segment.text };
+            continue;
+        }
+        normalized.push(segment);
+    }
+    return normalized;
+};
+/**
+ * Replace the logical range [from, to) with the inserted segments. A chip is
+ * atomic: it is removed iff its position falls inside the range (range edges
+ * never split it).
+ */
+export const spliceSegments = (doc, from, to, insert) => {
+    const before = [];
+    const after = [];
+    let offset = 0;
+    for (const segment of doc) {
+        const segmentLength = segment.type === "text" ? segment.text.length : 1;
+        const segmentStart = offset;
+        const segmentEnd = offset + segmentLength;
+        offset = segmentEnd;
+        if (segmentEnd <= from) {
+            before.push(segment);
+            continue;
+        }
+        if (segmentStart >= to) {
+            after.push(segment);
+            continue;
+        }
+        // Overlapping the range. Chips are atomic — fully covered, fully removed.
+        if (segment.type === "chip")
+            continue;
+        const keepLeft = segment.text.slice(0, Math.max(0, from - segmentStart));
+        const keepRight = segment.text.slice(Math.min(segmentLength, to - segmentStart));
+        if (keepLeft)
+            before.push({ type: "text", text: keepLeft });
+        if (keepRight)
+            after.push({ type: "text", text: keepRight });
+    }
+    return normalizeSegments([...before, ...insert, ...after]);
+};
+/** Extract [from, to) as a sub-document. Chips are included iff fully inside. */
+export const sliceSegments = (doc, from, to) => {
+    const slice = [];
+    let offset = 0;
+    for (const segment of doc) {
+        const segmentLength = segment.type === "text" ? segment.text.length : 1;
+        const segmentStart = offset;
+        const segmentEnd = offset + segmentLength;
+        offset = segmentEnd;
+        if (segmentEnd <= from || segmentStart >= to)
+            continue;
+        if (segment.type === "chip") {
+            slice.push(segment);
+            continue;
+        }
+        const text = segment.text.slice(Math.max(0, from - segmentStart), Math.min(segmentLength, to - segmentStart));
+        if (text)
+            slice.push({ type: "text", text });
+    }
+    return normalizeSegments(slice);
+};
+/**
+ * Fit segments into `room` logical units for maxLength: text is sliced at the
+ * boundary; a chip that doesn't fit whole is dropped entirely.
+ */
+export const truncateToFit = (insert, room) => {
+    const fitted = [];
+    let remaining = Math.max(0, room);
+    for (const segment of insert) {
+        if (remaining === 0)
+            break;
+        if (segment.type === "chip") {
+            fitted.push(segment);
+            remaining -= 1;
+            continue;
+        }
+        const text = segment.text.slice(0, remaining);
+        if (text)
+            fitted.push({ type: "text", text });
+        remaining -= text.length;
+    }
+    return normalizeSegments(fitted);
+};
+// ---------------------------------------------------------------------------
+// Position mapping — carry a position across one change.
+// The tracker's sticky token rests on the bias semantics: insertion exactly
+// at a position stays before it with bias -1 and moves after it with bias +1,
+// which is what lets the token end grow while its start holds.
+// ---------------------------------------------------------------------------
+export const mapPositionResult = (position, change, bias) => {
+    const { rangeStart, rangeEnd, insertedLength } = change;
+    if (position < rangeStart)
+        return { position, deleted: false };
+    if (position > rangeEnd) {
+        return { position: position + insertedLength - (rangeEnd - rangeStart), deleted: false };
+    }
+    if (position === rangeStart) {
+        return bias < 0
+            ? { position: rangeStart, deleted: false }
+            : { position: rangeStart + insertedLength, deleted: false };
+    }
+    if (position === rangeEnd) {
+        return {
+            position: rangeStart + insertedLength,
+            deleted: bias < 0 && rangeEnd > rangeStart,
+        };
+    }
+    // Strictly inside the replaced range — the content at this position is gone.
+    return {
+        position: bias < 0 ? rangeStart : rangeStart + insertedLength,
+        deleted: true,
+    };
+};
+export const mapPosition = (position, change, bias) => mapPositionResult(position, change, bias).position;
+// ---------------------------------------------------------------------------
+// Diffing — recover the TextChange from a native edit (there is no transaction
+// to consume; the browser already mutated the DOM). Common prefix/suffix diff;
+// the caret disambiguates repeated-character runs (prefer the edit that ends
+// at the caret, à la CodeMirror).
+// ---------------------------------------------------------------------------
+export const diffFlatText = (oldFlat, newFlat, caretHint) => {
+    if (oldFlat === newFlat)
+        return null;
+    let prefix = 0;
+    const maxPrefix = Math.min(oldFlat.length, newFlat.length);
+    while (prefix < maxPrefix && oldFlat[prefix] === newFlat[prefix])
+        prefix++;
+    let suffix = 0;
+    const maxSuffix = Math.min(oldFlat.length, newFlat.length) - prefix;
+    while (suffix < maxSuffix &&
+        oldFlat[oldFlat.length - 1 - suffix] === newFlat[newFlat.length - 1 - suffix]) {
+        suffix++;
+    }
+    let rangeStart = prefix;
+    let rangeEnd = oldFlat.length - suffix;
+    const insertedLength = newFlat.length - suffix - prefix;
+    // Slide the window left over equal characters until the inserted region
+    // ends at the caret ("aa" + typed "a": rightmost by default, caret decides).
+    if (caretHint !== undefined) {
+        while (rangeStart + insertedLength > caretHint &&
+            rangeStart > 0 &&
+            oldFlat[rangeStart - 1] === newFlat[rangeStart + insertedLength - 1]) {
+            rangeStart--;
+            rangeEnd--;
+        }
+    }
+    return { rangeStart, rangeEnd, insertedLength };
+};
+// Text-level inputTypes the browser may perform natively (subject to the
+// chip-intersection and maxLength checks below).
+const NATIVE_SAFE_INPUT_TYPES = new Set([
+    "insertText",
+    "insertReplacementText",
+    "deleteContentBackward",
+    "deleteContentForward",
+    "deleteWordBackward",
+    "deleteWordForward",
+    "deleteSoftLineBackward",
+    "deleteHardLineBackward",
+    "deleteEntireSoftLine",
+    "deleteContent",
+    "deleteByCut",
+]);
+const isInsertType = (inputType) => inputType === "insertText" || inputType === "insertReplacementText";
+export const planBeforeInput = (args) => {
+    const { inputType, data, doc, maxLength } = args;
+    const range = args.targetRange ?? args.caret;
+    // IME composition is not cancelable — the composition guard owns it.
+    if (inputType === "insertCompositionText")
+        return { kind: "native" };
+    // Enter/Shift+Enter backstop (keydown normally consumes these first):
+    // emulate as a soft break through the programmatic pipeline.
+    if (inputType === "insertParagraph" || inputType === "insertLineBreak") {
+        return planTextInsertion(doc, range, "\n", maxLength);
+    }
+    if (!NATIVE_SAFE_INPUT_TYPES.has(inputType))
+        return { kind: "block" };
+    const rangeTouchesChip = chipRangesOf(doc).some((chip) => chip.start < range.end && chip.end > range.start);
+    if (isInsertType(inputType)) {
+        const insertedText = data ?? "";
+        // Chip in the replaced selection (select-all + type-over) or over the cap:
+        // do the splice ourselves. Otherwise the browser handles it.
+        const over = maxLength !== undefined &&
+            documentLength(doc) - (range.end - range.start) + insertedText.length > maxLength;
+        if (!rangeTouchesChip && !over)
+            return { kind: "native" };
+        return planTextInsertion(doc, range, insertedText, maxLength);
+    }
+    // Delete variants: native unless the target range touches a chip — engines
+    // disagree on atom deletion (WebKit caret placement, word-deletes across
+    // atoms), so chip deletion always goes through the model.
+    if (!rangeTouchesChip)
+        return { kind: "native" };
+    return { kind: "splice", from: range.start, to: range.end, insert: [], caret: range.start };
+};
+const planTextInsertion = (doc, range, text, maxLength) => {
+    let insertedText = text;
+    if (maxLength !== undefined) {
+        const room = maxLength - (documentLength(doc) - (range.end - range.start));
+        if (room <= 0)
+            return { kind: "block" };
+        insertedText = insertedText.slice(0, room);
+    }
+    if (insertedText.length === 0)
+        return { kind: "block" };
+    return {
+        kind: "splice",
+        from: range.start,
+        to: range.end,
+        insert: [{ type: "text", text: insertedText }],
+        caret: range.start + insertedText.length,
+    };
+};
+export const segmentsToParagraphJSON = (doc) => {
+    const paragraphs = [{ type: "paragraph", content: [] }];
+    const pushInline = (node) => {
+        const target = paragraphs.at(-1);
+        if (!target)
+            return;
+        target.content = target.content ?? [];
+        target.content.push(node);
+    };
+    for (const segment of doc) {
+        if (segment.type === "chip") {
+            pushInline({
+                type: "mentionChip",
+                attrs: {
+                    prefix: segment.chip.prefix,
+                    value: segment.chip.value,
+                    label: segment.chip.label,
+                    ...(segment.chip.icon ? { icon: segment.chip.icon } : {}),
+                },
+            });
+            continue;
+        }
+        const lines = segment.text.split("\n");
+        lines.forEach((line, lineIndex) => {
+            if (lineIndex > 0)
+                paragraphs.push({ type: "paragraph", content: [] });
+            if (line.length > 0)
+                pushInline({ type: "text", text: line });
+        });
+    }
+    // Empty paragraphs stay — they encode blank lines ("\n\n"), and dropping
+    // them would make applySnapshot(getSnapshot()) lossy. (The legacy paste
+    // path filters them; the snapshot path must not.)
+    return paragraphs;
+};
+export const segmentsFromParagraphJSON = (paragraphs, makeId = nextChipId) => {
+    const doc = [];
+    paragraphs.forEach((paragraph, paragraphIndex) => {
+        if (paragraphIndex > 0)
+            doc.push({ type: "text", text: "\n" });
+        for (const node of paragraph.content ?? []) {
+            if (node.type === "text") {
+                doc.push({ type: "text", text: node.text });
+                continue;
+            }
+            // A legacy-engine snapshot may carry node types we don't model
+            // (hardBreak etc.) — only mention chips convert; the rest are skipped.
+            if (node.type !== "mentionChip")
+                continue;
+            doc.push({
+                type: "chip",
+                id: makeId(),
+                chip: {
+                    prefix: node.attrs.prefix,
+                    value: node.attrs.value,
+                    label: node.attrs.label,
+                    ...(node.attrs.icon ? { icon: node.attrs.icon } : {}),
+                },
+            });
+        }
+    });
+    return normalizeSegments(doc);
+};

package/dist/composer/store.d.ts

@@ -0,0 +1,97 @@
+import { type RefObject } from "react";
+import type { AskUserOptionsHandle } from "../ask-user/index.js";
+import { type AttachmentErrorCode, type AttachmentItem } from "../attachments/index.js";
+import { type AnswerEntry } from "./ask-user-machine.js";
+import { type AttachmentStoreConfig } from "./attachments-machine.js";
+import type { AskUserQuestion, ComposerAnswerEntry, ComposerEditorHandle, RegisteredEditor } from "./types.js";
+export type ComposerEditorState = ComposerEditorHandle & {
+    getText: () => string;
+    setText: (text: string) => void;
+    serialize: () => {
+        text: string;
+    };
+    ensureFocus: () => void;
+};
+export type ComposerAttachmentsState = {
+    items: AttachmentItem[];
+    add: (files: File[] | FileList) => void;
+    remove: (id: string) => void;
+    openFileDialog: () => void;
+    error: AttachmentErrorCode | null;
+    isDragging: boolean;
+    fileInputRef: RefObject<HTMLInputElement | null>;
+    globalDropRef: RefObject<boolean>;
+};
+export type ComposerAskUserState = ComposerPanelSlice & {
+    questions: AskUserQuestion[] | null;
+    step: number;
+    answers: Map<number, AnswerEntry>;
+    toggleOption: (label: string) => void;
+    continueStep: (freeText?: string) => void;
+    dismissStep: () => void;
+    isLastStep: boolean;
+    isSingle: boolean;
+    clearSelections: () => void;
+    goBack: () => void;
+    goNext: () => void;
+    optionsRef: RefObject<AskUserOptionsHandle | null>;
+};
+export type ComposerPanelSlice = {
+    active: boolean;
+    present: boolean;
+};
+export type ComposerCommandsState = ComposerPanelSlice & {
+    trigger: string | null;
+    query: string;
+    highlightIndex: number;
+    /** DOM id of the highlighted option row — the editor's aria-activedescendant. Written by the mounted Command as the highlight resolves. */
+    activeOptionId: string | null;
+};
+export type ComposerState = {
+    textarea: {
+        hasContent: boolean;
+    };
+    isSubmitting: boolean;
+    commands: ComposerCommandsState;
+    attachments: ComposerAttachmentsState;
+    askUser: ComposerAskUserState;
+};
+export type ComposerStore = {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => ComposerState;
+    setHasContent: (value: boolean) => void;
+    setIsSubmitting: (value: boolean) => void;
+    setCommands: (next: {
+        active: boolean;
+        trigger: string | null;
+        query: string;
+    }) => void;
+    setActiveOptionId: (id: string | null) => void;
+    /**
+     * Stable per-instance id for the command listbox — the editor references it
+     * via aria-controls; option rows derive their ids from it. Assigned by the
+     * mounting Composer.Root from React's useId (SSR-stable); the factory can't
+     * mint it because explicit handles are created outside React.
+     */
+    listboxId: string;
+    moveHighlight: (direction: number) => void;
+    setHighlight: (index: number) => void;
+    setQuestions: (questions: AskUserQuestion[] | null) => void;
+    setDragging: (active: boolean) => void;
+    resetAttachments: () => void;
+    activateAskUser: () => () => void;
+    finalizePanelClose: () => void;
+    reset: () => void;
+    editorRef: RefObject<RegisteredEditor | null>;
+    controller: ComposerEditorState;
+    registerEditor: (editor: RegisteredEditor) => () => void;
+    containerRef: RefObject<HTMLElement | null>;
+    attachmentConfigRef: RefObject<AttachmentStoreConfig>;
+    submitAnswersRef: RefObject<((answers: ComposerAnswerEntry[]) => void) | null>;
+    commandSelectRef: RefObject<(() => void) | null>;
+};
+export declare const createComposerStore: () => ComposerStore;
+export declare const ComposerStoreContext: import("react").Context<ComposerStore | null>;
+export declare const useComposerContextStore: () => ComposerStore;
+export declare const useComposerStore: <Selected = ComposerState>(store: ComposerStore, selector?: (composer: ComposerState) => Selected) => Selected;
+export declare const useComposer: <Selected = ComposerState>(selector?: (composer: ComposerState) => Selected) => Selected;