Skip to content

Beautiful Open-Source Form Builder

28.9 KB
Raw Blame
/* eslint-disable */
/**
 * OpnForm SDK Bridge & Local SDK
 * Handles communication between embedded form iframe and parent window SDK
 * Also provides local SDK for non-iframe usage (custom code support)
 */
import { watch, toValue, onMounted, onUnmounted, toRaw, isRef, unref } from 'vue'
import { useIsIframe } from '~/composables/useIsIframe'
import { handleDarkMode } from '~/lib/forms/public-page'
import {
  MSG_PREFIX,
  WILDCARD_ORIGIN,
  createSdkBridgeMessageHandler,
  readSdkTokenFromUrl,
  resolveInitialTrustedOrigin,
} from '~/lib/sdk/sdkBridgeMessaging'

// Event types
const EVENTS = {
  READY: 'ready',
  SUBMIT: 'submit',
  SUBMIT_START: 'submitStart',
  SUBMIT_ERROR: 'submitError',
  RESET: 'reset',
  PAGE_CHANGE: 'pageChange',
  NEXT_PAGE: 'nextPage',
  PREVIOUS_PAGE: 'previousPage',
  DATA_CHANGE: 'dataChange',
  ERROR: 'error',
  SHOW: 'show',
  HIDE: 'hide',
  RESIZE: 'resize'
}

// ============================================================================
// Local SDK Classes (for custom code support without iframe)
// ============================================================================

/**
 * Simple EventEmitter implementation
 */
class EventEmitter {
  constructor() {
    this._listeners = {}
    this._onceListeners = {}
  }

  on(event, callback) {
    if (Array.isArray(event)) {
      event.forEach(e => this.on(e, callback))
      return this
    }
    if (!this._listeners[event]) {
      this._listeners[event] = []
    }
    this._listeners[event].push(callback)
    return this
  }

  once(event, callback) {
    if (!this._onceListeners[event]) {
      this._onceListeners[event] = []
    }
    this._onceListeners[event].push(callback)
    return this
  }

  off(event, callback) {
    if (!callback) {
      delete this._listeners[event]
      delete this._onceListeners[event]
      return this
    }
    if (this._listeners[event]) {
      this._listeners[event] = this._listeners[event].filter(cb => cb !== callback)
    }
    if (this._onceListeners[event]) {
      this._onceListeners[event] = this._onceListeners[event].filter(cb => cb !== callback)
    }
    return this
  }

  emit(event, data) {
    if (this._listeners[event]) {
      this._listeners[event].forEach(callback => {
        try { callback(data) } catch (e) { console.error('[OpnForm SDK] Error in event handler:', e) }
      })
    }
    if (this._onceListeners[event]) {
      const callbacks = this._onceListeners[event]
      delete this._onceListeners[event]
      callbacks.forEach(callback => {
        try { callback(data) } catch (e) { console.error('[OpnForm SDK] Error in once handler:', e) }
      })
    }
  }
}

/**
 * Local Form Instance - represents the current form on the page
 */
class LocalFormInstance extends EventEmitter {
  constructor(slug, sdk) {
    super()
    this.slug = slug
    this.id = slug
    this._sdk = sdk
    this._ready = false
    this._bridgeData = null
    this._cachedData = {}
    this._cachedErrors = {}
    this._darkMode = false
    this._currentPage = { index: 0, total: 1 }
  }

  /**
   * Register the SDK bridge data from the form component
   */
  _registerBridge(bridgeData) {
    this._bridgeData = bridgeData
    
    // Migrate listeners from stub if exists
    if (typeof window !== 'undefined' && window.opnform?._isStub) {
      const formStub = window.opnform._forms?.[this.slug]
      if (formStub) {
        Object.entries(formStub._listeners || {}).forEach(([event, cbs]) => {
          cbs.forEach(cb => this.on(event, cb))
        })
        Object.entries(formStub._onceListeners || {}).forEach(([event, cbs]) => {
          cbs.forEach(cb => this.once(event, cb))
        })
      }
    }
  }

  _getFormManager() {
    return this._bridgeData?.formManager
  }

  isReady() { return this._ready }

