sailfork / t3code-github / apps/ mobile/ src/ native/ T3ComposerEditor.ios.tsx

import { PASTED_TEXT_ATTACHMENT_THRESHOLD_BYTES } from "@t3tools/client-runtime/text-paste";
import { PROVIDER_SEND_TURN_MAX_INPUT_CHARS } from "@t3tools/contracts";
import { collectComposerInlineTokens } from "@t3tools/shared/composerInlineTokens";
import { composerContextEditorTokens, composerSkillLabels } from "../lib/composerContext";
import { requireNativeView } from "expo";
import {
  useCallback,
  useEffect,
  useImperativeHandle,
  useMemo,
  useRef,
  useState,
  type Ref,
} from "react";
import type { NativeSyntheticEvent, StyleProp, ViewProps, ViewStyle } from "react-native";
import { StyleSheet } from "react-native";

import {
  composerChipSizeSuffix,
  contextChipIcon,
  contextChipAccent,
  contextChipPresentation,
  contextRecordFileName,
} from "../lib/composerChipPresentation";
import { contextChipIconUri } from "../lib/contextChipIconSource";
import { useUniwindTheme } from "../lib/useUniwindTheme";
import { createNativeComposerTheme } from "../lib/nativeComposerTheme";
import { FONT_FAMILIES } from "../lib/fontFamilies";
import { useScaledTextRole } from "../features/settings/appearance/useScaledTextRole";
import {
  acknowledgeComposerNativeEvent,
  assumeComposerControlledState,
  isComposerNativeEcho,
  pruneAcknowledgedComposerNativeEvents,
  resolveComposerControlledEventCount,
  type ComposerNativeEventSnapshot,
} from "./composerEditorRevision";
import { DEFAULT_COMPOSER_ENTER_BEHAVIOR } from "../lib/composerEnterBehavior";
import type { ComposerEditorProps, ComposerEditorSelection } from "./T3ComposerEditor.types";

const NATIVE_MODULE_NAME = "T3ComposerEditor";
const EMPTY_SKILLS: NonNullable<ComposerEditorProps["skills"]> = [];
const NO_RESET = () => 0;

type NativeEditorEvent = NativeSyntheticEvent<{
  readonly value: string;
  readonly selection: ComposerEditorSelection;
  readonly eventCount: number;
  readonly resetGeneration: number;
}>;

type NativeSelectionEvent = NativeSyntheticEvent<{
  readonly value: string;
  readonly selection: ComposerEditorSelection;
  readonly eventCount: number;
  readonly resetGeneration: number;
}>;

type NativePasteImagesEvent = NativeSyntheticEvent<{
  readonly uris: ReadonlyArray<string>;
}>;

type NativePasteTextEvent = NativeSyntheticEvent<{
  readonly value: string;
  readonly eventCount: number;
  readonly resetGeneration: number;
  readonly text: string;
  readonly selection: ComposerEditorSelection;
}>;

interface NativeComposerEditorRef {
  focus: () => Promise<void>;
  blur: () => Promise<void>;
  setSelection: (start: number, end: number) => Promise<void>;
  readState: () => Promise<{
    readonly value: string;
    readonly selection: ComposerEditorSelection;
    readonly eventCount: number;
    readonly resetGeneration: number;
    readonly pasteEventCount: number;
  }>;
}

interface NativeComposerEditorProps extends ViewProps {
  readonly ref?: Ref<NativeComposerEditorRef>;
  readonly controlledDocumentJson: string;
  readonly clipboardFragment: string;
  readonly themeJson: string;
  readonly placeholder: string;
  readonly fontFamily: string;
  readonly fontSize: number;
  readonly lineHeight: number;
  readonly contentInsetVertical: number;
  readonly editable: boolean;
  readonly readOnly: boolean;
  readonly enterBehavior: string;
  readonly submitTitle: string;
  readonly alternateSubmitTitle: string;
  readonly scrollEnabled: boolean;
  readonly autoFocus: boolean;
  readonly autoCorrect: boolean;
  readonly spellCheck: boolean;
  readonly onComposerChange: (event: NativeEditorEvent) => void;
  readonly onComposerSelectionChange?: (event: NativeSelectionEvent) => void;
  readonly onComposerPasteImages?: (event: NativePasteImagesEvent) => void;
  readonly onComposerContextPress?: (
    event: NativeSyntheticEvent<{ source: string; start: number; end: number }>,
  ) => void;
  readonly onComposerPasteContext?: (
    event: NativePasteTextEvent & NativeSyntheticEvent<{ fragment: string; html: string }>,
  ) => void;
  readonly textPasteThresholdBytes: number;
  readonly maxInputChars: number;
  readonly onComposerPasteText?: (event: NativePasteTextEvent) => void;
  readonly onComposerFocus?: () => void;
  readonly onComposerBlur?: () => void;
  readonly onComposerSubmit?: (event: NativeSyntheticEvent<{ alternate: boolean }>) => void;
  readonly onComposerContentSizeChange?: (
    event: NativeSyntheticEvent<{ readonly width: number; readonly height: number }>,
  ) => void;
}

