@juzi/wechaty 1.0.0

package/src/wechaty/wechaty-base.spec.ts

@@ -0,0 +1,392 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/wechaty
+ *
+ *   @copyright 2016 Huan LI (李卓桓) <https://github.com/huan>, and
+ *                   Wechaty Contributors <https://github.com/wechaty>.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+import {
+  test,
+  sinon,
+}              from 'tstest'
+
+import { MemoryCard } from 'memory-card'
+import { PuppetMock } from 'wechaty-puppet-mock'
+
+/**
+ * Huan(202111): must import `./wechaty-impl.js`
+ *  before import `./wechaty-base.js`
+ *
+ * Or will throw error:
+ *
+ *    ReferenceError: Cannot access 'WechatyBase' before initialization
+ *    at file:///home/huan/git/wechaty/wechaty/src/wechaty/wechaty-impl.ts:25:47
+ *
+ * TODO: find out why
+ */
+import './wechaty-impl.js'
+
+import type {
+  WechatyBaseProtectedProperty,
+}                                 from './wechaty-base.js'
+import {
+  WechatyBase,
+}                                 from './wechaty-base.js'
+
+import type {
+  WechatyInterface,
+}                           from '../wechaty/wechaty-impl.js'
+import { WechatySkeleton }  from './wechaty-skeleton.js'
+
+class WechatyTest extends WechatyBase {
+}
+
+test('static VERSION', async t => {
+  t.ok('VERSION' in WechatyBase, 'Wechaty should has a static VERSION property')
+})
+
+test('event:start/stop', async t => {
+  const wechaty = new WechatyBase({ puppet: 'wechaty-puppet-mock' })
+
+  const startSpy = sinon.spy()
+  const stopSpy  = sinon.spy()
+
+  wechaty.on('start', startSpy)
+  wechaty.on('stop',  stopSpy)
+
+  await wechaty.start()
+  await wechaty.stop()
+
+  // console.log(startSpy.callCount)
+  t.ok(startSpy.calledOnce, 'should get event:start once')
+  t.ok(stopSpy.calledOnce,  'should get event:stop once')
+})
+
+//
+// FIXME: restore this unit test !!!
+//
+// test.only('event:scan', async t => {
+//   const m = {} as any
+
+//   const asyncHook = asyncHooks.createHook({
+//     init(asyncId: number, type: string, triggerAsyncId: number, resource: Object) {
+//       m[asyncId] = type
+//     },
+//     before(asyncId) {
+//       // delete m[asyncId]
+//     },
+//     after(asyncId) {
+//       // delete m[asyncId]
+//     },
+//     destroy(asyncId) {
+//       delete m[asyncId]
+//     },
+//   })
+//   asyncHook.enable()
+
+//   const wechaty = Wechaty.instance()
+
+//   const spy = sinon.spy()
+
+//   wechaty.on('scan', spy)
+
+//   const scanFuture  = new Promise(resolve => wechaty.once('scan', resolve))
+//   // wechaty.once('scan', () => console.log('FAINT'))
+
+//   await wechaty.start()
+//   await scanFuture
+//   // await new Promise(r => setTimeout(r, 1000))
+//   await wechaty.stop()
+
+//   t.ok(spy.calledOnce, 'should get event:scan')
+//   asyncHook.disable()
+
+//   console.log(m)
+// })
+
+test.skip('SKIP DEALING WITH THE LISTENER EXCEPTIONS. on(event, Function)', async t => {
+  const spy     = sinon.spy()
+  const wechaty = new WechatyBase()
+
+  const EXPECTED_ERROR = new Error('testing123')
+  wechaty.on('message', () => { throw EXPECTED_ERROR })
+  // wechaty.on('scan',    () => 42)
+  wechaty.on('error',   spy)
+
+  const messageFuture  = new Promise(resolve => wechaty.once('message', resolve))
+  wechaty.emit('message', {} as any)
+
+  await messageFuture
+  await wechaty.stop()
+
+  t.ok(spy.calledOnce, 'should get event:error once')
+  t.equal(spy.firstCall.args[0], EXPECTED_ERROR, 'should get error from message listener')
+
+})
+
+test.skip('SKIP DEALING WITH THE LISTENER EXCEPTIONS. test async error', async t => {
+
+  // Do not modify the global Wechaty instance
+  class MyWechatyTest extends WechatyBase {}
+
+  const EXPECTED_ERROR = new Error('test')
+
+  const bot = new MyWechatyTest({
+    puppet: new PuppetMock(),
+  })
+
+  const asyncErrorFunction = function () {
+    return new Promise<void>((resolve, reject) => {
+      setTimeout(function () {
+        reject(EXPECTED_ERROR)
+      }, 100)
+      // tslint ask resolve must be called,
+      // so write a falsy value, so that it never called
+      if (+new Date() < 0) {
+        resolve()
+      }
+    })
+  }
+
+  bot.on('message', async () => {
+    await asyncErrorFunction()
+  })
+  bot.on('error', (e) => {
+    t.ok(e.message === EXPECTED_ERROR.message)
+  })
+
+  bot.emit('message', {} as any)
+
+  await bot.stop()
+})
+
+test('use plugin', async t => {
+
+  // Do not modify the gloabl Wechaty instance
+  class MyWechatyTest extends WechatyBase {}
+
+  let result = ''
+
+  // const myGlobalPlugin = function () {
+  //   return function (bot: WechatyInterface) {
+  //     bot.on('message', () => { result += 'FROM_GLOBAL_PLUGIN:' })
+  //   }
+  // }
+
+  const myPlugin = function () {
+    return function (bot: WechatyInterface) {
+      bot.on('message', () => { result += 'FROM_MY_PLUGIN:' })
+    }
+  }
+
+  // MyWechatyTest.use(myGlobalPlugin())
+
+  const bot = new MyWechatyTest({
+    puppet: new PuppetMock(),
+  })
+
+  bot.use(myPlugin())
+
+  await bot.start()
+
+  bot.on('message', () => (result += 'FROM_BOT'))
+
+  bot.emit('message', {} as any)
+
+  await bot.stop()
+
+  t.equal(result, 'FROM_MY_PLUGIN:FROM_BOT', 'should get plugin works')
+
+})
+
+test('wechatifyUserModules init()', async t => {
+  const wechatyTest = new WechatyTest()
+
+  t.doesNotThrow(() => wechatyTest.init(), 'should not throw for the 1st time init')
+  t.doesNotThrow(() => wechatyTest.init(), 'should not throw for the 2nd time init (silence skip)')
+})
+
+// TODO: add test for event args
+
+test('Perfect restart', async t => {
+  const wechaty = new WechatyBase({
+    puppet: new PuppetMock(),
+  })
+
+  try {
+    for (let i = 0; i < 3; i++) {
+      await wechaty.start()
+      await wechaty.stop()
+      t.pass('start/stop-ed at #' + i)
+    }
+    t.pass('Wechaty start/restart successed.')
+  } catch (e) {
+    t.fail(e as any)
+  }
+
+})
+
+test('@event ready', async t => {
+  const puppet  = new PuppetMock()
+  const wechaty = new WechatyBase({ puppet })
+
+  const sandbox = sinon.createSandbox()
+  const spy     = sandbox.spy()
+
+  wechaty.on('ready', spy)
+  t.ok(spy.notCalled, 'should no ready event with new wechaty instance')
+
+  await wechaty.start()
+  t.ok(spy.notCalled, 'should no ready event right start wechaty started')
+
+  puppet.emit('ready', { data: 'test' })
+  t.equal(spy.callCount, 1, 'should fire ready event after puppet ready')
+
+  await wechaty.stop()
+  await wechaty.start()
+  t.equal(spy.callCount, 1, 'should fire ready event second time after stop/start wechaty')
+
+  puppet.emit('ready', { data: 'test' })
+
+  t.equal(spy.callCount, 2, 'should fire ready event third time after stop/start wechaty')
+
+  await wechaty.stop()
+})
+
+test('ready()', async t => {
+  const puppet = new PuppetMock()
+  const wechaty = new WechatyBase({ puppet })
+
+  const sandbox = sinon.createSandbox()
+
+  const spy = sandbox.spy()
+
+  wechaty.ready()
+    .then(spy)
+    .catch(e => t.fail('rejection: ' + e))
+
+  t.ok(spy.notCalled, 'should not ready with new wechaty instance')
+
+  await wechaty.start()
+
+  t.ok(spy.notCalled, 'should not ready after right start wechaty')
+
+  puppet.emit('ready', { data: 'test' })
+  await new Promise(resolve => setImmediate(resolve))
+  t.ok(spy.calledOnce, 'should ready after puppet ready')
+
+  await wechaty.stop()
+  await wechaty.start()
+  wechaty.ready()
+    .then(spy)
+    .catch(e => t.fail('rejection: ' + e))
+
+  puppet.emit('ready', { data: 'test' })
+  await new Promise(resolve => setImmediate(resolve))
+  t.ok(spy.calledTwice, 'should ready again after stop/start wechaty')
+
+  await wechaty.stop()
+})
+
+test('on/off event listener management', async t => {
+  const puppet = new PuppetMock()
+  const wechaty = new WechatyBase({ puppet })
+
+  const onMessage = (_: any) => {}
+  t.equal(wechaty.listenerCount('message'), 0, 'should no listener after initializing')
+
+  wechaty.on('message', onMessage)
+  t.equal(wechaty.listenerCount('message'), 1, 'should +1 listener after on(message)')
+
+  wechaty.off('message', onMessage)
+  t.equal(wechaty.listenerCount('message'), 0, 'should -1 listener after off(message)')
+})
+
+test('wrapAsync() async function', async t => {
+  const puppet = new PuppetMock()
+  const wechaty = new WechatyBase({ puppet })
+
+  const spy = sinon.spy()
+  wechaty.on('error', spy)
+
+  const DATA = 'test'
+  const asyncFunc = async () => DATA
+  const syncFunc = wechaty.wrapAsync(asyncFunc)
+
+  t.notOk(syncFunc(), 'should get sync function return void')
+  t.ok(spy.notCalled, 'should not emit error when sync function return value')
+
+  const asyncFunc2 = async () => { throw new Error('test') }
+  const syncFunc2 = wechaty.wrapAsync(asyncFunc2)
+  t.doesNotThrow(() => syncFunc2(), 'should not throw when async function throw error')
+  await wechaty.sleep(0)  // wait async event loop task to be executed
+  t.ok(spy.calledOnce, 'should emit error when async function throw error')
+})
+
+test('wrapAsync() promise', async t => {
+  const puppet = new PuppetMock()
+  const wechaty = new WechatyBase({ puppet })
+
+  const spy = sinon.spy()
+  wechaty.on('error', spy)
+
+  const DATA = 'test'
+  const promise = Promise.resolve(DATA)
+  const wrappedPromise = wechaty.wrapAsync(promise)
+  t.equal(await wrappedPromise, undefined, 'should resolve Promise<any> to void')
+
+  const rejection = Promise.reject(new Error('test'))
+  const wrappedRejection = wechaty.wrapAsync(rejection)
+  t.equal(wrappedRejection, undefined, 'should be void and not to reject')
+
+  t.equal(spy.callCount, 0, 'should have no error before sleep')
+  await wechaty.sleep(0)  // wait async event loop task to be executed
+  t.equal(spy.callCount, 1, 'should emit error when promise reject with error')
+})
+
+test('WechatyBaseProtectedProperty', async t => {
+  type NotExistInMixin = Exclude<WechatyBaseProtectedProperty, keyof WechatyBase | `_${string}`>
+  type NotExistTest = NotExistInMixin extends never ? true : false
+
+  const noOneLeft: NotExistTest = true
+  t.ok(noOneLeft, 'should match Wechaty properties for every protected property')
+})
+
+test('WechatySkeleton: super.{start,stop}()', async t => {
+  const sandbox = sinon.createSandbox()
+
+  const puppet = new PuppetMock()
+  const memory = new MemoryCard()
+
+  const wechaty = new WechatyTest({
+    memory,
+    puppet,
+  })
+
+  const startStub = sandbox.stub(WechatySkeleton.prototype, 'start').resolves()
+  const stopStub  = sandbox.stub(WechatySkeleton.prototype, 'stop').resolves()
+
+  t.ok(startStub.notCalled, 'should not called before start')
+  t.ok(stopStub.notCalled, 'should not called before stop')
+
+  await wechaty.start()
+  t.ok(startStub.calledOnce, 'should call the skeleton start(), which means all mixin start()s are chained correctly')
+  t.ok(stopStub.notCalled, 'should not call stop yet')
+
+  await wechaty.stop()
+  t.ok(startStub.calledOnce, 'should only call start once')
+  t.ok(stopStub.calledOnce, 'should call the skeleton stop(), which means all mixin stops()s are chained correctly')
+})