  // --- Field Operations ---
  getField(fieldId) { 
    const fm = this._getFormManager()
    return fm?.form ? fm.form[fieldId] : this._cachedData[fieldId]
  }

  setField(fieldId, value) { 
    const fm = this._getFormManager()
    if (fm?.form) {
      fm.form[fieldId] = value
      return true
    }
    return false
  }

  setFields(data) { 
    const fm = this._getFormManager()
    if (fm?.form && data) {
      Object.entries(data).forEach(([fieldId, value]) => {
        fm.form[fieldId] = value
      })
      return true
    }
    return false
  }

  getData() { 
    const fm = this._getFormManager()
    return fm?.form?.data ? fm.form.data() : { ...this._cachedData }
  }

  clearField(fieldId) { 
    const fm = this._getFormManager()
    if (fm?.form) {
      fm.form[fieldId] = null
      return true
    }
    return false
  }

  clearAll() { 
    const fm = this._getFormManager()
    if (fm?.form?.reset) {
      fm.form.reset()
      return true
    }
    return false
  }

  // --- Field State ---
  hasError(fieldId) { 
    const fm = this._getFormManager()
    if (fm?.form?.errors) {
      return !!fm.form.errors.all()[fieldId]
    }
    return !!this._cachedErrors[fieldId]
  }

  getError(fieldId) { 
    const fm = this._getFormManager()
    if (fm?.form?.errors) {
      return fm.form.errors.all()[fieldId] || null
    }
    return this._cachedErrors[fieldId] || null
  }

  getErrors() { 
    const fm = this._getFormManager()
    return fm?.form?.errors ? fm.form.errors.all() : { ...this._cachedErrors }
  }

  isFieldVisible(fieldId) { 
    const fm = this._getFormManager()
    if (fm?.fieldState?.isFieldVisible) {
      const visible = fm.fieldState.isFieldVisible(fieldId)
      return typeof visible === 'object' && 'value' in visible ? visible.value : visible
    }
    return true
  }

  // --- Theme ---
  toggleDarkMode() { 
    return this.setDarkMode(!this._darkMode)
  }

  setDarkMode(enabled) {
    if (typeof window !== 'undefined') {
      if (enabled === 'auto') {
        handleDarkMode('auto')
        this._darkMode = null
      } else {
        handleDarkMode(enabled ? 'dark' : 'light')
        this._darkMode = !!enabled
      }
    }
    return true
  }

  isDarkMode() { return this._darkMode }

  setTheme(theme) { 
    console.warn('[OpnForm SDK] setTheme is not yet implemented')
    return false
  }

  // --- Navigation ---
  goToPage(index) { 
    const fm = this._getFormManager()
    if (fm?.goToPage) {
      fm.goToPage(index)
      return true
    } else if (fm?.state) {
      fm.state.currentPage = index
      return true
    }
    return false
  }

  nextPage() { 
    const fm = this._getFormManager()
    if (fm?.nextPage) {
      fm.nextPage()
      return true
    }
    return false
  }

  previousPage() { 
    const fm = this._getFormManager()
    if (fm?.previousPage) {
      fm.previousPage()
      return true
    }
    return false
  }

  getCurrentPage() { 
    const fm = this._getFormManager()
    if (fm?.state) {
      const total = fm.structure?.value?.pageCount?.value || 1
      return { index: fm.state.currentPage || 0, total }
    }
    return { ...this._currentPage }
  }

  canGoNext() { 
    const page = this.getCurrentPage()
    return page.index < page.total - 1
  }

  canGoPrevious() { 
    const page = this.getCurrentPage()
    return page.index > 0
  }

  // --- Actions ---
  submit() { 
    const submitBtn = document.querySelector('#public-form button[type="submit"], #public-form [data-submit-button]')
    if (submitBtn) {
      submitBtn.click()
      return Promise.resolve(true)
    }
    return Promise.reject(new Error('Submit button not found'))
  }

  reset() { 
    const fm = this._getFormManager()
    if (fm?.restart) {
      fm.restart()
      return true
    } else if (fm?.form?.reset) {
      fm.form.reset()
      return true
    }
    return false
  }

