Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

15.5 KB
Raw Blame
import {
  createEffect,
  createSignal,
  createUniqueId,
  For,
  mergeProps,
  on,
  onCleanup,
  onMount,
  Show,
} from 'solid-js';
import { Portal } from 'solid-js/web';
import type { SpreadsheetMentions } from '../context/spreadsheet-mentions';
import {
  argumentLabel,
  formulaFunctions,
  functionSummary,
  type TableReferences,
} from '../core/formula-completion';
import type {
  FormulaReferenceSpan,
  FormulaTextSelection,
} from '../core/formula-reference';
import {
  type CompleteFormula,
  createFormulaAssistance,
} from '../primitives/create-formula-assistance';
import { createTouchPress } from '../primitives/create-touch-press';
import { EditorPopup } from './EditorPopup';

/** Shared cell/formula-bar input. The popup keeps focus and editing in the textarea. */
export type FormulaInputProps = {
  mentions?: SpreadsheetMentions;
  label: string;
  value: string;
  class: string;
  readonly?: boolean;
  autoFocus?: boolean;
  placeholder?: string;
  complete?: CompleteFormula;
  /** Tables whose names and columns formulas complete. */
  tableReferences?: () => TableReferences | undefined;
  selectionRequest?: FormulaTextSelection;
  /** Spans of `value` to draw in their reference's color. */
  references?: FormulaReferenceSpan[];
  pickingReference?: boolean;
  onSelectionChange?: (start: number, end: number) => void;
  onFocus?: () => void;
  onInput: (value: string) => void;
  onKeyDown: (event: KeyboardEvent) => void;
  onBlur: () => void;
};
export function FormulaInput(props: FormulaInputProps) {
  let transferFocus = false;
  const inputProps = mergeProps(props, {
    get autoFocus() {
      return props.autoFocus || transferFocus;
    },
    get typed() {
      return transferFocus;
    },
    onFocus: () => {
      transferFocus = false;
      props.onFocus?.();
    },
    onBlur: () => {
      if (!transferFocus) props.onBlur();
    },
    onInput: (value: string) => {
      transferFocus =
        !!props.mentions &&
        value.startsWith('=') !== props.value.startsWith('=');
      props.onInput(value);
    },
  });
  return (
    <Show
      when={props.mentions && !props.value.startsWith('=')}
      fallback={<FormulaTextarea {...inputProps} />}
    >
      {(_enabled) => props.mentions!.renderEditor(inputProps)}
    </Show>
  );
}

