tgo-widget-miniprogram 1.0.0

package/miniprogram_dist/services/wukongim.js

@@ -0,0 +1,183 @@
+/**
+ * WuKongIM EasyJSSDK wrapper for miniprogram
+ * easyjssdk v1.1.0+ natively supports WeChat MiniProgram WebSocket
+ */
+var WKIM = require('easyjssdk').WKIM
+var WKIMEvent = require('easyjssdk').WKIMEvent
+var adapter = require('../adapters/request')
+
+function WuKongIMService() {
+  this._inited = false
+  this._im = null
+  this._cfg = null
+  this._uid = null
+  this._bound = false
+  this._hConnect = null
+  this._hDisconnect = null
+  this._hError = null
+  this._hMessage = null
+  this._hCustom = null
+  this._msgListeners = []
+  this._statusListeners = []
+  this._customListeners = []
+}
+
+WuKongIMService.prototype.isReady = function () {
+  return this._inited && !!this._im && !!this._cfg
+}
+
+WuKongIMService.prototype.getUid = function () {
+  return this._uid
+}
+
+WuKongIMService.prototype.init = function (opts) {
+  var self = this
+  this._cfg = Object.assign({}, opts, { channelType: opts.channelType || 'person' })
+  this._uid = opts.uid
+
+  return this._fetchRouteWsAddr(opts.apiBase, opts.uid, 10000).then(function (wsAddr) {
+    if (self._im && self._bound) {
+      try { self._unbindInternalEvents() } catch (e) {}
+    }
+    self._im = WKIM.init(wsAddr, { uid: opts.uid, token: opts.token || '' })
+    self._bindInternalEvents()
+    self._inited = true
+  })
+}
+
+WuKongIMService.prototype._bindInternalEvents = function () {
+  if (!this._im || this._bound) return
+  var self = this
+
+  this._hConnect = function (result) { self._emitStatus('connected', result) }
+  this._hDisconnect = function (info) { self._emitStatus('disconnected', info) }
+  this._hError = function (err) { self._emitStatus('error', err) }
+  this._hMessage = function (message) { self._emitMessage(message) }
+  this._hCustom = function (ev) { self._emitCustom(ev) }
+
+  this._im.on(WKIMEvent.Connect, this._hConnect)
+  this._im.on(WKIMEvent.Disconnect, this._hDisconnect)
+  this._im.on(WKIMEvent.Error, this._hError)
+  this._im.on(WKIMEvent.Message, this._hMessage)
+  this._im.on(WKIMEvent.CustomEvent, this._hCustom)
+  this._bound = true
+}
+
+WuKongIMService.prototype._unbindInternalEvents = function () {
+  if (!this._im || !this._bound) return
+  if (this._hConnect) this._im.off(WKIMEvent.Connect, this._hConnect)
+  if (this._hDisconnect) this._im.off(WKIMEvent.Disconnect, this._hDisconnect)
+  if (this._hError) this._im.off(WKIMEvent.Error, this._hError)
+  if (this._hMessage) this._im.off(WKIMEvent.Message, this._hMessage)
+  if (this._hCustom) this._im.off(WKIMEvent.CustomEvent, this._hCustom)
+  this._hConnect = this._hDisconnect = this._hError = this._hMessage = this._hCustom = null
+  this._bound = false
+}
+
+WuKongIMService.prototype._emitMessage = function (m) {
+  this._msgListeners.forEach(function (fn) { try { fn(m) } catch (e) {} })
+}
+
+WuKongIMService.prototype._emitStatus = function (s, info) {
+  this._statusListeners.forEach(function (fn) { try { fn(s, info) } catch (e) {} })
+}
+
+WuKongIMService.prototype._emitCustom = function (e) {
+  this._customListeners.forEach(function (fn) { try { fn(e) } catch (e2) {} })
+}
+
+WuKongIMService.prototype.onMessage = function (cb) {
+  this._msgListeners.push(cb)
+  var self = this
+  return function () {
+    var idx = self._msgListeners.indexOf(cb)
+    if (idx >= 0) self._msgListeners.splice(idx, 1)
+  }
+}
+
+WuKongIMService.prototype.onStatus = function (cb) {
+  this._statusListeners.push(cb)
+  var self = this
+  return function () {
+    var idx = self._statusListeners.indexOf(cb)
+    if (idx >= 0) self._statusListeners.splice(idx, 1)
+  }
+}
+
+WuKongIMService.prototype.onCustom = function (cb) {
+  this._customListeners.push(cb)
+  var self = this
+  return function () {
+    var idx = self._customListeners.indexOf(cb)
+    if (idx >= 0) self._customListeners.splice(idx, 1)
+  }
+}
+
+WuKongIMService.prototype.connect = function () {
+  if (!this._im) throw new Error('WuKongIMService not initialized')
+  this._emitStatus('connecting')
+  return this._im.connect()
+}
+
+WuKongIMService.prototype.disconnect = function () {
+  if (!this._im) return Promise.resolve()
+  if (typeof this._im.disconnect === 'function') {
+    try { return this._im.disconnect() } catch (e) { return Promise.resolve() }
+  }
+  return Promise.resolve()
+}
+
+WuKongIMService.prototype._fetchRouteWsAddr = function (apiBase, uid, timeoutMs) {
+  var base = apiBase.endsWith('/') ? apiBase : apiBase + '/'
+  var url = base + 'v1/wukongim/route?uid=' + encodeURIComponent(uid)
+
+  return adapter.request({
+    url: url,
+    method: 'GET',
+    timeout: timeoutMs || 10000
+  }).then(function (res) {
+    if (!res.ok) throw new Error('route HTTP ' + res.status)
+    return res.json().then(function (data) {
+      // Priority 1: wss_addr
+      if (data && data.wss_addr && typeof data.wss_addr === 'string' && data.wss_addr.trim()) {
+        return data.wss_addr.trim()
+      }
+      // Priority 2: ws_addr fallbacks
+      var addr = data.ws_addr || data.ws || data.ws_url || data.wsAddr || data.websocket
+      if (!addr && data.wss) addr = data.wss
+      if (!addr || typeof addr !== 'string') throw new Error('missing ws address')
+      var wsAddr = String(addr)
+      if (/^http(s)?:/i.test(wsAddr)) wsAddr = wsAddr.replace(/^http/i, 'ws')
+      return wsAddr
+    })
+  }).catch(function (e) {
+    var msg = e && e.message ? String(e.message) : String(e)
+    throw new Error('[WuKongIM] route fetch failed: ' + msg)
+  })
+}
+
+WuKongIMService.prototype.sendText = function (text, opts) {
+  if (!this._im || !this._cfg) throw new Error('WuKongIMService not ready')
+  opts = opts || {}
+  var to = opts.to || this._cfg.target
+  var payload = { type: 1, content: text }
+  return this._im.send(to, opts.channelType || 251, payload, {
+    clientMsgNo: opts.clientMsgNo,
+    header: opts.header
+  })
+}
+
+WuKongIMService.prototype.sendPayload = function (payload, opts) {
+  if (!this._im || !this._cfg) throw new Error('WuKongIMService not ready')
+  opts = opts || {}
+  var to = opts.to || this._cfg.target
+  return this._im.send(to, opts.channelType || 251, payload, {
+    clientMsgNo: opts.clientMsgNo,
+    header: opts.header
+  })
+}
+
+// Singleton
+var instance = new WuKongIMService()
+
+module.exports = instance