  focusFirstError() { 
    const errors = this.getErrors()
    const firstField = Object.keys(errors)[0]
    if (firstField) {
      const element = document.querySelector(`[name="${firstField}"], #${firstField}`)
      if (element) {
        element.focus()
        element.scrollIntoView({ behavior: 'smooth', block: 'center' })
        return true
      }
    }
    return false
  }

  // --- Popup Control (not applicable for direct page) ---
  open() { console.warn('[OpnForm SDK] open() not applicable for non-iframe forms') }
  close() { console.warn('[OpnForm SDK] close() not applicable for non-iframe forms') }
  toggle() { console.warn('[OpnForm SDK] toggle() not applicable for non-iframe forms') }
  isOpen() { return true }

  _getFormInfo() {
    return { slug: this.slug, id: this.id }
  }
}

/**
 * Local OpnForm SDK - runs on form pages directly
 */
class OpnFormLocalSDK extends EventEmitter {
  constructor() {
    super()
    this._forms = {}
    this._options = { defaultDarkMode: 'auto' }
    this._initialized = false
    this._messageHandler = this._handleMessage.bind(this)
  }

  init(options = {}) {
    this._options = { ...this._options, ...options }
    
    if (!this._initialized && typeof window !== 'undefined') {
      window.addEventListener('message', this._messageHandler)
      this._initialized = true
    }

    if (this._options.onReady && Object.keys(this._forms).length > 0) {
      const readyForms = Object.values(this._forms).filter(f => f.isReady())
      if (readyForms.length > 0) {
        this._options.onReady(readyForms)
      }
    }
  }

  _registerForm(slug, bridgeData) {
    if (!this._forms[slug]) {
      this._forms[slug] = new LocalFormInstance(slug, this)
    }
    this._forms[slug]._registerBridge(bridgeData)
    
    // Migrate global listeners from stub
    if (typeof window !== 'undefined' && window.opnform?._isStub) {
      const stub = window.opnform
      Object.entries(stub._listeners || {}).forEach(([event, cbs]) => {
        cbs.forEach(cb => this.on(event, cb))
      })
      Object.entries(stub._onceListeners || {}).forEach(([event, cbs]) => {
        cbs.forEach(cb => this.once(event, cb))
      })
    }
    
    return this._forms[slug]
  }

  _handleMessage(event) {
    if (event.source !== window) return

    const data = event.data
    if (!data || typeof data !== 'object') return

    if (data.type && data.type.startsWith && data.type.startsWith(MSG_PREFIX)) {
      const messageType = data.type.replace(MSG_PREFIX, '')
      if (messageType === 'event') {
        this._handleEvent(data)
      }
    }
  }

  _handleEvent(message) {
    const { event, formSlug, payload } = message
    let form = this._forms[formSlug]

    if (!form && formSlug) {
      form = new LocalFormInstance(formSlug, this)
      this._forms[formSlug] = form
    }

    if (!form) return

    // Update internal state
    switch (event) {
      case EVENTS.READY:
        form._ready = true
        if (payload.data) form._cachedData = payload.data
        if (payload.currentPage) form._currentPage = payload.currentPage
        if (payload.darkMode !== undefined) form._darkMode = payload.darkMode
        break
      case EVENTS.DATA_CHANGE:
        form._cachedData = payload.data || {}
        break
      case EVENTS.ERROR:
      case EVENTS.SUBMIT_ERROR:
        form._cachedErrors = payload.errors || {}
        break
      case EVENTS.SUBMIT:
        form._cachedData = payload.data || {}
        break
      case EVENTS.PAGE_CHANGE:
      case EVENTS.NEXT_PAGE:
      case EVENTS.PREVIOUS_PAGE:
        if (payload.currentPage !== undefined) form._currentPage.index = payload.currentPage
        if (payload.toPage !== undefined) form._currentPage.index = payload.toPage
        if (payload.totalPages !== undefined) form._currentPage.total = payload.totalPages
        break
      case EVENTS.RESET:
        form._cachedData = {}
        form._cachedErrors = {}
        form._currentPage = { index: 0, total: form._currentPage.total }
        break
    }

    // Emit events
    const eventData = { form: form._getFormInfo(), ...payload }
    form.emit(event, eventData)
    this.emit(event, eventData)

    if (event === EVENTS.READY && this._options.onReady) {
      const allForms = Object.values(this._forms)
      if (allForms.every(f => f.isReady())) {
        this._options.onReady(allForms)
      }
    }
  }