const NativeView = requireNativeView<NativeComposerEditorProps>(NATIVE_MODULE_NAME);

// A view command rejects with "Unable to find the view" when the composer's native view is
// unmounted, which can happen while an open question hides the composer slot. There is nothing
// to act on then.
function settleViewCommand(command: Promise<void> | undefined): void {
  command?.catch(() => undefined);
}

function basename(path: string): string {
  const separator = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
  return separator >= 0 ? path.slice(separator + 1) : path;
}

export function ComposerEditor({
  ref,
  skills = EMPTY_SKILLS,
  selection,
  style,
  textStyle,
  onChangeText,
  onSelectionChange,
  onPasteImages,
  onPasteText,
  onFocus,
  onBlur,
  onSubmit,
  onContentSizeChange,
  contentInsetVertical = 0,
  readResetGeneration = NO_RESET,
  ...props
}: ComposerEditorProps) {
  const nativeRef = useRef<NativeComposerEditorRef>(null);
  const mostRecentEventCountRef = useRef(0);
  const [mostRecentEventCount, setMostRecentEventCount] = useState(0);
  const [, forceNativeEventRender] = useState(0);
  // Native stamps every event with the reset generation it had applied.
  const nativeResetGenerationRef = useRef(0);
  // Start history empty so restored drafts or recycled views receive a non-echo controlled payload.
  const nativeEventSnapshotsRef = useRef<ComposerNativeEventSnapshot[]>([]);
  // Tokens advance from the previous committed value; render-phase state keeps
  // an abandoned render from leaking a trailing token into the next one.
  const [confirmedTokens, setConfirmedTokens] = useState(() => ({
    value: props.value,
    tokens: collectComposerInlineTokens(props.value),
  }));
  let tokens = confirmedTokens.tokens;
  if (confirmedTokens.value !== props.value) {
    tokens = collectComposerInlineTokens(props.value, {
      preserveTrailingFrom: confirmedTokens.tokens,
    });
    setConfirmedTokens({ value: props.value, tokens });
  }
  const bodyText = useScaledTextRole("body");
  const theme = useUniwindTheme();
  const fontFamily = FONT_FAMILIES.regular;

  const skillLabels = useMemo(() => composerSkillLabels(skills), [skills]);
  const chipTextColor = createNativeComposerTheme(theme).text;
  const tokensJson = useMemo(() => {
    return JSON.stringify(
      composerContextEditorTokens(props.value, tokens, skillLabels).map((token) => {
        const record =
          token.type === "context"
            ? props.context?.records.find((record) => record.contextId === token.contextId)
            : undefined;
        const presentation = contextChipPresentation(
          token.type === "context" ? token.kind : token.type,
          record,
        );
        const icon = contextChipIcon(
          presentation,
          token.type === "mention" ? token.value : contextRecordFileName(record),
        );
        return {
          type: token.type,
          source: token.source,
          start: token.start,
          end: token.end,
          accent: contextChipAccent(presentation.accent, theme, chipTextColor),
          label:
            token.type === "skill"
              ? (skillLabels.get(token.value) ?? token.value)
              : token.type === "context"
                ? `${token.label}${props.context?.records.some((record) => record.contextId === token.contextId) ? "" : " · unavailable"}`
                : basename(token.value),
          detail: token.type === "context" ? composerChipSizeSuffix(record) : "",
          iconUri: contextChipIconUri(icon),
          tintsIcon: icon.kind === "chip",
        };
      }),
    );
  }, [props.value, tokens, props.context, skillLabels, theme, chipTextColor]);
  // Every render resolves against the snapshot history, so a render whose
  // (value, selection) lags the acknowledged native state is stamped behind
  // the native revision and rejected by the editor instead of re-applying a
  // stale caret or stale text mid-typing.
  /* oxlint-disable react/refs -- Native controlled edits must reconcile against the last acknowledged native event before sending the next payload. */
  const resetGeneration = readResetGeneration();
  // Native restarts its revision at a reset's stamp, so stamp it at the latest acknowledged event.
  const controlledEventCount =
    resetGeneration > nativeResetGenerationRef.current
      ? mostRecentEventCount
      : resolveComposerControlledEventCount(
          props.value,
          selection ?? null,
          mostRecentEventCount,
          nativeEventSnapshotsRef.current,
        );
  const acknowledgesLatestNativeEvent = isComposerNativeEcho(
    props.value,
    selection ?? null,
    mostRecentEventCount,
    nativeEventSnapshotsRef.current,
  );
  /* oxlint-enable react/refs */
  const isNativeEcho =
    controlledEventCount === mostRecentEventCount && acknowledgesLatestNativeEvent;
  const controlledDocumentJson = JSON.stringify({
    value: props.value,
    selection: isNativeEcho ? null : (selection ?? null),
    tokensJson,
    mostRecentEventCount: controlledEventCount,
    isNativeEcho,
    resetGeneration,
  });
  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- prunes native editor event snapshots once a committed payload acknowledges them
  useEffect(() => {
    if (!acknowledgesLatestNativeEvent) return;
    nativeEventSnapshotsRef.current = pruneAcknowledgedComposerNativeEvents(
      nativeEventSnapshotsRef.current,
      mostRecentEventCount,
    );
  }, [acknowledgesLatestNativeEvent, mostRecentEventCount, nativeEventSnapshotsRef]);
  const assumedValue = props.value;
  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- records the committed controlled payload as the native editor's assumed state
  useEffect(() => {
    // Newer native events make this payload stale; do not record it as applied.
    if (isNativeEcho || controlledEventCount !== mostRecentEventCountRef.current) return;
    nativeEventSnapshotsRef.current = assumeComposerControlledState(
      nativeEventSnapshotsRef.current,
      controlledEventCount,
      assumedValue,
    );
  }, [
    assumedValue,
    controlledEventCount,
    isNativeEcho,
    // oxlint-disable-next-line react/exhaustive-effect-dependencies -- Every changed native payload, including selection-only changes, must update the assumed native snapshot.
    controlledDocumentJson,
    nativeEventSnapshotsRef,
  ]);
  const acceptNativeEvent = useCallback(
    (event: NativeEditorEvent["nativeEvent"]) => {
      // Read at delivery: a send can clear the draft in the same batch, before this view re-renders.
      const acknowledgedEventCount = acknowledgeComposerNativeEvent(
        mostRecentEventCountRef.current,
        event.eventCount,
        readResetGeneration(),
        event.resetGeneration,
      );
      if (acknowledgedEventCount === null) {
        return false;
      }
      mostRecentEventCountRef.current = acknowledgedEventCount;
      nativeResetGenerationRef.current = event.resetGeneration;
      nativeEventSnapshotsRef.current.push({
        eventCount: acknowledgedEventCount,
        value: event.value,
        selection: event.selection,
      });
      return acknowledgedEventCount;
    },
    [nativeEventSnapshotsRef, readResetGeneration],
  );
  const applyNativeChange = (event: NativeEditorEvent["nativeEvent"]) => {
    const acknowledgedEventCount = acceptNativeEvent(event);
    if (acknowledgedEventCount === false) return;
    onChangeText(event.value);
    onSelectionChange?.(event.selection);
    setMostRecentEventCount(acknowledgedEventCount);
    forceNativeEventRender((sequence) => sequence + 1);
  };
  useImperativeHandle(ref, () => ({
    focus: () => settleViewCommand(nativeRef.current?.focus()),
    blur: () => settleViewCommand(nativeRef.current?.blur()),
    setSelection: (nextSelection) =>
      settleViewCommand(nativeRef.current?.setSelection(nextSelection.start, nextSelection.end)),
    // Tapping outside the editor makes iOS accept a pending autocorrection, and that edit's
    // event can reach JS after the tap's handler has already read the draft.
    flushPendingInput: async () => {
      const state = await Promise.resolve()
        .then(() => nativeRef.current?.readState())
        .catch(() => undefined);
      // Acknowledging past a paste JS has not received yet would get the paste rejected.
      if (state && state.pasteEventCount <= mostRecentEventCountRef.current) {
        applyNativeChange(state);
      }
    },
  }));
  const themeJson = JSON.stringify(createNativeComposerTheme(theme));
  const resolvedTextStyle = StyleSheet.flatten(textStyle) ?? {};
  return (
    <NativeView
      ref={nativeRef}
      controlledDocumentJson={controlledDocumentJson}
      clipboardFragment={props.clipboardFragment ?? ""}
      themeJson={themeJson}
      placeholder={props.placeholder ?? ""}
      fontFamily={
        typeof resolvedTextStyle.fontFamily === "string" ? resolvedTextStyle.fontFamily : fontFamily
      }
      fontSize={
        typeof resolvedTextStyle.fontSize === "number"
          ? resolvedTextStyle.fontSize
          : bodyText.fontSize
      }
      lineHeight={
        typeof resolvedTextStyle.lineHeight === "number"
          ? resolvedTextStyle.lineHeight
          : bodyText.lineHeight
      }
      contentInsetVertical={contentInsetVertical}
      editable={props.editable ?? true}
      readOnly={props.readOnly ?? false}
      enterBehavior={props.enterBehavior ?? DEFAULT_COMPOSER_ENTER_BEHAVIOR}
      submitTitle={props.submitTitle ?? "Send Message"}
      alternateSubmitTitle={props.alternateSubmitTitle ?? props.submitTitle ?? "Send Message"}
      scrollEnabled={props.scrollEnabled ?? true}
      autoFocus={props.autoFocus ?? false}
      autoCorrect={props.autoCorrect ?? true}
      spellCheck={props.spellCheck ?? true}
      textPasteThresholdBytes={onPasteText ? PASTED_TEXT_ATTACHMENT_THRESHOLD_BYTES : 0}
      maxInputChars={PROVIDER_SEND_TURN_MAX_INPUT_CHARS}
      style={style as StyleProp<ViewStyle>}
      onComposerChange={(event) => applyNativeChange(event.nativeEvent)}
      onComposerSelectionChange={(event) => {
        const acknowledgedEventCount = acceptNativeEvent(event.nativeEvent);
        if (acknowledgedEventCount === false) return;
        // Selection events may carry post-edit text; publish it with its revision or stale drafts can overwrite native text.
        if (event.nativeEvent.value !== props.value) {
          onChangeText(event.nativeEvent.value);
        }
        onSelectionChange?.(event.nativeEvent.selection);
        setMostRecentEventCount(acknowledgedEventCount);
        forceNativeEventRender((sequence) => sequence + 1);
      }}
      onComposerPasteImages={(event) => onPasteImages?.(event.nativeEvent.uris)}
      onComposerContextPress={(event) => props.onContextPress?.(event.nativeEvent)}
      onComposerPasteContext={(event) => {
        const paste = event.nativeEvent;
        const acknowledgedEventCount = acceptNativeEvent(paste);
        if (acknowledgedEventCount === false) return;
        onChangeText(paste.value);
        onSelectionChange?.(paste.selection);
        props.onPasteContext?.(paste);
        setMostRecentEventCount(acknowledgedEventCount);
        forceNativeEventRender((sequence) => sequence + 1);
      }}
      onComposerPasteText={(event) => {
        const paste = event.nativeEvent;
        const acknowledgedEventCount = acceptNativeEvent(paste);
        if (acknowledgedEventCount === false) return;
        // Sync before capturing async paste targets; props may lag the last native keystroke.
        onChangeText(paste.value);
        onSelectionChange?.(paste.selection);
        onPasteText?.(paste);
        setMostRecentEventCount(acknowledgedEventCount);
        forceNativeEventRender((sequence) => sequence + 1);
      }}
      onComposerFocus={onFocus}
      onComposerBlur={onBlur}
      onComposerContentSizeChange={
        onContentSizeChange === undefined
          ? undefined
          : (event) => onContentSizeChange(event.nativeEvent)
      }
      onComposerSubmit={
        onSubmit === undefined
          ? undefined
          : (event) => onSubmit(event.nativeEvent.alternate === true)
      }
    />
  );
}

export type {
  ComposerEditorHandle,
  ComposerEditorProps,
  ComposerEditorSelection,
  ComposerTextPaste,
} from "./T3ComposerEditor.types";