package/miniprogram_dist/utils/jsonRender.js

@@ -0,0 +1,158 @@
+/**
+ * json-render utilities for miniprogram
+ * Ported from @json-render/react (buildSpecFromParts, groupParts)
+ * and tgo-widget-app JSONRenderSurface (formatActionMessage, collectActionNames)
+ */
+var core = require('@json-render/core')
+
+// Re-export core functions
+var createMixedStreamParser = core.createMixedStreamParser
+var createStateStore = core.createStateStore
+var applySpecPatch = core.applySpecPatch
+var nestedToFlat = core.nestedToFlat
+
+var SPEC_DATA_PART_TYPE = 'data-' + (core.SPEC_DATA_PART || 'spec')
+
+// ---- buildSpecFromParts ----
+// Ported from @json-render/react buildSpecFromParts
+function isSpecDataPart(data) {
+  if (typeof data !== 'object' || data === null) return false
+  switch (data.type) {
+    case 'patch':
+      return typeof data.patch === 'object' && data.patch !== null
+    case 'flat':
+    case 'nested':
+      return typeof data.spec === 'object' && data.spec !== null
+    default:
+      return false
+  }
+}
+
+function buildSpecFromParts(parts) {
+  var spec = { root: '', elements: {} }
+  var hasSpec = false
+  for (var i = 0; i < parts.length; i++) {
+    var part = parts[i]
+    if (part.type === SPEC_DATA_PART_TYPE) {
+      if (!isSpecDataPart(part.data)) continue
+      var payload = part.data
+      if (payload.type === 'patch') {
+        hasSpec = true
+        applySpecPatch(spec, payload.patch)
+      } else if (payload.type === 'flat') {
+        hasSpec = true
+        Object.assign(spec, payload.spec)
+      } else if (payload.type === 'nested') {
+        hasSpec = true
+        var flat = nestedToFlat(payload.spec)
+        Object.assign(spec, flat)
+      }
+    }
+  }
+  return hasSpec ? spec : null
+}
+
+// ---- groupParts ----
+// Ported from JSONRenderMessage.tsx groupParts
+function groupParts(parts) {
+  var groups = []
+  for (var i = 0; i < parts.length; i++) {
+    var part = parts[i]
+    if (part.type === 'text') {
+      var last = groups.length > 0 ? groups[groups.length - 1] : null
+      if (last && last.type === 'text') {
+        last.text += part.text || ''
+      } else {
+        groups.push({ type: 'text', text: part.text || '' })
+      }
+    } else {
+      var lastG = groups.length > 0 ? groups[groups.length - 1] : null
+      if (lastG && lastG.type === 'spec') {
+        lastG.parts.push(part)
+      } else {
+        groups.push({ type: 'spec', parts: [part] })
+      }
+    }
+  }
+  return groups
+}
+
+// ---- collectActionNames ----
+// Ported from JSONRenderSurface.tsx
+var BUILTIN_ACTIONS = { setState: 1, pushState: 1, removeState: 1, validateForm: 1 }
+
+function collectActionNames(spec) {
+  if (!spec) return []
+  var names = {}
+  var elements = spec.elements || {}
+  var keys = Object.keys(elements)
+  for (var i = 0; i < keys.length; i++) {
+    var element = elements[keys[i]]
+    if (!element) continue
+    var events = element.on
+    if (!events || typeof events !== 'object') continue
+    var evKeys = Object.keys(events)
+    for (var j = 0; j < evKeys.length; j++) {
+      var binding = events[evKeys[j]]
+      if (Array.isArray(binding)) {
+        for (var k = 0; k < binding.length; k++) {
+          if (binding[k] && typeof binding[k].action === 'string') {
+            names[binding[k].action] = true
+          }
+        }
+        continue
+      }
+      if (binding && typeof binding.action === 'string') {
+        names[binding.action] = true
+      }
+    }
+  }
+  var result = []
+  var nameKeys = Object.keys(names)
+  for (var n = 0; n < nameKeys.length; n++) {
+    if (!BUILTIN_ACTIONS[nameKeys[n]]) {
+      result.push(nameKeys[n])
+    }
+  }
+  return result
+}
+
+// ---- formatActionMessage ----
+// Ported from JSONRenderSurface.tsx
+function formatActionMessage(actionName, params, state) {
+  var parts = ['[' + actionName + ']']
+  if (params) {
+    var pKeys = Object.keys(params)
+    for (var i = 0; i < pKeys.length; i++) {
+      var v = params[pKeys[i]]
+      if (v != null && v !== '') parts.push(pKeys[i] + ': ' + v)
+    }
+  }
+  if (state) {
+    var sKeys = Object.keys(state)
+    for (var j = 0; j < sKeys.length; j++) {
+      var sv = state[sKeys[j]]
+      if (typeof sv === 'object' && sv !== null) {
+        var fKeys = Object.keys(sv)
+        for (var k = 0; k < fKeys.length; k++) {
+          var fv = sv[fKeys[k]]
+          if (fv != null && fv !== '') parts.push(fKeys[k] + ': ' + fv)
+        }
+      } else if (sv != null && sv !== '') {
+        parts.push(sKeys[j] + ': ' + sv)
+      }
+    }
+  }
+  return parts.join('\n')
+}
+
+module.exports = {
+  createMixedStreamParser: createMixedStreamParser,
+  createStateStore: createStateStore,
+  applySpecPatch: applySpecPatch,
+  nestedToFlat: nestedToFlat,
+  buildSpecFromParts: buildSpecFromParts,
+  groupParts: groupParts,
+  collectActionNames: collectActionNames,
+  formatActionMessage: formatActionMessage
+}