package/src/wechaty/wechaty-base.ts

@@ -0,0 +1,307 @@
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/wechaty
+ *
+ *   @copyright 2016 Huan LI (李卓桓) <https://github.com/huan>, and
+ *                   Wechaty Contributors <https://github.com/wechaty>.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+import {
+  serviceCtlMixin,
+}                       from 'state-switch'
+import { function as FP } from 'fp-ts'
+import type * as PUPPET from 'wechaty-puppet'
+
+import {
+  config,
+  log,
+  VERSION,
+}                       from '../config.js'
+
+import type {
+  SayableSayer,
+  Sayable,
+}                             from '../sayable/mod.js'
+import {
+  gErrorMixin,
+  ioMixin,
+  loginMixin,
+  miscMixin,
+  pluginMixin,
+  puppetMixin,
+  wechatifyUserModuleMixin,
+}                             from '../wechaty-mixins/mod.js'
+
+import {
+  WechatySkeleton,
+}                             from './wechaty-skeleton.js'
+import type {
+  WechatyInterface,
+}                             from './wechaty-impl.js'
+import type {
+  WechatyOptions,
+}                             from '../schemas/wechaty-options.js'
+import type { PostInterface } from '../user-modules/post.js'
+
+const mixinBase = FP.pipe(
+  WechatySkeleton,
+  gErrorMixin,
+  wechatifyUserModuleMixin,
+  ioMixin,
+  puppetMixin,
+  loginMixin,
+  miscMixin,
+  pluginMixin,
+  /**
+   * Huan(202002):
+   *
+   * The `serviceCtlMixin` must be the most outer mixin
+   *  because the `wechaty.start/stop()` should first entry `serviceCtlMixin.start/stop()`
+   *  which can be managed correctly by the `serviceCtlMixin`
+   */
+  serviceCtlMixin('Wechaty', { log }),
+)
+
+/**
+ * Huan(2021211): Keep the below call back hell
+ *  because it's easy for testing
+ *  especially when there's some typing mismatch and we need to figure it out.
+ */
+// const mixinTest = serviceCtlMixin('Wechaty', { log })(
+//   pluginMixin(
+//     puppetMixin(
+//       wechatifyUserModuleMixin(
+//         gErrorMixin(
+//           WechatySkeleton,
+//         ),
+//       ),
+//     ),
+//   ),
+// )
+
+/**
+ * Main bot class.
+ *
+ * A `Bot` is a WeChat client depends on which puppet you use.
+ * It may equals
+ * - web-WeChat, when you use: [puppet-puppeteer](https://github.com/wechaty/wechaty-puppet-puppeteer)/[puppet-wechat4u](https://github.com/wechaty/wechaty-puppet-wechat4u)
+ * - ipad-WeChat, when you use: [puppet-padchat](https://github.com/wechaty/wechaty-puppet-padchat)
+ * - ios-WeChat, when you use: puppet-ioscat
+ *
+ * See more:
+ * - [What is a Puppet in Wechaty](https://github.com/wechaty/getting-started/wiki/FAQ#31-what-is-a-puppet-in-wechaty)
+ *
+ * > If you want to know how to send message, see [Message](#Message) <br>
+ * > If you want to know how to get contact, see [Contact](#Contact)
+ *
+ * @example <caption>The World's Shortest ChatBot Code: 6 lines of JavaScript</caption>
+ * import { WechatyBuilder } from 'wechaty'
+ * const bot = WechatyBuilder.build()
+ * bot.on('scan',    (qrCode, status) => console.log('https://wechaty.js.org/qrcode/' + encodeURIComponent(qrcode)))
+ * bot.on('login',   user => console.log(`User ${user} logged in`))
+ * bot.on('message', message => console.log(`Message: ${message}`))
+ * bot.start()
+ */
+class WechatyBase extends mixinBase implements SayableSayer {
+
+  static   override readonly VERSION = VERSION
+  readonly wechaty : WechatyInterface
+
+  readonly _stopCallbackList: (() => void)[] = []
+
+  /**
+   * The term [Puppet](https://wechaty.js.org/docs/specs/puppet) in Wechaty is an Abstract Class for implementing protocol plugins.
+   * The plugins are the component that helps Wechaty to control the WeChat(that's the reason we call it puppet).
+   * The plugins are named XXXPuppet, for example:
+   * - [PuppetWeChat](https://github.com/wechaty/puppet-wechat):
+   * - [PuppetWeChat](https://github.com/wechaty/puppet-service):
+   * - [PuppetXP](https://github.com/wechaty/puppet-xp)
+   *
+   * @typedef    PuppetModuleName
+   * @property   {string}  PUPPET_DEFAULT
+   * The default puppet.
+   * @property   {string}  wechaty-puppet-wechat4u
+   * The default puppet, using the [wechat4u](https://github.com/nodeWechat/wechat4u) to control the [WeChat Web API](https://wx.qq.com/) via a chrome browser.
+   * @property   {string}  wechaty-puppet-service
+   * - Using the gRPC protocol to connect with a Protocol Server for controlling the any protocol of any IM  program.
+   * @property   {string}  wechaty-puppet-wechat
+   * - Using the [google puppeteer](https://github.com/GoogleChrome/puppeteer) to control the [WeChat Web API](https://wx.qq.com/) via a chrome browser.
+   * @property   {string}  wechaty-puppet-mock
+   * - Using the mock data to mock wechat operation, just for test.
+   */
+
+  /**
+   * The option parameter to create a wechaty instance
+   *
+   * @typedef    WechatyOptions
+   * @property   {string}                 name            -Wechaty Name. </br>
+   *          When you set this: </br>
+   *          `new Wechaty({name: 'wechaty-name'}) ` </br>
+   *          it will generate a file called `wechaty-name.memory-card.json`. </br>
+   *          This file stores the login information for bot. </br>
+   *          If the file is valid, the bot can auto login so you don't need to scan the qrCode to login again. </br>
+   *          Also, you can set the environment variable for `WECHATY_NAME` to set this value when you start. </br>
+   *          eg:  `WECHATY_NAME="your-cute-bot-name" node bot.js`
+   * @property   {PuppetModuleName | Puppet}    puppet             -Puppet name or instance
+   * @property   {Partial<PuppetOptions>} puppetOptions      -Puppet TOKEN
+   * @property   {string}                 ioToken            -Io TOKEN
+   */
+
+  /**
+   * Creates an instance of Wechaty.
+   * @param {WechatyOptions} [options={}]
+   *
+   */
+  constructor (
+    override __options: WechatyOptions = {},
+  ) {
+    super(__options)
+    log.verbose('Wechaty', 'constructor()')
+
+    this.__memory = this.__options.memory
+    this.wechaty  = this
+  }
+
+  override async start (): Promise<void> {
+    log.verbose('Wechaty', 'start()')
+    await this.init()
+    return super.start()
+  }
+
+  override async onStart (): Promise<void> {
+    log.verbose('Wechaty', 'onStart()')
+
+    log.verbose('Wechaty', '<%s>(%s) onStart() v%s is starting...',
+      this.__options.puppet || config.systemPuppetName(),
+      this.__options.name   || '',
+      this.version(),
+    )
+    log.verbose('Wechaty', 'id: %s', this.id)
+
+    const lifeTimer = setInterval(() => {
+      log.silly('Wechaty', 'onStart() setInterval() this timer is to keep Wechaty running...')
+    }, 1000 * 60 * 60)
+    this._stopCallbackList.push(() => clearInterval(lifeTimer))
+
+    this.emit('start')
+    log.verbose('Wechaty', 'onStart() ... done')
+  }
+
+  override async onStop (): Promise<void> {
+    log.verbose('Wechaty', 'onStop()')
+
+    log.verbose('Wechaty', '<%s> onStop() v%s is stopping ...',
+      this.__options.puppet || config.systemPuppetName(),
+      this.version(),
+    )
+
+    // put to the end of the event loop in case of it need to be executed while stopping
+    this._stopCallbackList.map(setImmediate)
+    this._stopCallbackList.length = 0
+
+    this.emit('stop')
+    log.verbose('Wechaty', 'onStop() ... done')
+  }
+
+  /**
+   * Send message to currentUser, in other words, bot send message to itself.
+   * > Tips:
+   * This function is depending on the Puppet Implementation, see [puppet-compatible-table](https://github.com/wechaty/wechaty/wiki/Puppet#3-puppet-compatible-table)
+   *
+   * @param {(string | Contact | FileBox | UrlLink | MiniProgram | Location)} sayable
+   * send text, Contact, or file to bot. </br>
+   * You can use {@link https://www.npmjs.com/package/file-box|FileBox} to send file
+   *
+   * @returns {Promise<void>}
+   *
+   * @example
+   * const bot = new Wechaty()
+   * await bot.start()
+   * // after logged in
+   *
+   * // 1. send text to bot itself
+   * await bot.say('hello!')
+   *
+   * // 2. send Contact to bot itself
+   * const contact = await bot.Contact.find()
+   * await bot.say(contact)
+   *
+   * // 3. send Image to bot itself from remote url
+   * import { FileBox }  from 'wechaty'
+   * const fileBox = FileBox.fromUrl('https://wechaty.github.io/wechaty/images/bot-qr-code.png')
+   * await bot.say(fileBox)
+   *
+   * // 4. send Image to bot itself from local file
+   * import { FileBox }  from 'wechaty'
+   * const fileBox = FileBox.fromFile('/tmp/text.jpg')
+   * await bot.say(fileBox)
+   *
+   * // 5. send Link to bot itself
+   * const linkPayload = new UrlLink ({
+   *   description : 'WeChat Bot SDK for Individual Account, Powered by TypeScript, Docker, and Love',
+   *   thumbnailUrl: 'https://avatars0.githubusercontent.com/u/25162437?s=200&v=4',
+   *   title       : 'Welcome to Wechaty',
+   *   url         : 'https://github.com/wechaty/wechaty',
+   * })
+   * await bot.say(linkPayload)
+   *
+   * // 6. send MiniProgram to bot itself
+   * const miniPayload = new MiniProgram ({
+   *   username           : 'gh_xxxxxxx',     //get from mp.weixin.qq.com
+   *   appid              : '',               //optional, get from mp.weixin.qq.com
+   *   title              : '',               //optional
+   *   pagepath           : '',               //optional
+   *   description        : '',               //optional
+   *   thumbnailurl       : '',               //optional
+   * })
+   * await bot.say(miniPayload)
+   */
+
+  async say (
+    sayable: Sayable,
+  ): Promise<void> {
+    log.verbose('Wechaty', 'say(%s)', sayable)
+    await this.currentUser.say(sayable)
+  }
+
+  async publish (
+    post: PostInterface,
+  ): Promise<void | PostInterface> {
+    log.verbose('Wechaty', 'publish(%s)',
+      (post.payload.sayableList as PUPPET.payloads.Sayable[])
+        .map(s => s.type).join(','),
+    )
+    const postId = await this.puppet.postPublish(post.payload)
+
+    if (postId) {
+      return this.Post.find({ id: postId })
+    }
+  }
+
+}
+
+type WechatyBaseProtectedProperty =
+  // | '_serviceCtlFsmInterpreter'  // from ServiceCtlFsm
+  | '__serviceCtlLogger'             // from ServiceCtl(&Fsm)
+  | '__serviceCtlResettingIndicator' // from ServiceCtl
+  | 'wechaty'
+  | 'onStart'
+  | 'onStop'
+
+export type {
+  WechatyBaseProtectedProperty,
+}
+export {
+  WechatyBase,
+}