  get(slugOrId) { 
    return this._forms[slugOrId] || null 
  }

  getAll() {
    return Object.values(this._forms)
  }

  isReady(slugOrId) {
    const form = this._forms[slugOrId]
    return form ? form.isReady() : false
  }

  create(slug, options = {}) {
    console.warn('[OpnForm SDK] create() not applicable for local SDK.')
    return null
  }
}

/**
 * Create and initialize the local SDK
 */
export function createLocalSDK() {
  if (typeof window === 'undefined') return null
  
  // Already initialized with real SDK
  if (window.opnform && window.opnform._isLocal) {
    return window.opnform
  }

  const sdk = new OpnFormLocalSDK()
  sdk._isLocal = true
  
  // Migrate from stub if exists
  if (window.opnform && window.opnform._isStub) {
    const stub = window.opnform
    
    // Copy global listeners
    Object.entries(stub._listeners || {}).forEach(([event, cbs]) => {
      cbs.forEach(cb => sdk.on(event, cb))
    })
    Object.entries(stub._onceListeners || {}).forEach(([event, cbs]) => {
      cbs.forEach(cb => sdk.once(event, cb))
    })
    
    // Copy form stubs
    Object.entries(stub._forms || {}).forEach(([slug, formStub]) => {
      if (!sdk._forms[slug]) {
        const instance = new LocalFormInstance(slug, sdk)
        Object.entries(formStub._listeners || {}).forEach(([event, cbs]) => {
          cbs.forEach(cb => instance.on(event, cb))
        })
        Object.entries(formStub._onceListeners || {}).forEach(([event, cbs]) => {
          cbs.forEach(cb => instance.once(event, cb))
        })
        sdk._forms[slug] = instance
      }
    })
  }
  
  sdk.init()
  return sdk
}

/**
 * Initialize local SDK for non-iframe custom code support
 */
function initLocalSDK() {
  if (typeof window === 'undefined') return null
  
  // Don't replace existing SDK (iframe SDK takes precedence)
  if (window.opnform && !window.opnform._isStub) return window.opnform
  
  const sdk = createLocalSDK()
  if (sdk) {
    window.opnform = sdk
  }
  return sdk
}

// ============================================================================
// SDK Bridge Composable (for form-parent communication)
// ============================================================================
function normalizeForPostMessage(value, seen = new WeakSet()) {
  if (isRef(value)) {
    return normalizeForPostMessage(unref(value), seen)
  }

  if (typeof window !== 'undefined' && value === window) {
    return '[Window]'
  }

  if (typeof document !== 'undefined' && value === document) {
    return '[Document]'
  }

  if (typeof Node !== 'undefined' && value instanceof Node) {
    if (value.nodeType === Node.TEXT_NODE) {
      return value.textContent || ''
    }
    return value.outerHTML || value.nodeName
  }

  if (value instanceof Error) {
    return {
      name: value.name,
      message: value.message,
      stack: value.stack
    }
  }

  if (value instanceof Date) {
    return value
  }

  if (value instanceof Map) {
    return Array.from(value.entries(), ([key, val]) => ([
      normalizeForPostMessage(key, seen),
      normalizeForPostMessage(val, seen)
    ]))
  }

  if (value instanceof Set) {
    return Array.from(value.values(), (val) => normalizeForPostMessage(val, seen))
  }

  if (typeof FormData !== 'undefined' && value instanceof FormData) {
    const entries = {}
    value.forEach((val, key) => {
      const normalized = normalizeForPostMessage(val, seen)
      if (normalized !== undefined) {
        entries[key] = normalized
      }
    })
    return entries
  }

  if (typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams) {
    return Object.fromEntries(value.entries())
  }

  if (typeof FileList !== 'undefined' && value instanceof FileList) {
    return Array.from(value, (file) => normalizeForPostMessage(file, seen))
  }

  if (typeof File !== 'undefined' && value instanceof File) {
    return value
  }

  if (typeof Blob !== 'undefined' && value instanceof Blob) {
    return value
  }

  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
    return value
  }

  if (Array.isArray(value)) {
    return value.map((item) => normalizeForPostMessage(item, seen))
  }

  if (value && typeof value === 'object') {
    const raw = toRaw(value)
    if (seen.has(raw)) return null
    seen.add(raw)

    const normalized = {}
    Object.entries(raw).forEach(([key, val]) => {
      const result = normalizeForPostMessage(val, seen)
      if (result !== undefined) {
        normalized[key] = result
      }
    })
    return normalized
  }

  if (typeof value === 'function' || typeof value === 'symbol') {
    return undefined
  }

  if (typeof value === 'bigint') {
    return value.toString()
  }

  return value
}