function FormulaTextarea(props: FormulaInputProps & { typed?: boolean }) {
  let input!: HTMLTextAreaElement;
  let popup: HTMLDivElement | undefined;
  const id = createUniqueId();
  const [focused, setFocused] = createSignal(false);
  // Help opens only after the user types, so focusing, clicking, or switching
  // sheets with a formula draft never covers the grid.
  let typing = !!props.typed;
  const assistance = createFormulaAssistance(
    (text, cursor) =>
      props.complete?.(text, cursor) ?? Promise.resolve(undefined),
    (text, cursor) => {
      if (props.readonly) return;
      props.onInput(text);
      input.value = text;
      input.focus({ preventScroll: true });
      input.setSelectionRange(cursor, cursor);
      update();
    },
    () => props.tableReferences?.()
  );
  const result = assistance.completion;
  const choices = () => {
    const value = result();
    return value?.kind === 'list' ? value.names : [];
  };
  const references = () => {
    const value = result();
    return value?.kind === 'references' ? value.items : [];
  };
  const name = () => {
    const value = result();
    return value?.kind === 'detail'
      ? value.name
      : choices()[assistance.selected()];
  };
  const info = () => formulaFunctions[name()];
  const referencesVisible = () =>
    focused() &&
    !props.readonly &&
    !props.pickingReference &&
    references().length > 0;
  const popupVisible = () =>
    focused() && !props.readonly && !props.pickingReference && !!info();
  const argument = () => {
    const value = result();
    return value?.kind === 'detail' ? value.argument : -1;
  };
  const activeArgument = () => {
    const args = info()?.args ?? [];
    if (argument() < 0 || !args.length) return -1;
    return Math.min(argument(), args.length - 1);
  };
  const dismiss = () => {
    typing = false;
    assistance.dismiss();
  };
  const update = () => {
    if (!focused() || props.readonly) return;
    props.onSelectionChange?.(input.selectionStart, input.selectionEnd);
    if (props.pickingReference || !typing) dismiss();
    else
      assistance.update(input.value, input.selectionStart, input.selectionEnd);
  };
  let appliedSelection: FormulaTextSelection | undefined;
  // Pointer selection changes the draft without moving focus out of this editor.
  createEffect(
    on(
      () => [props.selectionRequest, props.pickingReference] as const,
      ([selection]) => {
        if (document.activeElement !== input) return;
        if (selection && selection !== appliedSelection) {
          appliedSelection = selection;
          input.value = props.value;
          input.setSelectionRange(selection.start, selection.end);
        }
        update();
      }
    )
  );
  onMount(() => {
    if (props.autoFocus) {
      input.focus();
      input.setSelectionRange(input.value.length, input.value.length);
      update();
    }
  });

  return (
    <>
      <textarea
        ref={input}
        aria-label={props.label}
        aria-autocomplete="list"
        aria-controls={
          (popupVisible() && choices().length) || referencesVisible()
            ? `${id}-list`
            : undefined
        }
        aria-activedescendant={
          (popupVisible() && choices().length) || referencesVisible()
            ? `${id}-${assistance.selected()}`
            : undefined
        }
        aria-describedby={popupVisible() ? `${id}-help` : undefined}
        rows={1}
        wrap="off"
        spellcheck={false}
        autocomplete="off"
        autocapitalize="off"
        autocorrect="off"
        enterkeyhint="done"
        readOnly={props.readonly}
        maxLength={10_000}
        placeholder={props.placeholder}
        class={`${props.class} touch:text-[max(16px,1rem)]`}
        style={
          props.references?.length
            ? { '-webkit-text-fill-color': 'transparent' }
            : undefined
        }
        value={props.value}
        onFocus={() => {
          props.onFocus?.();
          setFocused(true);
          update();
        }}
        onInput={() => {
          typing = true;
          props.onInput(input.value);
          update();
        }}
        onSelect={update}
        onClick={update}
        onKeyUp={(event) => {
          if (['ArrowLeft', 'ArrowRight', 'Home', 'End'].includes(event.key))
            update();
        }}
        onKeyDown={(event) => {
          event.stopPropagation();
          if (!props.readonly && assistance.keyDown(event)) {
            if (event.key === 'Escape') typing = false;
            if (event.key === 'ArrowDown' || event.key === 'ArrowUp')
              popup
                ?.querySelector('[aria-selected="true"]')
                ?.scrollIntoView({ block: 'nearest' });
            return;
          }
          props.onKeyDown(event);
        }}
        onBlur={() => {
          setFocused(false);
          dismiss();
          props.onBlur();
        }}
      />
      <Show when={props.references?.length ? props.references : undefined}>
        {(references) => (
          <ReferenceMirror
            input={input}
            value={props.value}
            references={references()}
          />
        )}
      </Show>
      <Show when={referencesVisible()}>
        <Portal>
          <EditorPopup
            anchor={input}
            interactive
            class="w-72"
            onReady={(element) => {
              popup = element;
            }}
            onOutsidePress={dismiss}
          >
            <div
              id={`${id}-list`}
              role="listbox"
              aria-label="Formula suggestions"
              class="min-h-0 max-h-48 shrink overflow-y-auto overscroll-contain p-1"
            >
              <For each={references()}>
                {(item, index) => {
                  const press = createTouchPress(
                    () => assistance.accept(index()),
                    () => props.readonly ?? false
                  );
                  return (
                    <div
                      {...press}
                      id={`${id}-${index()}`}
                      role="option"
                      aria-selected={assistance.selected() === index()}
                      class="flex items-center gap-2 rounded px-2 py-1 text-xs touch:min-h-[44px] touch:text-sm"
                      classList={{
                        'bg-accent-bg text-accent':
                          assistance.selected() === index(),
                        'text-ink hover:bg-hover':
                          assistance.selected() !== index(),
                      }}
                      onPointerMove={(event) => {
                        press.onPointerMove(event);
                        assistance.setSelected(index());
                      }}
                    >
                      <span class="font-mono font-semibold">{item.label}</span>
                      <span class="truncate text-[11px] text-ink-muted">
                        {item.detail}
                      </span>
                    </div>
                  );
                }}
              </For>
            </div>
          </EditorPopup>
        </Portal>
      </Show>
      <Show when={popupVisible()}>
        <Portal>
          <EditorPopup
            anchor={input}
            interactive={choices().length > 0}
            class="w-72"
            onReady={(element) => {
              popup = element;
            }}
            onOutsidePress={dismiss}
          >
            <Show when={choices().length}>
              <div
                id={`${id}-list`}
                role="listbox"
                aria-label="Formula suggestions"
                class="min-h-0 max-h-40 shrink overflow-y-auto overscroll-contain p-1"
              >
                <For each={choices()}>
                  {(choice, index) => {
                    const press = createTouchPress(
                      () => assistance.accept(index()),
                      () => props.readonly ?? false
                    );
                    return (
                      <div
                        {...press}
                        id={`${id}-${index()}`}
                        role="option"
                        aria-selected={assistance.selected() === index()}
                        class="flex items-center gap-2 rounded px-2 py-1 text-xs touch:min-h-[44px] touch:text-sm"
                        classList={{
                          'bg-accent-bg text-accent':
                            assistance.selected() === index(),
                          'text-ink hover:bg-hover':
                            assistance.selected() !== index(),
                        }}
                        onPointerMove={(event) => {
                          press.onPointerMove(event);
                          assistance.setSelected(index());
                        }}
                      >
                        <span class="font-mono font-semibold">{choice}</span>
                        <span class="truncate text-[11px] text-ink-muted">
                          {functionSummary(formulaFunctions[choice])}
                        </span>
                      </div>
                    );
                  }}
                </For>
              </div>
            </Show>
            <div
              id={`${id}-help`}
              class="min-h-0 overflow-y-auto px-2.5 py-1.5 text-xs touch:text-sm"
              classList={{
                'border-t border-edge-muted touch:hidden': choices().length > 0,
              }}
            >
              <div class="break-words font-mono leading-5 text-ink">
                <span class="font-semibold text-accent">{name()}</span>(
                <For each={info().args}>
                  {(arg, index) => (
                    <>
                      {index() > 0 ? ', ' : ''}
                      <span
                        classList={{
                          'rounded bg-accent-bg px-0.5 text-accent font-semibold':
                            index() === activeArgument(),
                        }}
                      >
                        {argumentLabel(arg[0])}
                      </span>
                    </>
                  )}
                </For>
                )
              </div>
              <Show when={!choices().length}>
                <p class="text-[11px] leading-4 text-ink-muted">
                  {activeArgument() >= 0
                    ? info().args[activeArgument()][2]
                    : functionSummary(info())}
                </p>
              </Show>
            </div>
          </EditorPopup>
        </Portal>
      </Show>
    </>
  );
}

