feat: publish HoloLake model-native living system source

product-source/hololake-platform/src/utils/plainTextPaste.ts

@@ -0,0 +1,197 @@
+import { invoke } from '@tauri-apps/api/core'
+import { trackEvent } from '../lib/telemetry'
+import { isTauri, mockInvoke } from '../mock-tauri'
+
+export type PlainTextPasteSurface =
+  | 'focused_contenteditable'
+  | 'focused_input'
+  | 'raw_editor'
+  | 'rich_editor'
+
+export interface PlainTextPasteTarget {
+  surface: PlainTextPasteSurface
+  contains: (element: Element | null) => boolean
+  insert: (text: string) => boolean
+  isConnected: () => boolean
+}
+
+let activePasteTarget: PlainTextPasteTarget | null = null
+
+function activeHTMLElement(): HTMLElement | null {
+  const active = document.activeElement
+  return active instanceof HTMLElement ? active : null
+}
+
+function isCommandPaletteElement(element: Element | null): boolean {
+  return Boolean(element?.closest('[data-command-palette="true"]'))
+}
+
+function isUsableTarget(target: PlainTextPasteTarget | null): target is PlainTextPasteTarget {
+  return Boolean(target?.isConnected())
+}
+
+function recordPlainTextPaste(surface: PlainTextPasteSurface): void {
+  trackEvent('plain_text_paste_used', { surface })
+}
+
+function inputEvent(text: string): Event {
+  if (typeof InputEvent === 'function') {
+    return new InputEvent('input', {
+      bubbles: true,
+      cancelable: false,
+      data: text,
+      inputType: 'insertText',
+    })
+  }
+
+  return new Event('input', { bubbles: true })
+}
+
+function isPlainTextInput(element: HTMLInputElement): boolean {
+  const plainTextTypes = new Set([
+    '',
+    'email',
+    'password',
+    'search',
+    'tel',
+    'text',
+    'url',
+  ])
+
+  return plainTextTypes.has(element.type)
+}
+
+function insertIntoTextControl(element: HTMLInputElement | HTMLTextAreaElement, text: string): boolean {
+  if (element.readOnly || element.disabled) return false
+  if (element instanceof HTMLInputElement && !isPlainTextInput(element)) return false
+
+  const start = element.selectionStart ?? element.value.length
+  const end = element.selectionEnd ?? start
+  element.setRangeText(text, start, end, 'end')
+  element.dispatchEvent(inputEvent(text))
+  return true
+}
+
+function insertIntoContentEditable(element: HTMLElement, text: string): boolean {
+  if (!element.isContentEditable && !element.closest('[contenteditable="true"]')) return false
+
+  const queryCommandSupported = Reflect.get(document, 'queryCommandSupported') as ((commandId: string) => boolean) | undefined
+  if (queryCommandSupported?.call(document, 'insertText') && document.execCommand('insertText', false, text)) {
+    return true
+  }
+
+  const selection = window.getSelection()
+  if (!selection || selection.rangeCount === 0) return false
+
+  const range = selection.getRangeAt(0)
+  range.deleteContents()
+  range.insertNode(document.createTextNode(text))
+  range.collapse(false)
+  selection.removeAllRanges()
+  selection.addRange(range)
+  element.dispatchEvent(inputEvent(text))
+  return true
+}
+
+function insertIntoFocusedEditable(text: string, element: HTMLElement | null): PlainTextPasteSurface | null {
+  if (!element) return null
+  if (isCommandPaletteElement(element)) return null
+
+  if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+    return insertIntoTextControl(element, text) ? 'focused_input' : null
+  }
+
+  return insertIntoContentEditable(element, text) ? 'focused_contenteditable' : null
+}
+
+function isEditableHTMLElementForPlainTextPaste(element: HTMLElement | null): boolean {
+  if (!element || isCommandPaletteElement(element)) return false
+  return (element instanceof HTMLInputElement && isPlainTextInput(element))
+    || element instanceof HTMLTextAreaElement
+    || element.isContentEditable
+    || element.closest('[contenteditable="true"]') !== null
+}
+
+function insertIntoTarget(target: PlainTextPasteTarget, text: string): boolean {
+  if (!target.insert(text)) return false
+  recordPlainTextPaste(target.surface)
+  return true
+}
+
+function currentPasteTarget(): PlainTextPasteTarget | null {
+  return isUsableTarget(activePasteTarget) ? activePasteTarget : null
+}
+
+function insertIntoContainedTarget(
+  target: PlainTextPasteTarget | null,
+  element: HTMLElement | null,
+  text: string,
+): boolean {
+  return Boolean(target?.contains(element) && insertIntoTarget(target, text))
+}
+
+function insertIntoFocusedSurface(text: string, element: HTMLElement | null): boolean {
+  const focusedSurface = insertIntoFocusedEditable(text, element)
+  if (!focusedSurface) return false
+
+  recordPlainTextPaste(focusedSurface)
+  return true
+}
+
+function shouldUseLastPasteTarget(element: HTMLElement | null): boolean {
+  if (!element) return true
+  if (isCommandPaletteElement(element)) return true
+  return !isEditableHTMLElementForPlainTextPaste(element)
+}
+
+function insertIntoLastTarget(
+  target: PlainTextPasteTarget | null,
+  element: HTMLElement | null,
+  text: string,
+): boolean {
+  if (!target || !shouldUseLastPasteTarget(element)) return false
+  return insertIntoTarget(target, text)
+}
+
+export function registerPlainTextPasteTarget(target: PlainTextPasteTarget): () => void {
+  activePasteTarget = target
+
+  return () => {
+    if (activePasteTarget === target) {
+      activePasteTarget = null
+    }
+  }
+}
+
+export function activatePlainTextPasteTarget(target: PlainTextPasteTarget): void {
+  activePasteTarget = target
+}
+
+export function insertPlainTextFromClipboardText(text: string): boolean {
+  if (text.length === 0) return false
+
+  const currentElement = activeHTMLElement()
+  const target = currentPasteTarget()
+
+  return insertIntoContainedTarget(target, currentElement, text)
+    || insertIntoFocusedSurface(text, currentElement)
+    || insertIntoLastTarget(target, currentElement, text)
+}
+
+async function readClipboardText(): Promise<string> {
+  if (isTauri()) {
+    return invoke<string>('read_text_from_clipboard')
+  }
+
+  const clipboard = Reflect.get(navigator, 'clipboard') as Clipboard | undefined
+  if (clipboard && typeof clipboard.readText === 'function') {
+    return clipboard.readText()
+  }
+
+  return mockInvoke<string>('read_text_from_clipboard')
+}
+
+export async function requestPlainTextPaste(): Promise<boolean> {
+  const text = await readClipboardText()
+  return insertPlainTextFromClipboardText(text)
+}