@skopon-cool/form-sdk 0.2.5 → 0.3.1

package/src/runtime/formRuntimeWs.ts

@@ -0,0 +1,158 @@
+import type {
+  FormAutoControlEventData,
+  FormRuntimeEnvelope,
+  FormRuntimeOutboundType,
+} from './types'
+
+const SEND_QUEUE_MAX = 100
+const RECONNECT_MAX_MS = 30_000
+
+export type FormAutoControlHandler = (
+  data: FormAutoControlEventData,
+  envelope: FormRuntimeEnvelope<FormAutoControlEventData>,
+) => void
+
+export interface FormRuntimeWsClientOptions {
+  url: string
+  askUserMessageId: string
+  onAutoControl?: FormAutoControlHandler
+}
+
+export class FormRuntimeWsClient {
+  private readonly url: string
+  private readonly askUserMessageId: string
+  private readonly onAutoControl?: FormAutoControlHandler
+  private ws: WebSocket | null = null
+  private closed = false
+  private reconnectAttempt = 0
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private sendQueue: string[] = []
+
+  constructor(options: FormRuntimeWsClientOptions) {
+    this.url = options.url
+    this.askUserMessageId = options.askUserMessageId
+    this.onAutoControl = options.onAutoControl
+  }
+
+  connect(): void {
+    if (this.closed || typeof WebSocket === 'undefined') return
+    this.clearReconnectTimer()
+    try {
+      const ws = new WebSocket(this.url)
+      this.ws = ws
+      ws.onopen = () => {
+        this.reconnectAttempt = 0
+        this.flushQueue()
+      }
+      ws.onmessage = (event) => {
+        this.handleMessage(event.data)
+      }
+      ws.onclose = () => {
+        this.ws = null
+        this.scheduleReconnect()
+      }
+      ws.onerror = () => {
+        // onclose will follow; avoid noisy logs
+      }
+    } catch (error) {
+      console.warn('[FormRuntimeWs] connect failed', error)
+      this.scheduleReconnect()
+    }
+  }
+
+  send(
+    type: FormRuntimeOutboundType,
+    data: Record<string, unknown>,
+  ): void {
+    if (this.closed) return
+    const payload: FormRuntimeEnvelope = {
+      type,
+      ask_user_message_id: this.askUserMessageId,
+      data,
+    }
+    let serialized: string
+    try {
+      serialized = JSON.stringify(payload)
+    } catch (error) {
+      console.warn('[FormRuntimeWs] serialize failed', error)
+      return
+    }
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(serialized)
+      return
+    }
+    this.enqueue(serialized)
+  }
+
+  close(): void {
+    this.closed = true
+    this.clearReconnectTimer()
+    this.sendQueue = []
+    if (this.ws) {
+      this.ws.onopen = null
+      this.ws.onmessage = null
+      this.ws.onclose = null
+      this.ws.onerror = null
+      try {
+        this.ws.close()
+      } catch {
+        // ignore
+      }
+      this.ws = null
+    }
+  }
+
+  private enqueue(serialized: string): void {
+    this.sendQueue.push(serialized)
+    while (this.sendQueue.length > SEND_QUEUE_MAX) {
+      this.sendQueue.shift()
+    }
+  }
+
+  private flushQueue(): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return
+    const pending = this.sendQueue
+    this.sendQueue = []
+    for (const item of pending) {
+      this.ws.send(item)
+    }
+  }
+
+  private scheduleReconnect(): void {
+    if (this.closed) return
+    this.clearReconnectTimer()
+    const delay = Math.min(
+      RECONNECT_MAX_MS,
+      1000 * 2 ** Math.min(this.reconnectAttempt, 5),
+    )
+    this.reconnectAttempt += 1
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      this.connect()
+    }, delay)
+  }
+
+  private clearReconnectTimer(): void {
+    if (this.reconnectTimer != null) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+  }
+
+  private handleMessage(raw: unknown): void {
+    if (typeof raw !== 'string') return
+    let parsed: unknown
+    try {
+      parsed = JSON.parse(raw)
+    } catch {
+      return
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return
+    const envelope = parsed as FormRuntimeEnvelope<FormAutoControlEventData>
+    if (envelope.type !== 'form_auto_control_event') return
+    if (String(envelope.ask_user_message_id ?? '') !== this.askUserMessageId) return
+    const data = envelope.data
+    if (!data || typeof data !== 'object' || Array.isArray(data)) return
+    this.onAutoControl?.(data, envelope)
+  }
+}

package/src/runtime/types.ts

@@ -0,0 +1,26 @@
+export type FormRuntimeAction = 'focus' | 'change' | 'select' | 'click' | 'submit'
+
+export interface FormRuntimeEventData {
+  action: FormRuntimeAction
+  component: string
+  field?: string
+  value?: unknown
+}
+
+export interface FormAutoControlEventData {
+  action: FormRuntimeAction
+  field?: string
+  value?: unknown
+  component?: string
+}
+
+export type FormRuntimeOutboundType =
+  | 'form_runtime_data'
+  | 'form_runtime_event'
+  | 'form_auto_control_bac_event'
+
+export interface FormRuntimeEnvelope<T = Record<string, unknown>> {
+  type: string
+  ask_user_message_id: string
+  data: T
+}