package/miniprogram_dist/utils/markdown.js

@@ -0,0 +1,31 @@
+/**
+ * Markdown to HTML using marked
+ * Output is used with <rich-text> component
+ */
+var marked = require('marked')
+
+// Configure marked for simple output
+marked.setOptions({
+  breaks: true,
+  gfm: true
+})
+
+/**
+ * Parse markdown string to HTML (safe for rich-text)
+ * rich-text does its own sanitization so no DOMPurify needed
+ */
+function parseMarkdown(text) {
+  if (!text) return ''
+  try {
+    var html = marked.parse(text)
+    // Remove outer <p> wrapper for simple single-paragraph text
+    if (typeof html === 'string') {
+      return html.trim()
+    }
+    return String(html || '')
+  } catch (e) {
+    return text
+  }
+}
+
+module.exports = { parseMarkdown: parseMarkdown }

package/miniprogram_dist/utils/time.js

@@ -0,0 +1,85 @@
+/**
+ * Time formatting utilities (ported from widget-app)
+ */
+var i18n = require('../core/i18n')
+
+function formatMessageTime(input) {
+  var msgDate = normalizeToDate(input)
+  if (!msgDate) return ''
+
+  var now = new Date()
+  var diff = now.getTime() - msgDate.getTime()
+
+  var lang = i18n.getLang()
+
+  // < 1 minute
+  if (diff < 60 * 1000) return lang === 'zh' ? '刚才' : 'Just now'
+
+  // < 1 hour
+  if (diff < 60 * 60 * 1000) {
+    var minutes = Math.floor(diff / (60 * 1000))
+    return lang === 'zh' ? minutes + '分钟前' : minutes + 'm ago'
+  }
+
+  var startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 0, 0, 0, 0)
+  var startOfYesterday = new Date(startOfToday.getTime() - 24 * 60 * 60 * 1000)
+
+  // Today
+  if (msgDate >= startOfToday) {
+    return fmt(msgDate, 'HH:mm')
+  }
+
+  // Yesterday
+  if (msgDate >= startOfYesterday) {
+    var prefix = lang === 'zh' ? '昨天' : 'Yesterday'
+    return prefix + ' ' + fmt(msgDate, 'HH:mm')
+  }
+
+  // Within 7 days
+  var sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
+  if (msgDate > sevenDaysAgo) {
+    var weekday = lang === 'zh' ? weekdayCN(msgDate) : weekdayEN(msgDate)
+    return weekday + ' ' + fmt(msgDate, 'HH:mm')
+  }
+
+  // Same year
+  if (msgDate.getFullYear() === now.getFullYear()) {
+    return fmt(msgDate, 'MM-DD HH:mm')
+  }
+
+  // Cross year
+  return fmt(msgDate, 'YYYY-MM-DD HH:mm')
+}
+
+function normalizeToDate(input) {
+  if (input instanceof Date) return input
+  if (typeof input === 'number' && isFinite(input)) {
+    var ms = input < 1e12 ? input * 1000 : input
+    var d = new Date(ms)
+    return isNaN(d.getTime()) ? null : d
+  }
+  return null
+}
+
+function pad(n) { return n < 10 ? '0' + n : String(n) }
+
+function fmt(d, pattern) {
+  var Y = d.getFullYear()
+  var M = pad(d.getMonth() + 1)
+  var D = pad(d.getDate())
+  var h = pad(d.getHours())
+  var m = pad(d.getMinutes())
+  if (pattern === 'HH:mm') return h + ':' + m
+  if (pattern === 'MM-DD HH:mm') return M + '-' + D + ' ' + h + ':' + m
+  return Y + '-' + M + '-' + D + ' ' + h + ':' + m
+}
+
+function weekdayCN(d) {
+  return ['星期日','星期一','星期二','星期三','星期四','星期五','星期六'][d.getDay()]
+}
+
+function weekdayEN(d) {
+  return ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'][d.getDay()]
+}
+
+module.exports = { formatMessageTime: formatMessageTime }