function makeCloneableMessage(message) {
  const normalized = normalizeForPostMessage(message)
  if (!normalized) return null

  if (typeof structuredClone === 'function') {
    try {
      return structuredClone(normalized)
    } catch (error) {
      if (error?.name !== 'DataCloneError') {
        throw error
      }
    }
  }

  try {
    return JSON.parse(JSON.stringify(normalized))
  } catch (error) {
    return {
      type: normalized?.type,
      event: normalized?.event,
      formSlug: normalized?.formSlug,
      payload: { error: 'Payload not cloneable' }
    }
  }
}
/**
 * Creates an SDK bridge for form-parent communication
 * @param {Object} options - Bridge options
 * @param {Ref} options.formConfig - Reactive form configuration
 * @param {Ref} options.formData - Reactive form data
 * @param {Ref} options.formErrors - Reactive form errors
 * @param {Object} options.formManager - Form manager instance
 * @param {Ref} options.darkMode - Dark mode state ref
 */
export function useSdkBridge(options) {
  const {
    formConfig,
    formData,
    formErrors,
    formManager,
    darkMode,
    attribution,
  } = options

  const isIframe = useIsIframe()
  let messageHandler = null
  let handshakeReceived = !isIframe
  let resolveHandshake = null
  const handshakePromise = handshakeReceived
    ? Promise.resolve()
    : new Promise((resolve) => {
        resolveHandshake = resolve
      })

  const initialSdkToken = typeof window !== 'undefined' ? readSdkTokenFromUrl() : null
  const initialTrustedOrigin = typeof window !== 'undefined'
    ? resolveInitialTrustedOrigin(isIframe)
    : null

  function postMessageSafe(target, message, origin) {
    try {
      target.postMessage(message, origin || WILDCARD_ORIGIN)
    } catch (error) {
      if (error?.name !== 'DataCloneError') {
        console.error('[OpnForm SDK Bridge] postMessage failed:', error)
      }
    }
  }

  function emitMessage(message) {
    const cloneableMessage = makeCloneableMessage(message)
    if (!cloneableMessage) return

    if (isIframe) {
      postMessageSafe(window.parent, cloneableMessage, bridgeMessaging.getPostTargetOrigin())
    }
    postMessageSafe(window, cloneableMessage, window.location.origin)
  }

  /**
   * Deep clone to convert reactive objects/proxies to plain objects
   * This is necessary because postMessage uses structured clone which cannot handle Proxies
   */
  function toPlainObject(obj) {
    if (obj === null || obj === undefined) return obj
    try {
      return JSON.parse(JSON.stringify(obj))
    } catch (e) {
      // If JSON serialization fails, return empty object
      console.warn('[OpnForm SDK] Failed to serialize payload:', e)
      return {}
    }
  }

  /**
   * Send event to parent window
   */
  function emitEvent(event, payload = {}) {
    if (!import.meta.client) return
    
    const config = toValue(formConfig)
    const message = {
      type: MSG_PREFIX + 'event',
      event: event,
      formSlug: config?.slug,
      payload: toPlainObject(payload)
    }

    emitMessage(message)
  }

  /**
   * Send response to parent window
   */
  function sendResponse(requestId, success, data = null, error = null) {
    if (!import.meta.client) return

    bridgeMessaging.sendResponse(
      requestId,
      success,
      toPlainObject(data),
      toPlainObject(error),
    )
  }

  /**
   * Handle incoming command from parent
   */
  function handleCommand(message, respond = sendResponse) {
    const { command, payload, requestId } = message
    const config = toValue(formConfig)
    
    // Verify this command is for our form
    if (message.formSlug !== config?.slug) return

    try {
      let result = null

      switch (command) {
        case 'setField':
          if (formManager?.form) {
            formManager.form[payload.fieldId] = payload.value
            result = { success: true }
          }
          break

        case 'setFields':
          if (formManager?.form && payload.data) {
            Object.entries(payload.data).forEach(([fieldId, value]) => {
              formManager.form[fieldId] = value
            })
            result = { success: true }
          }
          break

        case 'clearField':
          if (formManager?.form) {
            formManager.form[payload.fieldId] = null
            result = { success: true }
          }
          break

        case 'clearAll':
          if (formManager?.form) {
            formManager.form.reset()
            result = { success: true }
          }
          break

        case 'isFieldVisible':
          // Check field visibility from form manager's field state
          if (formManager?.fieldState) {
            const visible = formManager.fieldState.isFieldVisible(payload.fieldId)
            result = { visible: toValue(visible) }
          } else {
            result = { visible: true }
          }
          break

        case 'setDarkMode':
          {
            const enabled = payload.enabled
            if (enabled === 'auto') {
              handleDarkMode('auto')
            } else {
              handleDarkMode(enabled ? 'dark' : 'light')
            }
            result = { success: true }
          }
          break

        case 'setTheme':
          // Future enhancement
          result = { success: false, error: 'Not implemented' }
          break

        case 'goToPage':
          if (formManager?.goToPage) {
            formManager.goToPage(payload.index)
            result = { success: true }
          } else if (formManager?.state) {
            formManager.state.currentPage = payload.index
            result = { success: true }
          }
          break

        case 'nextPage':
          if (formManager?.nextPage) {
            formManager.nextPage()
            result = { success: true }
          }
          break

        case 'previousPage':
          if (formManager?.previousPage) {
            formManager.previousPage()
            result = { success: true }
          }
          break

        case 'submit':
          if (formManager?.submit) {
            formManager.submit()
              .then(() => respond(requestId, true, { success: true }))
              .catch((err) => respond(requestId, false, null, err?.message || 'Submit failed'))
            return
          }
          break

        case 'reset':
          if (formManager?.restart) {
            formManager.restart()
            result = { success: true }
          } else if (formManager?.form) {
            formManager.form.reset()
            result = { success: true }
          }
          break

        case 'focusFirstError':
          // Find and focus first field with error
          if (formManager?.form?.errors) {
            const errors = formManager.form.errors.all()
            const firstField = Object.keys(errors)[0]
            if (firstField) {
              const element = document.querySelector(`[name="${firstField}"], #${firstField}`)
              if (element) {
                element.focus()
                element.scrollIntoView({ behavior: 'smooth', block: 'center' })
              }
            }
            result = { success: true }
          }
          break

        default:
          result = { success: false, error: 'Unknown command: ' + command }
      }

      if (result !== null) {
        respond(requestId, result.success !== false, result)
      }
    } catch (e) {
      console.error('[OpnForm SDK Bridge] Command error:', e)
      respond(requestId, false, null, e.message)
    }
  }

  const bridgeMessaging = createSdkBridgeMessageHandler({
    isIframe,
    getFormSlug: () => toValue(formConfig)?.slug,
    initialSdkToken,
    initialTrustedOrigin,
    postToParent: (message, origin) => {
      if (!import.meta.client || !isIframe) return
      postMessageSafe(window.parent, message, origin)
    },
    onCommand: handleCommand,
    onHandshake: (trackingParameters) => {
      formManager?.mergeParentAttribution?.(trackingParameters)
      handshakeReceived = true
      resolveHandshake?.()
      resolveHandshake = null
    },
  })

  function waitForHandshake(timeoutMs = 3000) {
    if (!import.meta.client || handshakeReceived) return Promise.resolve()

    return new Promise((resolve) => {
      const timeoutId = setTimeout(resolve, timeoutMs)
      handshakePromise.then(() => {
        clearTimeout(timeoutId)
        resolve()
      })
    })
  }

  /**
   * Handle incoming messages
   */
  function onMessage(event) {
    bridgeMessaging.onMessage(event)
  }

  /**
   * Emit ready event with initial state
   */
  function emitReady() {
    const config = toValue(formConfig)
    const data = toValue(formData) || {}
    const pageCount = formManager?.structure?.value?.pageCount?.value || 1
    const currentPage = formManager?.state?.currentPage || 0

    emitEvent(EVENTS.READY, {
      slug: config?.slug,
      id: config?.id,
      data: data,
      currentPage: { index: currentPage, total: pageCount },
      darkMode: toValue(darkMode)
    })
  }

  /**
   * Set up watchers for reactive data
   */
  function setupWatchers() {
    // Watch form data changes
    if (formData) {
      let previousData = JSON.stringify(toValue(formData) || {})
      
      watch(formData, (newData) => {
        const newDataStr = JSON.stringify(newData || {})
        if (newDataStr !== previousData) {
          // Find what changed
          const oldData = JSON.parse(previousData)
          let changedField = null
          let previousValue = null
          let newValue = null

          for (const key of Object.keys(newData || {})) {
            if (JSON.stringify(oldData[key]) !== JSON.stringify(newData[key])) {
              changedField = key
              previousValue = oldData[key]
              newValue = newData[key]
              break
            }
          }

          emitEvent(EVENTS.DATA_CHANGE, {
            data: newData,
            changedField,
            previousValue,
            newValue
          })

          previousData = newDataStr
        }
      }, { deep: true })
    }

    // Watch form errors
    if (formErrors) {
      watch(formErrors, (errors) => {
        if (errors && Object.keys(errors).length > 0) {
          emitEvent(EVENTS.ERROR, { errors })
        }
      }, { deep: true })
    }

    // Watch page changes
    if (formManager?.state) {
      let previousPage = formManager.state.currentPage
      
      watch(() => formManager.state.currentPage, (newPage) => {
        if (newPage !== previousPage) {
          const totalPages = formManager.structure?.value?.pageCount?.value || 1
          
          emitEvent(EVENTS.PAGE_CHANGE, {
            fromPage: previousPage,
            toPage: newPage,
            currentPage: newPage,
            totalPages
          })

          if (newPage > previousPage) {
            emitEvent(EVENTS.NEXT_PAGE, { currentPage: newPage, totalPages })
          } else {
            emitEvent(EVENTS.PREVIOUS_PAGE, { currentPage: newPage, totalPages })
          }

          previousPage = newPage
        }
      })
    }
  }

  // --- Public API ---
  function onSubmitStart() {
    emitEvent(EVENTS.SUBMIT_START, {})
  }

  function onSubmitSuccess(submissionData) {
    const trackingParameters = toValue(attribution) || {}
    emitEvent(EVENTS.SUBMIT, {
      data: submissionData.data || toValue(formData),
      submissionId: submissionData.submissionId,
      completionTime: submissionData.completionTime,
      ...(Object.keys(trackingParameters).length > 0
        ? { meta: { attribution: trackingParameters } }
        : {}),
    })
  }

  function onSubmitError(errors) {
    emitEvent(EVENTS.SUBMIT_ERROR, { errors })
  }

  function onReset() {
    emitEvent(EVENTS.RESET, {})
  }

  // Lifecycle
  onMounted(() => {
    if (!import.meta.client) return

    messageHandler = onMessage
    window.addEventListener('message', messageHandler)
    setupWatchers()

    // Initialize local SDK for custom code support
    const localSDK = initLocalSDK()
    if (localSDK && localSDK._registerForm) {
      const config = toValue(formConfig)
      if (config?.slug) {
        localSDK._registerForm(config.slug, {
          formManager,
          formConfig,
          formData,
          formErrors,
          darkMode
        })
      }
    }

    // Emit ready after short delay
    setTimeout(() => emitReady(), 100)
  })

  onUnmounted(() => {
    if (messageHandler) {
      window.removeEventListener('message', messageHandler)
    }
  })

  return {
    emitEvent,
    onSubmitStart,
    onSubmitSuccess,
    onSubmitError,
    onReset,
    waitForHandshake,
    EVENTS
  }
}

// Export for external use
export { OpnFormLocalSDK, EVENTS }