/**
 * Draws the textarea's text over it, with references in their colors. A
 * textarea cannot style part of its text, so it keeps the caret, selection and
 * text color while its glyphs are transparent.
 */
function ReferenceMirror(props: {
  input: HTMLTextAreaElement;
  value: string;
  references: FormulaReferenceSpan[];
}) {
  let mirror!: HTMLDivElement;
  let text!: HTMLSpanElement;
  const segments = () => {
    const parts: { text: string; color?: string }[] = [];
    let at = 0;
    for (const reference of props.references) {
      if (reference.start < at || reference.end > props.value.length) continue;
      parts.push({ text: props.value.slice(at, reference.start) });
      parts.push({
        text: props.value.slice(reference.start, reference.end),
        color: reference.color,
      });
      at = reference.end;
    }
    parts.push({ text: props.value.slice(at) });
    return parts;
  };
  const sync = () => {
    const { input } = props;
    const style = getComputedStyle(input);
    Object.assign(mirror.style, {
      left: `${input.offsetLeft}px`,
      top: `${input.offsetTop}px`,
      width: `${input.offsetWidth}px`,
      height: `${input.offsetHeight}px`,
      fontFamily: style.fontFamily,
      fontSize: style.fontSize,
      fontWeight: style.fontWeight,
      fontStyle: style.fontStyle,
      color: style.color,
      letterSpacing: style.letterSpacing,
      lineHeight: style.lineHeight,
      textAlign: style.textAlign,
      paddingTop: style.paddingTop,
      paddingRight: style.paddingRight,
      paddingBottom: style.paddingBottom,
      paddingLeft: style.paddingLeft,
      borderTopWidth: style.borderTopWidth,
      borderRightWidth: style.borderRightWidth,
      borderBottomWidth: style.borderBottomWidth,
      borderLeftWidth: style.borderLeftWidth,
    });
    text.style.transform = `translate(${-input.scrollLeft}px, ${-input.scrollTop}px)`;
  };
  onMount(() => {
    sync();
    props.input.addEventListener('scroll', sync);
    const observer =
      typeof ResizeObserver === 'undefined'
        ? undefined
        : new ResizeObserver(sync);
    observer?.observe(props.input);
    onCleanup(() => {
      props.input.removeEventListener('scroll', sync);
      observer?.disconnect();
    });
  });
  createEffect(on(() => props.value, sync, { defer: true }));
  return (
    <div
      ref={mirror}
      aria-hidden="true"
      data-formula-mirror
      class="pointer-events-none absolute box-border overflow-hidden whitespace-pre border-solid border-transparent"
    >
      <span ref={text} class="block">
        <For each={segments()}>
          {(segment) => (
            <span style={segment.color ? { color: segment.color } : undefined}>
              {segment.text}
            </span>
          )}
        </For>
      </span>
    </div>
  );
}