package/miniprogram_dist/utils/uid.js

@@ -0,0 +1,11 @@
+/**
+ * Generate unique clientMsgNo
+ */
+function generateClientMsgNo(prefix) {
+  var p = prefix || 'cmn'
+  var ts = Date.now()
+  var rand = Math.random().toString(36).slice(2, 8)
+  return p + '-' + ts + '-' + rand
+}
+
+module.exports = { generateClientMsgNo: generateClientMsgNo }

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "tgo-widget-miniprogram",
+  "version": "1.0.0",
+  "description": "TGO visitor chat widget for WeChat Mini Program",
+  "miniprogram": "miniprogram_dist",
+  "main": "miniprogram_dist/chat/index.js",
+  "files": [
+    "miniprogram_dist"
+  ],
+  "scripts": {
+    "build": "node tools/build.js",
+    "ci:pack-npm": "node tools/build.js && cd example && node ci.js pack-npm",
+    "ci:compile": "node tools/build.js && cd example && node ci.js compile",
+    "ci:preview": "node tools/build.js && cd example && node ci.js preview",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "wechat",
+    "miniprogram",
+    "chat",
+    "widget",
+    "tgo"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@json-render/core": "^0.11.0",
+    "easyjssdk": "^2.0.0",
+    "marked": "^16.4.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.29.0",
+    "@babel/preset-env": "^7.29.0",
+    "miniprogram-ci": "^2.1.26"
+  }
+}